├── .gitignore ├── hack ├── cursor.h ├── ddhack.cpp ├── ddhack.def ├── ddhack.h ├── ddhack.ini ├── ddhack.sln ├── ddhack.vcproj ├── ddhack.vcxproj ├── ddraw.h ├── fixed.h ├── logo.h ├── myGdi.cpp ├── myGdi.h ├── myIDDraw.cpp ├── myIDDraw.h ├── myIDDraw1.cpp ├── myIDDraw2.cpp ├── myIDDraw7.cpp ├── myIDDrawClipper.cpp ├── myIDDrawPalette.cpp ├── myIDDrawSurface1.cpp ├── myIDDrawSurface7.cpp ├── stdafx.cpp └── stdafx.h ├── logger ├── ddraw.h ├── ddwrapper.cpp ├── ddwrapper.def ├── ddwrapper.h ├── ddwrapper.sln ├── ddwrapper.vcproj ├── ddwrapper.vcxproj ├── myIDDraw.h ├── myIDDraw1.cpp ├── myIDDraw2.cpp ├── myIDDraw4.cpp ├── myIDDraw7.cpp ├── myIDDrawPalette.cpp ├── myIDDrawSurface1.cpp ├── myIDDrawSurface2.cpp ├── myIDDrawSurface3.cpp ├── myIDDrawSurface4.cpp ├── myIDDrawSurface7.cpp ├── stdafx.cpp └── stdafx.h └── makefixed.py /.gitignore: -------------------------------------------------------------------------------- 1 | hack/Debug 2 | hack/Release 3 | hack/ddhack.ncb 4 | hack/ddhack.opensdf 5 | hack/ddhack.sdf 6 | hack/ddhack.suo 7 | hack/ddhack.vcxproj.user 8 | hack/ipch 9 | hack/out 10 | logger/Debug 11 | logger/Release 12 | logger/ddwrapper.ncb 13 | logger/ddwrapper.opensdf 14 | logger/ddwrapper.sdf 15 | logger/ddwrapper.suo 16 | logger/ddwrapper.vcxproj.user 17 | logger/ipch 18 | logger/out -------------------------------------------------------------------------------- /hack/cursor.h: -------------------------------------------------------------------------------- 1 | #define B 0x00000000, 2 | #define W 0x00FFFFFF, 3 | #define T 0xFF000000, 4 | 5 | static unsigned int cursor[] = { 6 | B T T T T T T T T T T T 7 | B B T T T T T T T T T T 8 | B W B T T T T T T T T T 9 | B W W B T T T T T T T T 10 | B W W W B T T T T T T T 11 | B W W W W B T T T T T T 12 | B W W W W W B T T T T T 13 | B W W W W W W B T T T T 14 | B W W W W W W W B T T T 15 | B W W W W W W W W B T T 16 | B W W W W W W W W W B T 17 | B W W W W W W W W W W B 18 | B W W W W W W B B B B B 19 | B W W W B W W B T T T T 20 | B W W B T B W W B T T T 21 | B W B T T B W W B T T T 22 | B B T T T T B W W B T T 23 | T T T T T T B W W B T T 24 | T T T T T T T B B T T T 25 | }; 26 | 27 | #undef B 28 | #undef W 29 | #undef T 30 | -------------------------------------------------------------------------------- /hack/ddhack.def: -------------------------------------------------------------------------------- 1 | LIBRARY "ddraw" 2 | 3 | EXPORTS 4 | AcquireDDThreadLock @1 5 | D3DParseUnknownCommand @4 6 | DirectDrawCreate @9 7 | DirectDrawCreateClipper @10 8 | DirectDrawCreateEx @11 9 | DirectDrawEnumerateA @12 10 | DirectDrawEnumerateExA @13 11 | DirectDrawEnumerateExW @14 12 | DirectDrawEnumerateW @15 13 | DllCanUnloadNow PRIVATE 14 | DllGetClassObject PRIVATE 15 | ReleaseDDThreadLock @22 -------------------------------------------------------------------------------- /hack/ddhack.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | inline HDC GetDC2(HWND hWnd) 4 | { 5 | return GetDC(hWnd); 6 | } 7 | 8 | inline int ReleaseDC2(HWND hWnd, HDC hDc) 9 | { 10 | return ReleaseDC(hWnd, hDc); 11 | } 12 | 13 | class myIDDrawSurface_Generic; 14 | 15 | // global variables 16 | #pragma data_seg (".ddraw_shared") 17 | extern HINSTANCE gHinst; 18 | extern HWND gHwnd; 19 | extern myIDDrawSurface_Generic * gPrimarySurface; 20 | extern myIDDrawSurface_Generic * gBackBuffer; 21 | extern int gScreenWidth; 22 | extern int gScreenHeight; 23 | extern int gScreenBits; 24 | extern int gRealScreenWidth; 25 | extern int gRealScreenHeight; 26 | extern int tex_w; 27 | extern int tex_h; 28 | extern int gAltWinPos; 29 | extern int gWc3SmallVid; 30 | extern int gGDI; 31 | extern unsigned char logo[]; 32 | #pragma data_seg () 33 | 34 | void logf(char *msg, ...); 35 | void updatescreen(); 36 | void init_gl(); 37 | void getgdibitmap(); 38 | 39 | // Exported function 40 | HRESULT WINAPI DirectDrawCreate(GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter); 41 | HRESULT WINAPI DirectDrawCreateEx(GUID FAR *lpGuid, LPVOID *lplpDD, REFIID iid,IUnknown FAR *pUnkOuter); 42 | HRESULT WINAPI DirectDrawCreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter); 43 | 44 | HRESULT WINAPI DirectDrawEnumerateW(LPDDENUMCALLBACKW lpCallback, LPVOID lpContext); 45 | HRESULT WINAPI DirectDrawEnumerateA(LPDDENUMCALLBACKA lpCallback, LPVOID lpContext); 46 | HRESULT WINAPI DirectDrawEnumerateExW(LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags); 47 | HRESULT WINAPI DirectDrawEnumerateExA(LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags); 48 | VOID WINAPI AcquireDDThreadLock(void); 49 | VOID WINAPI ReleaseDDThreadLock(void); 50 | DWORD WINAPI D3DParseUnknownCommand(LPVOID lpCmd, LPVOID *lpRetCmd); 51 | HRESULT WINAPI DllCanUnloadNow(void); 52 | HRESULT WINAPI DllGetClassObject (const CLSID &rclsid, const IID &riid, void **ppv); 53 | 54 | // Exported functions still missing 55 | /* 56 | GetSurfaceFromDC 57 | CheckFullscreen 58 | CompleteCreateSysmemSurface 59 | DDGetAttachedSurfaceLcl 60 | DDInternalLock 61 | DDInternalUnlock 62 | DSoundHelp 63 | GetDDSurfaceLocal 64 | GetOLEThunkData 65 | RegisterSpecialCase 66 | */ 67 | 68 | // regular functions 69 | void InitInstance(HANDLE hModule); 70 | void ExitInstance(void); 71 | -------------------------------------------------------------------------------- /hack/ddhack.ini: -------------------------------------------------------------------------------- 1 | ;config file for ddhack wrapper. 2 | [Rendering] 3 | bilinear_filter=0 4 | halfnhalf=0 5 | show_logo=1 6 | ;Sets LCD effect simulation 7 | ;0 = none 8 | ;1 = subtle 9 | ;2 = old LCD 10 | ;4 = very old 11 | old_lcd_level=0 12 | ;Wing Commander 3 specific hax 13 | w3scanlinedouble=0 14 | w3blurvideo=0 15 | w3smallvid=0 16 | ;alternate win pos hack 17 | altwinpos=0 18 | ignore_aspect_ratio=0 19 | vsync=0 20 | 21 | -------------------------------------------------------------------------------- /hack/ddhack.sln: -------------------------------------------------------------------------------- 1 | Microsoft Visual Studio Solution File, Format Version 11.00 2 | # Visual Studio 2010 3 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ddhack", "ddhack.vcxproj", "{62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}" 4 | EndProject 5 | Global 6 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 | Debug|Win32 = Debug|Win32 8 | Release|Win32 = Release|Win32 9 | EndGlobalSection 10 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 11 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}.Debug|Win32.ActiveCfg = Debug|Win32 12 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}.Debug|Win32.Build.0 = Debug|Win32 13 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}.Release|Win32.ActiveCfg = Release|Win32 14 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}.Release|Win32.Build.0 = Release|Win32 15 | EndGlobalSection 16 | GlobalSection(SolutionProperties) = preSolution 17 | HideSolutionNode = FALSE 18 | EndGlobalSection 19 | EndGlobal 20 | -------------------------------------------------------------------------------- /hack/ddhack.vcproj: -------------------------------------------------------------------------------- 1 | 2 | 10 | 11 | 14 | 15 | 16 | 17 | 18 | 26 | 29 | 32 | 35 | 38 | 41 | 53 | 56 | 59 | 62 | 77 | 80 | 83 | 86 | 89 | 92 | 95 | 98 | 99 | 107 | 110 | 113 | 116 | 119 | 122 | 136 | 139 | 142 | 145 | 161 | 164 | 167 | 170 | 173 | 176 | 179 | 182 | 183 | 184 | 185 | 186 | 187 | 191 | 194 | 195 | 198 | 199 | 202 | 203 | 206 | 207 | 210 | 211 | 214 | 215 | 218 | 221 | 225 | 226 | 229 | 233 | 234 | 235 | 236 | 240 | 243 | 244 | 247 | 248 | 251 | 252 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | -------------------------------------------------------------------------------- /hack/ddhack.vcxproj: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66} 15 | Win32Proj 16 | 17 | 18 | 19 | DynamicLibrary 20 | MultiByte 21 | 22 | 23 | DynamicLibrary 24 | MultiByte 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | <_ProjectFileVersion>10.0.40219.1 40 | Debug\ 41 | Debug\ 42 | true 43 | out\ 44 | Release\ 45 | false 46 | AllRules.ruleset 47 | 48 | 49 | AllRules.ruleset 50 | 51 | 52 | $(DXSDK_DIR)\Include;C:\Program Files (x86)\Microsoft Research\Detours Express 2.1\include;$(IncludePath) 53 | $(DXSDK_DIR)\Lib\x86;C:\Program Files (x86)\Microsoft Research\Detours Express 2.1\lib;$(LibraryPath) 54 | $(DXSDK_DIR)\Include;C:\Program Files (x86)\Microsoft Research\Detours Express 2.1\include;$(IncludePath) 55 | $(DXSDK_DIR)\Lib\x86;C:\Program Files (x86)\Microsoft Research\Detours Express 2.1\lib;$(LibraryPath) 56 | ddraw 57 | ddraw 58 | 59 | 60 | 61 | Disabled 62 | WIN32;_DEBUG;_WINDOWS;_USRDLL;ddhack_EXPORTS;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 63 | true 64 | EnableFastChecks 65 | MultiThreadedDebug 66 | Use 67 | Level4 68 | EditAndContinue 69 | 70 | 71 | dxguid.lib;opengl32.lib;detours.lib;detoured.lib;%(AdditionalDependencies) 72 | $(OutDir)\$(TargetName)$(TargetExt) 73 | ddhack.def 74 | opengl32.dll;%(DelayLoadDLLs) 75 | true 76 | $(OutDir)ddhack.pdb 77 | Windows 78 | false 79 | 80 | 81 | $(OutDir)ddhack.lib 82 | MachineX86 83 | 84 | 85 | 86 | 87 | MaxSpeed 88 | OnlyExplicitInline 89 | true 90 | WIN32;NDEBUG;_WINDOWS;_USRDLL;DDHACK_EXPORTS;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 91 | true 92 | MultiThreaded 93 | true 94 | Use 95 | Level4 96 | ProgramDatabase 97 | 98 | 99 | dxguid.lib;opengl32.lib;detours.lib;detoured.lib;%(AdditionalDependencies) 100 | $(OutDir)\$(TargetName)$(TargetExt) 101 | ddhack.def 102 | opengl32.dll;%(DelayLoadDLLs) 103 | true 104 | Windows 105 | true 106 | true 107 | true 108 | 109 | 110 | $(OutDir)ddhack.lib 111 | MachineX86 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | Create 131 | Create 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | -------------------------------------------------------------------------------- /hack/fixed.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ToadKing/ddhack/ec028ad5baf444e689088288efa1cf12225c4b85/hack/fixed.h -------------------------------------------------------------------------------- /hack/myGdi.cpp: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include "myGdi.h" 3 | #include "fixed.h" 4 | 5 | #include 6 | #include 7 | 8 | void gdi_write_string(HDC hdc, int nXStart, int nYStart, LPCTSTR lpString, int cchString, LPRECT lprc, UINT dwDTFormat) 9 | { 10 | if (open_dcs.find(hdc) == open_dcs.end()) 11 | return; 12 | std::hash_map kernings; 13 | char lc = 0; 14 | MAT2 m2; 15 | m2.eM11.fract = 0; 16 | m2.eM11.value = 1; 17 | m2.eM12.fract = 0; 18 | m2.eM12.value = 0; 19 | m2.eM21.fract = 0; 20 | m2.eM21.value = 0; 21 | m2.eM22.fract = 0; 22 | m2.eM22.value = 1; 23 | GLYPHMETRICS t; 24 | LOGFONT lf; 25 | GetObject(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf); 26 | COLORREF c = GetTextColor(hdc); 27 | if (GetGlyphOutline(hdc, 'A', GGO_BITMAP, &t, 0, 0, &m2) == GDI_ERROR) 28 | goto fallback; 29 | // hack: draw child window text to parent, calculate offset here 30 | HWND hWnd = WindowFromDC(hdc); 31 | logf("gdi_write_string"); 32 | logf("hWdc: %08x", hWnd); 33 | if (hWnd != NULL) 34 | { 35 | POINT p1 = {0}, p2 = {0}; 36 | GetViewportOrgEx(hdc, &p1); 37 | GetViewportOrgEx(GetDC(gHwnd), &p2); 38 | nXStart += p1.x - p2.x; 39 | nYStart += p1.y - p2.y; 40 | } 41 | logf("newX: %3d, newY: %3d", nXStart, nYStart); 42 | 43 | int height = lf.lfHeight < 0 ? -lf.lfHeight : lf.lfHeight; 44 | unsigned char **buffers = new unsigned char*[cchString]; 45 | GLYPHMETRICS *gms = new GLYPHMETRICS[cchString]; 46 | int *kerns = new int[cchString]; 47 | int i; 48 | logf(" facename: %s", lf.lfFaceName); 49 | 50 | // get kerning pairs 51 | int numpairs = GetKerningPairs(hdc, 0, 0); 52 | 53 | if (numpairs) 54 | { 55 | KERNINGPAIR *pairs = new KERNINGPAIR[numpairs]; 56 | GetKerningPairs(hdc, numpairs, pairs); 57 | 58 | for (int i = 0; i < numpairs; i++) 59 | { 60 | if (pairs[i].wFirst > 255 || pairs[i].wSecond > 255) 61 | continue; 62 | kernings[pairs[i].wFirst | (pairs[i].wSecond << 8)] = pairs[i].iKernAmount; 63 | } 64 | 65 | delete [] pairs; 66 | } 67 | logf("1"); 68 | int totalwidth = 0, totalheight = 0; 69 | 70 | for (i = 0; i < cchString; i++) 71 | { 72 | int size = GetGlyphOutline(hdc, lpString[i], GGO_BITMAP, &gms[i], 0, 0, &m2); 73 | buffers[i] = new unsigned char[size]; 74 | GetGlyphOutline(hdc, lpString[i], GGO_BITMAP, &gms[i], size, buffers[i], &m2); 75 | kerns[i] = kernings[lc | (lpString[i] << 8)]; 76 | lc = lpString[i]; 77 | } 78 | 79 | logf("2"); 80 | SIZE s; 81 | GetTextExtentPoint32(hdc, lpString, cchString, &s); 82 | totalwidth = s.cx; 83 | totalheight = s.cy; 84 | UINT align = GetTextAlign(hdc); 85 | 86 | if (lprc != NULL) 87 | { 88 | nXStart += lprc->left; 89 | if (dwDTFormat & DT_CENTER) 90 | nXStart += (lprc->right - lprc->left - totalwidth) / 2; 91 | nYStart += lprc->top; 92 | if (dwDTFormat & DT_BOTTOM) 93 | nYStart += (lprc->bottom - lprc->top - totalheight); 94 | } 95 | else if (align & TA_RIGHT) 96 | nXStart -= totalwidth; 97 | else if (align & TA_CENTER) 98 | nXStart -= totalwidth / 2; 99 | 100 | for (i = 0; i < cchString; i++) 101 | { 102 | nXStart += kerns[i]; 103 | DWORD pitch = ((gms[i].gmBlackBoxX / 8) + 3) & ~3; 104 | if (!pitch) pitch = 4; 105 | for (DWORD j = 0; j < gms[i].gmBlackBoxX; j++) 106 | { 107 | if ((int) j + nXStart < 0) 108 | continue; 109 | if ((int) j + nXStart > open_dcs[hdc]->getWidth()) 110 | break; 111 | for (DWORD k = 0; k < gms[i].gmBlackBoxY; k++) 112 | { 113 | if ((int) k + nYStart < 0) 114 | continue; 115 | if ((int) k + nYStart > open_dcs[hdc]->getHeight()) 116 | break; 117 | unsigned char pixel= ((buffers[i][(k * pitch) + (j / 8)] >> ((7 - (j + 8)) & 7)) & 1) * 0xFF; 118 | if (!pixel) continue; 119 | int bpp = open_dcs[hdc]->getPitch() / open_dcs[hdc]->getWidth(); 120 | int gdi_offset = (open_dcs[hdc]->getWidth() * (k + nYStart - gms[i].gmptGlyphOrigin.y + height) + (j + nXStart)) * bpp; 121 | unsigned char *dest = open_dcs[hdc]->getSurfaceData(); 122 | switch (bpp) 123 | { 124 | case 4: 125 | dest[gdi_offset] = (unsigned char) (pixel * ((c & 0x000000FF) / 255.f)); 126 | dest[gdi_offset + 1] = (unsigned char) (pixel * (((c & 0x0000FF00) >> 8) / 255.f)); 127 | dest[gdi_offset + 2] = (unsigned char) (pixel * (((c & 0x00FF0000) >> 16) / 255.f)); 128 | dest[gdi_offset + 3] = pixel; 129 | break; 130 | case 1: 131 | dest[gdi_offset] = color2palette(c); 132 | break; 133 | } 134 | } 135 | } 136 | 137 | delete [] buffers[i]; 138 | nXStart += gms[i].gmCellIncX; 139 | } 140 | delete [] buffers; 141 | delete [] gms; 142 | delete [] kerns; 143 | logf("done"); 144 | return; 145 | 146 | // we can't use GetGlyphOutline for bitmap fonts, so we have this hackish workaround. :( 147 | fallback: 148 | 149 | if (lprc != NULL) 150 | { 151 | nXStart += lprc->left; 152 | nYStart += lprc->top; 153 | } 154 | 155 | for (int i = 0; i < cchString; i++) 156 | { 157 | char ch = lpString[i]; 158 | nXStart += fixed_kernings[lc | (ch << 8)]; 159 | ch -= 0x20; 160 | 161 | for (unsigned int j = 0; j < fixed_width[ch]; j++) 162 | { 163 | if ((int) j + nXStart < 0) 164 | continue; 165 | if ((int) j + nXStart > open_dcs[hdc]->getWidth()) 166 | break; 167 | for (unsigned int k = 0; k < fixed_height[ch]; k++) 168 | { 169 | if ((int) k + nYStart < 0) 170 | continue; 171 | if ((int) k + nYStart > open_dcs[hdc]->getHeight()) 172 | break; 173 | unsigned int pixel= fixed_data[ch][k * fixed_width[ch] + j] * c; 174 | if (!pixel) continue; 175 | int bpp = open_dcs[hdc]->getPitch() / open_dcs[hdc]->getWidth(); 176 | int gdi_offset = (open_dcs[hdc]->getWidth() * (k + nYStart) + (j + nXStart)) * bpp; 177 | unsigned char *dest = open_dcs[hdc]->getSurfaceData(); 178 | switch (bpp) 179 | { 180 | case 4: 181 | *(unsigned int *)(dest[gdi_offset]) = pixel; 182 | break; 183 | case 1: 184 | dest[gdi_offset] = color2palette(c); 185 | break; 186 | } 187 | } 188 | } 189 | nXStart += fixed_aw[ch]; 190 | } 191 | } 192 | 193 | /*void gdi_clear(const RECT *lpRect) 194 | { 195 | if (tex_w == 0 || tex_h == 0) 196 | return; 197 | if (lpRect == NULL) 198 | { 199 | for(std::unordered_set::iterator it = full_surfaces.begin(); it != full_surfaces.end(); it++) 200 | memset((*it)->getGdiBuffer(), 0, tex_w * tex_h * 4); 201 | return; 202 | } 203 | for(std::unordered_set::iterator it = full_surfaces.begin(); it != full_surfaces.end(); it++) 204 | for (int i = lpRect->top; i <= lpRect->bottom; i++) 205 | memset(&(*it)->getGdiBuffer()[(i * tex_w + lpRect->left) * 4], 0, (lpRect->right - lpRect->left) * 4); 206 | } 207 | 208 | void gdi_invalidate(const RECT *lpRect) 209 | { 210 | if (lpRect == 0) 211 | return; 212 | if (invalidateRectsCount >= 1024) 213 | return; 214 | memcpy(&invalidateRects[invalidateRectsCount++], lpRect, sizeof(RECT)); 215 | } 216 | 217 | void gdi_run_invalidations() 218 | { 219 | if (invalidateRectsCount) 220 | for (;invalidateRectsCount >= 0; --invalidateRectsCount) 221 | gdi_clear(&invalidateRects[invalidateRectsCount]); 222 | 223 | gdi_clear_invalidations(); 224 | } 225 | 226 | void gdi_clear_invalidations() 227 | { 228 | invalidateRectsCount = 0; 229 | }*/ 230 | -------------------------------------------------------------------------------- /hack/myGdi.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void gdi_write_string(HDC hdc, int nXStart, int nYStart, LPCTSTR lpString, int cchString, LPRECT lprc, UINT dwDTFormat); 4 | -------------------------------------------------------------------------------- /hack/myIDDraw.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | #include 4 | 5 | 6 | HRESULT WINAPI DirectDrawCreate(GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter) 7 | { 8 | logf("DirectDrawCreate(%08X,%08X,%08X)", lpGUID, lplpDD, pUnkOuter); 9 | 10 | *lplpDD = (LPDIRECTDRAW) new myIDDraw1(); 11 | 12 | return 0; 13 | } 14 | 15 | 16 | HRESULT WINAPI DirectDrawCreateEx(GUID FAR * lpGuid, LPVOID *lplpDD, REFIID iid, IUnknown FAR *pUnkOuter) 17 | { 18 | logf("DirectDrawCreateEx(%08X,%08X,(guid),%08X)",lpGuid, lplpDD, pUnkOuter); 19 | 20 | // Hooking DDRAW interface from Original Library IDirectDraw *pDD; 21 | 22 | if (iid == IID_IDirectDraw) 23 | { 24 | *lplpDD = (LPVOID) new myIDDraw1(); 25 | 26 | return 0; 27 | } 28 | 29 | if (iid == IID_IDirectDraw2) 30 | { 31 | *lplpDD = (LPVOID) new myIDDraw2(); 32 | 33 | return 0; 34 | } 35 | 36 | if (iid == IID_IDirectDraw4) 37 | { 38 | logf("IDDRAW4 requested"); 39 | } 40 | 41 | if (iid == IID_IDirectDraw7) 42 | { 43 | *lplpDD = (LPVOID) new myIDDraw7(); 44 | 45 | return 0; 46 | } 47 | 48 | logf("Unsupported ddraw interface version"); 49 | ::ExitProcess(0); 50 | 51 | } 52 | 53 | 54 | HRESULT WINAPI DirectDrawCreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter) 55 | { 56 | logf("Exported function DirectDrawCreateClipper"); 57 | 58 | *lplpDDClipper = new myIDDrawClipper(); 59 | return (DD_OK); 60 | } 61 | 62 | 63 | HRESULT WINAPI DirectDrawEnumerateW(LPDDENUMCALLBACKW lpCallback, LPVOID lpContext) 64 | { 65 | logf("Exported function DirectDrawEnumerateW"); 66 | 67 | (*lpCallback)(NULL, L"Primary Display Driver", L"display", lpContext); 68 | return (DD_OK); 69 | } 70 | 71 | 72 | HRESULT WINAPI DirectDrawEnumerateA(LPDDENUMCALLBACKA lpCallback, LPVOID lpContext) 73 | { 74 | logf("Exported function DirectDrawEnumerateA"); 75 | 76 | 77 | (*lpCallback)(NULL, "Primary Display Driver", "display", lpContext); 78 | return (DD_OK); 79 | } 80 | 81 | 82 | HRESULT WINAPI DirectDrawEnumerateExW(LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags) 83 | { 84 | logf("Exported function DirectDrawEnumerateExW"); 85 | 86 | (*lpCallback)(NULL, L"Primary Display Driver", L"display", lpContext, 0); 87 | return (DD_OK); 88 | } 89 | 90 | 91 | HRESULT WINAPI DirectDrawEnumerateExA(LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags) 92 | { 93 | logf("Exported function DirectDrawEnumerateExA"); 94 | 95 | (*lpCallback)(NULL, "Primary Display Driver", "display", lpContext, 0); 96 | return (DD_OK); 97 | } 98 | 99 | 100 | VOID WINAPI AcquireDDThreadLock() 101 | { 102 | logf("Exported function AcquireDDThreadLock"); 103 | } 104 | 105 | 106 | VOID WINAPI ReleaseDDThreadLock() 107 | { 108 | logf("Exported function ReleaseDDThreadLock"); 109 | 110 | } 111 | 112 | 113 | DWORD WINAPI D3DParseUnknownCommand(LPVOID lpCmd, LPVOID *lpRetCmd) 114 | { 115 | logf("Exported function D3DParseUnknownCommand"); 116 | 117 | return(0); 118 | } 119 | 120 | 121 | HRESULT WINAPI DllCanUnloadNow(void) 122 | { 123 | logf("Exported function DllCanUnloadNow"); 124 | 125 | return(DDERR_UNSUPPORTED); 126 | } 127 | 128 | HRESULT WINAPI DllGetClassObject (const CLSID &rclsid, const IID &riid, void **ppv) 129 | { 130 | logf("Exported function DllGetClassObject"); 131 | 132 | return(DDERR_UNSUPPORTED); 133 | } 134 | -------------------------------------------------------------------------------- /hack/myIDDraw.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | class myIDDrawSurface_Generic; 6 | class myIDDrawPalette; 7 | class myIDDrawClipper; 8 | 9 | unsigned char color2palette(unsigned int c); 10 | 11 | extern std::hash_map open_dcs; 12 | //extern std::unordered_set full_surfaces; 13 | extern std::hash_map color_map; 14 | 15 | class myIDDraw1 : public IDirectDraw 16 | { 17 | public: 18 | myIDDraw1(); 19 | virtual ~myIDDraw1(void); 20 | 21 | // The original DDraw function definitions BEGIN 22 | HRESULT __stdcall QueryInterface (REFIID a, LPVOID FAR * b); 23 | ULONG __stdcall AddRef(void); 24 | ULONG __stdcall Release(void); 25 | 26 | HRESULT __stdcall Compact(void); 27 | HRESULT __stdcall CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c); 28 | HRESULT __stdcall CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d); 29 | HRESULT __stdcall CreateSurface(LPDDSURFACEDESC a, LPDIRECTDRAWSURFACE FAR* b, IUnknown FAR* c); 30 | HRESULT __stdcall DuplicateSurface(LPDIRECTDRAWSURFACE a, LPDIRECTDRAWSURFACE FAR* b); 31 | HRESULT __stdcall EnumDisplayModes(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMMODESCALLBACK d); 32 | HRESULT __stdcall EnumSurfaces(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMSURFACESCALLBACK d); 33 | HRESULT __stdcall FlipToGDISurface(void); 34 | HRESULT __stdcall GetCaps(LPDDCAPS a, LPDDCAPS b); 35 | HRESULT __stdcall GetDisplayMode(LPDDSURFACEDESC a); 36 | HRESULT __stdcall GetFourCCCodes(LPDWORD a, LPDWORD b); 37 | HRESULT __stdcall GetGDISurface(LPDIRECTDRAWSURFACE FAR * a); 38 | HRESULT __stdcall GetMonitorFrequency(LPDWORD a); 39 | HRESULT __stdcall GetScanLine(LPDWORD a); 40 | HRESULT __stdcall GetVerticalBlankStatus(LPBOOL a); 41 | HRESULT __stdcall Initialize(GUID FAR* a); 42 | HRESULT __stdcall RestoreDisplayMode(void); 43 | HRESULT __stdcall SetCooperativeLevel(HWND a, DWORD b); 44 | HRESULT __stdcall SetDisplayMode(DWORD a, DWORD b, DWORD c); 45 | HRESULT __stdcall WaitForVerticalBlank(DWORD a, HANDLE b); 46 | 47 | }; 48 | 49 | 50 | class myIDDraw2 : public IDirectDraw2 51 | { 52 | public: 53 | myIDDraw2(); 54 | virtual ~myIDDraw2(void); 55 | 56 | // The original DDraw function definitions BEGIN 57 | HRESULT __stdcall QueryInterface (REFIID a, LPVOID FAR * b); 58 | ULONG __stdcall AddRef(void); 59 | ULONG __stdcall Release(void); 60 | 61 | HRESULT __stdcall Compact(void); 62 | HRESULT __stdcall CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c); 63 | HRESULT __stdcall CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d); 64 | HRESULT __stdcall CreateSurface(LPDDSURFACEDESC a, LPDIRECTDRAWSURFACE FAR* b, IUnknown FAR* c); 65 | HRESULT __stdcall DuplicateSurface(LPDIRECTDRAWSURFACE a, LPDIRECTDRAWSURFACE FAR* b); 66 | HRESULT __stdcall EnumDisplayModes(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMMODESCALLBACK d); 67 | HRESULT __stdcall EnumSurfaces(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMSURFACESCALLBACK d); 68 | HRESULT __stdcall FlipToGDISurface(void); 69 | HRESULT __stdcall GetCaps(LPDDCAPS a, LPDDCAPS b); 70 | HRESULT __stdcall GetDisplayMode(LPDDSURFACEDESC a); 71 | HRESULT __stdcall GetFourCCCodes(LPDWORD a, LPDWORD b); 72 | HRESULT __stdcall GetGDISurface(LPDIRECTDRAWSURFACE FAR * a); 73 | HRESULT __stdcall GetMonitorFrequency(LPDWORD a); 74 | HRESULT __stdcall GetScanLine(LPDWORD a); 75 | HRESULT __stdcall GetVerticalBlankStatus(LPBOOL a); 76 | HRESULT __stdcall Initialize(GUID FAR* a); 77 | HRESULT __stdcall RestoreDisplayMode(void); 78 | HRESULT __stdcall SetCooperativeLevel(HWND a, DWORD b); 79 | HRESULT __stdcall SetDisplayMode(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e); 80 | HRESULT __stdcall WaitForVerticalBlank(DWORD a, HANDLE b); 81 | 82 | /*** Added in the v2 interface ***/ 83 | HRESULT __stdcall GetAvailableVidMem(LPDDSCAPS a, LPDWORD b, LPDWORD c); 84 | 85 | }; 86 | 87 | class myIDDraw7 : public IDirectDraw7 88 | { 89 | public: 90 | myIDDraw7(); 91 | virtual ~myIDDraw7(void); 92 | 93 | // The original DDraw function definitions BEGIN 94 | HRESULT __stdcall QueryInterface (REFIID a, LPVOID FAR * b); 95 | ULONG __stdcall AddRef(void); 96 | ULONG __stdcall Release(void); 97 | 98 | HRESULT __stdcall Compact(void); 99 | HRESULT __stdcall CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c); 100 | HRESULT __stdcall CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d); 101 | HRESULT __stdcall CreateSurface(LPDDSURFACEDESC2 a, LPDIRECTDRAWSURFACE7 FAR* b, IUnknown FAR* c); 102 | HRESULT __stdcall DuplicateSurface(LPDIRECTDRAWSURFACE7 a, LPDIRECTDRAWSURFACE7 FAR* b); 103 | HRESULT __stdcall EnumDisplayModes(DWORD a, LPDDSURFACEDESC2 b, LPVOID c, LPDDENUMMODESCALLBACK2 d); 104 | HRESULT __stdcall EnumSurfaces(DWORD a, LPDDSURFACEDESC2 b, LPVOID c, LPDDENUMSURFACESCALLBACK7 d); 105 | HRESULT __stdcall FlipToGDISurface(void); 106 | HRESULT __stdcall GetCaps(LPDDCAPS a, LPDDCAPS b); 107 | HRESULT __stdcall GetDisplayMode(LPDDSURFACEDESC2 a); 108 | HRESULT __stdcall GetFourCCCodes(LPDWORD a, LPDWORD b); 109 | HRESULT __stdcall GetGDISurface(LPDIRECTDRAWSURFACE7 FAR * a); 110 | HRESULT __stdcall GetMonitorFrequency(LPDWORD a); 111 | HRESULT __stdcall GetScanLine(LPDWORD a); 112 | HRESULT __stdcall GetVerticalBlankStatus(LPBOOL a); 113 | HRESULT __stdcall Initialize(GUID FAR* a); 114 | HRESULT __stdcall RestoreDisplayMode(void); 115 | HRESULT __stdcall SetCooperativeLevel(HWND a, DWORD b); 116 | HRESULT __stdcall SetDisplayMode(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e); 117 | HRESULT __stdcall WaitForVerticalBlank(DWORD a, HANDLE b); 118 | 119 | /*** Added in the v2 interface ***/ 120 | HRESULT __stdcall GetAvailableVidMem(LPDDSCAPS2 a, LPDWORD b, LPDWORD c); 121 | 122 | /*** Added in the V4 Interface ***/ 123 | HRESULT __stdcall GetSurfaceFromDC(HDC a, LPDIRECTDRAWSURFACE7 *b); 124 | HRESULT __stdcall RestoreAllSurfaces(void); 125 | HRESULT __stdcall TestCooperativeLevel(void); 126 | HRESULT __stdcall GetDeviceIdentifier(LPDDDEVICEIDENTIFIER2 a, DWORD b); 127 | HRESULT __stdcall StartModeTest(LPSIZE a, DWORD b, DWORD c); 128 | HRESULT __stdcall EvaluateMode(DWORD a, DWORD *b); 129 | }; 130 | 131 | class myIDDrawPalette : public IDirectDrawPalette 132 | { 133 | public: 134 | myIDDrawPalette(DWORD a, LPPALETTEENTRY b); 135 | virtual ~myIDDrawPalette(void); 136 | 137 | // The original DDraw function definitions BEGIN 138 | HRESULT __stdcall QueryInterface (REFIID a, LPVOID FAR * b); 139 | ULONG __stdcall AddRef(void); 140 | ULONG __stdcall Release(void); 141 | 142 | /*** IDirectDrawPalette methods ***/ 143 | HRESULT __stdcall GetCaps(LPDWORD); 144 | HRESULT __stdcall GetEntries(DWORD,DWORD,DWORD,LPPALETTEENTRY); 145 | HRESULT __stdcall Initialize(LPDIRECTDRAW, DWORD, LPPALETTEENTRY); 146 | HRESULT __stdcall SetEntries(DWORD,DWORD,DWORD,LPPALETTEENTRY); 147 | 148 | PALETTEENTRY mPal[256]; 149 | }; 150 | 151 | class myIDDrawSurface_Generic 152 | { 153 | public: 154 | virtual ~myIDDrawSurface_Generic() {}; 155 | virtual myIDDrawPalette *getCurrentPalette() const = 0; 156 | virtual unsigned char * getSurfaceData() const = 0; 157 | virtual unsigned char * getGdiBuffer() const = 0; 158 | virtual int getWidth() const = 0; 159 | virtual int getHeight() const = 0; 160 | virtual int getPitch() const = 0; 161 | virtual bool isTextBuffer() const = 0; 162 | virtual void setTextBuffer() = 0; 163 | virtual void clearGdi() = 0; 164 | }; 165 | 166 | class myIDDrawSurface1 : public IDirectDrawSurface, public myIDDrawSurface_Generic 167 | { 168 | public: 169 | myIDDrawSurface1(LPDDSURFACEDESC a); 170 | virtual ~myIDDrawSurface1(void); 171 | 172 | // The original DDraw function definitions BEGIN 173 | HRESULT __stdcall QueryInterface (REFIID a, LPVOID FAR * b); 174 | ULONG __stdcall AddRef(void); 175 | ULONG __stdcall Release(void); 176 | 177 | /*** IDirectDrawSurface methods ***/ 178 | HRESULT __stdcall AddAttachedSurface(LPDIRECTDRAWSURFACE); 179 | HRESULT __stdcall AddOverlayDirtyRect(LPRECT); 180 | HRESULT __stdcall Blt(LPRECT,LPDIRECTDRAWSURFACE, LPRECT,DWORD, LPDDBLTFX); 181 | HRESULT __stdcall BltBatch(LPDDBLTBATCH, DWORD, DWORD ); 182 | HRESULT __stdcall BltFast(DWORD,DWORD,LPDIRECTDRAWSURFACE, LPRECT,DWORD); 183 | HRESULT __stdcall DeleteAttachedSurface(DWORD,LPDIRECTDRAWSURFACE); 184 | HRESULT __stdcall EnumAttachedSurfaces(LPVOID,LPDDENUMSURFACESCALLBACK); 185 | HRESULT __stdcall EnumOverlayZOrders(DWORD,LPVOID,LPDDENUMSURFACESCALLBACK); 186 | HRESULT __stdcall Flip(LPDIRECTDRAWSURFACE, DWORD); 187 | HRESULT __stdcall GetAttachedSurface(LPDDSCAPS, LPDIRECTDRAWSURFACE FAR *); 188 | HRESULT __stdcall GetBltStatus(DWORD); 189 | HRESULT __stdcall GetCaps(LPDDSCAPS); 190 | HRESULT __stdcall GetClipper(LPDIRECTDRAWCLIPPER FAR*); 191 | HRESULT __stdcall GetColorKey(DWORD, LPDDCOLORKEY); 192 | HRESULT __stdcall GetDC(HDC FAR *); 193 | HRESULT __stdcall GetFlipStatus(DWORD); 194 | HRESULT __stdcall GetOverlayPosition(LPLONG, LPLONG ); 195 | HRESULT __stdcall GetPalette(LPDIRECTDRAWPALETTE FAR*); 196 | HRESULT __stdcall GetPixelFormat(LPDDPIXELFORMAT); 197 | HRESULT __stdcall GetSurfaceDesc(LPDDSURFACEDESC); 198 | HRESULT __stdcall Initialize(LPDIRECTDRAW, LPDDSURFACEDESC); 199 | HRESULT __stdcall IsLost(); 200 | HRESULT __stdcall Lock(LPRECT,LPDDSURFACEDESC,DWORD,HANDLE); 201 | HRESULT __stdcall ReleaseDC(HDC); 202 | HRESULT __stdcall Restore(); 203 | HRESULT __stdcall SetClipper(LPDIRECTDRAWCLIPPER); 204 | HRESULT __stdcall SetColorKey(DWORD, LPDDCOLORKEY); 205 | HRESULT __stdcall SetOverlayPosition(LONG, LONG ); 206 | HRESULT __stdcall SetPalette(LPDIRECTDRAWPALETTE); 207 | HRESULT __stdcall Unlock(LPVOID); 208 | HRESULT __stdcall UpdateOverlay(LPRECT, LPDIRECTDRAWSURFACE,LPRECT,DWORD, LPDDOVERLAYFX); 209 | HRESULT __stdcall UpdateOverlayDisplay(DWORD); 210 | HRESULT __stdcall UpdateOverlayZOrder(DWORD, LPDIRECTDRAWSURFACE); 211 | 212 | virtual myIDDrawPalette *getCurrentPalette() const { return mCurrentPalette; } 213 | virtual unsigned char * getSurfaceData() const { return mSurfaceData; } 214 | virtual unsigned char * getGdiBuffer() const { return (unsigned char *) mGdiBuffer; } 215 | virtual int getWidth() const { return mWidth; } 216 | virtual int getHeight() const { return mHeight; } 217 | virtual int getPitch() const { return mPitch; } 218 | virtual bool isTextBuffer() const { return mIsTextBuffer; } 219 | virtual void setTextBuffer() { mIsTextBuffer = true; } 220 | virtual void clearGdi() { memset(mGdiBuffer, 0, mHeight * mWidth * 4); } 221 | 222 | DDSURFACEDESC mSurfaceDesc; 223 | DDCOLORKEY mSrcColorKey; 224 | DDCOLORKEY mDestColorKey; 225 | DDSCAPS mCaps; 226 | myIDDrawPalette *mCurrentPalette; 227 | myIDDrawClipper *mClipper; 228 | unsigned char * mSurfaceData; 229 | unsigned char * mRealSurfaceData; 230 | unsigned int * mGdiBuffer; 231 | unsigned int * mRealGdiBuffer; 232 | int mWidth; 233 | int mHeight; 234 | int mPitch; 235 | bool mIsTextBuffer; 236 | }; 237 | 238 | class myIDDrawSurface7 : public IDirectDrawSurface7, public myIDDrawSurface_Generic 239 | { 240 | public: 241 | myIDDrawSurface7(LPDDSURFACEDESC2 a); 242 | virtual ~myIDDrawSurface7(void); 243 | 244 | // The original DDraw function definitions BEGIN 245 | HRESULT __stdcall QueryInterface (REFIID a, LPVOID FAR * b); 246 | ULONG __stdcall AddRef(void); 247 | ULONG __stdcall Release(void); 248 | 249 | /*** IDirectDrawSurface methods ***/ 250 | HRESULT __stdcall AddAttachedSurface(LPDIRECTDRAWSURFACE7); 251 | HRESULT __stdcall AddOverlayDirtyRect(LPRECT); 252 | HRESULT __stdcall Blt(LPRECT,LPDIRECTDRAWSURFACE7, LPRECT,DWORD, LPDDBLTFX); 253 | HRESULT __stdcall BltBatch(LPDDBLTBATCH, DWORD, DWORD ); 254 | HRESULT __stdcall BltFast(DWORD,DWORD,LPDIRECTDRAWSURFACE7, LPRECT,DWORD); 255 | HRESULT __stdcall DeleteAttachedSurface(DWORD,LPDIRECTDRAWSURFACE7); 256 | HRESULT __stdcall EnumAttachedSurfaces(LPVOID,LPDDENUMSURFACESCALLBACK7); 257 | HRESULT __stdcall EnumOverlayZOrders(DWORD,LPVOID,LPDDENUMSURFACESCALLBACK7); 258 | HRESULT __stdcall Flip(LPDIRECTDRAWSURFACE7, DWORD); 259 | HRESULT __stdcall GetAttachedSurface(LPDDSCAPS2, LPDIRECTDRAWSURFACE7 FAR *); 260 | HRESULT __stdcall GetBltStatus(DWORD); 261 | HRESULT __stdcall GetCaps(LPDDSCAPS2); 262 | HRESULT __stdcall GetClipper(LPDIRECTDRAWCLIPPER FAR*); 263 | HRESULT __stdcall GetColorKey(DWORD, LPDDCOLORKEY); 264 | HRESULT __stdcall GetDC(HDC FAR *); 265 | HRESULT __stdcall GetFlipStatus(DWORD); 266 | HRESULT __stdcall GetOverlayPosition(LPLONG, LPLONG ); 267 | HRESULT __stdcall GetPalette(LPDIRECTDRAWPALETTE FAR*); 268 | HRESULT __stdcall GetPixelFormat(LPDDPIXELFORMAT); 269 | HRESULT __stdcall GetSurfaceDesc(LPDDSURFACEDESC2); 270 | HRESULT __stdcall Initialize(LPDIRECTDRAW, LPDDSURFACEDESC2); 271 | HRESULT __stdcall IsLost(); 272 | HRESULT __stdcall Lock(LPRECT,LPDDSURFACEDESC2,DWORD,HANDLE); 273 | HRESULT __stdcall ReleaseDC(HDC); 274 | HRESULT __stdcall Restore(); 275 | HRESULT __stdcall SetClipper(LPDIRECTDRAWCLIPPER); 276 | HRESULT __stdcall SetColorKey(DWORD, LPDDCOLORKEY); 277 | HRESULT __stdcall SetOverlayPosition(LONG, LONG ); 278 | HRESULT __stdcall SetPalette(LPDIRECTDRAWPALETTE); 279 | HRESULT __stdcall Unlock(LPRECT); 280 | HRESULT __stdcall UpdateOverlay(LPRECT, LPDIRECTDRAWSURFACE7,LPRECT,DWORD, LPDDOVERLAYFX); 281 | HRESULT __stdcall UpdateOverlayDisplay(DWORD); 282 | HRESULT __stdcall UpdateOverlayZOrder(DWORD, LPDIRECTDRAWSURFACE7); 283 | 284 | /*** Added in the v2 interface ***/ 285 | HRESULT __stdcall GetDDInterface(LPVOID FAR *); 286 | HRESULT __stdcall PageLock(DWORD); 287 | HRESULT __stdcall PageUnlock(DWORD); 288 | 289 | /*** Added in the V3 interface ***/ 290 | HRESULT __stdcall SetSurfaceDesc(LPDDSURFACEDESC2, DWORD); 291 | 292 | /*** Added in the v4 interface ***/ 293 | HRESULT __stdcall SetPrivateData(REFGUID, LPVOID, DWORD, DWORD); 294 | HRESULT __stdcall GetPrivateData(REFGUID, LPVOID, LPDWORD); 295 | HRESULT __stdcall FreePrivateData(REFGUID); 296 | HRESULT __stdcall GetUniquenessValue(LPDWORD); 297 | HRESULT __stdcall ChangeUniquenessValue(); 298 | 299 | /*** Moved Texture7 methods here ***/ 300 | HRESULT __stdcall SetPriority(DWORD); 301 | HRESULT __stdcall GetPriority(LPDWORD); 302 | HRESULT __stdcall SetLOD(DWORD); 303 | HRESULT __stdcall GetLOD(LPDWORD); 304 | 305 | virtual myIDDrawPalette *getCurrentPalette() const { return mCurrentPalette; } 306 | virtual unsigned char * getSurfaceData() const { return mSurfaceData; } 307 | virtual unsigned char * getGdiBuffer() const { return (unsigned char *) mGdiBuffer; } 308 | virtual int getWidth() const { return mWidth; } 309 | virtual int getHeight() const { return mHeight; } 310 | virtual int getPitch() const { return mPitch; } 311 | virtual bool isTextBuffer() const { return mIsTextBuffer; } 312 | virtual void setTextBuffer() { mIsTextBuffer = true; } 313 | virtual void clearGdi() { memset(mGdiBuffer, 0, mHeight * mWidth * 4); } 314 | 315 | DDSURFACEDESC2 mSurfaceDesc; 316 | DDCOLORKEY mSrcColorKey; 317 | DDCOLORKEY mDestColorKey; 318 | DDSCAPS2 mCaps; 319 | myIDDrawPalette *mCurrentPalette; 320 | myIDDrawClipper *mClipper; 321 | unsigned char * mSurfaceData; 322 | unsigned char * mRealSurfaceData; 323 | unsigned int * mGdiBuffer; 324 | unsigned int * mRealGdiBuffer; 325 | int mWidth; 326 | int mHeight; 327 | int mPitch; 328 | bool mIsTextBuffer; 329 | }; 330 | 331 | class myIDDrawClipper : public IDirectDrawClipper 332 | { 333 | public: 334 | myIDDrawClipper(void); 335 | virtual ~myIDDrawClipper(void); 336 | 337 | // The original DDraw function definitions BEGIN 338 | HRESULT __stdcall QueryInterface (REFIID a, LPVOID FAR * b); 339 | ULONG __stdcall AddRef(void); 340 | ULONG __stdcall Release(void); 341 | 342 | /*** IDirectDrawClipper methods ***/ 343 | HRESULT __stdcall GetClipList(LPRECT, LPRGNDATA, LPDWORD); 344 | HRESULT __stdcall GetHWnd(HWND FAR *); 345 | HRESULT __stdcall Initialize(LPDIRECTDRAW, DWORD); 346 | HRESULT __stdcall IsClipListChanged(BOOL FAR *); 347 | HRESULT __stdcall SetClipList(LPRGNDATA, DWORD); 348 | HRESULT __stdcall SetHWnd(DWORD, HWND); 349 | 350 | HWND mHwnd; 351 | }; 352 | 353 | unsigned char gdi_get_palette(unsigned int color, myIDDrawPalette *pal); 354 | -------------------------------------------------------------------------------- /hack/myIDDraw1.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | myIDDraw1::myIDDraw1() 5 | { 6 | logf("myIDDraw1 Constructor"); 7 | } 8 | 9 | 10 | myIDDraw1::~myIDDraw1(void) 11 | { 12 | logf("myIDDraw1 Destructor"); 13 | } 14 | 15 | 16 | HRESULT __stdcall myIDDraw1::QueryInterface (REFIID a, LPVOID FAR * b) 17 | { 18 | char *iid = "?"; 19 | if (a == IID_IDirectDraw) iid = "IID_IDirectDraw"; 20 | if (a == IID_IDirectDraw2) iid = "IID_IDirectDraw2"; 21 | // if (a == IID_IDirectDraw4) iid = "IID_IDirectDraw4"; 22 | if (a == IID_IDirectDraw7) iid = "IID_IDirectDraw7"; 23 | 24 | logf("myIDDraw1::QueryInterface(%s,%08x)",iid,b); 25 | 26 | if (a == IID_IDirectDraw) 27 | { 28 | *b = this; 29 | return NOERROR; 30 | } 31 | 32 | if (a == IID_IDirectDraw2) 33 | { 34 | *b = new myIDDraw2(); 35 | return NOERROR; 36 | } 37 | 38 | if (a == IID_IDirectDraw7) 39 | { 40 | *b = new myIDDraw7(); 41 | return NOERROR; 42 | } 43 | 44 | return DDERR_UNSUPPORTED; 45 | } 46 | 47 | 48 | ULONG __stdcall myIDDraw1::AddRef(void) 49 | { 50 | logf("myIDDraw1::AddRef"); 51 | return 1; 52 | } 53 | 54 | 55 | ULONG __stdcall myIDDraw1::Release(void) 56 | { 57 | logf("myIDDraw1::Release"); 58 | delete this; 59 | return (0); 60 | } 61 | 62 | 63 | HRESULT __stdcall myIDDraw1::Compact(void) 64 | { 65 | logf("myIDDraw1::Compact"); 66 | return DDERR_UNSUPPORTED; 67 | } 68 | 69 | 70 | HRESULT __stdcall myIDDraw1::CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c) 71 | { 72 | logf("myIDDraw1::CreateClipper"); 73 | *b = new myIDDrawClipper(); 74 | return DD_OK; 75 | } 76 | 77 | 78 | HRESULT __stdcall myIDDraw1::CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d) 79 | { 80 | *c = new myIDDrawPalette(a,b); 81 | logf("myIDDraw1::CreatePalette(%d,%08x,%08x,%08x)",a,b,c,d); 82 | return NOERROR; 83 | } 84 | 85 | 86 | HRESULT __stdcall myIDDraw1::CreateSurface(LPDDSURFACEDESC a, LPDIRECTDRAWSURFACE FAR* b, IUnknown FAR* c) 87 | { 88 | logf("myIDDraw1::CreateSurface([%d,0x%x,%d,%d,%d,%d,%d], %08x, %08x)", a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, a->ddsCaps, b, c); 89 | *b = new myIDDrawSurface1(a); 90 | 91 | return NOERROR; 92 | } 93 | 94 | 95 | HRESULT __stdcall myIDDraw1::DuplicateSurface(LPDIRECTDRAWSURFACE a, LPDIRECTDRAWSURFACE FAR* b) 96 | { 97 | logf("myIDDraw1::DuplicateSurface"); 98 | return DDERR_UNSUPPORTED; 99 | } 100 | 101 | 102 | HRESULT __stdcall myIDDraw1::EnumDisplayModes(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMMODESCALLBACK d) 103 | { 104 | logf("myIDDraw1::EnumDisplayModes"); 105 | 106 | // Send a bunch of modes, most modern systems should support all of these 107 | 108 | static int resolutions[22][2] = { 109 | {640, 480}, 110 | {720, 480}, 111 | {720, 576}, 112 | {800, 600}, 113 | {1024, 768}, 114 | {1152, 864}, 115 | {1176, 664}, 116 | {1280, 720}, 117 | {1280, 768}, 118 | {1280, 800}, 119 | {1280, 960}, 120 | {1280, 1024}, 121 | {1360, 768}, 122 | {1366, 768}, 123 | {1600, 900}, 124 | {1600, 1024}, 125 | {1600, 1200}, 126 | {1600, 1050}, 127 | {1768, 992}, 128 | {1920, 1080}, 129 | {1920, 1200}, 130 | {NULL, NULL} 131 | }; 132 | 133 | static int pixelformats[4][5] = { 134 | { 8, DDPF_RGB | DDPF_PALETTEINDEXED8, 0x00000000, 0x00000000, 0x00000000 }, 135 | { 16, DDPF_RGB, 0x0000f800, 0x000007e0, 0x0000001f }, 136 | { 32, DDPF_RGB, 0x00ff0000, 0x0000ff00, 0x000000ff }, 137 | {NULL, NULL, NULL, NULL, NULL } 138 | }; 139 | 140 | for (int i = 0; ; i++) 141 | { 142 | if (resolutions[i][0] == NULL) break; 143 | 144 | for (int j = 0; ; j++) 145 | { 146 | if (pixelformats[j][0] == NULL) break; 147 | 148 | DDSURFACEDESC temp; 149 | memset(&temp, 0, sizeof(temp)); 150 | temp.dwSize = sizeof(temp); 151 | temp.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE; 152 | temp.dwWidth = resolutions[i][0]; 153 | temp.dwHeight = resolutions[i][1]; 154 | temp.lPitch = temp.dwWidth * pixelformats[j][0] / 8; 155 | temp.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); 156 | temp.ddpfPixelFormat.dwFlags = pixelformats[j][1]; 157 | temp.ddpfPixelFormat.dwRGBBitCount = pixelformats[j][0]; 158 | temp.ddpfPixelFormat.dwRBitMask = pixelformats[j][2]; 159 | temp.ddpfPixelFormat.dwGBitMask = pixelformats[j][3]; 160 | temp.ddpfPixelFormat.dwBBitMask = pixelformats[j][4]; 161 | (*d)(&temp, c); 162 | } 163 | } 164 | 165 | return DD_OK; 166 | } 167 | 168 | 169 | HRESULT __stdcall myIDDraw1::EnumSurfaces(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMSURFACESCALLBACK d) 170 | { 171 | logf("myIDDraw1::EnumSurfaces"); 172 | return DDERR_UNSUPPORTED; 173 | } 174 | 175 | 176 | HRESULT __stdcall myIDDraw1::FlipToGDISurface(void) 177 | { 178 | logf("myIDDraw1::FlipToGDISurface"); 179 | gGDI = 1; 180 | // WC4 *most of the time* pumps FlipToGDISurface when 181 | // the GDI surface is updated.. but not always. 182 | updatescreen(); 183 | return DD_OK; 184 | } 185 | 186 | 187 | HRESULT __stdcall myIDDraw1::GetCaps(LPDDCAPS a, LPDDCAPS b) 188 | { 189 | logf("myIDDraw1::GetCaps(%08x, %08x)", a, b); 190 | 191 | LPDDCAPS p; 192 | 193 | if (a) 194 | { 195 | p = a; 196 | } 197 | else 198 | { 199 | p = b; 200 | } 201 | 202 | int size = p->dwSize; 203 | memset(p, 0, size); 204 | p->dwSize = size; 205 | 206 | // results from ddwrapper: 207 | //[ +0ms] (006a8160) surface caps: 85d27fc1 a06ab270 210 3aad54e0 0 0 0 fe548000 fddf5000 0 0 0 0 0 304672fc 21fc8 208 | //[ +16ms] (006a8160) HEL caps: f4c08241 1 200 3fce3 0 347 0 0 0 0 0 0 0 0 421350 21fc8 209 | 210 | if (a) 211 | { 212 | a->dwCaps = 0x85d27fc1; 213 | a->dwCaps2 = 0xa06ab270; 214 | a->dwCKeyCaps = 0x210; 215 | a->dwFXCaps = 0x3aad54e0; 216 | a->dwFXAlphaCaps = 0; 217 | a->dwPalCaps = 0; 218 | a->dwSVCaps = 0; 219 | a->dwVidMemTotal = 0xfe548000; 220 | a->dwVidMemFree = 0xfddf5000; 221 | a->dwAlignBoundarySrc = 0; 222 | a->dwAlignSizeSrc = 0; 223 | a->dwAlignBoundaryDest = 0; 224 | a->dwAlignSizeDest = 0; 225 | a->dwAlignStrideAlign = 0x304672fc; 226 | a->ddsCaps.dwCaps = 0x21fc8; 227 | } 228 | if (b) 229 | { 230 | b->dwCaps = 0xf4c08241; 231 | b->dwCaps2 = 1; 232 | b->dwCKeyCaps = 0x200; 233 | b->dwFXCaps = 0x3fce3; 234 | b->dwFXAlphaCaps = 0; 235 | b->dwPalCaps = 347; 236 | b->dwSVCaps = 0; 237 | b->dwVidMemTotal = 0; 238 | b->dwVidMemFree = 0; 239 | b->dwAlignBoundarySrc = 0; 240 | b->dwAlignSizeSrc = 0; 241 | b->dwAlignBoundaryDest = 0; 242 | b->dwAlignSizeDest = 0; 243 | b->dwAlignStrideAlign = 0x421350; 244 | b->ddsCaps.dwCaps = 0x21fc8; 245 | } 246 | 247 | return DD_OK; 248 | } 249 | 250 | 251 | HRESULT __stdcall myIDDraw1::GetDisplayMode(LPDDSURFACEDESC a) 252 | { 253 | logf("myIDDraw1::GetDisplayMode"); 254 | return DDERR_UNSUPPORTED; 255 | } 256 | 257 | 258 | HRESULT __stdcall myIDDraw1::GetFourCCCodes(LPDWORD a, LPDWORD b) 259 | { 260 | logf("myIDDraw1::GetFourCCCodes"); 261 | return DDERR_UNSUPPORTED; 262 | } 263 | 264 | 265 | HRESULT __stdcall myIDDraw1::GetGDISurface(LPDIRECTDRAWSURFACE FAR * a) 266 | { 267 | logf("myIDDraw1::GetGDISurface"); 268 | return DDERR_UNSUPPORTED; 269 | } 270 | 271 | 272 | HRESULT __stdcall myIDDraw1::GetMonitorFrequency(LPDWORD a) 273 | { 274 | logf("myIDDraw1::GetMonitorFrequency"); 275 | return DDERR_UNSUPPORTED; 276 | } 277 | 278 | 279 | HRESULT __stdcall myIDDraw1::GetScanLine(LPDWORD a) 280 | { 281 | logf("myIDDraw1::GetScanLine"); 282 | return DDERR_UNSUPPORTED; 283 | } 284 | 285 | 286 | HRESULT __stdcall myIDDraw1::GetVerticalBlankStatus(LPBOOL a) 287 | { 288 | logf("myIDDraw1::GetVerticalBlankStatus"); 289 | return DDERR_UNSUPPORTED; 290 | } 291 | 292 | 293 | HRESULT __stdcall myIDDraw1::Initialize(GUID FAR* a) 294 | { 295 | logf("myIDDraw1::Initialize"); 296 | return DDERR_UNSUPPORTED; 297 | } 298 | 299 | 300 | HRESULT __stdcall myIDDraw1::RestoreDisplayMode(void) 301 | { 302 | logf("myIDDraw1::RestoreDisplayMode"); 303 | return NOERROR; 304 | } 305 | 306 | 307 | HRESULT __stdcall myIDDraw1::SetCooperativeLevel(HWND a, DWORD b) 308 | { 309 | logf("myIDDraw1::SetCooperativeLevel(%08x, %d)", a, b); 310 | 311 | gHwnd = a; 312 | 313 | return NOERROR; 314 | } 315 | 316 | 317 | HRESULT __stdcall myIDDraw1::SetDisplayMode(DWORD a, DWORD b, DWORD c) 318 | { 319 | logf("myIDDraw1::SetDisplayMode(%d, %d, %d)",a,b,c); 320 | 321 | gScreenWidth = a; 322 | gScreenHeight = b; 323 | gScreenBits = c; 324 | 325 | // reset to "non-gdi mode" by default 326 | gGDI = 0; 327 | 328 | return NOERROR; 329 | } 330 | 331 | 332 | 333 | HRESULT __stdcall myIDDraw1::WaitForVerticalBlank(DWORD a, HANDLE b) 334 | { 335 | logf("myIDDraw1::WaitForVerticalBlank"); 336 | 337 | updatescreen(); 338 | 339 | return NOERROR; 340 | } 341 | 342 | 343 | -------------------------------------------------------------------------------- /hack/myIDDraw2.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | myIDDraw2::myIDDraw2() 6 | { 7 | logf("myIDDraw2 Constructor"); 8 | } 9 | 10 | 11 | myIDDraw2::~myIDDraw2(void) 12 | { 13 | logf("myIDDraw2 Destructor"); 14 | } 15 | 16 | 17 | HRESULT __stdcall myIDDraw2::QueryInterface (REFIID a, LPVOID FAR * b) 18 | { 19 | char *iid = "?"; 20 | if (a == IID_IDirectDraw) iid = "IID_IDirectDraw"; 21 | if (a == IID_IDirectDraw2) iid = "IID_IDirectDraw2"; 22 | // if (a == IID_IDirectDraw4) iid = "IID_IDirectDraw4"; 23 | if (a == IID_IDirectDraw7) iid = "IID_IDirectDraw7"; 24 | 25 | logf("myIDDraw2::QueryInterface(%s,%08x)",iid,b); 26 | 27 | if (a == IID_IDirectDraw2) 28 | { 29 | *b = this; 30 | return NOERROR; 31 | } 32 | 33 | if (a == IID_IDirectDraw) 34 | { 35 | *b = new myIDDraw1(); 36 | return NOERROR; 37 | } 38 | 39 | if (a == IID_IDirectDraw7) 40 | { 41 | *b = new myIDDraw7(); 42 | return NOERROR; 43 | } 44 | return DDERR_UNSUPPORTED; 45 | } 46 | 47 | 48 | ULONG __stdcall myIDDraw2::AddRef(void) 49 | { 50 | logf("myIDDraw2::AddRef"); 51 | return 1; 52 | } 53 | 54 | 55 | ULONG __stdcall myIDDraw2::Release(void) 56 | { 57 | logf("myIDDraw2::Release"); 58 | delete this; 59 | 60 | return 0; 61 | } 62 | 63 | 64 | HRESULT __stdcall myIDDraw2::Compact(void) 65 | { 66 | logf("myIDDraw2::Compact"); 67 | return DDERR_UNSUPPORTED; 68 | } 69 | 70 | 71 | HRESULT __stdcall myIDDraw2::CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c) 72 | { 73 | logf("myIDDraw2::CreateClipper"); 74 | return DDERR_UNSUPPORTED; 75 | } 76 | 77 | 78 | HRESULT __stdcall myIDDraw2::CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d) 79 | { 80 | *c = new myIDDrawPalette(a, b); 81 | logf("myIDDraw2::CreatePalette(%d,%08x,%08x,%08x)",a,b,c,d); 82 | return NOERROR; 83 | } 84 | 85 | 86 | HRESULT __stdcall myIDDraw2::CreateSurface(LPDDSURFACEDESC a, LPDIRECTDRAWSURFACE FAR* b, IUnknown FAR* c) 87 | { 88 | logf("myIDDraw2::CreateSurface([%d,0x%x,%d,%d,%d,%d,%d], %08x, %08x)", a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, a->ddsCaps, b, c); 89 | 90 | *b = new myIDDrawSurface1(a); 91 | 92 | return NOERROR; 93 | } 94 | 95 | 96 | HRESULT __stdcall myIDDraw2::DuplicateSurface(LPDIRECTDRAWSURFACE a, LPDIRECTDRAWSURFACE FAR* b) 97 | { 98 | logf("myIDDraw2::DuplicateSurface"); 99 | return DDERR_UNSUPPORTED; 100 | } 101 | 102 | 103 | HRESULT __stdcall myIDDraw2::EnumDisplayModes(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMMODESCALLBACK d) 104 | { 105 | logf("myIDDraw2::EnumDisplayModes"); 106 | 107 | // Send a bunch of modes, most modern systems should support all of these 108 | 109 | static int resolutions[22][2] = { 110 | {640, 480}, 111 | {720, 480}, 112 | {720, 576}, 113 | {800, 600}, 114 | {1024, 768}, 115 | {1152, 864}, 116 | {1176, 664}, 117 | {1280, 720}, 118 | {1280, 768}, 119 | {1280, 800}, 120 | {1280, 960}, 121 | {1280, 1024}, 122 | {1360, 768}, 123 | {1366, 768}, 124 | {1600, 900}, 125 | {1600, 1024}, 126 | {1600, 1200}, 127 | {1600, 1050}, 128 | {1768, 992}, 129 | {1920, 1080}, 130 | {1920, 1200}, 131 | {NULL, NULL} 132 | }; 133 | 134 | static int pixelformats[4][5] = { 135 | { 8, DDPF_RGB | DDPF_PALETTEINDEXED8, 0x00000000, 0x00000000, 0x00000000 }, 136 | { 16, DDPF_RGB, 0x0000f800, 0x000007e0, 0x0000001f }, 137 | { 32, DDPF_RGB, 0x00ff0000, 0x0000ff00, 0x000000ff }, 138 | {NULL, NULL, NULL, NULL, NULL } 139 | }; 140 | 141 | for (int i = 0; ; i++) 142 | { 143 | if (resolutions[i][0] == NULL) break; 144 | 145 | for (int j = 0; ; j++) 146 | { 147 | if (pixelformats[j][0] == NULL) break; 148 | 149 | DDSURFACEDESC temp; 150 | memset(&temp, 0, sizeof(temp)); 151 | temp.dwSize = sizeof(temp); 152 | temp.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE; 153 | temp.dwWidth = resolutions[i][0]; 154 | temp.dwHeight = resolutions[i][1]; 155 | temp.lPitch = temp.dwWidth * pixelformats[j][0] / 8; 156 | temp.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); 157 | temp.ddpfPixelFormat.dwFlags = pixelformats[j][1]; 158 | temp.ddpfPixelFormat.dwRGBBitCount = pixelformats[j][0]; 159 | temp.ddpfPixelFormat.dwRBitMask = pixelformats[j][2]; 160 | temp.ddpfPixelFormat.dwGBitMask = pixelformats[j][3]; 161 | temp.ddpfPixelFormat.dwBBitMask = pixelformats[j][4]; 162 | (*d)(&temp, c); 163 | } 164 | } 165 | 166 | return DD_OK; 167 | } 168 | 169 | 170 | HRESULT __stdcall myIDDraw2::EnumSurfaces(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMSURFACESCALLBACK d) 171 | { 172 | logf("myIDDraw2::EnumSurfaces"); 173 | return DDERR_UNSUPPORTED; 174 | } 175 | 176 | 177 | HRESULT __stdcall myIDDraw2::FlipToGDISurface(void) 178 | { 179 | logf("myIDDraw2::FlipToGDISurface"); 180 | return DD_OK; 181 | } 182 | 183 | 184 | HRESULT __stdcall myIDDraw2::GetCaps(LPDDCAPS a, LPDDCAPS b) 185 | { 186 | logf("myIDDraw2::GetCaps"); 187 | return DDERR_UNSUPPORTED; 188 | } 189 | 190 | 191 | HRESULT __stdcall myIDDraw2::GetDisplayMode(LPDDSURFACEDESC a) 192 | { 193 | logf("myIDDraw2::GetDisplayMode"); 194 | 195 | static int pixelformats[4][5] = { 196 | { 8, DDPF_RGB | DDPF_PALETTEINDEXED8, 0x00000000, 0x00000000, 0x00000000 }, 197 | { 16, DDPF_RGB, 0x0000f800, 0x000007e0, 0x0000001f }, 198 | { 32, DDPF_RGB, 0x00ff0000, 0x0000ff00, 0x000000ff }, 199 | {NULL, NULL, NULL, NULL, NULL } 200 | }; 201 | 202 | int j = (gScreenBits == 8) ? 0 : (gScreenBits == 16) ? 1 : (gScreenBits == 32) ? 2 : 3; 203 | 204 | memset(a, 0, sizeof(DDSURFACEDESC)); 205 | a->dwSize = sizeof(DDSURFACEDESC); 206 | a->dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE; 207 | a->dwWidth = gScreenWidth; 208 | a->dwHeight = gScreenHeight; 209 | a->lPitch = gScreenWidth * gScreenBits / 8; 210 | a->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); 211 | a->ddpfPixelFormat.dwFlags = pixelformats[j][1]; 212 | a->ddpfPixelFormat.dwRGBBitCount = pixelformats[j][0]; 213 | a->ddpfPixelFormat.dwRBitMask = pixelformats[j][2]; 214 | a->ddpfPixelFormat.dwGBitMask = pixelformats[j][3]; 215 | a->ddpfPixelFormat.dwBBitMask = pixelformats[j][4]; 216 | 217 | return DD_OK; 218 | } 219 | 220 | 221 | HRESULT __stdcall myIDDraw2::GetFourCCCodes(LPDWORD a, LPDWORD b) 222 | { 223 | logf("myIDDraw2::GetFourCCCodes"); 224 | return DDERR_UNSUPPORTED; 225 | } 226 | 227 | 228 | HRESULT __stdcall myIDDraw2::GetGDISurface(LPDIRECTDRAWSURFACE FAR * a) 229 | { 230 | logf("myIDDraw2::GetGDISurface"); 231 | return DDERR_UNSUPPORTED; 232 | } 233 | 234 | 235 | HRESULT __stdcall myIDDraw2::GetMonitorFrequency(LPDWORD a) 236 | { 237 | logf("myIDDraw2::GetMonitorFrequency"); 238 | return DDERR_UNSUPPORTED; 239 | } 240 | 241 | 242 | HRESULT __stdcall myIDDraw2::GetScanLine(LPDWORD a) 243 | { 244 | logf("myIDDraw2::GetScanLine"); 245 | return DDERR_UNSUPPORTED; 246 | } 247 | 248 | 249 | HRESULT __stdcall myIDDraw2::GetVerticalBlankStatus(LPBOOL a) 250 | { 251 | logf("myIDDraw2::GetVerticalBlankStatus"); 252 | return DDERR_UNSUPPORTED; 253 | } 254 | 255 | 256 | HRESULT __stdcall myIDDraw2::Initialize(GUID FAR* a) 257 | { 258 | logf("myIDDraw2::Initialize"); 259 | return DDERR_UNSUPPORTED; 260 | } 261 | 262 | 263 | HRESULT __stdcall myIDDraw2::RestoreDisplayMode(void) 264 | { 265 | logf("myIDDraw2::RestoreDisplayMode"); 266 | return NOERROR; 267 | } 268 | 269 | 270 | HRESULT __stdcall myIDDraw2::SetCooperativeLevel(HWND a, DWORD b) 271 | { 272 | logf("myIDDraw2::SetCooperativeLevel(%08x, %d)", a, b); 273 | 274 | gHwnd = a; 275 | 276 | return NOERROR; 277 | } 278 | 279 | 280 | HRESULT __stdcall myIDDraw2::SetDisplayMode(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e) 281 | { 282 | logf("myIDDraw2::SetDisplayMode(%d, %d, %d, %d, %d)",a,b,c,d,e); 283 | 284 | gScreenWidth = a; 285 | gScreenHeight = b; 286 | gScreenBits = c; 287 | gGDI = 0; 288 | 289 | return NOERROR; 290 | } 291 | 292 | 293 | HRESULT __stdcall myIDDraw2::WaitForVerticalBlank(DWORD a, HANDLE b) 294 | { 295 | logf("myIDDraw2::WaitForVerticalBlank(%d,%d)",a,b); 296 | 297 | updatescreen(); 298 | 299 | return NOERROR; 300 | } 301 | 302 | 303 | HRESULT __stdcall myIDDraw2::GetAvailableVidMem(LPDDSCAPS a, LPDWORD b, LPDWORD c) 304 | { 305 | logf("myIDDraw2::GetAvailableVidMem"); 306 | return DDERR_UNSUPPORTED; 307 | } 308 | 309 | 310 | 311 | -------------------------------------------------------------------------------- /hack/myIDDraw7.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | HINSTANCE gl_hOriginalDll = 0; 5 | 6 | void LoadOriginalDll(void) 7 | { 8 | logf(0, "LoadOriginalDll."); 9 | 10 | char buffer[MAX_PATH]; 11 | 12 | // Getting path to system dir and to d3d9.dll 13 | ::GetSystemDirectory(buffer,MAX_PATH); 14 | 15 | // Append dll name 16 | strcat(buffer,"\\ddraw.dll"); 17 | 18 | if (!gl_hOriginalDll) gl_hOriginalDll = ::LoadLibrary(buffer); 19 | 20 | // Debug 21 | if (!gl_hOriginalDll) 22 | { 23 | logf(0, "Original ddraw.dll not loaded"); 24 | ::ExitProcess(0); // exit the hard way 25 | } 26 | } 27 | 28 | myIDDraw7::myIDDraw7() 29 | { 30 | logf("myIDDraw7 Constructor"); 31 | } 32 | 33 | 34 | myIDDraw7::~myIDDraw7(void) 35 | { 36 | logf("myIDDraw7 Destructor"); 37 | } 38 | 39 | 40 | HRESULT __stdcall myIDDraw7::QueryInterface (REFIID a, LPVOID FAR * b) 41 | { 42 | char *iid = "?"; 43 | if (a == IID_IDirectDraw) iid = "IID_IDirectDraw"; 44 | if (a == IID_IDirectDraw2) iid = "IID_IDirectDraw2"; 45 | // if (a == IID_IDirectDraw4) iid = "IID_IDirectDraw4"; 46 | if (a == IID_IDirectDraw7) iid = "IID_IDirectDraw7"; 47 | 48 | logf("myIDDraw7::QueryInterface(%s,%08x)",iid,b); 49 | 50 | if (a == IID_IDirectDraw7) 51 | { 52 | *b = this; 53 | return NOERROR; 54 | } 55 | 56 | if (a == IID_IDirectDraw2) 57 | { 58 | *b = new myIDDraw2(); 59 | return NOERROR; 60 | } 61 | 62 | if (a == IID_IDirectDraw) 63 | { 64 | *b = new myIDDraw1(); 65 | return NOERROR; 66 | } 67 | return DDERR_UNSUPPORTED; 68 | } 69 | 70 | 71 | ULONG __stdcall myIDDraw7::AddRef(void) 72 | { 73 | logf("myIDDraw7::AddRef"); 74 | return 1; 75 | } 76 | 77 | 78 | ULONG __stdcall myIDDraw7::Release(void) 79 | { 80 | logf("myIDDraw7::Release"); 81 | delete this; 82 | 83 | return 0; 84 | } 85 | 86 | 87 | HRESULT __stdcall myIDDraw7::Compact(void) 88 | { 89 | logf("myIDDraw7::Compact"); 90 | return DDERR_UNSUPPORTED; 91 | } 92 | 93 | 94 | HRESULT __stdcall myIDDraw7::CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c) 95 | { 96 | logf("myIDDraw7::CreateClipper"); 97 | *b = new myIDDrawClipper(); 98 | return DD_OK; 99 | } 100 | 101 | 102 | HRESULT __stdcall myIDDraw7::CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d) 103 | { 104 | *c = new myIDDrawPalette(a, b); 105 | logf("myIDDraw7::CreatePalette(%d,%08x,%08x,%08x)",a,b,c,d); 106 | return DD_OK; 107 | } 108 | 109 | 110 | HRESULT __stdcall myIDDraw7::CreateSurface(LPDDSURFACEDESC2 a, LPDIRECTDRAWSURFACE7 FAR* b, IUnknown FAR* c) 111 | { 112 | logf("myIDDraw7::CreateSurface([%d,0x%x,%d,%d,%d,%d,%d], %08x, %08x)", a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, a->ddsCaps, b, c); 113 | 114 | *b = new myIDDrawSurface7(a); 115 | 116 | return DD_OK; 117 | } 118 | 119 | 120 | HRESULT __stdcall myIDDraw7::DuplicateSurface(LPDIRECTDRAWSURFACE7 a, LPDIRECTDRAWSURFACE7 FAR* b) 121 | { 122 | logf("myIDDraw7::DuplicateSurface"); 123 | return DDERR_UNSUPPORTED; 124 | } 125 | 126 | 127 | HRESULT __stdcall myIDDraw7::EnumDisplayModes(DWORD a, LPDDSURFACEDESC2 b, LPVOID c, LPDDENUMMODESCALLBACK2 d) 128 | { 129 | logf("myIDDraw7::EnumDisplayModes"); 130 | 131 | // Send a bunch of modes, most modern systems should support all of these 132 | 133 | static int resolutions[22][2] = { 134 | {640, 480}, 135 | {720, 480}, 136 | {720, 576}, 137 | {800, 600}, 138 | {1024, 768}, 139 | {1152, 864}, 140 | {1176, 664}, 141 | {1280, 720}, 142 | {1280, 768}, 143 | {1280, 800}, 144 | {1280, 960}, 145 | {1280, 1024}, 146 | {1360, 768}, 147 | {1366, 768}, 148 | {1600, 900}, 149 | {1600, 1024}, 150 | {1600, 1200}, 151 | {1600, 1050}, 152 | {1768, 992}, 153 | {1920, 1080}, 154 | {1920, 1200}, 155 | {NULL, NULL} 156 | }; 157 | 158 | static int pixelformats[4][5] = { 159 | { 8, DDPF_RGB | DDPF_PALETTEINDEXED8, 0x00000000, 0x00000000, 0x00000000 }, 160 | { 16, DDPF_RGB, 0x0000f800, 0x000007e0, 0x0000001f }, 161 | { 32, DDPF_RGB, 0x00ff0000, 0x0000ff00, 0x000000ff }, 162 | {NULL, NULL, NULL, NULL, NULL } 163 | }; 164 | 165 | for (int i = 0; ; i++) 166 | { 167 | if (resolutions[i][0] == NULL) break; 168 | 169 | for (int j = 0; ; j++) 170 | { 171 | if (pixelformats[j][0] == NULL) break; 172 | 173 | DDSURFACEDESC2 temp; 174 | memset(&temp, 0, sizeof(temp)); 175 | temp.dwSize = sizeof(temp); 176 | temp.dwFlags = DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_PITCH | DDSD_REFRESHRATE; 177 | temp.dwWidth = resolutions[i][0]; 178 | temp.dwHeight = resolutions[i][1]; 179 | temp.lPitch = temp.dwWidth * pixelformats[j][0] / 8; 180 | temp.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); 181 | temp.ddpfPixelFormat.dwFlags = pixelformats[j][1]; 182 | temp.ddpfPixelFormat.dwRGBBitCount = pixelformats[j][0]; 183 | temp.ddpfPixelFormat.dwRBitMask = pixelformats[j][2]; 184 | temp.ddpfPixelFormat.dwGBitMask = pixelformats[j][3]; 185 | temp.ddpfPixelFormat.dwBBitMask = pixelformats[j][4]; 186 | (*d)(&temp, c); 187 | } 188 | } 189 | 190 | return DD_OK; 191 | } 192 | 193 | 194 | HRESULT __stdcall myIDDraw7::EnumSurfaces(DWORD a, LPDDSURFACEDESC2 b, LPVOID c, LPDDENUMSURFACESCALLBACK7 d) 195 | { 196 | logf("myIDDraw7::EnumSurfaces"); 197 | return DDERR_UNSUPPORTED; 198 | } 199 | 200 | 201 | HRESULT __stdcall myIDDraw7::FlipToGDISurface(void) 202 | { 203 | logf("myIDDraw7::FlipToGDISurface"); 204 | return DDERR_UNSUPPORTED; 205 | } 206 | 207 | 208 | HRESULT __stdcall myIDDraw7::GetCaps(LPDDCAPS a, LPDDCAPS b) 209 | { 210 | logf("myIDDraw7::GetCaps"); 211 | return DDERR_UNSUPPORTED; 212 | } 213 | 214 | 215 | HRESULT __stdcall myIDDraw7::GetDisplayMode(LPDDSURFACEDESC2 a) 216 | { 217 | logf("myIDDraw7::GetDisplayMode"); 218 | return DDERR_UNSUPPORTED; 219 | } 220 | 221 | 222 | HRESULT __stdcall myIDDraw7::GetFourCCCodes(LPDWORD a, LPDWORD b) 223 | { 224 | logf("myIDDraw7::GetFourCCCodes"); 225 | return DDERR_UNSUPPORTED; 226 | } 227 | 228 | 229 | HRESULT __stdcall myIDDraw7::GetGDISurface(LPDIRECTDRAWSURFACE7 FAR * a) 230 | { 231 | logf("myIDDraw7::GetGDISurface"); 232 | return DDERR_UNSUPPORTED; 233 | } 234 | 235 | 236 | HRESULT __stdcall myIDDraw7::GetMonitorFrequency(LPDWORD a) 237 | { 238 | logf("myIDDraw7::GetMonitorFrequency"); 239 | return DDERR_UNSUPPORTED; 240 | } 241 | 242 | 243 | HRESULT __stdcall myIDDraw7::GetScanLine(LPDWORD a) 244 | { 245 | logf("myIDDraw7::GetScanLine"); 246 | return DDERR_UNSUPPORTED; 247 | } 248 | 249 | 250 | HRESULT __stdcall myIDDraw7::GetVerticalBlankStatus(LPBOOL a) 251 | { 252 | logf("myIDDraw7::GetVerticalBlankStatus"); 253 | return DDERR_UNSUPPORTED; 254 | } 255 | 256 | 257 | HRESULT __stdcall myIDDraw7::Initialize(GUID FAR* a) 258 | { 259 | logf("myIDDraw7::Initialize"); 260 | return DDERR_UNSUPPORTED; 261 | } 262 | 263 | 264 | HRESULT __stdcall myIDDraw7::RestoreDisplayMode(void) 265 | { 266 | logf("myIDDraw7::RestoreDisplayMode"); 267 | return NOERROR; 268 | } 269 | 270 | 271 | HRESULT __stdcall myIDDraw7::SetCooperativeLevel(HWND a, DWORD b) 272 | { 273 | logf("myIDDraw7::SetCooperativeLevel(%08x, %d)", a, b); 274 | 275 | gHwnd = a; 276 | 277 | return NOERROR; 278 | } 279 | 280 | 281 | HRESULT __stdcall myIDDraw7::SetDisplayMode(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e) 282 | { 283 | logf("myIDDraw7::SetDisplayMode(%d, %d, %d, %d, %d)",a,b,c,d,e); 284 | 285 | gScreenWidth = a; 286 | gScreenHeight = b; 287 | gScreenBits = c; 288 | gGDI = 0; 289 | 290 | return NOERROR; 291 | } 292 | 293 | 294 | HRESULT __stdcall myIDDraw7::WaitForVerticalBlank(DWORD a, HANDLE b) 295 | { 296 | logf("myIDDraw7::WaitForVerticalBlank(%d,%d)",a,b); 297 | 298 | updatescreen(); 299 | 300 | return NOERROR; 301 | } 302 | 303 | 304 | HRESULT __stdcall myIDDraw7::GetAvailableVidMem(LPDDSCAPS2 a, LPDWORD b, LPDWORD c) 305 | { 306 | logf("myIDDraw7::GetAvailableVidMem"); 307 | return DDERR_UNSUPPORTED; 308 | } 309 | 310 | 311 | HRESULT __stdcall myIDDraw7::GetSurfaceFromDC(HDC a, LPDIRECTDRAWSURFACE7 *b) 312 | { 313 | logf("myIDDraw7::GetSurfaceFromDC"); 314 | return DDERR_UNSUPPORTED; 315 | } 316 | 317 | 318 | HRESULT __stdcall myIDDraw7::RestoreAllSurfaces(void) 319 | { 320 | logf("myIDDraw7::RestoreAllSurfaces"); 321 | return DDERR_UNSUPPORTED; 322 | } 323 | 324 | 325 | HRESULT __stdcall myIDDraw7::TestCooperativeLevel(void) 326 | { 327 | logf("myIDDraw7::TestCooperativeLevel"); 328 | return DDERR_UNSUPPORTED; 329 | } 330 | 331 | 332 | HRESULT __stdcall myIDDraw7::GetDeviceIdentifier(LPDDDEVICEIDENTIFIER2 a, DWORD b) 333 | { 334 | logf("myIDDraw7::GetDeviceIdentifier"); 335 | return DDERR_UNSUPPORTED; 336 | } 337 | 338 | 339 | HRESULT __stdcall myIDDraw7::StartModeTest(LPSIZE a, DWORD b, DWORD c) 340 | { 341 | logf("myIDDraw7::StartModeTest"); 342 | return DDERR_UNSUPPORTED; 343 | } 344 | 345 | 346 | HRESULT __stdcall myIDDraw7::EvaluateMode(DWORD a, DWORD *b) 347 | { 348 | logf("myIDDraw7::EvaluateMode"); 349 | return DDERR_UNSUPPORTED; 350 | } 351 | -------------------------------------------------------------------------------- /hack/myIDDrawClipper.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | myIDDrawClipper::myIDDrawClipper(void) 6 | { 7 | } 8 | 9 | 10 | myIDDrawClipper::~myIDDrawClipper(void) 11 | { 12 | } 13 | 14 | 15 | HRESULT __stdcall myIDDrawClipper::QueryInterface (REFIID, LPVOID FAR * b) 16 | { 17 | logf("myIDDrawClipper::QueryInterface"); 18 | 19 | *b = NULL; 20 | 21 | return DDERR_UNSUPPORTED; 22 | } 23 | 24 | 25 | ULONG __stdcall myIDDrawClipper::AddRef(void) 26 | { 27 | logf("myIDDrawClipper::AddRef"); 28 | return 1; 29 | } 30 | 31 | 32 | ULONG __stdcall myIDDrawClipper::Release(void) 33 | { 34 | logf("myIDDrawClipper::Release"); 35 | delete this; 36 | 37 | return 0; 38 | } 39 | 40 | 41 | HRESULT __stdcall myIDDrawClipper::GetClipList(LPRECT a, LPRGNDATA b, LPDWORD c) 42 | { 43 | logf("myIDDrawClipper::GetClipList"); 44 | return DDERR_UNSUPPORTED; 45 | } 46 | 47 | 48 | HRESULT __stdcall myIDDrawClipper::GetHWnd(HWND FAR *a) 49 | { 50 | logf("myIDDrawClipper::GetHWnd"); 51 | a = &mHwnd; 52 | return DD_OK; 53 | } 54 | 55 | 56 | HRESULT __stdcall myIDDrawClipper::Initialize(LPDIRECTDRAW a, DWORD b) 57 | { 58 | logf("myIDDrawClipper::Initialize"); 59 | return DDERR_UNSUPPORTED; 60 | } 61 | 62 | 63 | HRESULT __stdcall myIDDrawClipper::IsClipListChanged(BOOL FAR *a) 64 | { 65 | logf("myIDDrawClipper::IsClipListChanged"); 66 | return DDERR_UNSUPPORTED; 67 | } 68 | 69 | 70 | HRESULT __stdcall myIDDrawClipper::SetClipList(LPRGNDATA a, DWORD b) 71 | { 72 | logf("myIDDrawClipper::SetClipList"); 73 | return DDERR_UNSUPPORTED; 74 | } 75 | 76 | 77 | HRESULT __stdcall myIDDrawClipper::SetHWnd(DWORD a, HWND b) 78 | { 79 | logf("myIDDrawClipper::SetHWnd"); 80 | mHwnd = b; 81 | return DD_OK; 82 | } 83 | -------------------------------------------------------------------------------- /hack/myIDDrawPalette.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | void logf(char *msg, ...); 5 | void updatescreen(); 6 | 7 | myIDDrawPalette::myIDDrawPalette(DWORD aFlags, LPPALETTEENTRY aPalette) 8 | { 9 | logf("myIDDrawPalette Constructor"); 10 | // Could check aFlags for DDCAPS_8BIT, but that's basically 11 | // the only sane mode.. right? 12 | memcpy(mPal, aPalette, sizeof(PALETTEENTRY) * 256); 13 | } 14 | 15 | 16 | myIDDrawPalette::~myIDDrawPalette(void) 17 | { 18 | logf("myIDDrawPalette Destructor"); 19 | } 20 | 21 | 22 | HRESULT __stdcall myIDDrawPalette::QueryInterface (REFIID, LPVOID FAR * b) 23 | { 24 | logf("myIDDrawPalette::QueryInterface"); 25 | 26 | *b = NULL; 27 | 28 | return DDERR_UNSUPPORTED; 29 | } 30 | 31 | 32 | ULONG __stdcall myIDDrawPalette::AddRef(void) 33 | { 34 | logf("myIDDrawPalette::AddRef"); 35 | return 1; 36 | } 37 | 38 | 39 | ULONG __stdcall myIDDrawPalette::Release(void) 40 | { 41 | logf("myIDDrawPalette::Release"); 42 | delete this; 43 | return 0; 44 | } 45 | 46 | 47 | 48 | HRESULT __stdcall myIDDrawPalette::GetCaps(LPDWORD a) 49 | { 50 | logf("myIDDrawPalette::GetCaps"); 51 | return DDERR_UNSUPPORTED; 52 | } 53 | 54 | 55 | 56 | HRESULT __stdcall myIDDrawPalette::GetEntries(DWORD a,DWORD b,DWORD c,LPPALETTEENTRY d) 57 | { 58 | logf("myIDDrawPalette::GetEntries"); 59 | 60 | if (d == NULL) 61 | return DDERR_INVALIDPARAMS; 62 | 63 | memcpy(d, &mPal[b], c * sizeof(*d)); 64 | return DD_OK; 65 | } 66 | 67 | 68 | 69 | HRESULT __stdcall myIDDrawPalette::Initialize(LPDIRECTDRAW a, DWORD b, LPPALETTEENTRY c) 70 | { 71 | logf("myIDDrawPalette::Initialize"); 72 | 73 | return DDERR_UNSUPPORTED; 74 | } 75 | 76 | 77 | 78 | HRESULT __stdcall myIDDrawPalette::SetEntries(DWORD aFlags,DWORD aStartEntry,DWORD aCount,LPPALETTEENTRY aPalEntries) 79 | { 80 | logf("myIDDrawPalette::SetEntries(%d,%d,%d,%08x)", aFlags, aStartEntry, aCount, aPalEntries); 81 | memcpy(mPal + aStartEntry, aPalEntries, aCount * sizeof(PALETTEENTRY)); 82 | for (int i = 0; i < 256; i++) 83 | mPal[i].peFlags = 0; 84 | color_map.empty(); 85 | updatescreen(); 86 | return NOERROR; 87 | } 88 | 89 | 90 | 91 | -------------------------------------------------------------------------------- /hack/myIDDrawSurface1.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | #include 4 | 5 | std::hash_map open_dcs; 6 | //std::unordered_set full_surfaces; 7 | std::hash_map color_map; 8 | 9 | unsigned char color2palette(unsigned int c) 10 | { 11 | if (!gPrimarySurface || !gPrimarySurface->getCurrentPalette()) 12 | { 13 | return 0; 14 | } 15 | 16 | if (color_map.find(c) != color_map.end()) 17 | return color_map[c]; 18 | 19 | // calculate closest palette entry for the color 20 | 21 | const unsigned int *palette = (unsigned int *) gPrimarySurface->getCurrentPalette()->mPal; 22 | double d = 999999999999.0; 23 | unsigned char index = 0; 24 | 25 | for (unsigned int i = 0; i < 256; i++) 26 | { 27 | double r = (((c & 0x00FF0000) >> 16) - ((palette[i] & 0x00FF0000) >> 16)); 28 | double g = (((c & 0x0000FF00) >> 8) - ((palette[i] & 0x0000FF00) >> 8)); 29 | double b = ((c & 0x000000FF) - (palette[i] & 0x000000FF)); 30 | 31 | double dist = r * r + g * g + b * b; 32 | 33 | if (dist < d) 34 | { 35 | d = dist; 36 | index = (unsigned char) i; 37 | } 38 | // exact match! 39 | if (dist == 0) 40 | break; 41 | } 42 | 43 | color_map[c] = index; 44 | return index; 45 | } 46 | 47 | myIDDrawSurface1::myIDDrawSurface1(LPDDSURFACEDESC a) 48 | { 49 | bool is_main = false; 50 | mWidth = gScreenWidth; 51 | mHeight = gScreenHeight; 52 | mSurfaceDesc = *a; 53 | mCaps = a->ddsCaps; 54 | 55 | if (a->dwFlags & DDSD_WIDTH) mWidth = a->dwWidth; 56 | if (a->dwFlags & DDSD_HEIGHT) mHeight = a->dwHeight; 57 | // we don't need no stinking extra pitch bytes.. 58 | 59 | if (a->dwFlags & DDSD_PITCH) mPitch = a->lPitch; 60 | if (a->dwFlags & DDSD_CAPS) 61 | { 62 | if (mCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) 63 | { 64 | gPrimarySurface = this; 65 | init_gl(); 66 | is_main = true; 67 | } 68 | } 69 | 70 | //if (mWidth == gScreenWidth && mHeight == gScreenHeight) 71 | // full_surfaces.emplace(this); 72 | 73 | mPitch = mWidth * gScreenBits / 8; 74 | 75 | mSurfaceDesc.dwWidth = mWidth; 76 | mSurfaceDesc.dwHeight = mHeight; 77 | mSurfaceDesc.lPitch = mPitch; 78 | mSurfaceDesc.dwFlags |= DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH; 79 | 80 | // Let's pad the framebuffer by a couple of megs, in case 81 | // the app writes outside bounds.. 82 | // (we have enough trouble being stable as it is) 83 | mRealSurfaceData = new unsigned char[mHeight * mPitch + 2 * 1024 * 1024]; 84 | mSurfaceData = mRealSurfaceData + 1024 * 1024 * 1; 85 | 86 | mRealGdiBuffer = new unsigned int[mHeight * mWidth + 1024 * 16]; 87 | mGdiBuffer = mRealGdiBuffer + 1024 * 8; 88 | 89 | memset(mSurfaceData, 0, mHeight * mPitch); 90 | memset(mGdiBuffer, 0, mHeight * mWidth * 4); 91 | 92 | mCurrentPalette = NULL; 93 | mIsTextBuffer = false; 94 | 95 | logf("myIDDrawSurface1 Constructor: %08x%s", this, is_main ? " primary" : ""); 96 | } 97 | 98 | 99 | myIDDrawSurface1::~myIDDrawSurface1(void) 100 | { 101 | logf("myIDDrawSurface1 Destructor"); 102 | 103 | if (this == gPrimarySurface) 104 | { 105 | gPrimarySurface = NULL; 106 | delete gBackBuffer; 107 | gBackBuffer = NULL; 108 | } 109 | if (this == gBackBuffer) 110 | { 111 | gBackBuffer = NULL; 112 | } 113 | 114 | delete[] mRealSurfaceData; 115 | delete[] mRealGdiBuffer; 116 | 117 | /*if (full_surfaces.find(this) != full_surfaces.end()) 118 | { 119 | full_surfaces.erase(this); 120 | }*/ 121 | } 122 | 123 | 124 | HRESULT __stdcall myIDDrawSurface1::QueryInterface (REFIID, LPVOID FAR * b) 125 | { 126 | logf("myIDDrawSurface1::QueryInterface"); 127 | 128 | *b = NULL; 129 | 130 | return DDERR_UNSUPPORTED; 131 | } 132 | 133 | 134 | ULONG __stdcall myIDDrawSurface1::AddRef(void) 135 | { 136 | logf("myIDDrawSurface1::AddRef"); 137 | return 1; 138 | } 139 | 140 | 141 | ULONG __stdcall myIDDrawSurface1::Release(void) 142 | { 143 | logf("myIDDrawSurface1::Release"); 144 | delete this; 145 | 146 | return 0; 147 | } 148 | 149 | 150 | 151 | HRESULT __stdcall myIDDrawSurface1::AddAttachedSurface(LPDIRECTDRAWSURFACE a) 152 | { 153 | logf("myIDDrawSurface1::AddAttachedSurface"); 154 | return DDERR_UNSUPPORTED; 155 | } 156 | 157 | 158 | 159 | HRESULT __stdcall myIDDrawSurface1::AddOverlayDirtyRect(LPRECT a) 160 | { 161 | logf("myIDDrawSurface1::AddOverlayDirtyRect"); 162 | return DDERR_UNSUPPORTED; 163 | } 164 | 165 | 166 | 167 | HRESULT __stdcall myIDDrawSurface1::Blt(LPRECT a,LPDIRECTDRAWSURFACE b, LPRECT c,DWORD d, LPDDBLTFX e) 168 | { 169 | if (a && c) 170 | logf("myIDDrawSurface1::Blt([%d,%d,%d,%d],%08x,[%d,%d,%d,%d],%08x,%08x)", 171 | a->top,a->left,a->bottom,a->right, 172 | b, 173 | c->top,c->left,c->bottom,c->right, 174 | d, 175 | e ? e->dwDDFX : 0); 176 | else 177 | if (a) 178 | logf("myIDDrawSurface1::Blt([%d,%d,%d,%d],%08x,[null],%08x,%08x)", 179 | a->top,a->left,a->bottom,a->right, 180 | b, 181 | d, 182 | e ? e->dwDDFX : 0); 183 | else 184 | if (c) 185 | logf("myIDDrawSurface1::Blt([null],%08x,[%d,%d,%d,%d],%08x,%08x)", 186 | b, 187 | c->top,c->left,c->bottom,c->right, 188 | d, 189 | e ? e->dwDDFX : 0); 190 | else 191 | logf("myIDDrawSurface1::Blt([null],%08x,[null],%08x,%08x)", 192 | b, 193 | d, 194 | e ? e->dwDDFX : 0); 195 | std::hash_map colors; 196 | int i, j; 197 | myIDDrawSurface1 *src = NULL; 198 | if (b) src = (myIDDrawSurface1*)b; 199 | if (src && src->isTextBuffer()) this->setTextBuffer(); 200 | int usingColorKey = d & DDBLT_KEYDEST || d & DDBLT_KEYSRC || d & DDBLT_ALPHADEST; 201 | unsigned char colorKey = 0; 202 | if (usingColorKey) 203 | colorKey = (unsigned char) (d & DDBLT_KEYDEST ? mDestColorKey.dwColorSpaceLowValue : src->mSrcColorKey.dwColorSpaceLowValue); 204 | 205 | if (b == NULL) 206 | { 207 | if (a) 208 | for (i = a->bottom; i < a->top; i++) 209 | for (j = a->left; j < a->right; j++) 210 | mSurfaceData[i*mPitch+j] = (d & DDBLT_COLORFILL ? (unsigned char) e->dwFillColor : 0); 211 | else 212 | memset(mSurfaceData, (d & DDBLT_COLORFILL ? e->dwFillColor : 0), mHeight * mPitch); 213 | } 214 | else 215 | { 216 | // Othewise we're scaling a 320x240 to 640x480.. or we're scaling the 217 | // video on screen. 218 | 219 | if (a && c && gWc3SmallVid) 220 | { 221 | for (i = c->top; i < c->bottom; i++) 222 | for (j = c->left; j < c->right; j++) 223 | mSurfaceData[(i + (480 - c->bottom)/2) * mPitch + j + 160] = src->mSurfaceData[i * src->mPitch + j]; 224 | } 225 | else 226 | { 227 | if (a && c) 228 | { 229 | for (i = 0; i < a->bottom - a->top; i++) 230 | for (j = 0; j < a->right - a->left; j++) 231 | if (!usingColorKey || src->mSurfaceData[(i + c->top) * src->mPitch + j + c->left] != colorKey) 232 | mSurfaceData[(i + a->top) * mPitch + j + a->left] = src->mSurfaceData[(i + c->top) * src->mPitch + j + c->left]; 233 | } 234 | else 235 | { 236 | for (i = 0; i < mHeight; i++) 237 | for (j = 0; j < mWidth; j++) 238 | if (!usingColorKey || src->mSurfaceData[i * src->mPitch + j] != colorKey) 239 | mSurfaceData[i * mPitch + j] = src->mSurfaceData[i * src->mPitch + j]; 240 | } 241 | } 242 | } 243 | 244 | return DD_OK; 245 | } 246 | 247 | 248 | 249 | HRESULT __stdcall myIDDrawSurface1::BltBatch(LPDDBLTBATCH a, DWORD b, DWORD c) 250 | { 251 | logf("myIDDrawSurface1::BltBatch"); 252 | return DDERR_UNSUPPORTED; 253 | } 254 | 255 | 256 | 257 | HRESULT __stdcall myIDDrawSurface1::BltFast(DWORD a,DWORD b,LPDIRECTDRAWSURFACE c, LPRECT d,DWORD e) 258 | { 259 | logf("myIDDrawSurface1::BltFast(%d,%d,%08x,[%d,%d,%d,%d],%08x)",a,b,c,d->top,d->left,d->bottom,d->right,e); 260 | myIDDrawSurface1 *src = (myIDDrawSurface1*)c; 261 | int usingColorKey = e & DDBLT_KEYDEST || e & DDBLT_KEYSRC || e & DDBLT_ALPHADEST; 262 | unsigned char colorKey = 0; 263 | if (usingColorKey) 264 | colorKey = (unsigned char) (e & DDBLT_KEYDEST ? mDestColorKey.dwColorSpaceLowValue : src->mSrcColorKey.dwColorSpaceLowValue); 265 | 266 | for (int i = 0; i < d->bottom - d->top; i++) 267 | for (int j = 0; j < d->right - d->left; j++) 268 | if (!usingColorKey || src->mSurfaceData[(i + d->top) * src->mPitch + j + d->left] != colorKey) 269 | mSurfaceData[(i + b) * mPitch + j + a] = src->mSurfaceData[(i + d->top) * src->mPitch + j + d->left]; 270 | 271 | return DD_OK; 272 | } 273 | 274 | 275 | 276 | HRESULT __stdcall myIDDrawSurface1::DeleteAttachedSurface(DWORD a,LPDIRECTDRAWSURFACE b) 277 | { 278 | logf("myIDDrawSurface1::DeleteAttachedSurface"); 279 | return DDERR_UNSUPPORTED; 280 | } 281 | 282 | 283 | 284 | HRESULT __stdcall myIDDrawSurface1::EnumAttachedSurfaces(LPVOID a,LPDDENUMSURFACESCALLBACK b) 285 | { 286 | logf("myIDDrawSurface1::EnumAttachedSurfaces"); 287 | return DDERR_UNSUPPORTED; 288 | } 289 | 290 | 291 | 292 | HRESULT __stdcall myIDDrawSurface1::EnumOverlayZOrders(DWORD a,LPVOID b,LPDDENUMSURFACESCALLBACK c) 293 | { 294 | logf("myIDDrawSurface1::EnumOverlayZOrders"); 295 | return DDERR_UNSUPPORTED; 296 | } 297 | 298 | 299 | 300 | HRESULT __stdcall myIDDrawSurface1::Flip(LPDIRECTDRAWSURFACE a, DWORD b) 301 | { 302 | logf("myIDDrawSurface1::Flip"); 303 | updatescreen(); 304 | return DD_OK; 305 | } 306 | 307 | 308 | 309 | HRESULT __stdcall myIDDrawSurface1::GetAttachedSurface(LPDDSCAPS a, LPDIRECTDRAWSURFACE FAR * b) 310 | { 311 | logf("myIDDrawSurface1::GetAttachedSurface([%d], %08x)", 312 | a->dwCaps, b); 313 | 314 | // wc3 and wc4 call this function to access the back buffer.. 315 | // hack: make a new surface which still uses the primary's 316 | // surface data. 317 | 318 | // Potential memory leak; should check and return gBackBuffer 319 | // if already exists... but the games I've checked don't call 320 | // this several times, so why bother. 321 | // And yes, I realize the checking code would take less space 322 | // than this comment that's complaining about it. 323 | // On the other hand, you wouldn't have so much fun reading 324 | // this if I just deleted it and wrote the check, now would you? 325 | 326 | DDSURFACEDESC newdesc = mSurfaceDesc; 327 | 328 | newdesc.ddsCaps.dwCaps |= a->dwCaps; 329 | newdesc.ddsCaps.dwCaps &= ~DDSCAPS_PRIMARYSURFACE; 330 | 331 | myIDDrawSurface1 * n = new myIDDrawSurface1(&newdesc); 332 | n->mSurfaceData = mSurfaceData; 333 | *b = n; 334 | gBackBuffer = n; 335 | 336 | return DD_OK; 337 | } 338 | 339 | 340 | 341 | HRESULT __stdcall myIDDrawSurface1::GetBltStatus(DWORD a) 342 | { 343 | logf("myIDDrawSurface1::GetBltStatus"); 344 | // we're always ready for bitblts 345 | return DD_OK; 346 | } 347 | 348 | 349 | 350 | HRESULT __stdcall myIDDrawSurface1::GetCaps(LPDDSCAPS a) 351 | { 352 | logf("myIDDrawSurface1::GetCaps"); 353 | *a = mCaps; 354 | return DD_OK; 355 | } 356 | 357 | 358 | 359 | HRESULT __stdcall myIDDrawSurface1::GetClipper(LPDIRECTDRAWCLIPPER FAR* a) 360 | { 361 | logf("myIDDrawSurface1::GetClipper"); 362 | a = (LPDIRECTDRAWCLIPPER *) mClipper; 363 | return DD_OK; 364 | } 365 | 366 | 367 | 368 | HRESULT __stdcall myIDDrawSurface1::GetColorKey(DWORD a, LPDDCOLORKEY b) 369 | { 370 | logf("myIDDrawSurface1::GetColorKey"); 371 | if (a & DDCKEY_DESTBLT) 372 | b = &mDestColorKey; 373 | else if (a & DDCKEY_SRCBLT) 374 | b = &mSrcColorKey; 375 | else 376 | return DDERR_UNSUPPORTED; 377 | return DD_OK; 378 | } 379 | 380 | 381 | 382 | HRESULT __stdcall myIDDrawSurface1::GetDC(HDC FAR *a) 383 | { 384 | logf("myIDDrawSurface1::GetDC(%08x)", this); 385 | *a = GetDC2(gHwnd); 386 | open_dcs[*a] = this; 387 | //if(full_surfaces.find(this) == full_surfaces.end()) clearGdi(); 388 | logf(" hdc: %08x", *a); 389 | return DD_OK; 390 | } 391 | 392 | 393 | 394 | HRESULT __stdcall myIDDrawSurface1::GetFlipStatus(DWORD a) 395 | { 396 | logf("myIDDrawSurface1::GetFlipStatus"); 397 | return DDERR_UNSUPPORTED; 398 | } 399 | 400 | 401 | 402 | HRESULT __stdcall myIDDrawSurface1::GetOverlayPosition(LPLONG a, LPLONG b) 403 | { 404 | logf("myIDDrawSurface1::GetOverlayPosition"); 405 | return DDERR_UNSUPPORTED; 406 | } 407 | 408 | 409 | 410 | HRESULT __stdcall myIDDrawSurface1::GetPalette(LPDIRECTDRAWPALETTE FAR*a) 411 | { 412 | logf("myIDDrawSurface1::GetPalette"); 413 | *a = mCurrentPalette; 414 | return DD_OK; 415 | } 416 | 417 | 418 | 419 | HRESULT __stdcall myIDDrawSurface1::GetPixelFormat(LPDDPIXELFORMAT a) 420 | { 421 | logf("myIDDrawSurface1::GetPixelFormat"); 422 | // Return codes based on what ddwrapper reported.. 423 | int bits = mPitch / mWidth; 424 | if (bits == 1) 425 | { 426 | a->dwSize = 0x20; 427 | a->dwFlags = 0x60; 428 | a->dwFourCC = 0; 429 | a->dwRGBBitCount = 0x8; 430 | a->dwRBitMask = 0; 431 | a->dwGBitMask = 0; 432 | a->dwBBitMask = 0; 433 | a->dwRGBAlphaBitMask = 0; 434 | } 435 | else 436 | if (bits == 2) 437 | { 438 | a->dwSize = 0x20; 439 | a->dwFlags = 0x40; 440 | a->dwFourCC = 0; 441 | a->dwRGBBitCount = 0x10; 442 | a->dwRBitMask = 0xf800; 443 | a->dwGBitMask = 0x07e0; 444 | a->dwBBitMask = 0x001f; 445 | a->dwRGBAlphaBitMask = 0; 446 | } 447 | else 448 | if (bits == 4) 449 | { 450 | a->dwSize = 0x20; 451 | a->dwFlags = 0x40; 452 | a->dwFourCC = 0; 453 | a->dwRGBBitCount = 24; 454 | a->dwRBitMask = 0xff0000; 455 | a->dwGBitMask = 0x00ff00; 456 | a->dwBBitMask = 0x0000ff; 457 | a->dwRGBAlphaBitMask = 0; 458 | } 459 | return DD_OK; 460 | } 461 | 462 | 463 | 464 | HRESULT __stdcall myIDDrawSurface1::GetSurfaceDesc(LPDDSURFACEDESC a) 465 | { 466 | logf("myIDDrawSurface1::GetSurfaceDesc([%d %d %d %d %d %d %d %d])", 467 | a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, 468 | a->lpSurface, a->ddsCaps.dwCaps); 469 | *a = mSurfaceDesc; 470 | int bits = mPitch / mWidth; 471 | if (bits == 1) 472 | { 473 | a->ddpfPixelFormat.dwSize = 0x20; 474 | a->ddpfPixelFormat.dwFlags = 0x60; 475 | a->ddpfPixelFormat.dwFourCC = 0; 476 | a->ddpfPixelFormat.dwRGBBitCount = 0x8; 477 | a->ddpfPixelFormat.dwRBitMask = 0; 478 | a->ddpfPixelFormat.dwGBitMask = 0; 479 | a->ddpfPixelFormat.dwBBitMask = 0; 480 | a->ddpfPixelFormat.dwRGBAlphaBitMask = 0; 481 | } 482 | else 483 | if (bits == 2) 484 | { 485 | a->ddpfPixelFormat.dwSize = 0x20; 486 | a->ddpfPixelFormat.dwFlags = 0x40; 487 | a->ddpfPixelFormat.dwFourCC = 0; 488 | a->ddpfPixelFormat.dwRGBBitCount = 0x10; 489 | a->ddpfPixelFormat.dwRBitMask = 0xf800; 490 | a->ddpfPixelFormat.dwGBitMask = 0x07e0; 491 | a->ddpfPixelFormat.dwBBitMask = 0x001f; 492 | a->ddpfPixelFormat.dwRGBAlphaBitMask = 0; 493 | } 494 | else 495 | if (bits == 4) 496 | { 497 | a->ddpfPixelFormat.dwSize = 0x20; 498 | a->ddpfPixelFormat.dwFlags = 0x40; 499 | a->ddpfPixelFormat.dwFourCC = 0; 500 | a->ddpfPixelFormat.dwRGBBitCount = 32; 501 | a->ddpfPixelFormat.dwRBitMask = 0xff0000; 502 | a->ddpfPixelFormat.dwGBitMask = 0x00ff00; 503 | a->ddpfPixelFormat.dwBBitMask = 0x0000ff; 504 | a->ddpfPixelFormat.dwRGBAlphaBitMask = 0; 505 | } 506 | logf("pixel format: %d bit, R%08x G%08x B%08x", a->ddpfPixelFormat.dwRGBBitCount, a->ddpfPixelFormat.dwRBitMask, a->ddpfPixelFormat.dwGBitMask, a->ddpfPixelFormat.dwBBitMask); 507 | return DD_OK;//DDERR_UNSUPPORTED; 508 | } 509 | 510 | 511 | 512 | HRESULT __stdcall myIDDrawSurface1::Initialize(LPDIRECTDRAW a, LPDDSURFACEDESC b) 513 | { 514 | logf("myIDDrawSurface1::Initialize"); 515 | return DDERR_UNSUPPORTED; 516 | } 517 | 518 | 519 | 520 | HRESULT __stdcall myIDDrawSurface1::IsLost() 521 | { 522 | logf("myIDDrawSurface1::IsLost"); 523 | // We're never lost.. 524 | return DD_OK; 525 | } 526 | 527 | 528 | 529 | HRESULT __stdcall myIDDrawSurface1::Lock(LPRECT a,LPDDSURFACEDESC b,DWORD aFlags,HANDLE d) 530 | { 531 | char *extra = ""; 532 | if (this == gPrimarySurface) 533 | extra = " primary"; 534 | if (this == gBackBuffer) 535 | extra = " backbuffer"; 536 | 537 | if (a) 538 | logf("myIDDrawSurface1::Lock([%d,%d,%d,%d],%08x,%d,%d)%s",a->top,a->left,a->bottom,a->right,b,aFlags,d,extra); 539 | else 540 | logf("myIDDrawSurface1::Lock([null],%08x,%d,%d)%s",b,aFlags,d,extra); 541 | 542 | gGDI = 0; 543 | 544 | *b = mSurfaceDesc; 545 | 546 | b->dwFlags |= DDSD_LPSURFACE | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH; 547 | b->lpSurface = mSurfaceData; 548 | 549 | b->dwWidth = mWidth; 550 | b->dwHeight = mHeight; 551 | b->lPitch = mPitch; 552 | 553 | return NOERROR; 554 | } 555 | 556 | 557 | 558 | HRESULT __stdcall myIDDrawSurface1::ReleaseDC(HDC a) 559 | { 560 | logf("myIDDrawSurface1::ReleaseDC"); 561 | DeleteDC(a); 562 | open_dcs.erase(a); 563 | 564 | const int bpp = mPitch / mWidth; 565 | // copy gdi drawing to actual surface data 566 | for (int i = 0; i < mWidth * mHeight; i++) 567 | { 568 | if (mGdiBuffer[i]) 569 | mSurfaceData[i * bpp] = color2palette(mGdiBuffer[i]); 570 | } 571 | clearGdi(); 572 | return DD_OK; 573 | } 574 | 575 | 576 | 577 | HRESULT __stdcall myIDDrawSurface1::Restore() 578 | { 579 | logf("myIDDrawSurface1::Restore"); 580 | // we can't lose surfaces, so.. 581 | return DD_OK; 582 | } 583 | 584 | 585 | 586 | HRESULT __stdcall myIDDrawSurface1::SetClipper(LPDIRECTDRAWCLIPPER a) 587 | { 588 | logf("myIDDrawSurface1::SetClipper"); 589 | mClipper = (myIDDrawClipper *) a; 590 | return DD_OK; 591 | } 592 | 593 | 594 | 595 | HRESULT __stdcall myIDDrawSurface1::SetColorKey(DWORD a, LPDDCOLORKEY b) 596 | { 597 | logf("myIDDrawSurface1::SetColorKey"); 598 | if (a & DDCKEY_DESTBLT) 599 | mDestColorKey = *b; 600 | else if (a & DDCKEY_SRCBLT) 601 | mSrcColorKey = *b; 602 | else 603 | return DDERR_UNSUPPORTED; 604 | return DD_OK; 605 | } 606 | 607 | 608 | 609 | HRESULT __stdcall myIDDrawSurface1::SetOverlayPosition(LONG a, LONG b) 610 | { 611 | logf("myIDDrawSurface1::SetOverlayPosition"); 612 | return DDERR_UNSUPPORTED; 613 | } 614 | 615 | 616 | 617 | HRESULT __stdcall myIDDrawSurface1::SetPalette(LPDIRECTDRAWPALETTE a) 618 | { 619 | logf("myIDDrawSurface1::SetPalette(%08x)",a); 620 | mCurrentPalette = (myIDDrawPalette *)a; 621 | return NOERROR; 622 | } 623 | 624 | HRESULT __stdcall myIDDrawSurface1::Unlock(LPVOID a) 625 | { 626 | logf("myIDDrawSurface1::Unlock(%08x)",a); 627 | 628 | // if primary has been updated, flush.. 629 | // otherwise wc2 misses some screens 630 | // (no retrace, flip, or even message pump) 631 | if (this == gPrimarySurface) 632 | updatescreen(); 633 | 634 | return NOERROR; 635 | } 636 | 637 | 638 | 639 | HRESULT __stdcall myIDDrawSurface1::UpdateOverlay(LPRECT a, LPDIRECTDRAWSURFACE b,LPRECT c,DWORD d, LPDDOVERLAYFX e) 640 | { 641 | logf("myIDDrawSurface1::UpdateOverlay"); 642 | return DDERR_UNSUPPORTED; 643 | } 644 | 645 | 646 | 647 | HRESULT __stdcall myIDDrawSurface1::UpdateOverlayDisplay(DWORD a) 648 | { 649 | logf("myIDDrawSurface1::UpdateOverlayDisplay"); 650 | return DDERR_UNSUPPORTED; 651 | } 652 | 653 | 654 | 655 | HRESULT __stdcall myIDDrawSurface1::UpdateOverlayZOrder(DWORD a, LPDIRECTDRAWSURFACE b) 656 | { 657 | logf("myIDDrawSurface1::UpdateOverlayZOrder"); 658 | return DDERR_UNSUPPORTED; 659 | } 660 | 661 | -------------------------------------------------------------------------------- /hack/myIDDrawSurface7.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | myIDDrawSurface7::myIDDrawSurface7(LPDDSURFACEDESC2 a) 6 | { 7 | logf("myIDDrawSurface7 Constructor"); 8 | 9 | mWidth = gScreenWidth; 10 | mHeight = gScreenHeight; 11 | mSurfaceDesc = *a; 12 | mCaps = a->ddsCaps; 13 | 14 | if (a->dwFlags & DDSD_WIDTH) mWidth = a->dwWidth; 15 | if (a->dwFlags & DDSD_HEIGHT) mHeight = a->dwHeight; 16 | gScreenWidth = mWidth; 17 | gScreenHeight = mHeight; 18 | // we don't need no stinking extra pitch bytes.. 19 | mPitch = mWidth * gScreenBits / 8; 20 | 21 | if (a->dwFlags & DDSD_PITCH) mPitch = a->lPitch; 22 | if (a->dwFlags & DDSD_CAPS) 23 | { 24 | if (mCaps.dwCaps & DDSCAPS_PRIMARYSURFACE) 25 | { 26 | gPrimarySurface = this; 27 | init_gl(); 28 | } 29 | } 30 | 31 | mSurfaceDesc.dwWidth = mWidth; 32 | mSurfaceDesc.dwHeight = mHeight; 33 | mSurfaceDesc.lPitch = mPitch; 34 | mSurfaceDesc.dwFlags |= DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH; 35 | 36 | // Let's pad the framebuffer by a couple of megs, in case 37 | // the app writes outside bounds.. 38 | // (we have enough trouble being stable as it is) 39 | mRealSurfaceData = new unsigned char[mHeight * mPitch + 2 * 1024 * 1024]; 40 | mSurfaceData = mRealSurfaceData + 1024 * 1024 * 1; 41 | memset(mSurfaceData, 0, mHeight * mPitch); 42 | 43 | mCurrentPalette = NULL; 44 | } 45 | 46 | 47 | myIDDrawSurface7::~myIDDrawSurface7(void) 48 | { 49 | logf("myIDDrawSurface7 Destructor"); 50 | 51 | if (this == gPrimarySurface) 52 | { 53 | gPrimarySurface = NULL; 54 | delete gBackBuffer; 55 | gBackBuffer = NULL; 56 | } 57 | delete[] mRealSurfaceData; 58 | } 59 | 60 | 61 | HRESULT __stdcall myIDDrawSurface7::QueryInterface (REFIID, LPVOID FAR * b) 62 | { 63 | logf("myIDDrawSurface7::QueryInterface"); 64 | 65 | *b = NULL; 66 | 67 | return DDERR_UNSUPPORTED; 68 | } 69 | 70 | 71 | ULONG __stdcall myIDDrawSurface7::AddRef(void) 72 | { 73 | logf("myIDDrawSurface7::AddRef"); 74 | return 1; 75 | } 76 | 77 | 78 | ULONG __stdcall myIDDrawSurface7::Release(void) 79 | { 80 | logf("myIDDrawSurface7::Release"); 81 | delete this; 82 | 83 | return 0; 84 | } 85 | 86 | 87 | 88 | HRESULT __stdcall myIDDrawSurface7::AddAttachedSurface(LPDIRECTDRAWSURFACE7 a) 89 | { 90 | logf("myIDDrawSurface7::AddAttachedSurface"); 91 | return DDERR_UNSUPPORTED; 92 | } 93 | 94 | 95 | 96 | HRESULT __stdcall myIDDrawSurface7::AddOverlayDirtyRect(LPRECT a) 97 | { 98 | logf("myIDDrawSurface7::AddOverlayDirtyRect"); 99 | return DDERR_UNSUPPORTED; 100 | } 101 | 102 | 103 | 104 | HRESULT __stdcall myIDDrawSurface7::Blt(LPRECT a,LPDIRECTDRAWSURFACE7 b, LPRECT c,DWORD d, LPDDBLTFX e) 105 | { 106 | if (a && c) 107 | logf("myIDDrawSurface7::Blt([%d,%d,%d,%d],%08x,[%d,%d,%d,%d],%08x,%08x)", 108 | a->top,a->left,a->bottom,a->right, 109 | b, 110 | c->top,c->left,c->bottom,c->right, 111 | d, 112 | e ? e->dwDDFX : 0); 113 | else 114 | if (a) 115 | logf("myIDDrawSurface7::Blt([%d,%d,%d,%d],%08x,[null],%08x,%08x)", 116 | a->top,a->left,a->bottom,a->right, 117 | b, 118 | d, 119 | e ? e->dwDDFX : 0); 120 | else 121 | if (c) 122 | logf("myIDDrawSurface7::Blt([null],%08x,[%d,%d,%d,%d],%08x,%08x)", 123 | b, 124 | c->top,c->left,c->bottom,c->right, 125 | d, 126 | e ? e->dwDDFX : 0); 127 | else 128 | logf("myIDDrawSurface7::Blt([null],%08x,[null],%08x,%08x)", 129 | b, 130 | d, 131 | e ? e->dwDDFX : 0); 132 | 133 | int i, j; 134 | myIDDrawSurface7 *src = NULL; 135 | if (b) src = (myIDDrawSurface7*)b; 136 | int usingColorKey = d & DDBLT_KEYDEST || d & DDBLT_KEYSRC || d & DDBLT_ALPHADEST; 137 | unsigned char colorKey = 0; 138 | if (usingColorKey) 139 | colorKey = (unsigned char) (d & DDBLT_KEYDEST ? mDestColorKey.dwColorSpaceLowValue : src->mSrcColorKey.dwColorSpaceLowValue); 140 | 141 | if (b == NULL) 142 | { 143 | if (a) 144 | for (i = a->bottom; i < a->top; i++) 145 | for (j = a->left; j < a->right; j++) 146 | mSurfaceData[i*mPitch+j] = (d & DDBLT_COLORFILL ? (unsigned char) e->dwFillColor : 0); 147 | else 148 | memset(mSurfaceData, (d & DDBLT_COLORFILL ? e->dwFillColor : 0), mHeight * mPitch); 149 | } 150 | else 151 | { 152 | // Othewise we're scaling a 320x240 to 640x480.. or we're scaling the 153 | // video on screen. 154 | 155 | if (a && c && gWc3SmallVid) 156 | { 157 | for (i = c->top; i < c->bottom; i++) 158 | for (j = c->left; j < c->right; j++) 159 | mSurfaceData[(i + (480 - c->bottom)/2) * mPitch + j + 160] = src->mSurfaceData[i * src->mPitch + j]; 160 | } 161 | else 162 | { 163 | if (a && c) 164 | { 165 | for (i = 0; i < a->bottom - a->top; i++) 166 | for (j = 0; j < a->right - a->left; j++) 167 | if (!usingColorKey || src->mSurfaceData[(i + c->top) * src->mPitch + j + c->left] != colorKey) 168 | mSurfaceData[(i + a->top) * mPitch + j + a->left] = src->mSurfaceData[(i + c->top) * src->mPitch + j + c->left]; 169 | } 170 | else 171 | { 172 | for (i = 0; i < mHeight; i++) 173 | for (j = 0; j < mWidth; j++) 174 | if (!usingColorKey || src->mSurfaceData[i * src->mPitch + j] != colorKey) 175 | mSurfaceData[i * mPitch + j] = src->mSurfaceData[i * src->mPitch + j]; 176 | } 177 | } 178 | } 179 | 180 | 181 | return DD_OK; 182 | } 183 | 184 | 185 | 186 | HRESULT __stdcall myIDDrawSurface7::BltBatch(LPDDBLTBATCH a, DWORD b, DWORD c) 187 | { 188 | logf("myIDDrawSurface7::BltBatch"); 189 | return DDERR_UNSUPPORTED; 190 | } 191 | 192 | 193 | 194 | HRESULT __stdcall myIDDrawSurface7::BltFast(DWORD a,DWORD b,LPDIRECTDRAWSURFACE7 c, LPRECT d,DWORD e) 195 | { 196 | logf("myIDDrawSurface7::BltFast(%d,%d,%08x,[%d,%d,%d,%d],%08x)",a,b,c,d->top,d->left,d->bottom,d->right,e); 197 | myIDDrawSurface7 *src = (myIDDrawSurface7*)c; 198 | int usingColorKey = e & DDBLT_KEYDEST || e & DDBLT_KEYSRC || e & DDBLT_ALPHADEST; 199 | unsigned char colorKey = 0; 200 | if (usingColorKey) 201 | colorKey = (unsigned char) (e & DDBLT_KEYDEST ? mDestColorKey.dwColorSpaceLowValue : src->mSrcColorKey.dwColorSpaceLowValue); 202 | 203 | for (int i = 0; i < d->bottom - d->top; i++) 204 | for (int j = 0; j < d->right - d->left; j++) 205 | if (!usingColorKey || src->mSurfaceData[(i + d->top) * src->mPitch + j + d->left] != colorKey) 206 | mSurfaceData[(i + b) * mPitch + j + a] = src->mSurfaceData[(i + d->top) * src->mPitch + j + d->left]; 207 | 208 | return DD_OK; 209 | } 210 | 211 | 212 | 213 | HRESULT __stdcall myIDDrawSurface7::DeleteAttachedSurface(DWORD a,LPDIRECTDRAWSURFACE7 b) 214 | { 215 | logf("myIDDrawSurface7::DeleteAttachedSurface"); 216 | return DDERR_UNSUPPORTED; 217 | } 218 | 219 | 220 | 221 | HRESULT __stdcall myIDDrawSurface7::EnumAttachedSurfaces(LPVOID a,LPDDENUMSURFACESCALLBACK7 b) 222 | { 223 | logf("myIDDrawSurface7::EnumAttachedSurfaces"); 224 | return DDERR_UNSUPPORTED; 225 | } 226 | 227 | 228 | 229 | HRESULT __stdcall myIDDrawSurface7::EnumOverlayZOrders(DWORD a,LPVOID b,LPDDENUMSURFACESCALLBACK7 c) 230 | { 231 | logf("myIDDrawSurface7::EnumOverlayZOrders"); 232 | return DDERR_UNSUPPORTED; 233 | } 234 | 235 | 236 | 237 | HRESULT __stdcall myIDDrawSurface7::Flip(LPDIRECTDRAWSURFACE7 a, DWORD b) 238 | { 239 | logf("myIDDrawSurface7::Flip"); 240 | updatescreen(); 241 | return DD_OK; 242 | } 243 | 244 | 245 | 246 | HRESULT __stdcall myIDDrawSurface7::GetAttachedSurface(LPDDSCAPS2 a, LPDIRECTDRAWSURFACE7 FAR * b) 247 | { 248 | logf("myIDDrawSurface7::GetAttachedSurface([%d], %08x)", 249 | a->dwCaps, b); 250 | 251 | // wc3 and wc4 call this function to access the back buffer.. 252 | // hack: make a new surface which still uses the primary's 253 | // surface data. 254 | 255 | // Potential memory leak; should check and return gBackBuffer 256 | // if already exists... but the games I've checked don't call 257 | // this several times, so why bother. 258 | // And yes, I realize the checking code would take less space 259 | // than this comment that's complaining about it. 260 | // On the other hand, you wouldn't have so much fun reading 261 | // this if I just deleted it and wrote the check, now would you? 262 | 263 | DDSURFACEDESC2 newdesc = mSurfaceDesc; 264 | 265 | newdesc.ddsCaps.dwCaps |= a->dwCaps; 266 | newdesc.ddsCaps.dwCaps &= ~DDSCAPS_PRIMARYSURFACE; 267 | 268 | myIDDrawSurface7 * n = new myIDDrawSurface7(&newdesc); 269 | n->mSurfaceData = mSurfaceData; 270 | *b = n; 271 | gBackBuffer = n; 272 | 273 | return DD_OK; 274 | } 275 | 276 | 277 | 278 | HRESULT __stdcall myIDDrawSurface7::GetBltStatus(DWORD a) 279 | { 280 | logf("myIDDrawSurface7::GetBltStatus"); 281 | // we're always ready for bitblts 282 | return DD_OK; 283 | } 284 | 285 | 286 | 287 | HRESULT __stdcall myIDDrawSurface7::GetCaps(LPDDSCAPS2 a) 288 | { 289 | logf("myIDDrawSurface7::GetCaps"); 290 | *a = mCaps; 291 | return DD_OK; 292 | } 293 | 294 | 295 | 296 | HRESULT __stdcall myIDDrawSurface7::GetClipper(LPDIRECTDRAWCLIPPER FAR* a) 297 | { 298 | logf("myIDDrawSurface7::GetClipper"); 299 | a = (LPDIRECTDRAWCLIPPER *) mClipper; 300 | return DD_OK; 301 | } 302 | 303 | 304 | 305 | HRESULT __stdcall myIDDrawSurface7::GetColorKey(DWORD a, LPDDCOLORKEY b) 306 | { 307 | logf("myIDDrawSurface7::GetColorKey"); 308 | if (a & DDCKEY_DESTBLT) 309 | b = &mDestColorKey; 310 | else if (a & DDCKEY_SRCBLT) 311 | b = &mSrcColorKey; 312 | else 313 | return DDERR_UNSUPPORTED; 314 | return DD_OK; 315 | } 316 | 317 | 318 | 319 | HRESULT __stdcall myIDDrawSurface7::GetDC(HDC FAR *a) 320 | { 321 | logf("myIDDrawSurface7::GetDC"); 322 | *a = GetDC2(gHwnd); 323 | gGDI = 1; 324 | return DD_OK; 325 | } 326 | 327 | 328 | 329 | HRESULT __stdcall myIDDrawSurface7::GetFlipStatus(DWORD a) 330 | { 331 | logf("myIDDrawSurface7::GetFlipStatus"); 332 | return DDERR_UNSUPPORTED; 333 | } 334 | 335 | 336 | 337 | HRESULT __stdcall myIDDrawSurface7::GetOverlayPosition(LPLONG a, LPLONG b) 338 | { 339 | logf("myIDDrawSurface7::GetOverlayPosition"); 340 | return DDERR_UNSUPPORTED; 341 | } 342 | 343 | 344 | 345 | HRESULT __stdcall myIDDrawSurface7::GetPalette(LPDIRECTDRAWPALETTE FAR*a) 346 | { 347 | logf("myIDDrawSurface7::GetPalette"); 348 | *a = mCurrentPalette; 349 | return DD_OK; 350 | } 351 | 352 | 353 | 354 | HRESULT __stdcall myIDDrawSurface7::GetPixelFormat(LPDDPIXELFORMAT a) 355 | { 356 | logf("myIDDrawSurface7::GetPixelFormat"); 357 | // Return codes based on what ddwrapper reported.. 358 | if (gScreenBits == 8) 359 | { 360 | a->dwSize = 0x20; 361 | a->dwFlags = 0x60; 362 | a->dwFourCC = 0; 363 | a->dwRGBBitCount = 0x8; 364 | a->dwRBitMask = 0; 365 | a->dwGBitMask = 0; 366 | a->dwBBitMask = 0; 367 | a->dwRGBAlphaBitMask = 0; 368 | } 369 | else 370 | if (gScreenBits == 16) 371 | { 372 | a->dwSize = 0x20; 373 | a->dwFlags = 0x40; 374 | a->dwFourCC = 0; 375 | a->dwRGBBitCount = 0x10; 376 | a->dwRBitMask = 0xf800; 377 | a->dwGBitMask = 0x07e0; 378 | a->dwBBitMask = 0x001f; 379 | a->dwRGBAlphaBitMask = 0; 380 | } 381 | else 382 | if (gScreenBits == 24) 383 | { 384 | a->dwSize = 0x20; 385 | a->dwFlags = 0x40; 386 | a->dwFourCC = 0; 387 | a->dwRGBBitCount = 24; 388 | a->dwRBitMask = 0xff0000; 389 | a->dwGBitMask = 0x00ff00; 390 | a->dwBBitMask = 0x0000ff; 391 | a->dwRGBAlphaBitMask = 0; 392 | } 393 | return DD_OK; 394 | } 395 | 396 | 397 | 398 | HRESULT __stdcall myIDDrawSurface7::GetSurfaceDesc(LPDDSURFACEDESC2 a) 399 | { 400 | logf("myIDDrawSurface7::GetSurfaceDesc([%d %d %d %d %d %d %d %d])", 401 | a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, 402 | a->lpSurface, a->ddsCaps.dwCaps); 403 | *a = mSurfaceDesc; 404 | if (gScreenBits == 8) 405 | { 406 | a->ddpfPixelFormat.dwSize = 0x20; 407 | a->ddpfPixelFormat.dwFlags = 0x60; 408 | a->ddpfPixelFormat.dwFourCC = 0; 409 | a->ddpfPixelFormat.dwRGBBitCount = 0x8; 410 | a->ddpfPixelFormat.dwRBitMask = 0; 411 | a->ddpfPixelFormat.dwGBitMask = 0; 412 | a->ddpfPixelFormat.dwBBitMask = 0; 413 | a->ddpfPixelFormat.dwRGBAlphaBitMask = 0; 414 | } 415 | else 416 | if (gScreenBits == 16) 417 | { 418 | a->ddpfPixelFormat.dwSize = 0x20; 419 | a->ddpfPixelFormat.dwFlags = 0x40; 420 | a->ddpfPixelFormat.dwFourCC = 0; 421 | a->ddpfPixelFormat.dwRGBBitCount = 0x10; 422 | a->ddpfPixelFormat.dwRBitMask = 0xf800; 423 | a->ddpfPixelFormat.dwGBitMask = 0x07e0; 424 | a->ddpfPixelFormat.dwBBitMask = 0x001f; 425 | a->ddpfPixelFormat.dwRGBAlphaBitMask = 0; 426 | } 427 | else 428 | if (gScreenBits == 24) 429 | { 430 | a->ddpfPixelFormat.dwSize = 0x20; 431 | a->ddpfPixelFormat.dwFlags = 0x40; 432 | a->ddpfPixelFormat.dwFourCC = 0; 433 | a->ddpfPixelFormat.dwRGBBitCount = 24; 434 | a->ddpfPixelFormat.dwRBitMask = 0xff0000; 435 | a->ddpfPixelFormat.dwGBitMask = 0x00ff00; 436 | a->ddpfPixelFormat.dwBBitMask = 0x0000ff; 437 | a->ddpfPixelFormat.dwRGBAlphaBitMask = 0; 438 | } 439 | logf("pixel format: %d bit, R%08x G%08x B%08x", a->ddpfPixelFormat.dwRGBBitCount, a->ddpfPixelFormat.dwRBitMask, a->ddpfPixelFormat.dwGBitMask, a->ddpfPixelFormat.dwBBitMask); 440 | return DD_OK;//DDERR_UNSUPPORTED; 441 | } 442 | 443 | 444 | 445 | HRESULT __stdcall myIDDrawSurface7::Initialize(LPDIRECTDRAW a, LPDDSURFACEDESC2 b) 446 | { 447 | logf("myIDDrawSurface7::Initialize"); 448 | return DDERR_UNSUPPORTED; 449 | } 450 | 451 | 452 | 453 | HRESULT __stdcall myIDDrawSurface7::IsLost() 454 | { 455 | logf("myIDDrawSurface7::IsLost"); 456 | // We're never lost.. 457 | return DD_OK; 458 | } 459 | 460 | 461 | 462 | HRESULT __stdcall myIDDrawSurface7::Lock(LPRECT a,LPDDSURFACEDESC2 b,DWORD aFlags,HANDLE d) 463 | { 464 | char *extra = ""; 465 | if (this == gPrimarySurface) 466 | extra = " primary"; 467 | if (this == gBackBuffer) 468 | extra = " backbuffer"; 469 | 470 | if (a) 471 | logf("myIDDrawSurface7::Lock([%d,%d,%d,%d],%08x,%d,%d)%s",a->top,a->left,a->bottom,a->right,b,aFlags,d,extra); 472 | else 473 | logf("myIDDrawSurface7::Lock([null],%08x,%d,%d)%s",b,aFlags,d,extra); 474 | 475 | gGDI = 0; 476 | 477 | *b = mSurfaceDesc; 478 | 479 | b->dwFlags |= DDSD_LPSURFACE | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH | DDSD_CAPS; 480 | b->lpSurface = mSurfaceData; 481 | 482 | b->dwWidth = mWidth; 483 | b->dwHeight = mHeight; 484 | b->lPitch = mPitch; 485 | 486 | return NOERROR; 487 | } 488 | 489 | 490 | 491 | HRESULT __stdcall myIDDrawSurface7::ReleaseDC(HDC a) 492 | { 493 | logf("myIDDrawSurface7::ReleaseDC"); 494 | return DD_OK; 495 | } 496 | 497 | 498 | 499 | HRESULT __stdcall myIDDrawSurface7::Restore() 500 | { 501 | logf("myIDDrawSurface7::Restore"); 502 | // we can't lose surfaces, so.. 503 | return DD_OK; 504 | } 505 | 506 | 507 | 508 | HRESULT __stdcall myIDDrawSurface7::SetClipper(LPDIRECTDRAWCLIPPER a) 509 | { 510 | logf("myIDDrawSurface7::SetClipper"); 511 | mClipper = (myIDDrawClipper *) a; 512 | return DD_OK; 513 | } 514 | 515 | 516 | 517 | HRESULT __stdcall myIDDrawSurface7::SetColorKey(DWORD a, LPDDCOLORKEY b) 518 | { 519 | logf("myIDDrawSurface7::SetColorKey"); 520 | if (a & DDCKEY_DESTBLT) 521 | mDestColorKey = *b; 522 | else if (a & DDCKEY_SRCBLT) 523 | mSrcColorKey = *b; 524 | else 525 | return DDERR_UNSUPPORTED; 526 | return DD_OK; 527 | } 528 | 529 | 530 | 531 | HRESULT __stdcall myIDDrawSurface7::SetOverlayPosition(LONG a, LONG b) 532 | { 533 | logf("myIDDrawSurface7::SetOverlayPosition"); 534 | return DDERR_UNSUPPORTED; 535 | } 536 | 537 | 538 | 539 | HRESULT __stdcall myIDDrawSurface7::SetPalette(LPDIRECTDRAWPALETTE a) 540 | { 541 | logf("myIDDrawSurface7::SetPalette(%08x)",a); 542 | mCurrentPalette = (myIDDrawPalette *)a; 543 | return NOERROR; 544 | } 545 | 546 | HRESULT __stdcall myIDDrawSurface7::Unlock(LPRECT a) 547 | { 548 | logf("myIDDrawSurface7::Unlock(%08x)",a); 549 | 550 | // if primary has been updated, flush.. 551 | // otherwise wc2 misses some screens 552 | // (no retrace, flip, or even message pump) 553 | if (this == gPrimarySurface) 554 | updatescreen(); 555 | 556 | return NOERROR; 557 | } 558 | 559 | 560 | 561 | HRESULT __stdcall myIDDrawSurface7::UpdateOverlay(LPRECT a, LPDIRECTDRAWSURFACE7 b,LPRECT c,DWORD d, LPDDOVERLAYFX e) 562 | { 563 | logf("myIDDrawSurface7::UpdateOverlay"); 564 | return DDERR_UNSUPPORTED; 565 | } 566 | 567 | 568 | 569 | HRESULT __stdcall myIDDrawSurface7::UpdateOverlayDisplay(DWORD a) 570 | { 571 | logf("myIDDrawSurface7::UpdateOverlayDisplay"); 572 | return DDERR_UNSUPPORTED; 573 | } 574 | 575 | 576 | 577 | HRESULT __stdcall myIDDrawSurface7::UpdateOverlayZOrder(DWORD a, LPDIRECTDRAWSURFACE7 b) 578 | { 579 | logf("myIDDrawSurface7::UpdateOverlayZOrder"); 580 | return DDERR_UNSUPPORTED; 581 | } 582 | 583 | 584 | 585 | HRESULT __stdcall myIDDrawSurface7::GetDDInterface(LPVOID FAR *a) 586 | { 587 | logf("myIDDrawSurface7::GetDDInterface"); 588 | return DDERR_UNSUPPORTED; 589 | } 590 | 591 | 592 | 593 | HRESULT __stdcall myIDDrawSurface7::PageLock(DWORD a) 594 | { 595 | logf("myIDDrawSurface7::PageLock"); 596 | return DDERR_UNSUPPORTED; 597 | } 598 | 599 | 600 | 601 | HRESULT __stdcall myIDDrawSurface7::PageUnlock(DWORD a) 602 | { 603 | logf("myIDDrawSurface7::PageUnlock"); 604 | return DDERR_UNSUPPORTED; 605 | } 606 | 607 | 608 | 609 | HRESULT __stdcall myIDDrawSurface7::SetSurfaceDesc(LPDDSURFACEDESC2 a, DWORD b) 610 | { 611 | logf("myIDDrawSurface7::SetSurfaceDesc"); 612 | return DDERR_UNSUPPORTED; 613 | } 614 | 615 | 616 | 617 | HRESULT __stdcall myIDDrawSurface7::SetPrivateData(REFGUID a, LPVOID b, DWORD c, DWORD d) 618 | { 619 | logf("myIDDrawSurface7::SetPrivateData"); 620 | return DDERR_UNSUPPORTED; 621 | } 622 | 623 | 624 | 625 | HRESULT __stdcall myIDDrawSurface7::GetPrivateData(REFGUID a, LPVOID b, LPDWORD c) 626 | { 627 | logf("myIDDrawSurface7::GetPrivateData"); 628 | return DDERR_UNSUPPORTED; 629 | } 630 | 631 | 632 | 633 | HRESULT __stdcall myIDDrawSurface7::FreePrivateData(REFGUID a) 634 | { 635 | logf("myIDDrawSurface7::FreePrivateData"); 636 | return DDERR_UNSUPPORTED; 637 | } 638 | 639 | 640 | 641 | HRESULT __stdcall myIDDrawSurface7::GetUniquenessValue(LPDWORD a) 642 | { 643 | logf("myIDDrawSurface7::GetUniquenessValue"); 644 | return DDERR_UNSUPPORTED; 645 | } 646 | 647 | 648 | 649 | HRESULT __stdcall myIDDrawSurface7::ChangeUniquenessValue() 650 | { 651 | logf("myIDDrawSurface7::ChangeUniquenessValue"); 652 | return DDERR_UNSUPPORTED; 653 | } 654 | 655 | 656 | 657 | HRESULT __stdcall myIDDrawSurface7::SetPriority(DWORD a) 658 | { 659 | logf("myIDDrawSurface7::SetPriority"); 660 | return DDERR_UNSUPPORTED; 661 | } 662 | 663 | 664 | 665 | HRESULT __stdcall myIDDrawSurface7::GetPriority(LPDWORD a) 666 | { 667 | logf("myIDDrawSurface7::GetPriority"); 668 | return DDERR_UNSUPPORTED; 669 | } 670 | 671 | 672 | 673 | HRESULT __stdcall myIDDrawSurface7::SetLOD(DWORD a) 674 | { 675 | logf("myIDDrawSurface7::SetLOD"); 676 | return DDERR_UNSUPPORTED; 677 | } 678 | 679 | 680 | 681 | HRESULT __stdcall myIDDrawSurface7::GetLOD(LPDWORD a) 682 | { 683 | logf("myIDDrawSurface7::GetLOD"); 684 | return DDERR_UNSUPPORTED; 685 | } -------------------------------------------------------------------------------- /hack/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // stdafx.cpp 2 | #include "stdafx.h" 3 | -------------------------------------------------------------------------------- /hack/stdafx.h: -------------------------------------------------------------------------------- 1 | // stdafx.h 2 | 3 | #pragma once 4 | 5 | #define WIN32_LEAN_AND_MEAN 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #include "ddraw.h" 13 | #include "myIDDraw.h" 14 | #include "ddhack.h" 15 | 16 | #define STFU(x) warning(disable: x) 17 | #pragma STFU(4100) // unreferenced formal parameter -------------------------------------------------------------------------------- /logger/ddwrapper.def: -------------------------------------------------------------------------------- 1 | LIBRARY "ddraw" 2 | 3 | EXPORTS 4 | AcquireDDThreadLock @1 5 | CompleteCreateSysmemSurface @3 6 | D3DParseUnknownCommand @4 7 | DDInternalLock @6 8 | DDInternalUnlock @7 9 | DirectDrawCreate @9 10 | DirectDrawCreateClipper @10 11 | DirectDrawCreateEx @11 12 | DirectDrawEnumerateA @12 13 | DirectDrawEnumerateExA @13 14 | DirectDrawEnumerateExW @14 15 | DirectDrawEnumerateW @15 16 | DllCanUnloadNow PRIVATE 17 | DllGetClassObject PRIVATE 18 | ReleaseDDThreadLock @22 -------------------------------------------------------------------------------- /logger/ddwrapper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Exported function 4 | HRESULT WINAPI DirectDrawCreate(GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter); 5 | HRESULT WINAPI DirectDrawCreateEx(GUID FAR *lpGuid, LPVOID *lplpDD, REFIID iid,IUnknown FAR *pUnkOuter); 6 | HRESULT WINAPI DirectDrawCreateClipper(DWORD dwFlags, LPDIRECTDRAWCLIPPER FAR *lplpDDClipper, IUnknown FAR *pUnkOuter); 7 | 8 | HRESULT WINAPI DirectDrawEnumerateW(LPDDENUMCALLBACKW lpCallback, LPVOID lpContext); 9 | HRESULT WINAPI DirectDrawEnumerateA(LPDDENUMCALLBACKA lpCallback, LPVOID lpContext); 10 | HRESULT WINAPI DirectDrawEnumerateExW(LPDDENUMCALLBACKEXW lpCallback, LPVOID lpContext, DWORD dwFlags); 11 | HRESULT WINAPI DirectDrawEnumerateExA(LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags); 12 | VOID WINAPI AcquireDDThreadLock(void); 13 | VOID WINAPI ReleaseDDThreadLock(void); 14 | DWORD WINAPI D3DParseUnknownCommand(LPVOID lpCmd, LPVOID *lpRetCmd); 15 | HRESULT WINAPI DllCanUnloadNow(void); 16 | HRESULT WINAPI DllGetClassObject (const CLSID &rclsid, const IID &riid, void **ppv); 17 | 18 | // Exported functions still missing 19 | /* 20 | GetSurfaceFromDC 21 | CheckFullscreen 22 | CompleteCreateSysmemSurface 23 | DDGetAttachedSurfaceLcl 24 | DDInternalLock 25 | DDInternalUnlock 26 | DSoundHelp 27 | GetDDSurfaceLocal 28 | GetOLEThunkData 29 | RegisterSpecialCase 30 | */ 31 | 32 | // regular functions 33 | void InitInstance(HANDLE hModule); 34 | void ExitInstance(void); 35 | void LoadOriginalDll(void); 36 | -------------------------------------------------------------------------------- /logger/ddwrapper.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 11.00 3 | # Visual Studio 2010 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ddwrapper", "ddwrapper.vcxproj", "{62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}.Debug|Win32.Build.0 = Debug|Win32 14 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}.Release|Win32.ActiveCfg = Release|Win32 15 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66}.Release|Win32.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /logger/ddwrapper.vcproj: -------------------------------------------------------------------------------- 1 | 2 | 10 | 11 | 14 | 15 | 16 | 17 | 18 | 26 | 29 | 32 | 35 | 38 | 41 | 53 | 56 | 59 | 62 | 76 | 79 | 82 | 85 | 88 | 91 | 94 | 97 | 98 | 106 | 109 | 112 | 115 | 118 | 121 | 135 | 138 | 141 | 144 | 159 | 162 | 165 | 168 | 171 | 174 | 177 | 180 | 181 | 182 | 183 | 184 | 185 | 189 | 192 | 193 | 196 | 197 | 200 | 201 | 204 | 205 | 208 | 209 | 212 | 213 | 216 | 217 | 220 | 221 | 224 | 225 | 228 | 229 | 232 | 233 | 236 | 237 | 240 | 243 | 247 | 248 | 251 | 255 | 256 | 257 | 258 | 262 | 265 | 266 | 269 | 270 | 273 | 274 | 277 | 278 | 279 | 280 | 281 | 282 | 283 | -------------------------------------------------------------------------------- /logger/ddwrapper.vcxproj: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | 14 | {62CCD15B-C8B5-43BC-94A2-553B9CBF1D66} 15 | Win32Proj 16 | 17 | 18 | 19 | DynamicLibrary 20 | MultiByte 21 | 22 | 23 | DynamicLibrary 24 | MultiByte 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | <_ProjectFileVersion>10.0.40219.1 40 | Debug\ 41 | Debug\ 42 | true 43 | Release\ 44 | Release\ 45 | false 46 | C:\Program Files (x86)\Microsoft Research\Detours Express 2.1\include;$(IncludePath) 47 | C:\Program Files (x86)\Microsoft Research\Detours Express 2.1\lib;$(LibraryPath) 48 | 49 | 50 | 51 | Disabled 52 | WIN32;_DEBUG;_WINDOWS;_USRDLL;DDWRAPPER_EXPORTS;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 53 | true 54 | EnableFastChecks 55 | MultiThreadedDebug 56 | Use 57 | Level4 58 | EditAndContinue 59 | 60 | 61 | dxguid.lib;detours.lib;detoured.lib;%(AdditionalDependencies) 62 | out\ddraw.dll 63 | ddwrapper.def 64 | true 65 | $(OutDir)ddwrapper.pdb 66 | Windows 67 | false 68 | 69 | 70 | $(OutDir)ddwrapper.lib 71 | MachineX86 72 | 73 | 74 | 75 | 76 | MaxSpeed 77 | OnlyExplicitInline 78 | true 79 | WIN32;NDEBUG;_WINDOWS;_USRDLL;DDWRAPPER_EXPORTS;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 80 | true 81 | MultiThreaded 82 | true 83 | Use 84 | Level4 85 | ProgramDatabase 86 | 87 | 88 | ddraw.lib;dxguid.lib;%(AdditionalDependencies) 89 | E:\Program Files (x86)\wing commander\wc3\ddraw.dll 90 | ddwrapper.def 91 | true 92 | Windows 93 | true 94 | true 95 | false 96 | 97 | 98 | $(OutDir)ddwrapper.lib 99 | MachineX86 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | Create 116 | Create 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | -------------------------------------------------------------------------------- /logger/myIDDraw1.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDraw1::myIDDraw1(LPDIRECTDRAW pOriginal) 7 | { 8 | logf(this, "myIDDraw1 Constructor"); 9 | m_pIDDraw = pOriginal; 10 | } 11 | 12 | 13 | myIDDraw1::~myIDDraw1(void) 14 | { 15 | logf(this, "myIDDraw1 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDraw1::QueryInterface (REFIID a, LPVOID FAR * b) 20 | { 21 | char *iid = "?"; 22 | if (a == IID_IDirectDraw) iid = "IID_IDirectDraw"; 23 | if (a == IID_IDirectDraw2) iid = "IID_IDirectDraw2"; 24 | if (a == IID_IDirectDraw4) iid = "IID_IDirectDraw4"; 25 | if (a == IID_IDirectDraw7) iid = "IID_IDirectDraw7"; 26 | 27 | logf(this, "myIDDraw1::QueryInterface(%s,%08x)",iid,b); 28 | 29 | 30 | *b = NULL; 31 | 32 | // call this to increase AddRef at original object 33 | // and to check if such an interface is there 34 | 35 | HRESULT hRes = m_pIDDraw->QueryInterface(a, b); 36 | 37 | if (hRes == NOERROR) // if OK, send our "fake" address 38 | { 39 | if (a == IID_IDirectDraw2) 40 | *b = new myIDDraw2((LPDIRECTDRAW2)*b); 41 | if (a == IID_IDirectDraw7) 42 | *b = new myIDDraw7((LPDIRECTDRAW7)*b); 43 | } 44 | 45 | return hRes; 46 | } 47 | 48 | 49 | ULONG __stdcall myIDDraw1::AddRef(void) 50 | { 51 | logf(this, "myIDDraw1::AddRef"); 52 | return(m_pIDDraw->AddRef()); 53 | } 54 | 55 | 56 | ULONG __stdcall myIDDraw1::Release(void) 57 | { 58 | logf(this, "myIDDraw1::Release"); 59 | 60 | // call original routine 61 | ULONG count = m_pIDDraw->Release(); 62 | 63 | logf(this, "Object Release."); 64 | 65 | // in case no further Ref is there, the Original Object has deleted itself 66 | // so do we here 67 | if (count == 0) 68 | { 69 | m_pIDDraw = NULL; 70 | delete(this); 71 | } 72 | 73 | return(count); 74 | } 75 | 76 | 77 | HRESULT __stdcall myIDDraw1::Compact(void) 78 | { 79 | logf(this, "myIDDraw1::Compact"); 80 | return(m_pIDDraw->Compact()); 81 | } 82 | 83 | 84 | HRESULT __stdcall myIDDraw1::CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c) 85 | { 86 | logf(this, "myIDDraw1::CreateClipper"); 87 | return(m_pIDDraw->CreateClipper(a, b, c)); 88 | } 89 | 90 | 91 | HRESULT __stdcall myIDDraw1::CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d) 92 | { 93 | HRESULT r = m_pIDDraw->CreatePalette(a, b, c, d); 94 | *c = new myIDDrawPalette(*c); 95 | logf(this, "myIDDraw1::CreatePalette(%d,%08x,%08x,%08x) return %d",a,b,c,d,r); 96 | return r; 97 | } 98 | 99 | 100 | HRESULT __stdcall myIDDraw1::CreateSurface(LPDDSURFACEDESC a, LPDIRECTDRAWSURFACE FAR* b, IUnknown FAR* c) 101 | { 102 | HRESULT r = m_pIDDraw->CreateSurface(a, b, c); 103 | logf(this, "myIDDraw1::CreateSurface([%d,0x%x,%d,%d,%d,%d,%d], %08x, %08x) return %d", a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, a->ddsCaps, b, c, r); 104 | 105 | *b = new myIDDrawSurface1(*b); 106 | 107 | return r; 108 | } 109 | 110 | 111 | HRESULT __stdcall myIDDraw1::DuplicateSurface(LPDIRECTDRAWSURFACE a, LPDIRECTDRAWSURFACE FAR* b) 112 | { 113 | logf(this, "myIDDraw1::DuplicateSurface"); 114 | return(m_pIDDraw->DuplicateSurface(a, b)); 115 | } 116 | 117 | 118 | HRESULT __stdcall myIDDraw1::EnumDisplayModes(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMMODESCALLBACK d) 119 | { 120 | logf(this, "myIDDraw1::EnumDisplayModes"); 121 | return(m_pIDDraw->EnumDisplayModes(a, b, c, d)); 122 | } 123 | 124 | 125 | HRESULT __stdcall myIDDraw1::EnumSurfaces(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMSURFACESCALLBACK d) 126 | { 127 | logf(this, "myIDDraw1::EnumSurfaces"); 128 | return(m_pIDDraw->EnumSurfaces(a, b, c, d)); 129 | } 130 | 131 | 132 | HRESULT __stdcall myIDDraw1::FlipToGDISurface(void) 133 | { 134 | logf(this, "myIDDraw1::FlipToGDISurface"); 135 | return(m_pIDDraw->FlipToGDISurface()); 136 | } 137 | 138 | 139 | HRESULT __stdcall myIDDraw1::GetCaps(LPDDCAPS a, LPDDCAPS b) 140 | { 141 | logf(this, "myIDDraw1::GetCaps(%08x, %08x)", a, b); 142 | HRESULT r = m_pIDDraw->GetCaps(a, b); 143 | if (a) 144 | { 145 | logf(this, "surface caps: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", 146 | a->dwCaps, 147 | a->dwCaps2, 148 | a->dwCKeyCaps, 149 | a->dwFXCaps, 150 | a->dwFXAlphaCaps, 151 | a->dwPalCaps, 152 | a->dwSVCaps, 153 | a->dwVidMemTotal, 154 | a->dwVidMemFree, 155 | a->dwAlignBoundarySrc, 156 | a->dwAlignSizeSrc, 157 | a->dwAlignBoundaryDest, 158 | a->dwAlignSizeDest, 159 | a->dwAlignStrideAlign, 160 | a->ddsCaps.dwCaps); 161 | } 162 | if (b) 163 | { 164 | logf(this, "HEL caps: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", 165 | b->dwCaps, 166 | b->dwCaps2, 167 | b->dwCKeyCaps, 168 | b->dwFXCaps, 169 | b->dwFXAlphaCaps, 170 | b->dwPalCaps, 171 | b->dwSVCaps, 172 | b->dwVidMemTotal, 173 | b->dwVidMemFree, 174 | b->dwAlignBoundarySrc, 175 | b->dwAlignSizeSrc, 176 | b->dwAlignBoundaryDest, 177 | b->dwAlignSizeDest, 178 | b->dwAlignStrideAlign, 179 | b->ddsCaps.dwCaps); 180 | } 181 | return r; 182 | } 183 | 184 | 185 | HRESULT __stdcall myIDDraw1::GetDisplayMode(LPDDSURFACEDESC a) 186 | { 187 | logf(this, "myIDDraw1::GetDisplayMode"); 188 | return(m_pIDDraw->GetDisplayMode(a)); 189 | } 190 | 191 | 192 | HRESULT __stdcall myIDDraw1::GetFourCCCodes(LPDWORD a, LPDWORD b) 193 | { 194 | logf(this, "myIDDraw1::GetFourCCCodes"); 195 | return(m_pIDDraw->GetFourCCCodes(a, b)); 196 | } 197 | 198 | 199 | HRESULT __stdcall myIDDraw1::GetGDISurface(LPDIRECTDRAWSURFACE FAR * a) 200 | { 201 | logf(this, "myIDDraw1::GetGDISurface"); 202 | return(m_pIDDraw->GetGDISurface(a)); 203 | } 204 | 205 | 206 | HRESULT __stdcall myIDDraw1::GetMonitorFrequency(LPDWORD a) 207 | { 208 | logf(this, "myIDDraw1::GetMonitorFrequency"); 209 | return(m_pIDDraw->GetMonitorFrequency(a)); 210 | } 211 | 212 | 213 | HRESULT __stdcall myIDDraw1::GetScanLine(LPDWORD a) 214 | { 215 | logf(this, "myIDDraw1::GetScanLine"); 216 | return(m_pIDDraw->GetScanLine(a)); 217 | } 218 | 219 | 220 | HRESULT __stdcall myIDDraw1::GetVerticalBlankStatus(LPBOOL a) 221 | { 222 | logf(this, "myIDDraw1::GetVerticalBlankStatus"); 223 | return(m_pIDDraw->GetVerticalBlankStatus(a)); 224 | } 225 | 226 | 227 | HRESULT __stdcall myIDDraw1::Initialize(GUID FAR* a) 228 | { 229 | logf(this, "myIDDraw1::Initialize"); 230 | return(m_pIDDraw->Initialize(a)); 231 | } 232 | 233 | 234 | HRESULT __stdcall myIDDraw1::RestoreDisplayMode(void) 235 | { 236 | logf(this, "myIDDraw1::RestoreDisplayMode"); 237 | return(m_pIDDraw->RestoreDisplayMode()); 238 | } 239 | 240 | 241 | HRESULT __stdcall myIDDraw1::SetCooperativeLevel(HWND a, DWORD b) 242 | { 243 | 244 | HRESULT h = m_pIDDraw->SetCooperativeLevel(a, b); 245 | 246 | logf(this, "myIDDraw1::SetCooperativeLevel(%08x, %d) return %d", a, b, h); 247 | 248 | return(h); 249 | } 250 | 251 | 252 | HRESULT __stdcall myIDDraw1::SetDisplayMode(DWORD a, DWORD b, DWORD c) 253 | { 254 | HRESULT h = m_pIDDraw->SetDisplayMode(a, b, c); 255 | 256 | logf(this, "myIDDraw1::SetDisplayMode(%d, %d, %d) return %d",a,b,c,h); 257 | 258 | return(h); 259 | } 260 | 261 | 262 | HRESULT __stdcall myIDDraw1::WaitForVerticalBlank(DWORD a, HANDLE b) 263 | { 264 | logf(this, "myIDDraw1::WaitForVerticalBlank"); 265 | return(m_pIDDraw->WaitForVerticalBlank(a, b)); 266 | } 267 | 268 | 269 | -------------------------------------------------------------------------------- /logger/myIDDraw2.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDraw2::myIDDraw2(LPDIRECTDRAW2 pOriginal) 7 | { 8 | logf(this, "myIDDraw2 Constructor"); 9 | m_pIDDraw = pOriginal; 10 | } 11 | 12 | 13 | myIDDraw2::~myIDDraw2(void) 14 | { 15 | logf(this, "myIDDraw2 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDraw2::QueryInterface (REFIID a, LPVOID FAR * b) 20 | { 21 | 22 | char *iid = "?"; 23 | if (a == IID_IDirectDraw) iid = "IID_IDirectDraw"; 24 | if (a == IID_IDirectDraw2) iid = "IID_IDirectDraw2"; 25 | if (a == IID_IDirectDraw4) iid = "IID_IDirectDraw4"; 26 | if (a == IID_IDirectDraw7) iid = "IID_IDirectDraw7"; 27 | 28 | logf(this, "myIDDraw2::QueryInterface(%s,%08x)",iid,b); 29 | 30 | *b = NULL; 31 | 32 | // call this to increase AddRef at original object 33 | // and to check if such an interface is there 34 | 35 | HRESULT hRes = m_pIDDraw->QueryInterface(a, b); 36 | 37 | if (hRes == NOERROR) // if OK, send our "fake" address 38 | { 39 | if (a == IID_IDirectDraw2) 40 | *b = this; 41 | } 42 | 43 | return hRes; 44 | } 45 | 46 | 47 | ULONG __stdcall myIDDraw2::AddRef(void) 48 | { 49 | logf(this, "myIDDraw2::AddRef"); 50 | return(m_pIDDraw->AddRef()); 51 | } 52 | 53 | 54 | ULONG __stdcall myIDDraw2::Release(void) 55 | { 56 | logf(this, "myIDDraw2::Release"); 57 | 58 | // call original routine 59 | ULONG count = m_pIDDraw->Release(); 60 | 61 | logf(this, "Object Release."); 62 | 63 | // in case no further Ref is there, the Original Object has deleted itself 64 | // so do we here 65 | if (count == 0) 66 | { 67 | m_pIDDraw = NULL; 68 | delete(this); 69 | } 70 | 71 | return(count); 72 | } 73 | 74 | 75 | HRESULT __stdcall myIDDraw2::Compact(void) 76 | { 77 | logf(this, "myIDDraw2::Compact"); 78 | return(m_pIDDraw->Compact()); 79 | } 80 | 81 | 82 | HRESULT __stdcall myIDDraw2::CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c) 83 | { 84 | logf(this, "myIDDraw2::CreateClipper"); 85 | return(m_pIDDraw->CreateClipper(a, b, c)); 86 | } 87 | 88 | 89 | HRESULT __stdcall myIDDraw2::CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d) 90 | { 91 | HRESULT r = m_pIDDraw->CreatePalette(a, b, c, d); 92 | *c = new myIDDrawPalette(*c); 93 | logf(this, "myIDDraw2::CreatePalette(%d,%08x,%08x,%08x) return %d",a,b,c,d,r); 94 | return r; 95 | } 96 | 97 | 98 | HRESULT __stdcall myIDDraw2::CreateSurface(LPDDSURFACEDESC a, LPDIRECTDRAWSURFACE FAR* b, IUnknown FAR* c) 99 | { 100 | HRESULT r = m_pIDDraw->CreateSurface(a, b, c); 101 | logf(this, "myIDDraw2::CreateSurface([%d,0x%x,%d,%d,%d,%d,%d], %08x, %08x) return %d", a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, a->ddsCaps, b, c, r); 102 | 103 | *b = new myIDDrawSurface1(*b); 104 | 105 | return r; 106 | } 107 | 108 | 109 | HRESULT __stdcall myIDDraw2::DuplicateSurface(LPDIRECTDRAWSURFACE a, LPDIRECTDRAWSURFACE FAR* b) 110 | { 111 | logf(this, "myIDDraw2::DuplicateSurface"); 112 | return(m_pIDDraw->DuplicateSurface(a, b)); 113 | } 114 | 115 | 116 | HRESULT __stdcall myIDDraw2::EnumDisplayModes(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMMODESCALLBACK d) 117 | { 118 | logf(this, "myIDDraw2::EnumDisplayModes"); 119 | return(m_pIDDraw->EnumDisplayModes(a, b, c, d)); 120 | } 121 | 122 | 123 | HRESULT __stdcall myIDDraw2::EnumSurfaces(DWORD a, LPDDSURFACEDESC b, LPVOID c, LPDDENUMSURFACESCALLBACK d) 124 | { 125 | logf(this, "myIDDraw2::EnumSurfaces"); 126 | return(m_pIDDraw->EnumSurfaces(a, b, c, d)); 127 | } 128 | 129 | 130 | HRESULT __stdcall myIDDraw2::FlipToGDISurface(void) 131 | { 132 | logf(this, "myIDDraw2::FlipToGDISurface"); 133 | return(m_pIDDraw->FlipToGDISurface()); 134 | } 135 | 136 | 137 | HRESULT __stdcall myIDDraw2::GetCaps(LPDDCAPS a, LPDDCAPS b) 138 | { 139 | logf(this, "myIDDraw2::GetCaps"); 140 | return(m_pIDDraw->GetCaps(a, b)); 141 | } 142 | 143 | 144 | HRESULT __stdcall myIDDraw2::GetDisplayMode(LPDDSURFACEDESC a) 145 | { 146 | logf(this, "myIDDraw2::GetDisplayMode"); 147 | return(m_pIDDraw->GetDisplayMode(a)); 148 | } 149 | 150 | 151 | HRESULT __stdcall myIDDraw2::GetFourCCCodes(LPDWORD a, LPDWORD b) 152 | { 153 | logf(this, "myIDDraw2::GetFourCCCodes"); 154 | return(m_pIDDraw->GetFourCCCodes(a, b)); 155 | } 156 | 157 | 158 | HRESULT __stdcall myIDDraw2::GetGDISurface(LPDIRECTDRAWSURFACE FAR * a) 159 | { 160 | logf(this, "myIDDraw2::GetGDISurface"); 161 | return(m_pIDDraw->GetGDISurface(a)); 162 | } 163 | 164 | 165 | HRESULT __stdcall myIDDraw2::GetMonitorFrequency(LPDWORD a) 166 | { 167 | logf(this, "myIDDraw2::GetMonitorFrequency"); 168 | return(m_pIDDraw->GetMonitorFrequency(a)); 169 | } 170 | 171 | 172 | HRESULT __stdcall myIDDraw2::GetScanLine(LPDWORD a) 173 | { 174 | logf(this, "myIDDraw2::GetScanLine"); 175 | return(m_pIDDraw->GetScanLine(a)); 176 | } 177 | 178 | 179 | HRESULT __stdcall myIDDraw2::GetVerticalBlankStatus(LPBOOL a) 180 | { 181 | logf(this, "myIDDraw2::GetVerticalBlankStatus"); 182 | return(m_pIDDraw->GetVerticalBlankStatus(a)); 183 | } 184 | 185 | 186 | HRESULT __stdcall myIDDraw2::Initialize(GUID FAR* a) 187 | { 188 | logf(this, "myIDDraw2::Initialize"); 189 | return(m_pIDDraw->Initialize(a)); 190 | } 191 | 192 | 193 | HRESULT __stdcall myIDDraw2::RestoreDisplayMode(void) 194 | { 195 | logf(this, "myIDDraw2::RestoreDisplayMode"); 196 | return(m_pIDDraw->RestoreDisplayMode()); 197 | } 198 | 199 | 200 | HRESULT __stdcall myIDDraw2::SetCooperativeLevel(HWND a, DWORD b) 201 | { 202 | 203 | HRESULT h = m_pIDDraw->SetCooperativeLevel(a, b); 204 | 205 | logf(this, "myIDDraw2::SetCooperativeLevel(%08x, %d) return %d", a, b, h); 206 | 207 | return(h); 208 | } 209 | 210 | 211 | HRESULT __stdcall myIDDraw2::SetDisplayMode(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e) 212 | { 213 | HRESULT h = m_pIDDraw->SetDisplayMode(a, b, c, d, e); 214 | 215 | logf(this, "myIDDraw2::SetDisplayMode(%d, %d, %d, %d, %d) return %d",a,b,c,d,e,h); 216 | 217 | return(h); 218 | } 219 | 220 | 221 | HRESULT __stdcall myIDDraw2::WaitForVerticalBlank(DWORD a, HANDLE b) 222 | { 223 | logf(this, "myIDDraw2::WaitForVerticalBlank(%d,%d)",a,b); 224 | return(m_pIDDraw->WaitForVerticalBlank(a, b)); 225 | } 226 | 227 | 228 | HRESULT __stdcall myIDDraw2::GetAvailableVidMem(LPDDSCAPS a, LPDWORD b, LPDWORD c) 229 | { 230 | logf(this, "myIDDraw2::GetAvailableVidMem"); 231 | return(m_pIDDraw->GetAvailableVidMem(a, b, c)); 232 | } 233 | 234 | 235 | 236 | -------------------------------------------------------------------------------- /logger/myIDDraw4.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDraw4::myIDDraw4(LPDIRECTDRAW4 pOriginal) 7 | { 8 | logf(this, "myIDDraw4 Constructor"); 9 | m_pIDDraw = pOriginal; 10 | } 11 | 12 | 13 | myIDDraw4::~myIDDraw4(void) 14 | { 15 | logf(this, "myIDDraw4 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDraw4::QueryInterface (REFIID a, LPVOID FAR * b) 20 | { 21 | 22 | char *iid = "?"; 23 | if (a == IID_IDirectDraw) iid = "IID_IDirectDraw"; 24 | if (a == IID_IDirectDraw2) iid = "IID_IDirectDraw2"; 25 | if (a == IID_IDirectDraw4) iid = "IID_IDirectDraw4"; 26 | if (a == IID_IDirectDraw7) iid = "IID_IDirectDraw7"; 27 | 28 | logf(this, "myIDDraw4::QueryInterface(%s,%08x)",iid,b); 29 | 30 | *b = NULL; 31 | 32 | // call this to increase AddRef at original object 33 | // and to check if such an interface is there 34 | 35 | HRESULT hRes = m_pIDDraw->QueryInterface(a, b); 36 | 37 | if (hRes == NOERROR) // if OK, send our "fake" address 38 | { 39 | if (a == IID_IDirectDraw4) 40 | *b = this; 41 | } 42 | 43 | return hRes; 44 | } 45 | 46 | 47 | ULONG __stdcall myIDDraw4::AddRef(void) 48 | { 49 | logf(this, "myIDDraw4::AddRef"); 50 | return(m_pIDDraw->AddRef()); 51 | } 52 | 53 | 54 | ULONG __stdcall myIDDraw4::Release(void) 55 | { 56 | logf(this, "myIDDraw4::Release"); 57 | 58 | // call original routine 59 | ULONG count = m_pIDDraw->Release(); 60 | 61 | logf(this, "Object Release."); 62 | 63 | // in case no further Ref is there, the Original Object has deleted itself 64 | // so do we here 65 | if (count == 0) 66 | { 67 | m_pIDDraw = NULL; 68 | delete(this); 69 | } 70 | 71 | return(count); 72 | } 73 | 74 | 75 | HRESULT __stdcall myIDDraw4::Compact(void) 76 | { 77 | logf(this, "myIDDraw4::Compact"); 78 | return(m_pIDDraw->Compact()); 79 | } 80 | 81 | 82 | HRESULT __stdcall myIDDraw4::CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c) 83 | { 84 | logf(this, "myIDDraw4::CreateClipper"); 85 | return(m_pIDDraw->CreateClipper(a, b, c)); 86 | } 87 | 88 | 89 | HRESULT __stdcall myIDDraw4::CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d) 90 | { 91 | HRESULT r = m_pIDDraw->CreatePalette(a, b, c, d); 92 | *c = new myIDDrawPalette(*c); 93 | logf(this, "myIDDraw4::CreatePalette(%d,%08x,%08x,%08x) return %d",a,b,c,d,r); 94 | return r; 95 | } 96 | 97 | 98 | HRESULT __stdcall myIDDraw4::CreateSurface(LPDDSURFACEDESC2 a, LPDIRECTDRAWSURFACE4 FAR* b, IUnknown FAR* c) 99 | { 100 | HRESULT r = m_pIDDraw->CreateSurface(a, b, c); 101 | logf(this, "myIDDraw4::CreateSurface([%d,0x%x,%d,%d,%d,%d,%d], %08x, %08x) return %d", a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, a->ddsCaps, b, c, r); 102 | 103 | 104 | *b = new myIDDrawSurface4(*b); 105 | 106 | return r; 107 | } 108 | 109 | 110 | HRESULT __stdcall myIDDraw4::DuplicateSurface(LPDIRECTDRAWSURFACE4 a, LPDIRECTDRAWSURFACE4 FAR* b) 111 | { 112 | logf(this, "myIDDraw4::DuplicateSurface"); 113 | return(m_pIDDraw->DuplicateSurface(a, b)); 114 | } 115 | 116 | 117 | HRESULT __stdcall myIDDraw4::EnumDisplayModes(DWORD a, LPDDSURFACEDESC2 b, LPVOID c, LPDDENUMMODESCALLBACK2 d) 118 | { 119 | logf(this, "myIDDraw4::EnumDisplayModes"); 120 | return(m_pIDDraw->EnumDisplayModes(a, b, c, d)); 121 | } 122 | 123 | 124 | HRESULT __stdcall myIDDraw4::EnumSurfaces(DWORD a, LPDDSURFACEDESC2 b, LPVOID c, LPDDENUMSURFACESCALLBACK2 d) 125 | { 126 | logf(this, "myIDDraw4::EnumSurfaces"); 127 | return(m_pIDDraw->EnumSurfaces(a, b, c, d)); 128 | } 129 | 130 | 131 | HRESULT __stdcall myIDDraw4::FlipToGDISurface(void) 132 | { 133 | logf(this, "myIDDraw4::FlipToGDISurface"); 134 | return(m_pIDDraw->FlipToGDISurface()); 135 | } 136 | 137 | 138 | HRESULT __stdcall myIDDraw4::GetCaps(LPDDCAPS a, LPDDCAPS b) 139 | { 140 | logf(this, "myIDDraw4::GetCaps"); 141 | return(m_pIDDraw->GetCaps(a, b)); 142 | } 143 | 144 | 145 | HRESULT __stdcall myIDDraw4::GetDisplayMode(LPDDSURFACEDESC2 a) 146 | { 147 | logf(this, "myIDDraw4::GetDisplayMode"); 148 | return(m_pIDDraw->GetDisplayMode(a)); 149 | } 150 | 151 | 152 | HRESULT __stdcall myIDDraw4::GetFourCCCodes(LPDWORD a, LPDWORD b) 153 | { 154 | logf(this, "myIDDraw4::GetFourCCCodes"); 155 | return(m_pIDDraw->GetFourCCCodes(a, b)); 156 | } 157 | 158 | 159 | HRESULT __stdcall myIDDraw4::GetGDISurface(LPDIRECTDRAWSURFACE4 FAR * a) 160 | { 161 | logf(this, "myIDDraw4::GetGDISurface"); 162 | return(m_pIDDraw->GetGDISurface(a)); 163 | } 164 | 165 | 166 | HRESULT __stdcall myIDDraw4::GetMonitorFrequency(LPDWORD a) 167 | { 168 | logf(this, "myIDDraw4::GetMonitorFrequency"); 169 | return(m_pIDDraw->GetMonitorFrequency(a)); 170 | } 171 | 172 | 173 | HRESULT __stdcall myIDDraw4::GetScanLine(LPDWORD a) 174 | { 175 | logf(this, "myIDDraw4::GetScanLine"); 176 | return(m_pIDDraw->GetScanLine(a)); 177 | } 178 | 179 | 180 | HRESULT __stdcall myIDDraw4::GetVerticalBlankStatus(LPBOOL a) 181 | { 182 | logf(this, "myIDDraw4::GetVerticalBlankStatus"); 183 | return(m_pIDDraw->GetVerticalBlankStatus(a)); 184 | } 185 | 186 | 187 | HRESULT __stdcall myIDDraw4::Initialize(GUID FAR* a) 188 | { 189 | logf(this, "myIDDraw4::Initialize"); 190 | return(m_pIDDraw->Initialize(a)); 191 | } 192 | 193 | 194 | HRESULT __stdcall myIDDraw4::RestoreDisplayMode(void) 195 | { 196 | logf(this, "myIDDraw4::RestoreDisplayMode"); 197 | return(m_pIDDraw->RestoreDisplayMode()); 198 | } 199 | 200 | 201 | HRESULT __stdcall myIDDraw4::SetCooperativeLevel(HWND a, DWORD b) 202 | { 203 | 204 | HRESULT h = m_pIDDraw->SetCooperativeLevel(a, b); 205 | 206 | logf(this, "myIDDraw4::SetCooperativeLevel(%08x, %d) return %d", a, b, h); 207 | 208 | return(h); 209 | } 210 | 211 | 212 | HRESULT __stdcall myIDDraw4::SetDisplayMode(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e) 213 | { 214 | HRESULT h = m_pIDDraw->SetDisplayMode(a, b, c, d, e); 215 | 216 | logf(this, "myIDDraw4::SetDisplayMode(%d, %d, %d, %d, %d) return %d",a,b,c,d,e,h); 217 | 218 | return(h); 219 | } 220 | 221 | 222 | HRESULT __stdcall myIDDraw4::WaitForVerticalBlank(DWORD a, HANDLE b) 223 | { 224 | logf(this, "myIDDraw4::WaitForVerticalBlank(%d,%d)",a,b); 225 | return(m_pIDDraw->WaitForVerticalBlank(a, b)); 226 | } 227 | 228 | 229 | HRESULT __stdcall myIDDraw4::GetAvailableVidMem(LPDDSCAPS2 a, LPDWORD b, LPDWORD c) 230 | { 231 | logf(this, "myIDDraw4::GetAvailableVidMem"); 232 | return(m_pIDDraw->GetAvailableVidMem(a, b, c)); 233 | } 234 | 235 | 236 | HRESULT __stdcall myIDDraw4::GetSurfaceFromDC(HDC a, LPDIRECTDRAWSURFACE4 * b) 237 | { 238 | logf(this, "myIDDraw4::GetSurfaceFromDC"); 239 | return(m_pIDDraw->GetSurfaceFromDC(a, b)); 240 | } 241 | 242 | 243 | HRESULT __stdcall myIDDraw4::RestoreAllSurfaces(void) 244 | { 245 | logf(this, "myIDDraw4::RestoreAllSurfaces"); 246 | return(m_pIDDraw->RestoreAllSurfaces()); 247 | } 248 | 249 | 250 | HRESULT __stdcall myIDDraw4::TestCooperativeLevel(void) 251 | { 252 | logf(this, "myIDDraw4::TestCooperativeLevel"); 253 | return(m_pIDDraw->TestCooperativeLevel()); 254 | } 255 | 256 | 257 | HRESULT __stdcall myIDDraw4::GetDeviceIdentifier(LPDDDEVICEIDENTIFIER a, DWORD b) 258 | { 259 | logf(this, "myIDDraw4::GetDeviceIdentifier"); 260 | return(m_pIDDraw->GetDeviceIdentifier(a, b)); 261 | } 262 | -------------------------------------------------------------------------------- /logger/myIDDraw7.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDraw7::myIDDraw7(LPDIRECTDRAW7 pOriginal) 7 | { 8 | logf(this, "myIDDraw7 Constructor"); 9 | m_pIDDraw = pOriginal; 10 | } 11 | 12 | 13 | myIDDraw7::~myIDDraw7(void) 14 | { 15 | logf(this, "myIDDraw7 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDraw7::QueryInterface (REFIID a, LPVOID FAR * b) 20 | { 21 | 22 | char *iid = "?"; 23 | if (a == IID_IDirectDraw) iid = "IID_IDirectDraw"; 24 | if (a == IID_IDirectDraw2) iid = "IID_IDirectDraw2"; 25 | if (a == IID_IDirectDraw4) iid = "IID_IDirectDraw4"; 26 | if (a == IID_IDirectDraw7) iid = "IID_IDirectDraw7"; 27 | 28 | logf(this, "myIDDraw7::QueryInterface(%s,%08x)",iid,b); 29 | 30 | *b = NULL; 31 | 32 | // call this to increase AddRef at original object 33 | // and to check if such an interface is there 34 | 35 | HRESULT hRes = m_pIDDraw->QueryInterface(a, b); 36 | 37 | if (hRes == NOERROR) // if OK, send our "fake" address 38 | { 39 | if (a == IID_IDirectDraw7) 40 | *b = this; 41 | } 42 | 43 | return hRes; 44 | } 45 | 46 | 47 | ULONG __stdcall myIDDraw7::AddRef(void) 48 | { 49 | logf(this, "myIDDraw7::AddRef"); 50 | return(m_pIDDraw->AddRef()); 51 | } 52 | 53 | 54 | ULONG __stdcall myIDDraw7::Release(void) 55 | { 56 | logf(this, "myIDDraw7::Release"); 57 | 58 | // call original routine 59 | ULONG count = m_pIDDraw->Release(); 60 | 61 | logf(this, "Object Release."); 62 | 63 | // in case no further Ref is there, the Original Object has deleted itself 64 | // so do we here 65 | if (count == 0) 66 | { 67 | m_pIDDraw = NULL; 68 | delete(this); 69 | } 70 | 71 | return(count); 72 | } 73 | 74 | 75 | HRESULT __stdcall myIDDraw7::Compact(void) 76 | { 77 | logf(this, "myIDDraw7::Compact"); 78 | return(m_pIDDraw->Compact()); 79 | } 80 | 81 | 82 | HRESULT __stdcall myIDDraw7::CreateClipper(DWORD a, LPDIRECTDRAWCLIPPER FAR* b, IUnknown FAR* c) 83 | { 84 | logf(this, "myIDDraw7::CreateClipper"); 85 | return(m_pIDDraw->CreateClipper(a, b, c)); 86 | } 87 | 88 | 89 | HRESULT __stdcall myIDDraw7::CreatePalette(DWORD a, LPPALETTEENTRY b, LPDIRECTDRAWPALETTE FAR* c, IUnknown FAR* d) 90 | { 91 | HRESULT r = m_pIDDraw->CreatePalette(a, b, c, d); 92 | *c = new myIDDrawPalette(*c); 93 | logf(this, "myIDDraw7::CreatePalette(%d,%08x,%08x,%08x) return %d",a,b,c,d,r); 94 | return r; 95 | } 96 | 97 | 98 | HRESULT __stdcall myIDDraw7::CreateSurface(LPDDSURFACEDESC2 a, LPDIRECTDRAWSURFACE7 FAR* b, IUnknown FAR* c) 99 | { 100 | HRESULT r = m_pIDDraw->CreateSurface(a, b, c); 101 | logf(this, "myIDDraw7::CreateSurface([%d,0x%x,%d,%d,%d,%d,%d], %08x, %08x) return %d", a->dwSize, a->dwFlags, a->dwWidth, a->dwHeight, a->lPitch, a->dwBackBufferCount, a->ddsCaps, b, c, r); 102 | *b = new myIDDrawSurface7(*b); 103 | return r; 104 | } 105 | 106 | 107 | HRESULT __stdcall myIDDraw7::DuplicateSurface(LPDIRECTDRAWSURFACE7 a, LPDIRECTDRAWSURFACE7 FAR* b) 108 | { 109 | logf(this, "myIDDraw7::DuplicateSurface"); 110 | return(m_pIDDraw->DuplicateSurface(a, b)); 111 | } 112 | 113 | 114 | HRESULT __stdcall myIDDraw7::EnumDisplayModes(DWORD a, LPDDSURFACEDESC2 b, LPVOID c, LPDDENUMMODESCALLBACK2 d) 115 | { 116 | logf(this, "myIDDraw7::EnumDisplayModes"); 117 | return(m_pIDDraw->EnumDisplayModes(a, b, c, d)); 118 | } 119 | 120 | 121 | HRESULT __stdcall myIDDraw7::EnumSurfaces(DWORD a, LPDDSURFACEDESC2 b, LPVOID c, LPDDENUMSURFACESCALLBACK7 d) 122 | { 123 | logf(this, "myIDDraw7::EnumSurfaces"); 124 | return(m_pIDDraw->EnumSurfaces(a, b, c, d)); 125 | } 126 | 127 | 128 | HRESULT __stdcall myIDDraw7::FlipToGDISurface(void) 129 | { 130 | logf(this, "myIDDraw7::FlipToGDISurface"); 131 | return(m_pIDDraw->FlipToGDISurface()); 132 | } 133 | 134 | 135 | HRESULT __stdcall myIDDraw7::GetCaps(LPDDCAPS a, LPDDCAPS b) 136 | { 137 | logf(this, "myIDDraw7::GetCaps"); 138 | return(m_pIDDraw->GetCaps(a, b)); 139 | } 140 | 141 | 142 | HRESULT __stdcall myIDDraw7::GetDisplayMode(LPDDSURFACEDESC2 a) 143 | { 144 | logf(this, "myIDDraw7::GetDisplayMode"); 145 | return(m_pIDDraw->GetDisplayMode(a)); 146 | } 147 | 148 | 149 | HRESULT __stdcall myIDDraw7::GetFourCCCodes(LPDWORD a, LPDWORD b) 150 | { 151 | logf(this, "myIDDraw7::GetFourCCCodes"); 152 | return(m_pIDDraw->GetFourCCCodes(a, b)); 153 | } 154 | 155 | 156 | HRESULT __stdcall myIDDraw7::GetGDISurface(LPDIRECTDRAWSURFACE7 FAR * a) 157 | { 158 | logf(this, "myIDDraw7::GetGDISurface"); 159 | return(m_pIDDraw->GetGDISurface(a)); 160 | } 161 | 162 | 163 | HRESULT __stdcall myIDDraw7::GetMonitorFrequency(LPDWORD a) 164 | { 165 | logf(this, "myIDDraw7::GetMonitorFrequency"); 166 | return(m_pIDDraw->GetMonitorFrequency(a)); 167 | } 168 | 169 | 170 | HRESULT __stdcall myIDDraw7::GetScanLine(LPDWORD a) 171 | { 172 | logf(this, "myIDDraw7::GetScanLine"); 173 | return(m_pIDDraw->GetScanLine(a)); 174 | } 175 | 176 | 177 | HRESULT __stdcall myIDDraw7::GetVerticalBlankStatus(LPBOOL a) 178 | { 179 | logf(this, "myIDDraw7::GetVerticalBlankStatus"); 180 | return(m_pIDDraw->GetVerticalBlankStatus(a)); 181 | } 182 | 183 | 184 | HRESULT __stdcall myIDDraw7::Initialize(GUID FAR* a) 185 | { 186 | logf(this, "myIDDraw7::Initialize"); 187 | return(m_pIDDraw->Initialize(a)); 188 | } 189 | 190 | 191 | HRESULT __stdcall myIDDraw7::RestoreDisplayMode(void) 192 | { 193 | logf(this, "myIDDraw7::RestoreDisplayMode"); 194 | return(m_pIDDraw->RestoreDisplayMode()); 195 | } 196 | 197 | 198 | HRESULT __stdcall myIDDraw7::SetCooperativeLevel(HWND a, DWORD b) 199 | { 200 | 201 | HRESULT h = m_pIDDraw->SetCooperativeLevel(a, b); 202 | 203 | logf(this, "myIDDraw7::SetCooperativeLevel(%08x, %d) return %d", a, b, h); 204 | 205 | return(h); 206 | } 207 | 208 | 209 | HRESULT __stdcall myIDDraw7::SetDisplayMode(DWORD a, DWORD b, DWORD c, DWORD d, DWORD e) 210 | { 211 | HRESULT h = m_pIDDraw->SetDisplayMode(a, b, c, d, e); 212 | 213 | logf(this, "myIDDraw7::SetDisplayMode(%d, %d, %d, %d, %d) return %d",a,b,c,d,e,h); 214 | 215 | return(h); 216 | } 217 | 218 | 219 | HRESULT __stdcall myIDDraw7::WaitForVerticalBlank(DWORD a, HANDLE b) 220 | { 221 | logf(this, "myIDDraw7::WaitForVerticalBlank(%d,%d)",a,b); 222 | return(m_pIDDraw->WaitForVerticalBlank(a, b)); 223 | } 224 | 225 | 226 | HRESULT __stdcall myIDDraw7::GetAvailableVidMem(LPDDSCAPS2 a, LPDWORD b, LPDWORD c) 227 | { 228 | logf(this, "myIDDraw7::GetAvailableVidMem"); 229 | return(m_pIDDraw->GetAvailableVidMem(a, b, c)); 230 | } 231 | 232 | 233 | HRESULT __stdcall myIDDraw7::GetSurfaceFromDC(HDC a, LPDIRECTDRAWSURFACE7 * b) 234 | { 235 | logf(this, "myIDDraw7::GetSurfaceFromDC"); 236 | return(m_pIDDraw->GetSurfaceFromDC(a, b)); 237 | } 238 | 239 | 240 | HRESULT __stdcall myIDDraw7::RestoreAllSurfaces(void) 241 | { 242 | logf(this, "myIDDraw7::RestoreAllSurfaces"); 243 | return(m_pIDDraw->RestoreAllSurfaces()); 244 | } 245 | 246 | 247 | HRESULT __stdcall myIDDraw7::TestCooperativeLevel(void) 248 | { 249 | logf(this, "myIDDraw7::TestCooperativeLevel"); 250 | return(m_pIDDraw->TestCooperativeLevel()); 251 | } 252 | 253 | 254 | HRESULT __stdcall myIDDraw7::GetDeviceIdentifier(LPDDDEVICEIDENTIFIER2 a, DWORD b) 255 | { 256 | logf(this, "myIDDraw7::GetDeviceIdentifier"); 257 | return(m_pIDDraw->GetDeviceIdentifier(a, b)); 258 | } 259 | 260 | 261 | HRESULT __stdcall myIDDraw7::StartModeTest(LPSIZE a, DWORD b, DWORD c) 262 | { 263 | logf(this, "myIDDraw7::StartModeTest"); 264 | return(m_pIDDraw->StartModeTest(a, b, c)); 265 | } 266 | 267 | 268 | HRESULT __stdcall myIDDraw7::EvaluateMode(DWORD a, DWORD * b) 269 | { 270 | logf(this, "myIDDraw7::EvaluateMode"); 271 | return(m_pIDDraw->EvaluateMode(a, b)); 272 | } 273 | -------------------------------------------------------------------------------- /logger/myIDDrawPalette.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDrawPalette::myIDDrawPalette(LPDIRECTDRAWPALETTE pOriginal) 7 | { 8 | logf(this, "myIDDrawPalette Constructor"); 9 | m_pIDDrawPalette = pOriginal; 10 | } 11 | 12 | 13 | myIDDrawPalette::~myIDDrawPalette(void) 14 | { 15 | logf(this, "myIDDrawPalette Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDrawPalette::QueryInterface (REFIID, LPVOID FAR * b) 20 | { 21 | logf(this, "myIDDrawPalette::QueryInterface"); 22 | 23 | *b = NULL; 24 | 25 | return E_NOTIMPL; 26 | } 27 | 28 | 29 | ULONG __stdcall myIDDrawPalette::AddRef(void) 30 | { 31 | logf(this, "myIDDrawPalette::AddRef"); 32 | return(m_pIDDrawPalette->AddRef()); 33 | } 34 | 35 | 36 | ULONG __stdcall myIDDrawPalette::Release(void) 37 | { 38 | logf(this, "myIDDrawPalette::Release"); 39 | 40 | // call original routine 41 | ULONG count = m_pIDDrawPalette->Release(); 42 | 43 | logf(this, "Object Release."); 44 | 45 | // in case no further Ref is there, the Original Object has deleted itself 46 | // so do we here 47 | if (count == 0) 48 | { 49 | m_pIDDrawPalette = NULL; 50 | delete(this); 51 | } 52 | 53 | return(count); 54 | } 55 | 56 | 57 | 58 | HRESULT __stdcall myIDDrawPalette::GetCaps(LPDWORD a) 59 | { 60 | logf(this, "myIDDrawPalette::GetCaps"); 61 | return m_pIDDrawPalette->GetCaps(a); 62 | } 63 | 64 | 65 | 66 | HRESULT __stdcall myIDDrawPalette::GetEntries(DWORD a,DWORD b,DWORD c,LPPALETTEENTRY d) 67 | { 68 | logf(this, "myIDDrawPalette::GetEntries"); 69 | return m_pIDDrawPalette->GetEntries(a,b,c,d); 70 | } 71 | 72 | 73 | 74 | HRESULT __stdcall myIDDrawPalette::Initialize(LPDIRECTDRAW a, DWORD b, LPPALETTEENTRY c) 75 | { 76 | logf(this, "myIDDrawPalette::Initialize"); 77 | return m_pIDDrawPalette->Initialize(((myIDDrawInterface*)a)->getAsDirectDraw(),b,c); 78 | } 79 | 80 | 81 | 82 | HRESULT __stdcall myIDDrawPalette::SetEntries(DWORD a,DWORD b,DWORD c,LPPALETTEENTRY d) 83 | { 84 | unsigned int i, j; 85 | char temp[128], temp2[32]; 86 | logf(this, "myIDDrawPalette::SetEntries(%d,%d,%d,%08x)",a,b,c,d); 87 | // some games spam an error dialog about corrupted stack with this logging enabled 88 | /*j = 0; 89 | temp[0] = 0; 90 | for (i = b; i < c; i++) 91 | { 92 | sprintf(temp2,"%06X ", ((int*)d)[i-b]); 93 | strcat(temp, temp2); 94 | j++; 95 | if (j == 16) 96 | { 97 | logf(this, "paldata %s", temp); 98 | temp[0] = 0; 99 | j = 0; 100 | } 101 | }*/ 102 | return m_pIDDrawPalette->SetEntries(a,b,c,d); 103 | } 104 | 105 | 106 | 107 | -------------------------------------------------------------------------------- /logger/myIDDrawSurface1.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDrawSurface1::myIDDrawSurface1(LPDIRECTDRAWSURFACE pOriginal) 7 | { 8 | logf(this, "myIDDrawSurface1 Constructor"); 9 | m_pIDDrawSurface = pOriginal; 10 | } 11 | 12 | 13 | myIDDrawSurface1::~myIDDrawSurface1(void) 14 | { 15 | logf(this, "myIDDrawSurface1 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDrawSurface1::QueryInterface (REFIID, LPVOID FAR * b) 20 | { 21 | logf(this, "myIDDrawSurface1::QueryInterface"); 22 | 23 | *b = NULL; 24 | 25 | return E_NOTIMPL; 26 | } 27 | 28 | 29 | ULONG __stdcall myIDDrawSurface1::AddRef(void) 30 | { 31 | logf(this, "myIDDrawSurface1::AddRef"); 32 | return(m_pIDDrawSurface->AddRef()); 33 | } 34 | 35 | 36 | ULONG __stdcall myIDDrawSurface1::Release(void) 37 | { 38 | logf(this, "myIDDrawSurface1::Release"); 39 | 40 | // call original routine 41 | ULONG count = m_pIDDrawSurface->Release(); 42 | 43 | logf(this, "Object Release."); 44 | 45 | // in case no further Ref is there, the Original Object has deleted itself 46 | // so do we here 47 | if (count == 0) 48 | { 49 | m_pIDDrawSurface = NULL; 50 | delete(this); 51 | } 52 | 53 | return(count); 54 | } 55 | 56 | 57 | 58 | HRESULT __stdcall myIDDrawSurface1::AddAttachedSurface(LPDIRECTDRAWSURFACE a) 59 | { 60 | logf(this, "myIDDrawSurface1::AddAttachedSurface"); 61 | return m_pIDDrawSurface->AddAttachedSurface(((myIDDrawSurface1*)a)->m_pIDDrawSurface); 62 | } 63 | 64 | 65 | 66 | HRESULT __stdcall myIDDrawSurface1::AddOverlayDirtyRect(LPRECT a) 67 | { 68 | logf(this, "myIDDrawSurface1::AddOverlayDirtyRect"); 69 | return m_pIDDrawSurface->AddOverlayDirtyRect(a); 70 | } 71 | 72 | 73 | 74 | HRESULT __stdcall myIDDrawSurface1::Blt(LPRECT a,LPDIRECTDRAWSURFACE b, LPRECT c,DWORD d, LPDDBLTFX e) 75 | { 76 | if (a && c) 77 | logf(this, "myIDDrawSurface1::Blt([%d,%d,%d,%d],%08x,[%d,%d,%d,%d],%d,%08x)", 78 | a->top,a->left,a->bottom,a->right, 79 | b, 80 | c->top,c->left,c->bottom,c->right, 81 | d, 82 | e ? e->dwDDFX : 0); 83 | else 84 | if (a) 85 | logf(this, "myIDDrawSurface1::Blt([%d,%d,%d,%d],%08x,[null],%d,%08x)", 86 | a->top,a->left,a->bottom,a->right, 87 | b, 88 | d, 89 | e ? e->dwDDFX : 0); 90 | else 91 | if (c) 92 | logf(this, "myIDDrawSurface1::Blt([null],%08x,[%d,%d,%d,%d],%d,%08x)", 93 | b, 94 | c->top,c->left,c->bottom,c->right, 95 | d, 96 | e ? e->dwDDFX : 0); 97 | else 98 | logf(this, "myIDDrawSurface1::Blt([null],%08x,[null],%d,%08x)", 99 | b, 100 | d, 101 | e ? e->dwDDFX : 0); 102 | if (b) b = ((myIDDrawSurface1*)b)->m_pIDDrawSurface; 103 | HRESULT r = m_pIDDrawSurface->Blt(a,b,c,d,e); 104 | logf(this, "return: %08x", r); 105 | return r; 106 | } 107 | 108 | 109 | 110 | HRESULT __stdcall myIDDrawSurface1::BltBatch(LPDDBLTBATCH a, DWORD b, DWORD c) 111 | { 112 | logf(this, "myIDDrawSurface1::BltBatch"); 113 | return m_pIDDrawSurface->BltBatch(a,b,c); 114 | } 115 | 116 | 117 | 118 | HRESULT __stdcall myIDDrawSurface1::BltFast(DWORD a,DWORD b,LPDIRECTDRAWSURFACE c, LPRECT d,DWORD e) 119 | { 120 | logf(this, "myIDDrawSurface1::BltFast"); 121 | return m_pIDDrawSurface->BltFast(a,b,((myIDDrawSurface1*)c)->m_pIDDrawSurface,d,e); 122 | } 123 | 124 | 125 | 126 | HRESULT __stdcall myIDDrawSurface1::DeleteAttachedSurface(DWORD a,LPDIRECTDRAWSURFACE b) 127 | { 128 | logf(this, "myIDDrawSurface1::DeleteAttachedSurface"); 129 | return m_pIDDrawSurface->DeleteAttachedSurface(a,((myIDDrawSurface1*)b)->m_pIDDrawSurface); 130 | } 131 | 132 | 133 | 134 | HRESULT __stdcall myIDDrawSurface1::EnumAttachedSurfaces(LPVOID a,LPDDENUMSURFACESCALLBACK b) 135 | { 136 | logf(this, "myIDDrawSurface1::EnumAttachedSurfaces"); 137 | return m_pIDDrawSurface->EnumAttachedSurfaces(a,b); 138 | } 139 | 140 | 141 | 142 | HRESULT __stdcall myIDDrawSurface1::EnumOverlayZOrders(DWORD a,LPVOID b,LPDDENUMSURFACESCALLBACK c) 143 | { 144 | logf(this, "myIDDrawSurface1::EnumOverlayZOrders"); 145 | return m_pIDDrawSurface->EnumOverlayZOrders(a,b,c); 146 | } 147 | 148 | 149 | 150 | HRESULT __stdcall myIDDrawSurface1::Flip(LPDIRECTDRAWSURFACE a, DWORD b) 151 | { 152 | logf(this, "myIDDrawSurface1::Flip(%08x,%d)", a, b); 153 | if (a) a = ((myIDDrawSurface1*)a)->m_pIDDrawSurface; 154 | return m_pIDDrawSurface->Flip(a,b); 155 | } 156 | 157 | 158 | 159 | HRESULT __stdcall myIDDrawSurface1::GetAttachedSurface(LPDDSCAPS a, LPDIRECTDRAWSURFACE FAR * b) 160 | { 161 | HRESULT r = m_pIDDrawSurface->GetAttachedSurface(a,b); 162 | *b = new myIDDrawSurface1(*b); 163 | 164 | logf(this, "myIDDrawSurface1::GetAttachedSurface([%d], %08x) return %d", 165 | a->dwCaps, b, r); 166 | 167 | return r; 168 | } 169 | 170 | 171 | 172 | HRESULT __stdcall myIDDrawSurface1::GetBltStatus(DWORD a) 173 | { 174 | logf(this, "myIDDrawSurface1::GetBltStatus"); 175 | return m_pIDDrawSurface->GetBltStatus(a); 176 | } 177 | 178 | 179 | 180 | HRESULT __stdcall myIDDrawSurface1::GetCaps(LPDDSCAPS a) 181 | { 182 | HRESULT r = m_pIDDrawSurface->GetCaps(a); 183 | logf(this, "myIDDrawSurface1::GetCaps sets %08x, returns %d", *a, r); 184 | return r; 185 | } 186 | 187 | 188 | 189 | HRESULT __stdcall myIDDrawSurface1::GetClipper(LPDIRECTDRAWCLIPPER FAR* a) 190 | { 191 | logf(this, "myIDDrawSurface1::GetClipper"); 192 | return m_pIDDrawSurface->GetClipper(a); 193 | } 194 | 195 | 196 | 197 | HRESULT __stdcall myIDDrawSurface1::GetColorKey(DWORD a, LPDDCOLORKEY b) 198 | { 199 | logf(this, "myIDDrawSurface1::GetColorKey"); 200 | return m_pIDDrawSurface->GetColorKey(a,b); 201 | } 202 | 203 | 204 | 205 | HRESULT __stdcall myIDDrawSurface1::GetDC(HDC FAR *a) 206 | { 207 | logf(this, "myIDDrawSurface1::GetDC"); 208 | return m_pIDDrawSurface->GetDC(a); 209 | } 210 | 211 | 212 | 213 | HRESULT __stdcall myIDDrawSurface1::GetFlipStatus(DWORD a) 214 | { 215 | logf(this, "myIDDrawSurface1::GetFlipStatus"); 216 | return m_pIDDrawSurface->GetFlipStatus(a); 217 | } 218 | 219 | 220 | 221 | HRESULT __stdcall myIDDrawSurface1::GetOverlayPosition(LPLONG a, LPLONG b) 222 | { 223 | logf(this, "myIDDrawSurface1::GetOverlayPosition"); 224 | return m_pIDDrawSurface->GetOverlayPosition(a,b); 225 | } 226 | 227 | 228 | 229 | HRESULT __stdcall myIDDrawSurface1::GetPalette(LPDIRECTDRAWPALETTE FAR*a) 230 | { 231 | logf(this, "myIDDrawSurface1::GetPalette"); 232 | return m_pIDDrawSurface->GetPalette(a); 233 | } 234 | 235 | 236 | 237 | HRESULT __stdcall myIDDrawSurface1::GetPixelFormat(LPDDPIXELFORMAT a) 238 | { 239 | logf(this, "myIDDrawSurface1::GetPixelFormat"); 240 | return m_pIDDrawSurface->GetPixelFormat(a); 241 | } 242 | 243 | 244 | 245 | HRESULT __stdcall myIDDrawSurface1::GetSurfaceDesc(LPDDSURFACEDESC a) 246 | { 247 | HRESULT r = m_pIDDrawSurface->GetSurfaceDesc(a); 248 | logf(this, "myIDDrawSurface1::GetSurfaceDesc([%x %x %x %x %x %x %x %x %x [%x %x %x %x %x %x %x %x] %x]) return %d", 249 | a->dwSize, 250 | a->dwFlags, 251 | a->dwWidth, 252 | a->dwHeight, 253 | a->lPitch, 254 | a->dwBackBufferCount, 255 | a->dwRefreshRate, 256 | a->dwAlphaBitDepth, 257 | a->lpSurface, 258 | a->ddpfPixelFormat.dwSize, 259 | a->ddpfPixelFormat.dwFlags, 260 | a->ddpfPixelFormat.dwFourCC, 261 | a->ddpfPixelFormat.dwRGBBitCount, 262 | a->ddpfPixelFormat.dwRBitMask, 263 | a->ddpfPixelFormat.dwGBitMask, 264 | a->ddpfPixelFormat.dwBBitMask, 265 | a->ddpfPixelFormat.dwRGBAlphaBitMask, 266 | a->ddsCaps.dwCaps, r); 267 | 268 | 269 | 270 | return r; 271 | } 272 | 273 | 274 | 275 | HRESULT __stdcall myIDDrawSurface1::Initialize(LPDIRECTDRAW a, LPDDSURFACEDESC b) 276 | { 277 | logf(this, "myIDDrawSurface1::Initialize"); 278 | return m_pIDDrawSurface->Initialize(a,b); 279 | } 280 | 281 | 282 | 283 | HRESULT __stdcall myIDDrawSurface1::IsLost() 284 | { 285 | logf(this, "myIDDrawSurface1::IsLost"); 286 | return m_pIDDrawSurface->IsLost(); 287 | } 288 | 289 | 290 | 291 | HRESULT __stdcall myIDDrawSurface1::Lock(LPRECT a,LPDDSURFACEDESC b,DWORD c,HANDLE d) 292 | { 293 | if (a) 294 | logf(this, "myIDDrawSurface1::Lock([%d,%d,%d,%d],%08x,%d,%d)",a->top,a->left,a->bottom,a->right,b,c,d); 295 | else 296 | logf(this, "myIDDrawSurface1::Lock([null],%08x,%d,%d)",b,c,d); 297 | HRESULT r = m_pIDDrawSurface->Lock(a,b,c,d); 298 | logf(this, "Locked surface data: %d,%d,%d,%d,%d,%08x,%d,%d", 299 | b->dwSize, 300 | b->dwFlags, 301 | b->dwHeight, 302 | b->dwWidth, 303 | b->lPitch, 304 | b->lpSurface, 305 | b->ddsCaps, 306 | b->ddpfPixelFormat); 307 | return r; 308 | } 309 | 310 | 311 | 312 | HRESULT __stdcall myIDDrawSurface1::ReleaseDC(HDC a) 313 | { 314 | logf(this, "myIDDrawSurface1::ReleaseDC"); 315 | return m_pIDDrawSurface->ReleaseDC(a); 316 | } 317 | 318 | 319 | 320 | HRESULT __stdcall myIDDrawSurface1::Restore() 321 | { 322 | logf(this, "myIDDrawSurface1::Restore"); 323 | return m_pIDDrawSurface->Restore(); 324 | } 325 | 326 | 327 | 328 | HRESULT __stdcall myIDDrawSurface1::SetClipper(LPDIRECTDRAWCLIPPER a) 329 | { 330 | logf(this, "myIDDrawSurface1::SetClipper"); 331 | return m_pIDDrawSurface->SetClipper(a); 332 | } 333 | 334 | 335 | 336 | HRESULT __stdcall myIDDrawSurface1::SetColorKey(DWORD a, LPDDCOLORKEY b) 337 | { 338 | logf(this, "myIDDrawSurface1::SetColorKey"); 339 | return m_pIDDrawSurface->SetColorKey(a,b); 340 | } 341 | 342 | 343 | 344 | HRESULT __stdcall myIDDrawSurface1::SetOverlayPosition(LONG a, LONG b) 345 | { 346 | logf(this, "myIDDrawSurface1::SetOverlayPosition"); 347 | return m_pIDDrawSurface->SetOverlayPosition(a,b); 348 | } 349 | 350 | 351 | 352 | HRESULT __stdcall myIDDrawSurface1::SetPalette(LPDIRECTDRAWPALETTE a) 353 | { 354 | logf(this, "myIDDrawSurface1::SetPalette(%08x)",a); 355 | if (a) a = ((myIDDrawPalette*)a)->m_pIDDrawPalette; 356 | return m_pIDDrawSurface->SetPalette(a); 357 | } 358 | 359 | 360 | 361 | HRESULT __stdcall myIDDrawSurface1::Unlock(LPVOID a) 362 | { 363 | logf(this, "myIDDrawSurface1::Unlock(%08x)",a); 364 | return m_pIDDrawSurface->Unlock(a); 365 | } 366 | 367 | 368 | 369 | HRESULT __stdcall myIDDrawSurface1::UpdateOverlay(LPRECT a, LPDIRECTDRAWSURFACE b,LPRECT c,DWORD d, LPDDOVERLAYFX e) 370 | { 371 | logf(this, "myIDDrawSurface1::UpdateOverlay"); 372 | return m_pIDDrawSurface->UpdateOverlay(a,((myIDDrawSurface1*)b)->m_pIDDrawSurface,c,d,e); 373 | } 374 | 375 | 376 | 377 | HRESULT __stdcall myIDDrawSurface1::UpdateOverlayDisplay(DWORD a) 378 | { 379 | logf(this, "myIDDrawSurface1::UpdateOverlayDisplay"); 380 | return m_pIDDrawSurface->UpdateOverlayDisplay(a); 381 | } 382 | 383 | 384 | 385 | HRESULT __stdcall myIDDrawSurface1::UpdateOverlayZOrder(DWORD a, LPDIRECTDRAWSURFACE b) 386 | { 387 | logf(this, "myIDDrawSurface1::UpdateOverlayZOrder"); 388 | return m_pIDDrawSurface->UpdateOverlayZOrder(a,((myIDDrawSurface1*)b)->m_pIDDrawSurface); 389 | } 390 | 391 | -------------------------------------------------------------------------------- /logger/myIDDrawSurface2.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDrawSurface2::myIDDrawSurface2(LPDIRECTDRAWSURFACE2 pOriginal) 7 | { 8 | logf(this, "myIDDrawSurface2 Constructor"); 9 | m_pIDDrawSurface = pOriginal; 10 | } 11 | 12 | 13 | myIDDrawSurface2::~myIDDrawSurface2(void) 14 | { 15 | logf(this, "myIDDrawSurface2 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDrawSurface2::QueryInterface (REFIID, LPVOID FAR * b) 20 | { 21 | logf(this, "myIDDrawSurface2::QueryInterface"); 22 | 23 | *b = NULL; 24 | 25 | return E_NOTIMPL; 26 | } 27 | 28 | 29 | ULONG __stdcall myIDDrawSurface2::AddRef(void) 30 | { 31 | logf(this, "myIDDrawSurface2::AddRef"); 32 | return(m_pIDDrawSurface->AddRef()); 33 | } 34 | 35 | 36 | ULONG __stdcall myIDDrawSurface2::Release(void) 37 | { 38 | logf(this, "myIDDrawSurface2::Release"); 39 | 40 | // call original routine 41 | ULONG count = m_pIDDrawSurface->Release(); 42 | 43 | logf(this, "Object Release."); 44 | 45 | // in case no further Ref is there, the Original Object has deleted itself 46 | // so do we here 47 | if (count == 0) 48 | { 49 | m_pIDDrawSurface = NULL; 50 | delete(this); 51 | } 52 | 53 | return(count); 54 | } 55 | 56 | 57 | 58 | HRESULT __stdcall myIDDrawSurface2::AddAttachedSurface(LPDIRECTDRAWSURFACE2 a) 59 | { 60 | logf(this, "myIDDrawSurface2::AddAttachedSurface"); 61 | return m_pIDDrawSurface->AddAttachedSurface(((myIDDrawSurface2*)a)->m_pIDDrawSurface); 62 | } 63 | 64 | 65 | 66 | HRESULT __stdcall myIDDrawSurface2::AddOverlayDirtyRect(LPRECT a) 67 | { 68 | logf(this, "myIDDrawSurface2::AddOverlayDirtyRect"); 69 | return m_pIDDrawSurface->AddOverlayDirtyRect(a); 70 | } 71 | 72 | 73 | 74 | HRESULT __stdcall myIDDrawSurface2::Blt(LPRECT a,LPDIRECTDRAWSURFACE2 b, LPRECT c,DWORD d, LPDDBLTFX e) 75 | { 76 | if (a && c) 77 | logf(this, "myIDDrawSurface2::Blt([%d,%d,%d,%d],%08x,[%d,%d,%d,%d],%d,%08x)", 78 | a->top,a->left,a->bottom,a->right, 79 | b, 80 | c->top,c->left,c->bottom,c->right, 81 | d, 82 | e->dwDDFX); 83 | else 84 | if (a) 85 | logf(this, "myIDDrawSurface2::Blt([%d,%d,%d,%d],%08x,[null],%d,%08x)", 86 | a->top,a->left,a->bottom,a->right, 87 | b, 88 | d, 89 | e->dwDDFX); 90 | else 91 | if (c) 92 | logf(this, "myIDDrawSurface2::Blt([null],%08x,[%d,%d,%d,%d],%d,%08x)", 93 | b, 94 | c->top,c->left,c->bottom,c->right, 95 | d, 96 | e->dwDDFX); 97 | else 98 | logf(this, "myIDDrawSurface2::Blt([null],%08x,[null],%d,%08x)", 99 | b, 100 | d, 101 | e->dwDDFX); 102 | if (b) b = ((myIDDrawSurface2*)b)->m_pIDDrawSurface; 103 | return m_pIDDrawSurface->Blt(a,b,c,d,e); 104 | } 105 | 106 | 107 | 108 | HRESULT __stdcall myIDDrawSurface2::BltBatch(LPDDBLTBATCH a, DWORD b, DWORD c) 109 | { 110 | logf(this, "myIDDrawSurface2::BltBatch"); 111 | return m_pIDDrawSurface->BltBatch(a,b,c); 112 | } 113 | 114 | 115 | 116 | HRESULT __stdcall myIDDrawSurface2::BltFast(DWORD a,DWORD b,LPDIRECTDRAWSURFACE2 c, LPRECT d,DWORD e) 117 | { 118 | logf(this, "myIDDrawSurface2::BltFast"); 119 | return m_pIDDrawSurface->BltFast(a,b,((myIDDrawSurface2*)c)->m_pIDDrawSurface,d,e); 120 | } 121 | 122 | 123 | 124 | HRESULT __stdcall myIDDrawSurface2::DeleteAttachedSurface(DWORD a,LPDIRECTDRAWSURFACE2 b) 125 | { 126 | logf(this, "myIDDrawSurface2::DeleteAttachedSurface"); 127 | return m_pIDDrawSurface->DeleteAttachedSurface(a,((myIDDrawSurface2*)b)->m_pIDDrawSurface); 128 | } 129 | 130 | 131 | 132 | HRESULT __stdcall myIDDrawSurface2::EnumAttachedSurfaces(LPVOID a,LPDDENUMSURFACESCALLBACK b) 133 | { 134 | logf(this, "myIDDrawSurface2::EnumAttachedSurfaces"); 135 | return m_pIDDrawSurface->EnumAttachedSurfaces(a,b); 136 | } 137 | 138 | 139 | 140 | HRESULT __stdcall myIDDrawSurface2::EnumOverlayZOrders(DWORD a,LPVOID b,LPDDENUMSURFACESCALLBACK c) 141 | { 142 | logf(this, "myIDDrawSurface2::EnumOverlayZOrders"); 143 | return m_pIDDrawSurface->EnumOverlayZOrders(a,b,c); 144 | } 145 | 146 | 147 | 148 | HRESULT __stdcall myIDDrawSurface2::Flip(LPDIRECTDRAWSURFACE2 a, DWORD b) 149 | { 150 | logf(this, "myIDDrawSurface2::Flip(%08x,%d)", a, b); 151 | if (a) a = ((myIDDrawSurface2*)a)->m_pIDDrawSurface; 152 | return m_pIDDrawSurface->Flip(a,b); 153 | } 154 | 155 | 156 | 157 | HRESULT __stdcall myIDDrawSurface2::GetAttachedSurface(LPDDSCAPS a, LPDIRECTDRAWSURFACE2 FAR * b) 158 | { 159 | HRESULT r = m_pIDDrawSurface->GetAttachedSurface(a,b); 160 | *b = new myIDDrawSurface2(*b); 161 | 162 | logf(this, "myIDDrawSurface2::GetAttachedSurface([%d], %08x) return %d", 163 | a->dwCaps, b, r); 164 | 165 | return r; 166 | } 167 | 168 | 169 | 170 | HRESULT __stdcall myIDDrawSurface2::GetBltStatus(DWORD a) 171 | { 172 | logf(this, "myIDDrawSurface2::GetBltStatus"); 173 | return m_pIDDrawSurface->GetBltStatus(a); 174 | } 175 | 176 | 177 | 178 | HRESULT __stdcall myIDDrawSurface2::GetCaps(LPDDSCAPS a) 179 | { 180 | logf(this, "myIDDrawSurface2::GetCaps"); 181 | return m_pIDDrawSurface->GetCaps(a); 182 | } 183 | 184 | 185 | 186 | HRESULT __stdcall myIDDrawSurface2::GetClipper(LPDIRECTDRAWCLIPPER FAR* a) 187 | { 188 | logf(this, "myIDDrawSurface2::GetClipper"); 189 | return m_pIDDrawSurface->GetClipper(a); 190 | } 191 | 192 | 193 | 194 | HRESULT __stdcall myIDDrawSurface2::GetColorKey(DWORD a, LPDDCOLORKEY b) 195 | { 196 | logf(this, "myIDDrawSurface2::GetColorKey"); 197 | return m_pIDDrawSurface->GetColorKey(a,b); 198 | } 199 | 200 | 201 | 202 | HRESULT __stdcall myIDDrawSurface2::GetDC(HDC FAR *a) 203 | { 204 | logf(this, "myIDDrawSurface2::GetDC"); 205 | return m_pIDDrawSurface->GetDC(a); 206 | } 207 | 208 | 209 | 210 | HRESULT __stdcall myIDDrawSurface2::GetFlipStatus(DWORD a) 211 | { 212 | logf(this, "myIDDrawSurface2::GetFlipStatus"); 213 | return m_pIDDrawSurface->GetFlipStatus(a); 214 | } 215 | 216 | 217 | 218 | HRESULT __stdcall myIDDrawSurface2::GetOverlayPosition(LPLONG a, LPLONG b) 219 | { 220 | logf(this, "myIDDrawSurface2::GetOverlayPosition"); 221 | return m_pIDDrawSurface->GetOverlayPosition(a,b); 222 | } 223 | 224 | 225 | 226 | HRESULT __stdcall myIDDrawSurface2::GetPalette(LPDIRECTDRAWPALETTE FAR*a) 227 | { 228 | logf(this, "myIDDrawSurface2::GetPalette"); 229 | return m_pIDDrawSurface->GetPalette(a); 230 | } 231 | 232 | 233 | 234 | HRESULT __stdcall myIDDrawSurface2::GetPixelFormat(LPDDPIXELFORMAT a) 235 | { 236 | logf(this, "myIDDrawSurface2::GetPixelFormat"); 237 | return m_pIDDrawSurface->GetPixelFormat(a); 238 | } 239 | 240 | 241 | 242 | HRESULT __stdcall myIDDrawSurface2::GetSurfaceDesc(LPDDSURFACEDESC a) 243 | { 244 | HRESULT r = m_pIDDrawSurface->GetSurfaceDesc(a); 245 | logf(this, "myIDDrawSurface2::GetSurfaceDesc([%x %x %x %x %x %x %x %x %x [%x %x %x %x %x %x %x %x] %x]) return %d", 246 | a->dwSize, 247 | a->dwFlags, 248 | a->dwWidth, 249 | a->dwHeight, 250 | a->lPitch, 251 | a->dwBackBufferCount, 252 | a->dwRefreshRate, 253 | a->dwAlphaBitDepth, 254 | a->lpSurface, 255 | a->ddpfPixelFormat.dwSize, 256 | a->ddpfPixelFormat.dwFlags, 257 | a->ddpfPixelFormat.dwFourCC, 258 | a->ddpfPixelFormat.dwRGBBitCount, 259 | a->ddpfPixelFormat.dwRBitMask, 260 | a->ddpfPixelFormat.dwGBitMask, 261 | a->ddpfPixelFormat.dwBBitMask, 262 | a->ddpfPixelFormat.dwRGBAlphaBitMask, 263 | a->ddsCaps.dwCaps, r); 264 | 265 | 266 | 267 | return r; 268 | } 269 | 270 | 271 | 272 | HRESULT __stdcall myIDDrawSurface2::Initialize(LPDIRECTDRAW a, LPDDSURFACEDESC b) 273 | { 274 | logf(this, "myIDDrawSurface2::Initialize"); 275 | return m_pIDDrawSurface->Initialize(a,b); 276 | } 277 | 278 | 279 | 280 | HRESULT __stdcall myIDDrawSurface2::IsLost() 281 | { 282 | logf(this, "myIDDrawSurface2::IsLost"); 283 | return m_pIDDrawSurface->IsLost(); 284 | } 285 | 286 | 287 | 288 | HRESULT __stdcall myIDDrawSurface2::Lock(LPRECT a,LPDDSURFACEDESC b,DWORD c,HANDLE d) 289 | { 290 | if (a) 291 | logf(this, "myIDDrawSurface2::Lock([%d,%d,%d,%d],%08x,%d,%d)",a->top,a->left,a->bottom,a->right,b,c,d); 292 | else 293 | logf(this, "myIDDrawSurface2::Lock([null],%08x,%d,%d)",b,c,d); 294 | HRESULT r = m_pIDDrawSurface->Lock(a,b,c,d); 295 | logf(this, "Locked surface data: %d,%d,%d,%d,%d,%08x,%d,%d", 296 | b->dwSize, 297 | b->dwFlags, 298 | b->dwHeight, 299 | b->dwWidth, 300 | b->lPitch, 301 | b->lpSurface, 302 | b->ddsCaps, 303 | b->ddpfPixelFormat); 304 | return r; 305 | } 306 | 307 | 308 | 309 | HRESULT __stdcall myIDDrawSurface2::ReleaseDC(HDC a) 310 | { 311 | logf(this, "myIDDrawSurface2::ReleaseDC"); 312 | return m_pIDDrawSurface->ReleaseDC(a); 313 | } 314 | 315 | 316 | 317 | HRESULT __stdcall myIDDrawSurface2::Restore() 318 | { 319 | logf(this, "myIDDrawSurface2::Restore"); 320 | return m_pIDDrawSurface->Restore(); 321 | } 322 | 323 | 324 | 325 | HRESULT __stdcall myIDDrawSurface2::SetClipper(LPDIRECTDRAWCLIPPER a) 326 | { 327 | logf(this, "myIDDrawSurface2::SetClipper"); 328 | return m_pIDDrawSurface->SetClipper(a); 329 | } 330 | 331 | 332 | 333 | HRESULT __stdcall myIDDrawSurface2::SetColorKey(DWORD a, LPDDCOLORKEY b) 334 | { 335 | logf(this, "myIDDrawSurface2::SetColorKey"); 336 | return m_pIDDrawSurface->SetColorKey(a,b); 337 | } 338 | 339 | 340 | 341 | HRESULT __stdcall myIDDrawSurface2::SetOverlayPosition(LONG a, LONG b) 342 | { 343 | logf(this, "myIDDrawSurface2::SetOverlayPosition"); 344 | return m_pIDDrawSurface->SetOverlayPosition(a,b); 345 | } 346 | 347 | 348 | 349 | HRESULT __stdcall myIDDrawSurface2::SetPalette(LPDIRECTDRAWPALETTE a) 350 | { 351 | logf(this, "myIDDrawSurface2::SetPalette(%08x)",a); 352 | if (a) a = ((myIDDrawPalette*)a)->m_pIDDrawPalette; 353 | return m_pIDDrawSurface->SetPalette(a); 354 | } 355 | 356 | 357 | 358 | HRESULT __stdcall myIDDrawSurface2::Unlock(LPVOID a) 359 | { 360 | logf(this, "myIDDrawSurface2::Unlock(%08x)",a); 361 | return m_pIDDrawSurface->Unlock(a); 362 | } 363 | 364 | 365 | 366 | HRESULT __stdcall myIDDrawSurface2::UpdateOverlay(LPRECT a, LPDIRECTDRAWSURFACE2 b,LPRECT c,DWORD d, LPDDOVERLAYFX e) 367 | { 368 | logf(this, "myIDDrawSurface2::UpdateOverlay"); 369 | return m_pIDDrawSurface->UpdateOverlay(a,((myIDDrawSurface2*)b)->m_pIDDrawSurface,c,d,e); 370 | } 371 | 372 | 373 | 374 | HRESULT __stdcall myIDDrawSurface2::UpdateOverlayDisplay(DWORD a) 375 | { 376 | logf(this, "myIDDrawSurface2::UpdateOverlayDisplay"); 377 | return m_pIDDrawSurface->UpdateOverlayDisplay(a); 378 | } 379 | 380 | 381 | 382 | HRESULT __stdcall myIDDrawSurface2::UpdateOverlayZOrder(DWORD a, LPDIRECTDRAWSURFACE2 b) 383 | { 384 | logf(this, "myIDDrawSurface2::UpdateOverlayZOrder"); 385 | return m_pIDDrawSurface->UpdateOverlayZOrder(a,((myIDDrawSurface2*)b)->m_pIDDrawSurface); 386 | } 387 | 388 | 389 | HRESULT __stdcall myIDDrawSurface2::GetDDInterface(LPVOID FAR * a) 390 | { 391 | logf(this, "myIDDrawSurface2::GetDDInterface"); 392 | return m_pIDDrawSurface->GetDDInterface(a); 393 | 394 | } 395 | 396 | 397 | HRESULT __stdcall myIDDrawSurface2::PageLock(DWORD a) 398 | { 399 | logf(this, "myIDDrawSurface2::PageLock"); 400 | return m_pIDDrawSurface->PageLock(a); 401 | 402 | } 403 | 404 | HRESULT __stdcall myIDDrawSurface2::PageUnlock(DWORD a) 405 | { 406 | logf(this, "myIDDrawSurface2::PageUnlock"); 407 | return m_pIDDrawSurface->PageUnlock(a); 408 | } 409 | -------------------------------------------------------------------------------- /logger/myIDDrawSurface3.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDrawSurface3::myIDDrawSurface3(LPDIRECTDRAWSURFACE3 pOriginal) 7 | { 8 | logf(this, "myIDDrawSurface3 Constructor"); 9 | m_pIDDrawSurface = pOriginal; 10 | } 11 | 12 | 13 | myIDDrawSurface3::~myIDDrawSurface3(void) 14 | { 15 | logf(this, "myIDDrawSurface3 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDrawSurface3::QueryInterface (REFIID, LPVOID FAR * b) 20 | { 21 | logf(this, "myIDDrawSurface3::QueryInterface"); 22 | 23 | *b = NULL; 24 | 25 | return E_NOTIMPL; 26 | } 27 | 28 | 29 | ULONG __stdcall myIDDrawSurface3::AddRef(void) 30 | { 31 | logf(this, "myIDDrawSurface3::AddRef"); 32 | return(m_pIDDrawSurface->AddRef()); 33 | } 34 | 35 | 36 | ULONG __stdcall myIDDrawSurface3::Release(void) 37 | { 38 | logf(this, "myIDDrawSurface3::Release"); 39 | 40 | // call original routine 41 | ULONG count = m_pIDDrawSurface->Release(); 42 | 43 | logf(this, "Object Release."); 44 | 45 | // in case no further Ref is there, the Original Object has deleted itself 46 | // so do we here 47 | if (count == 0) 48 | { 49 | m_pIDDrawSurface = NULL; 50 | delete(this); 51 | } 52 | 53 | return(count); 54 | } 55 | 56 | 57 | 58 | HRESULT __stdcall myIDDrawSurface3::AddAttachedSurface(LPDIRECTDRAWSURFACE3 a) 59 | { 60 | logf(this, "myIDDrawSurface3::AddAttachedSurface"); 61 | return m_pIDDrawSurface->AddAttachedSurface(((myIDDrawSurface3*)a)->m_pIDDrawSurface); 62 | } 63 | 64 | 65 | 66 | HRESULT __stdcall myIDDrawSurface3::AddOverlayDirtyRect(LPRECT a) 67 | { 68 | logf(this, "myIDDrawSurface3::AddOverlayDirtyRect"); 69 | return m_pIDDrawSurface->AddOverlayDirtyRect(a); 70 | } 71 | 72 | 73 | 74 | HRESULT __stdcall myIDDrawSurface3::Blt(LPRECT a,LPDIRECTDRAWSURFACE3 b, LPRECT c,DWORD d, LPDDBLTFX e) 75 | { 76 | if (a && c) 77 | logf(this, "myIDDrawSurface3::Blt([%d,%d,%d,%d],%08x,[%d,%d,%d,%d],%d,%08x)", 78 | a->top,a->left,a->bottom,a->right, 79 | b, 80 | c->top,c->left,c->bottom,c->right, 81 | d, 82 | e->dwDDFX); 83 | else 84 | if (a) 85 | logf(this, "myIDDrawSurface3::Blt([%d,%d,%d,%d],%08x,[null],%d,%08x)", 86 | a->top,a->left,a->bottom,a->right, 87 | b, 88 | d, 89 | e->dwDDFX); 90 | else 91 | if (c) 92 | logf(this, "myIDDrawSurface3::Blt([null],%08x,[%d,%d,%d,%d],%d,%08x)", 93 | b, 94 | c->top,c->left,c->bottom,c->right, 95 | d, 96 | e->dwDDFX); 97 | else 98 | logf(this, "myIDDrawSurface3::Blt([null],%08x,[null],%d,%08x)", 99 | b, 100 | d, 101 | e->dwDDFX); 102 | if (b) b = ((myIDDrawSurface3*)b)->m_pIDDrawSurface; 103 | return m_pIDDrawSurface->Blt(a,b,c,d,e); 104 | } 105 | 106 | 107 | 108 | HRESULT __stdcall myIDDrawSurface3::BltBatch(LPDDBLTBATCH a, DWORD b, DWORD c) 109 | { 110 | logf(this, "myIDDrawSurface3::BltBatch"); 111 | return m_pIDDrawSurface->BltBatch(a,b,c); 112 | } 113 | 114 | 115 | 116 | HRESULT __stdcall myIDDrawSurface3::BltFast(DWORD a,DWORD b,LPDIRECTDRAWSURFACE3 c, LPRECT d,DWORD e) 117 | { 118 | logf(this, "myIDDrawSurface3::BltFast"); 119 | return m_pIDDrawSurface->BltFast(a,b,((myIDDrawSurface3*)c)->m_pIDDrawSurface,d,e); 120 | } 121 | 122 | 123 | 124 | HRESULT __stdcall myIDDrawSurface3::DeleteAttachedSurface(DWORD a,LPDIRECTDRAWSURFACE3 b) 125 | { 126 | logf(this, "myIDDrawSurface3::DeleteAttachedSurface"); 127 | return m_pIDDrawSurface->DeleteAttachedSurface(a,((myIDDrawSurface3*)b)->m_pIDDrawSurface); 128 | } 129 | 130 | 131 | 132 | HRESULT __stdcall myIDDrawSurface3::EnumAttachedSurfaces(LPVOID a,LPDDENUMSURFACESCALLBACK b) 133 | { 134 | logf(this, "myIDDrawSurface3::EnumAttachedSurfaces"); 135 | return m_pIDDrawSurface->EnumAttachedSurfaces(a,b); 136 | } 137 | 138 | 139 | 140 | HRESULT __stdcall myIDDrawSurface3::EnumOverlayZOrders(DWORD a,LPVOID b,LPDDENUMSURFACESCALLBACK c) 141 | { 142 | logf(this, "myIDDrawSurface3::EnumOverlayZOrders"); 143 | return m_pIDDrawSurface->EnumOverlayZOrders(a,b,c); 144 | } 145 | 146 | 147 | 148 | HRESULT __stdcall myIDDrawSurface3::Flip(LPDIRECTDRAWSURFACE3 a, DWORD b) 149 | { 150 | logf(this, "myIDDrawSurface3::Flip(%08x,%d)", a, b); 151 | if (a) a = ((myIDDrawSurface3*)a)->m_pIDDrawSurface; 152 | return m_pIDDrawSurface->Flip(a,b); 153 | } 154 | 155 | 156 | 157 | HRESULT __stdcall myIDDrawSurface3::GetAttachedSurface(LPDDSCAPS a, LPDIRECTDRAWSURFACE3 FAR * b) 158 | { 159 | HRESULT r = m_pIDDrawSurface->GetAttachedSurface(a,b); 160 | *b = new myIDDrawSurface3(*b); 161 | 162 | logf(this, "myIDDrawSurface3::GetAttachedSurface([%d], %08x) return %d", 163 | a->dwCaps, b, r); 164 | 165 | return r; 166 | } 167 | 168 | 169 | 170 | HRESULT __stdcall myIDDrawSurface3::GetBltStatus(DWORD a) 171 | { 172 | logf(this, "myIDDrawSurface3::GetBltStatus"); 173 | return m_pIDDrawSurface->GetBltStatus(a); 174 | } 175 | 176 | 177 | 178 | HRESULT __stdcall myIDDrawSurface3::GetCaps(LPDDSCAPS a) 179 | { 180 | logf(this, "myIDDrawSurface3::GetCaps"); 181 | return m_pIDDrawSurface->GetCaps(a); 182 | } 183 | 184 | 185 | 186 | HRESULT __stdcall myIDDrawSurface3::GetClipper(LPDIRECTDRAWCLIPPER FAR* a) 187 | { 188 | logf(this, "myIDDrawSurface3::GetClipper"); 189 | return m_pIDDrawSurface->GetClipper(a); 190 | } 191 | 192 | 193 | 194 | HRESULT __stdcall myIDDrawSurface3::GetColorKey(DWORD a, LPDDCOLORKEY b) 195 | { 196 | logf(this, "myIDDrawSurface3::GetColorKey"); 197 | return m_pIDDrawSurface->GetColorKey(a,b); 198 | } 199 | 200 | 201 | 202 | HRESULT __stdcall myIDDrawSurface3::GetDC(HDC FAR *a) 203 | { 204 | logf(this, "myIDDrawSurface3::GetDC"); 205 | return m_pIDDrawSurface->GetDC(a); 206 | } 207 | 208 | 209 | 210 | HRESULT __stdcall myIDDrawSurface3::GetFlipStatus(DWORD a) 211 | { 212 | logf(this, "myIDDrawSurface3::GetFlipStatus"); 213 | return m_pIDDrawSurface->GetFlipStatus(a); 214 | } 215 | 216 | 217 | 218 | HRESULT __stdcall myIDDrawSurface3::GetOverlayPosition(LPLONG a, LPLONG b) 219 | { 220 | logf(this, "myIDDrawSurface3::GetOverlayPosition"); 221 | return m_pIDDrawSurface->GetOverlayPosition(a,b); 222 | } 223 | 224 | 225 | 226 | HRESULT __stdcall myIDDrawSurface3::GetPalette(LPDIRECTDRAWPALETTE FAR*a) 227 | { 228 | logf(this, "myIDDrawSurface3::GetPalette"); 229 | return m_pIDDrawSurface->GetPalette(a); 230 | } 231 | 232 | 233 | 234 | HRESULT __stdcall myIDDrawSurface3::GetPixelFormat(LPDDPIXELFORMAT a) 235 | { 236 | logf(this, "myIDDrawSurface3::GetPixelFormat"); 237 | return m_pIDDrawSurface->GetPixelFormat(a); 238 | } 239 | 240 | 241 | 242 | HRESULT __stdcall myIDDrawSurface3::GetSurfaceDesc(LPDDSURFACEDESC a) 243 | { 244 | HRESULT r = m_pIDDrawSurface->GetSurfaceDesc(a); 245 | logf(this, "myIDDrawSurface3::GetSurfaceDesc([%x %x %x %x %x %x %x %x %x [%x %x %x %x %x %x %x %x] %x]) return %d", 246 | a->dwSize, 247 | a->dwFlags, 248 | a->dwWidth, 249 | a->dwHeight, 250 | a->lPitch, 251 | a->dwBackBufferCount, 252 | a->dwRefreshRate, 253 | a->dwAlphaBitDepth, 254 | a->lpSurface, 255 | a->ddpfPixelFormat.dwSize, 256 | a->ddpfPixelFormat.dwFlags, 257 | a->ddpfPixelFormat.dwFourCC, 258 | a->ddpfPixelFormat.dwRGBBitCount, 259 | a->ddpfPixelFormat.dwRBitMask, 260 | a->ddpfPixelFormat.dwGBitMask, 261 | a->ddpfPixelFormat.dwBBitMask, 262 | a->ddpfPixelFormat.dwRGBAlphaBitMask, 263 | a->ddsCaps.dwCaps, r); 264 | 265 | 266 | 267 | return r; 268 | } 269 | 270 | 271 | 272 | HRESULT __stdcall myIDDrawSurface3::Initialize(LPDIRECTDRAW a, LPDDSURFACEDESC b) 273 | { 274 | logf(this, "myIDDrawSurface3::Initialize"); 275 | return m_pIDDrawSurface->Initialize(a,b); 276 | } 277 | 278 | 279 | 280 | HRESULT __stdcall myIDDrawSurface3::IsLost() 281 | { 282 | logf(this, "myIDDrawSurface3::IsLost"); 283 | return m_pIDDrawSurface->IsLost(); 284 | } 285 | 286 | 287 | 288 | HRESULT __stdcall myIDDrawSurface3::Lock(LPRECT a,LPDDSURFACEDESC b,DWORD c,HANDLE d) 289 | { 290 | if (a) 291 | logf(this, "myIDDrawSurface3::Lock([%d,%d,%d,%d],%08x,%d,%d)",a->top,a->left,a->bottom,a->right,b,c,d); 292 | else 293 | logf(this, "myIDDrawSurface3::Lock([null],%08x,%d,%d)",b,c,d); 294 | HRESULT r = m_pIDDrawSurface->Lock(a,b,c,d); 295 | logf(this, "Locked surface data: %d,%d,%d,%d,%d,%08x,%d,%d", 296 | b->dwSize, 297 | b->dwFlags, 298 | b->dwHeight, 299 | b->dwWidth, 300 | b->lPitch, 301 | b->lpSurface, 302 | b->ddsCaps, 303 | b->ddpfPixelFormat); 304 | return r; 305 | } 306 | 307 | 308 | 309 | HRESULT __stdcall myIDDrawSurface3::ReleaseDC(HDC a) 310 | { 311 | logf(this, "myIDDrawSurface3::ReleaseDC"); 312 | return m_pIDDrawSurface->ReleaseDC(a); 313 | } 314 | 315 | 316 | 317 | HRESULT __stdcall myIDDrawSurface3::Restore() 318 | { 319 | logf(this, "myIDDrawSurface3::Restore"); 320 | return m_pIDDrawSurface->Restore(); 321 | } 322 | 323 | 324 | 325 | HRESULT __stdcall myIDDrawSurface3::SetClipper(LPDIRECTDRAWCLIPPER a) 326 | { 327 | logf(this, "myIDDrawSurface3::SetClipper"); 328 | return m_pIDDrawSurface->SetClipper(a); 329 | } 330 | 331 | 332 | 333 | HRESULT __stdcall myIDDrawSurface3::SetColorKey(DWORD a, LPDDCOLORKEY b) 334 | { 335 | logf(this, "myIDDrawSurface3::SetColorKey"); 336 | return m_pIDDrawSurface->SetColorKey(a,b); 337 | } 338 | 339 | 340 | 341 | HRESULT __stdcall myIDDrawSurface3::SetOverlayPosition(LONG a, LONG b) 342 | { 343 | logf(this, "myIDDrawSurface3::SetOverlayPosition"); 344 | return m_pIDDrawSurface->SetOverlayPosition(a,b); 345 | } 346 | 347 | 348 | 349 | HRESULT __stdcall myIDDrawSurface3::SetPalette(LPDIRECTDRAWPALETTE a) 350 | { 351 | logf(this, "myIDDrawSurface3::SetPalette(%08x)",a); 352 | if (a) a = ((myIDDrawPalette*)a)->m_pIDDrawPalette; 353 | return m_pIDDrawSurface->SetPalette(a); 354 | } 355 | 356 | 357 | 358 | HRESULT __stdcall myIDDrawSurface3::Unlock(LPVOID a) 359 | { 360 | logf(this, "myIDDrawSurface3::Unlock(%08x)",a); 361 | return m_pIDDrawSurface->Unlock(a); 362 | } 363 | 364 | 365 | 366 | HRESULT __stdcall myIDDrawSurface3::UpdateOverlay(LPRECT a, LPDIRECTDRAWSURFACE3 b,LPRECT c,DWORD d, LPDDOVERLAYFX e) 367 | { 368 | logf(this, "myIDDrawSurface3::UpdateOverlay"); 369 | return m_pIDDrawSurface->UpdateOverlay(a,((myIDDrawSurface3*)b)->m_pIDDrawSurface,c,d,e); 370 | } 371 | 372 | 373 | 374 | HRESULT __stdcall myIDDrawSurface3::UpdateOverlayDisplay(DWORD a) 375 | { 376 | logf(this, "myIDDrawSurface3::UpdateOverlayDisplay"); 377 | return m_pIDDrawSurface->UpdateOverlayDisplay(a); 378 | } 379 | 380 | 381 | 382 | HRESULT __stdcall myIDDrawSurface3::UpdateOverlayZOrder(DWORD a, LPDIRECTDRAWSURFACE3 b) 383 | { 384 | logf(this, "myIDDrawSurface3::UpdateOverlayZOrder"); 385 | return m_pIDDrawSurface->UpdateOverlayZOrder(a,((myIDDrawSurface3*)b)->m_pIDDrawSurface); 386 | } 387 | 388 | 389 | HRESULT __stdcall myIDDrawSurface3::GetDDInterface(LPVOID FAR * a) 390 | { 391 | logf(this, "myIDDrawSurface3::GetDDInterface"); 392 | return m_pIDDrawSurface->GetDDInterface(a); 393 | 394 | } 395 | 396 | HRESULT __stdcall myIDDrawSurface3::PageLock(DWORD a) 397 | { 398 | logf(this, "myIDDrawSurface3::PageLock"); 399 | return m_pIDDrawSurface->PageLock(a); 400 | 401 | } 402 | 403 | HRESULT __stdcall myIDDrawSurface3::PageUnlock(DWORD a) 404 | { 405 | logf(this, "myIDDrawSurface3::PageUnlock"); 406 | return m_pIDDrawSurface->PageUnlock(a); 407 | } 408 | 409 | HRESULT __stdcall myIDDrawSurface3::SetSurfaceDesc(LPDDSURFACEDESC a, DWORD b) 410 | { 411 | logf(this, "myIDDrawSurface3::SetSurfaceDesc"); 412 | return m_pIDDrawSurface->SetSurfaceDesc(a, b); 413 | 414 | } -------------------------------------------------------------------------------- /logger/myIDDrawSurface4.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDrawSurface4::myIDDrawSurface4(LPDIRECTDRAWSURFACE4 pOriginal) 7 | { 8 | logf(this, "myIDDrawSurface4 Constructor"); 9 | m_pIDDrawSurface = pOriginal; 10 | } 11 | 12 | 13 | myIDDrawSurface4::~myIDDrawSurface4(void) 14 | { 15 | logf(this, "myIDDrawSurface4 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDrawSurface4::QueryInterface (REFIID, LPVOID FAR * b) 20 | { 21 | logf(this, "myIDDrawSurface4::QueryInterface"); 22 | 23 | *b = NULL; 24 | 25 | return E_NOTIMPL; 26 | } 27 | 28 | 29 | ULONG __stdcall myIDDrawSurface4::AddRef(void) 30 | { 31 | logf(this, "myIDDrawSurface4::AddRef"); 32 | return(m_pIDDrawSurface->AddRef()); 33 | } 34 | 35 | 36 | ULONG __stdcall myIDDrawSurface4::Release(void) 37 | { 38 | logf(this, "myIDDrawSurface4::Release"); 39 | 40 | // call original routine 41 | ULONG count = m_pIDDrawSurface->Release(); 42 | 43 | logf(this, "Object Release."); 44 | 45 | // in case no further Ref is there, the Original Object has deleted itself 46 | // so do we here 47 | if (count == 0) 48 | { 49 | m_pIDDrawSurface = NULL; 50 | delete(this); 51 | } 52 | 53 | return(count); 54 | } 55 | 56 | 57 | 58 | HRESULT __stdcall myIDDrawSurface4::AddAttachedSurface(LPDIRECTDRAWSURFACE4 a) 59 | { 60 | logf(this, "myIDDrawSurface4::AddAttachedSurface"); 61 | return m_pIDDrawSurface->AddAttachedSurface(((myIDDrawSurface4*)a)->m_pIDDrawSurface); 62 | } 63 | 64 | 65 | 66 | HRESULT __stdcall myIDDrawSurface4::AddOverlayDirtyRect(LPRECT a) 67 | { 68 | logf(this, "myIDDrawSurface4::AddOverlayDirtyRect"); 69 | return m_pIDDrawSurface->AddOverlayDirtyRect(a); 70 | } 71 | 72 | 73 | 74 | HRESULT __stdcall myIDDrawSurface4::Blt(LPRECT a,LPDIRECTDRAWSURFACE4 b, LPRECT c,DWORD d, LPDDBLTFX e) 75 | { 76 | if (a && c) 77 | logf(this, "myIDDrawSurface4::Blt([%d,%d,%d,%d],%08x,[%d,%d,%d,%d],%d,%08x)", 78 | a->top,a->left,a->bottom,a->right, 79 | b, 80 | c->top,c->left,c->bottom,c->right, 81 | d, 82 | e->dwDDFX); 83 | else 84 | if (a) 85 | logf(this, "myIDDrawSurface4::Blt([%d,%d,%d,%d],%08x,[null],%d,%08x)", 86 | a->top,a->left,a->bottom,a->right, 87 | b, 88 | d, 89 | e->dwDDFX); 90 | else 91 | if (c) 92 | logf(this, "myIDDrawSurface4::Blt([null],%08x,[%d,%d,%d,%d],%d,%08x)", 93 | b, 94 | c->top,c->left,c->bottom,c->right, 95 | d, 96 | e->dwDDFX); 97 | else 98 | logf(this, "myIDDrawSurface4::Blt([null],%08x,[null],%d,%08x)", 99 | b, 100 | d, 101 | e->dwDDFX); 102 | if (b) b = ((myIDDrawSurface4*)b)->m_pIDDrawSurface; 103 | return m_pIDDrawSurface->Blt(a,b,c,d,e); 104 | } 105 | 106 | 107 | 108 | HRESULT __stdcall myIDDrawSurface4::BltBatch(LPDDBLTBATCH a, DWORD b, DWORD c) 109 | { 110 | logf(this, "myIDDrawSurface4::BltBatch"); 111 | return m_pIDDrawSurface->BltBatch(a,b,c); 112 | } 113 | 114 | 115 | 116 | HRESULT __stdcall myIDDrawSurface4::BltFast(DWORD a,DWORD b,LPDIRECTDRAWSURFACE4 c, LPRECT d,DWORD e) 117 | { 118 | logf(this, "myIDDrawSurface4::BltFast"); 119 | return m_pIDDrawSurface->BltFast(a,b,((myIDDrawSurface4*)c)->m_pIDDrawSurface,d,e); 120 | } 121 | 122 | 123 | 124 | HRESULT __stdcall myIDDrawSurface4::DeleteAttachedSurface(DWORD a,LPDIRECTDRAWSURFACE4 b) 125 | { 126 | logf(this, "myIDDrawSurface4::DeleteAttachedSurface"); 127 | return m_pIDDrawSurface->DeleteAttachedSurface(a,((myIDDrawSurface4*)b)->m_pIDDrawSurface); 128 | } 129 | 130 | 131 | 132 | HRESULT __stdcall myIDDrawSurface4::EnumAttachedSurfaces(LPVOID a,LPDDENUMSURFACESCALLBACK2 b) 133 | { 134 | logf(this, "myIDDrawSurface4::EnumAttachedSurfaces"); 135 | return m_pIDDrawSurface->EnumAttachedSurfaces(a,b); 136 | } 137 | 138 | 139 | 140 | HRESULT __stdcall myIDDrawSurface4::EnumOverlayZOrders(DWORD a,LPVOID b,LPDDENUMSURFACESCALLBACK2 c) 141 | { 142 | logf(this, "myIDDrawSurface4::EnumOverlayZOrders"); 143 | return m_pIDDrawSurface->EnumOverlayZOrders(a,b,c); 144 | } 145 | 146 | 147 | 148 | HRESULT __stdcall myIDDrawSurface4::Flip(LPDIRECTDRAWSURFACE4 a, DWORD b) 149 | { 150 | logf(this, "myIDDrawSurface4::Flip(%08x,%d)", a, b); 151 | if (a) a = ((myIDDrawSurface4*)a)->m_pIDDrawSurface; 152 | return m_pIDDrawSurface->Flip(a,b); 153 | } 154 | 155 | 156 | 157 | HRESULT __stdcall myIDDrawSurface4::GetAttachedSurface(LPDDSCAPS2 a, LPDIRECTDRAWSURFACE4 FAR * b) 158 | { 159 | HRESULT r = m_pIDDrawSurface->GetAttachedSurface(a,b); 160 | *b = new myIDDrawSurface4(*b); 161 | 162 | logf(this, "myIDDrawSurface4::GetAttachedSurface([%d], %08x) return %d", 163 | a->dwCaps, b, r); 164 | 165 | return r; 166 | } 167 | 168 | 169 | 170 | HRESULT __stdcall myIDDrawSurface4::GetBltStatus(DWORD a) 171 | { 172 | logf(this, "myIDDrawSurface4::GetBltStatus"); 173 | return m_pIDDrawSurface->GetBltStatus(a); 174 | } 175 | 176 | 177 | 178 | HRESULT __stdcall myIDDrawSurface4::GetCaps(LPDDSCAPS2 a) 179 | { 180 | logf(this, "myIDDrawSurface4::GetCaps"); 181 | return m_pIDDrawSurface->GetCaps(a); 182 | } 183 | 184 | 185 | 186 | HRESULT __stdcall myIDDrawSurface4::GetClipper(LPDIRECTDRAWCLIPPER FAR* a) 187 | { 188 | logf(this, "myIDDrawSurface4::GetClipper"); 189 | return m_pIDDrawSurface->GetClipper(a); 190 | } 191 | 192 | 193 | 194 | HRESULT __stdcall myIDDrawSurface4::GetColorKey(DWORD a, LPDDCOLORKEY b) 195 | { 196 | logf(this, "myIDDrawSurface4::GetColorKey"); 197 | return m_pIDDrawSurface->GetColorKey(a,b); 198 | } 199 | 200 | 201 | 202 | HRESULT __stdcall myIDDrawSurface4::GetDC(HDC FAR *a) 203 | { 204 | logf(this, "myIDDrawSurface4::GetDC"); 205 | return m_pIDDrawSurface->GetDC(a); 206 | } 207 | 208 | 209 | 210 | HRESULT __stdcall myIDDrawSurface4::GetFlipStatus(DWORD a) 211 | { 212 | logf(this, "myIDDrawSurface4::GetFlipStatus"); 213 | return m_pIDDrawSurface->GetFlipStatus(a); 214 | } 215 | 216 | 217 | 218 | HRESULT __stdcall myIDDrawSurface4::GetOverlayPosition(LPLONG a, LPLONG b) 219 | { 220 | logf(this, "myIDDrawSurface4::GetOverlayPosition"); 221 | return m_pIDDrawSurface->GetOverlayPosition(a,b); 222 | } 223 | 224 | 225 | 226 | HRESULT __stdcall myIDDrawSurface4::GetPalette(LPDIRECTDRAWPALETTE FAR*a) 227 | { 228 | logf(this, "myIDDrawSurface4::GetPalette"); 229 | return m_pIDDrawSurface->GetPalette(a); 230 | } 231 | 232 | 233 | 234 | HRESULT __stdcall myIDDrawSurface4::GetPixelFormat(LPDDPIXELFORMAT a) 235 | { 236 | logf(this, "myIDDrawSurface4::GetPixelFormat"); 237 | return m_pIDDrawSurface->GetPixelFormat(a); 238 | } 239 | 240 | 241 | 242 | HRESULT __stdcall myIDDrawSurface4::GetSurfaceDesc(LPDDSURFACEDESC2 a) 243 | { 244 | HRESULT r = m_pIDDrawSurface->GetSurfaceDesc(a); 245 | logf(this, "myIDDrawSurface4::GetSurfaceDesc([%x %x %x %x %x %x %x %x %x [%x %x %x %x %x %x %x %x] %x]) return %d", 246 | a->dwSize, 247 | a->dwFlags, 248 | a->dwWidth, 249 | a->dwHeight, 250 | a->lPitch, 251 | a->dwBackBufferCount, 252 | a->dwRefreshRate, 253 | a->dwAlphaBitDepth, 254 | a->lpSurface, 255 | a->ddpfPixelFormat.dwSize, 256 | a->ddpfPixelFormat.dwFlags, 257 | a->ddpfPixelFormat.dwFourCC, 258 | a->ddpfPixelFormat.dwRGBBitCount, 259 | a->ddpfPixelFormat.dwRBitMask, 260 | a->ddpfPixelFormat.dwGBitMask, 261 | a->ddpfPixelFormat.dwBBitMask, 262 | a->ddpfPixelFormat.dwRGBAlphaBitMask, 263 | a->ddsCaps.dwCaps, r); 264 | 265 | 266 | 267 | return r; 268 | } 269 | 270 | 271 | 272 | HRESULT __stdcall myIDDrawSurface4::Initialize(LPDIRECTDRAW a, LPDDSURFACEDESC2 b) 273 | { 274 | logf(this, "myIDDrawSurface4::Initialize"); 275 | return m_pIDDrawSurface->Initialize(a,b); 276 | } 277 | 278 | 279 | 280 | HRESULT __stdcall myIDDrawSurface4::IsLost() 281 | { 282 | logf(this, "myIDDrawSurface4::IsLost"); 283 | return m_pIDDrawSurface->IsLost(); 284 | } 285 | 286 | 287 | 288 | HRESULT __stdcall myIDDrawSurface4::Lock(LPRECT a,LPDDSURFACEDESC2 b,DWORD c,HANDLE d) 289 | { 290 | if (a) 291 | logf(this, "myIDDrawSurface4::Lock([%d,%d,%d,%d],%08x,%d,%d)",a->top,a->left,a->bottom,a->right,b,c,d); 292 | else 293 | logf(this, "myIDDrawSurface4::Lock([null],%08x,%d,%d)",b,c,d); 294 | HRESULT r = m_pIDDrawSurface->Lock(a,b,c,d); 295 | logf(this, "Locked surface data: %d,%d,%d,%d,%d,%08x,%d,%d", 296 | b->dwSize, 297 | b->dwFlags, 298 | b->dwHeight, 299 | b->dwWidth, 300 | b->lPitch, 301 | b->lpSurface, 302 | b->ddsCaps, 303 | b->ddpfPixelFormat); 304 | return r; 305 | } 306 | 307 | 308 | 309 | HRESULT __stdcall myIDDrawSurface4::ReleaseDC(HDC a) 310 | { 311 | logf(this, "myIDDrawSurface4::ReleaseDC"); 312 | return m_pIDDrawSurface->ReleaseDC(a); 313 | } 314 | 315 | 316 | 317 | HRESULT __stdcall myIDDrawSurface4::Restore() 318 | { 319 | logf(this, "myIDDrawSurface4::Restore"); 320 | return m_pIDDrawSurface->Restore(); 321 | } 322 | 323 | 324 | 325 | HRESULT __stdcall myIDDrawSurface4::SetClipper(LPDIRECTDRAWCLIPPER a) 326 | { 327 | logf(this, "myIDDrawSurface4::SetClipper"); 328 | return m_pIDDrawSurface->SetClipper(a); 329 | } 330 | 331 | 332 | 333 | HRESULT __stdcall myIDDrawSurface4::SetColorKey(DWORD a, LPDDCOLORKEY b) 334 | { 335 | logf(this, "myIDDrawSurface4::SetColorKey"); 336 | return m_pIDDrawSurface->SetColorKey(a,b); 337 | } 338 | 339 | 340 | 341 | HRESULT __stdcall myIDDrawSurface4::SetOverlayPosition(LONG a, LONG b) 342 | { 343 | logf(this, "myIDDrawSurface4::SetOverlayPosition"); 344 | return m_pIDDrawSurface->SetOverlayPosition(a,b); 345 | } 346 | 347 | 348 | 349 | HRESULT __stdcall myIDDrawSurface4::SetPalette(LPDIRECTDRAWPALETTE a) 350 | { 351 | logf(this, "myIDDrawSurface4::SetPalette(%08x)",a); 352 | if (a) a = ((myIDDrawPalette*)a)->m_pIDDrawPalette; 353 | return m_pIDDrawSurface->SetPalette(a); 354 | } 355 | 356 | 357 | 358 | HRESULT __stdcall myIDDrawSurface4::Unlock(LPRECT a) 359 | { 360 | logf(this, "myIDDrawSurface4::Unlock(%08x)",a); 361 | return m_pIDDrawSurface->Unlock(a); 362 | } 363 | 364 | 365 | 366 | HRESULT __stdcall myIDDrawSurface4::UpdateOverlay(LPRECT a, LPDIRECTDRAWSURFACE4 b,LPRECT c,DWORD d, LPDDOVERLAYFX e) 367 | { 368 | logf(this, "myIDDrawSurface4::UpdateOverlay"); 369 | return m_pIDDrawSurface->UpdateOverlay(a,((myIDDrawSurface4*)b)->m_pIDDrawSurface,c,d,e); 370 | } 371 | 372 | 373 | 374 | HRESULT __stdcall myIDDrawSurface4::UpdateOverlayDisplay(DWORD a) 375 | { 376 | logf(this, "myIDDrawSurface4::UpdateOverlayDisplay"); 377 | return m_pIDDrawSurface->UpdateOverlayDisplay(a); 378 | } 379 | 380 | 381 | 382 | HRESULT __stdcall myIDDrawSurface4::UpdateOverlayZOrder(DWORD a, LPDIRECTDRAWSURFACE4 b) 383 | { 384 | logf(this, "myIDDrawSurface4::UpdateOverlayZOrder"); 385 | return m_pIDDrawSurface->UpdateOverlayZOrder(a,((myIDDrawSurface4*)b)->m_pIDDrawSurface); 386 | } 387 | 388 | HRESULT __stdcall myIDDrawSurface4::GetDDInterface(LPVOID FAR * a) 389 | { 390 | logf(this, "myIDDrawSurface4::GetDDInterface"); 391 | return m_pIDDrawSurface->GetDDInterface(a); 392 | 393 | } 394 | 395 | HRESULT __stdcall myIDDrawSurface4::PageLock(DWORD a) 396 | { 397 | logf(this, "myIDDrawSurface4::PageLock"); 398 | return m_pIDDrawSurface->PageLock(a); 399 | 400 | } 401 | 402 | HRESULT __stdcall myIDDrawSurface4::PageUnlock(DWORD a) 403 | { 404 | logf(this, "myIDDrawSurface4::PageUnlock"); 405 | return m_pIDDrawSurface->PageUnlock(a); 406 | } 407 | 408 | HRESULT __stdcall myIDDrawSurface4::SetSurfaceDesc(LPDDSURFACEDESC2 a, DWORD b) 409 | { 410 | logf(this, "myIDDrawSurface4::SetSurfaceDesc"); 411 | return m_pIDDrawSurface->SetSurfaceDesc(a, b); 412 | 413 | } 414 | 415 | HRESULT __stdcall myIDDrawSurface4::SetPrivateData(REFGUID a, LPVOID b, DWORD c, DWORD d) 416 | { 417 | logf(this, "myIDDrawSurface4::SetPrivateData"); 418 | return m_pIDDrawSurface->SetPrivateData(a, b,c, d); 419 | } 420 | 421 | HRESULT __stdcall myIDDrawSurface4::GetPrivateData(REFGUID a, LPVOID b, LPDWORD c) 422 | { 423 | logf(this, "myIDDrawSurface4::GetPrivateData"); 424 | return m_pIDDrawSurface->GetPrivateData( a, b, c); 425 | } 426 | 427 | HRESULT __stdcall myIDDrawSurface4::FreePrivateData(REFGUID a) 428 | { 429 | logf(this, "myIDDrawSurface4::FreePrivateData"); 430 | return m_pIDDrawSurface->FreePrivateData(a); 431 | } 432 | 433 | HRESULT __stdcall myIDDrawSurface4::GetUniquenessValue(LPDWORD a) 434 | { 435 | logf(this, "myIDDrawSurface4::GetUniquenessValue"); 436 | return m_pIDDrawSurface->GetUniquenessValue(a); 437 | } 438 | 439 | HRESULT __stdcall myIDDrawSurface4::ChangeUniquenessValue() 440 | { 441 | logf(this, "myIDDrawSurface4::ChangeUniquenessValue"); 442 | return m_pIDDrawSurface->ChangeUniquenessValue(); 443 | } 444 | 445 | -------------------------------------------------------------------------------- /logger/myIDDrawSurface7.cpp: -------------------------------------------------------------------------------- 1 | #include "StdAfx.h" 2 | #include 3 | 4 | 5 | 6 | myIDDrawSurface7::myIDDrawSurface7(LPDIRECTDRAWSURFACE7 pOriginal) 7 | { 8 | logf(this, "myIDDrawSurface7 Constructor"); 9 | m_pIDDrawSurface = pOriginal; 10 | } 11 | 12 | 13 | myIDDrawSurface7::~myIDDrawSurface7(void) 14 | { 15 | logf(this, "myIDDrawSurface7 Destructor"); 16 | } 17 | 18 | 19 | HRESULT __stdcall myIDDrawSurface7::QueryInterface (REFIID, LPVOID FAR * b) 20 | { 21 | logf(this, "myIDDrawSurface7::QueryInterface"); 22 | 23 | *b = NULL; 24 | 25 | return E_NOTIMPL; 26 | } 27 | 28 | 29 | ULONG __stdcall myIDDrawSurface7::AddRef(void) 30 | { 31 | logf(this, "myIDDrawSurface7::AddRef"); 32 | return(m_pIDDrawSurface->AddRef()); 33 | } 34 | 35 | 36 | ULONG __stdcall myIDDrawSurface7::Release(void) 37 | { 38 | logf(this, "myIDDrawSurface7::Release"); 39 | 40 | // call original routine 41 | ULONG count = m_pIDDrawSurface->Release(); 42 | 43 | logf(this, "Object Release."); 44 | 45 | // in case no further Ref is there, the Original Object has deleted itself 46 | // so do we here 47 | if (count == 0) 48 | { 49 | m_pIDDrawSurface = NULL; 50 | delete(this); 51 | } 52 | 53 | return(count); 54 | } 55 | 56 | 57 | 58 | HRESULT __stdcall myIDDrawSurface7::AddAttachedSurface(LPDIRECTDRAWSURFACE7 a) 59 | { 60 | logf(this, "myIDDrawSurface7::AddAttachedSurface"); 61 | return m_pIDDrawSurface->AddAttachedSurface(((myIDDrawSurface7*)a)->m_pIDDrawSurface); 62 | } 63 | 64 | 65 | 66 | HRESULT __stdcall myIDDrawSurface7::AddOverlayDirtyRect(LPRECT a) 67 | { 68 | logf(this, "myIDDrawSurface7::AddOverlayDirtyRect"); 69 | return m_pIDDrawSurface->AddOverlayDirtyRect(a); 70 | } 71 | 72 | 73 | 74 | HRESULT __stdcall myIDDrawSurface7::Blt(LPRECT a,LPDIRECTDRAWSURFACE7 b, LPRECT c,DWORD d, LPDDBLTFX e) 75 | { 76 | if (a && c) 77 | logf(this, "myIDDrawSurface7::Blt([%d,%d,%d,%d],%08x,[%d,%d,%d,%d],%d,%08x)", 78 | a->top,a->left,a->bottom,a->right, 79 | b, 80 | c->top,c->left,c->bottom,c->right, 81 | d, 82 | e->dwDDFX); 83 | else 84 | if (a) 85 | logf(this, "myIDDrawSurface7::Blt([%d,%d,%d,%d],%08x,[null],%d,%08x)", 86 | a->top,a->left,a->bottom,a->right, 87 | b, 88 | d, 89 | e->dwDDFX); 90 | else 91 | if (c) 92 | logf(this, "myIDDrawSurface7::Blt([null],%08x,[%d,%d,%d,%d],%d,%08x)", 93 | b, 94 | c->top,c->left,c->bottom,c->right, 95 | d, 96 | e->dwDDFX); 97 | else 98 | logf(this, "myIDDrawSurface7::Blt([null],%08x,[null],%d,%08x)", 99 | b, 100 | d, 101 | e->dwDDFX); 102 | if (b) b = ((myIDDrawSurface7*)b)->m_pIDDrawSurface; 103 | return m_pIDDrawSurface->Blt(a,b,c,d,e); 104 | } 105 | 106 | 107 | 108 | HRESULT __stdcall myIDDrawSurface7::BltBatch(LPDDBLTBATCH a, DWORD b, DWORD c) 109 | { 110 | logf(this, "myIDDrawSurface7::BltBatch"); 111 | return m_pIDDrawSurface->BltBatch(a,b,c); 112 | } 113 | 114 | 115 | 116 | HRESULT __stdcall myIDDrawSurface7::BltFast(DWORD a,DWORD b,LPDIRECTDRAWSURFACE7 c, LPRECT d,DWORD e) 117 | { 118 | logf(this, "myIDDrawSurface7::BltFast"); 119 | return m_pIDDrawSurface->BltFast(a,b,((myIDDrawSurface7*)c)->m_pIDDrawSurface,d,e); 120 | } 121 | 122 | 123 | 124 | HRESULT __stdcall myIDDrawSurface7::DeleteAttachedSurface(DWORD a,LPDIRECTDRAWSURFACE7 b) 125 | { 126 | logf(this, "myIDDrawSurface7::DeleteAttachedSurface"); 127 | return m_pIDDrawSurface->DeleteAttachedSurface(a,((myIDDrawSurface7*)b)->m_pIDDrawSurface); 128 | } 129 | 130 | 131 | 132 | HRESULT __stdcall myIDDrawSurface7::EnumAttachedSurfaces(LPVOID a,LPDDENUMSURFACESCALLBACK7 b) 133 | { 134 | logf(this, "myIDDrawSurface7::EnumAttachedSurfaces"); 135 | return m_pIDDrawSurface->EnumAttachedSurfaces(a,b); 136 | } 137 | 138 | 139 | 140 | HRESULT __stdcall myIDDrawSurface7::EnumOverlayZOrders(DWORD a,LPVOID b,LPDDENUMSURFACESCALLBACK7 c) 141 | { 142 | logf(this, "myIDDrawSurface7::EnumOverlayZOrders"); 143 | return m_pIDDrawSurface->EnumOverlayZOrders(a,b,c); 144 | } 145 | 146 | 147 | 148 | HRESULT __stdcall myIDDrawSurface7::Flip(LPDIRECTDRAWSURFACE7 a, DWORD b) 149 | { 150 | logf(this, "myIDDrawSurface7::Flip(%08x,%d)", a, b); 151 | if (a) a = ((myIDDrawSurface7*)a)->m_pIDDrawSurface; 152 | return m_pIDDrawSurface->Flip(a,b); 153 | } 154 | 155 | 156 | 157 | HRESULT __stdcall myIDDrawSurface7::GetAttachedSurface(LPDDSCAPS2 a, LPDIRECTDRAWSURFACE7 FAR * b) 158 | { 159 | HRESULT r = m_pIDDrawSurface->GetAttachedSurface(a,b); 160 | *b = new myIDDrawSurface7(*b); 161 | 162 | logf(this, "myIDDrawSurface7::GetAttachedSurface([%d], %08x) return %d", 163 | a->dwCaps, b, r); 164 | 165 | return r; 166 | } 167 | 168 | 169 | 170 | HRESULT __stdcall myIDDrawSurface7::GetBltStatus(DWORD a) 171 | { 172 | logf(this, "myIDDrawSurface7::GetBltStatus"); 173 | return m_pIDDrawSurface->GetBltStatus(a); 174 | } 175 | 176 | 177 | 178 | HRESULT __stdcall myIDDrawSurface7::GetCaps(LPDDSCAPS2 a) 179 | { 180 | logf(this, "myIDDrawSurface7::GetCaps"); 181 | return m_pIDDrawSurface->GetCaps(a); 182 | } 183 | 184 | 185 | 186 | HRESULT __stdcall myIDDrawSurface7::GetClipper(LPDIRECTDRAWCLIPPER FAR* a) 187 | { 188 | logf(this, "myIDDrawSurface7::GetClipper"); 189 | return m_pIDDrawSurface->GetClipper(a); 190 | } 191 | 192 | 193 | 194 | HRESULT __stdcall myIDDrawSurface7::GetColorKey(DWORD a, LPDDCOLORKEY b) 195 | { 196 | logf(this, "myIDDrawSurface7::GetColorKey"); 197 | return m_pIDDrawSurface->GetColorKey(a,b); 198 | } 199 | 200 | 201 | 202 | HRESULT __stdcall myIDDrawSurface7::GetDC(HDC FAR *a) 203 | { 204 | logf(this, "myIDDrawSurface7::GetDC"); 205 | return m_pIDDrawSurface->GetDC(a); 206 | } 207 | 208 | 209 | 210 | HRESULT __stdcall myIDDrawSurface7::GetFlipStatus(DWORD a) 211 | { 212 | logf(this, "myIDDrawSurface7::GetFlipStatus"); 213 | return m_pIDDrawSurface->GetFlipStatus(a); 214 | } 215 | 216 | 217 | 218 | HRESULT __stdcall myIDDrawSurface7::GetOverlayPosition(LPLONG a, LPLONG b) 219 | { 220 | logf(this, "myIDDrawSurface7::GetOverlayPosition"); 221 | return m_pIDDrawSurface->GetOverlayPosition(a,b); 222 | } 223 | 224 | 225 | 226 | HRESULT __stdcall myIDDrawSurface7::GetPalette(LPDIRECTDRAWPALETTE FAR*a) 227 | { 228 | logf(this, "myIDDrawSurface7::GetPalette"); 229 | return m_pIDDrawSurface->GetPalette(a); 230 | } 231 | 232 | 233 | 234 | HRESULT __stdcall myIDDrawSurface7::GetPixelFormat(LPDDPIXELFORMAT a) 235 | { 236 | logf(this, "myIDDrawSurface7::GetPixelFormat"); 237 | return m_pIDDrawSurface->GetPixelFormat(a); 238 | } 239 | 240 | 241 | 242 | HRESULT __stdcall myIDDrawSurface7::GetSurfaceDesc(LPDDSURFACEDESC2 a) 243 | { 244 | HRESULT r = m_pIDDrawSurface->GetSurfaceDesc(a); 245 | logf(this, "myIDDrawSurface7::GetSurfaceDesc([%x %x %x %x %x %x %x %x %x [%x %x %x %x %x %x %x %x] %x]) return %d", 246 | a->dwSize, 247 | a->dwFlags, 248 | a->dwWidth, 249 | a->dwHeight, 250 | a->lPitch, 251 | a->dwBackBufferCount, 252 | a->dwRefreshRate, 253 | a->dwAlphaBitDepth, 254 | a->lpSurface, 255 | a->ddpfPixelFormat.dwSize, 256 | a->ddpfPixelFormat.dwFlags, 257 | a->ddpfPixelFormat.dwFourCC, 258 | a->ddpfPixelFormat.dwRGBBitCount, 259 | a->ddpfPixelFormat.dwRBitMask, 260 | a->ddpfPixelFormat.dwGBitMask, 261 | a->ddpfPixelFormat.dwBBitMask, 262 | a->ddpfPixelFormat.dwRGBAlphaBitMask, 263 | a->ddsCaps.dwCaps, r); 264 | 265 | 266 | 267 | return r; 268 | } 269 | 270 | 271 | 272 | HRESULT __stdcall myIDDrawSurface7::Initialize(LPDIRECTDRAW a, LPDDSURFACEDESC2 b) 273 | { 274 | logf(this, "myIDDrawSurface7::Initialize"); 275 | return m_pIDDrawSurface->Initialize(a,b); 276 | } 277 | 278 | 279 | 280 | HRESULT __stdcall myIDDrawSurface7::IsLost() 281 | { 282 | logf(this, "myIDDrawSurface7::IsLost"); 283 | return m_pIDDrawSurface->IsLost(); 284 | } 285 | 286 | 287 | 288 | HRESULT __stdcall myIDDrawSurface7::Lock(LPRECT a,LPDDSURFACEDESC2 b,DWORD c,HANDLE d) 289 | { 290 | if (a) 291 | logf(this, "myIDDrawSurface7::Lock([%d,%d,%d,%d],%08x,%d,%d)",a->top,a->left,a->bottom,a->right,b,c,d); 292 | else 293 | logf(this, "myIDDrawSurface7::Lock([null],%08x,%d,%d)",b,c,d); 294 | HRESULT r = m_pIDDrawSurface->Lock(a,b,c,d); 295 | logf(this, "Locked surface data: %d,%d,%d,%d,%d,%08x,%d,%d", 296 | b->dwSize, 297 | b->dwFlags, 298 | b->dwHeight, 299 | b->dwWidth, 300 | b->lPitch, 301 | b->lpSurface, 302 | b->ddsCaps, 303 | b->ddpfPixelFormat); 304 | return r; 305 | } 306 | 307 | 308 | 309 | HRESULT __stdcall myIDDrawSurface7::ReleaseDC(HDC a) 310 | { 311 | logf(this, "myIDDrawSurface7::ReleaseDC"); 312 | return m_pIDDrawSurface->ReleaseDC(a); 313 | } 314 | 315 | 316 | 317 | HRESULT __stdcall myIDDrawSurface7::Restore() 318 | { 319 | logf(this, "myIDDrawSurface7::Restore"); 320 | return m_pIDDrawSurface->Restore(); 321 | } 322 | 323 | 324 | 325 | HRESULT __stdcall myIDDrawSurface7::SetClipper(LPDIRECTDRAWCLIPPER a) 326 | { 327 | logf(this, "myIDDrawSurface7::SetClipper"); 328 | return m_pIDDrawSurface->SetClipper(a); 329 | } 330 | 331 | 332 | 333 | HRESULT __stdcall myIDDrawSurface7::SetColorKey(DWORD a, LPDDCOLORKEY b) 334 | { 335 | logf(this, "myIDDrawSurface7::SetColorKey"); 336 | return m_pIDDrawSurface->SetColorKey(a,b); 337 | } 338 | 339 | 340 | 341 | HRESULT __stdcall myIDDrawSurface7::SetOverlayPosition(LONG a, LONG b) 342 | { 343 | logf(this, "myIDDrawSurface7::SetOverlayPosition"); 344 | return m_pIDDrawSurface->SetOverlayPosition(a,b); 345 | } 346 | 347 | 348 | 349 | HRESULT __stdcall myIDDrawSurface7::SetPalette(LPDIRECTDRAWPALETTE a) 350 | { 351 | logf(this, "myIDDrawSurface7::SetPalette(%08x)",a); 352 | if (a) a = ((myIDDrawPalette*)a)->m_pIDDrawPalette; 353 | return m_pIDDrawSurface->SetPalette(a); 354 | } 355 | 356 | 357 | 358 | HRESULT __stdcall myIDDrawSurface7::Unlock(LPRECT a) 359 | { 360 | logf(this, "myIDDrawSurface7::Unlock(%08x)",a); 361 | return m_pIDDrawSurface->Unlock(a); 362 | } 363 | 364 | 365 | 366 | HRESULT __stdcall myIDDrawSurface7::UpdateOverlay(LPRECT a, LPDIRECTDRAWSURFACE7 b,LPRECT c,DWORD d, LPDDOVERLAYFX e) 367 | { 368 | logf(this, "myIDDrawSurface7::UpdateOverlay"); 369 | return m_pIDDrawSurface->UpdateOverlay(a,((myIDDrawSurface7*)b)->m_pIDDrawSurface,c,d,e); 370 | } 371 | 372 | 373 | 374 | HRESULT __stdcall myIDDrawSurface7::UpdateOverlayDisplay(DWORD a) 375 | { 376 | logf(this, "myIDDrawSurface7::UpdateOverlayDisplay"); 377 | return m_pIDDrawSurface->UpdateOverlayDisplay(a); 378 | } 379 | 380 | 381 | 382 | HRESULT __stdcall myIDDrawSurface7::UpdateOverlayZOrder(DWORD a, LPDIRECTDRAWSURFACE7 b) 383 | { 384 | logf(this, "myIDDrawSurface7::UpdateOverlayZOrder"); 385 | return m_pIDDrawSurface->UpdateOverlayZOrder(a,((myIDDrawSurface7*)b)->m_pIDDrawSurface); 386 | } 387 | 388 | HRESULT __stdcall myIDDrawSurface7::GetDDInterface(LPVOID FAR * a) 389 | { 390 | logf(this, "myIDDrawSurface7::GetDDInterface"); 391 | return m_pIDDrawSurface->GetDDInterface(a); 392 | 393 | } 394 | 395 | HRESULT __stdcall myIDDrawSurface7::PageLock(DWORD a) 396 | { 397 | logf(this, "myIDDrawSurface7::PageLock"); 398 | return m_pIDDrawSurface->PageLock(a); 399 | 400 | } 401 | 402 | HRESULT __stdcall myIDDrawSurface7::PageUnlock(DWORD a) 403 | { 404 | logf(this, "myIDDrawSurface7::PageUnlock"); 405 | return m_pIDDrawSurface->PageUnlock(a); 406 | } 407 | 408 | HRESULT __stdcall myIDDrawSurface7::SetSurfaceDesc(LPDDSURFACEDESC2 a, DWORD b) 409 | { 410 | logf(this, "myIDDrawSurface7::SetSurfaceDesc"); 411 | return m_pIDDrawSurface->SetSurfaceDesc(a, b); 412 | 413 | } 414 | 415 | HRESULT __stdcall myIDDrawSurface7::SetPrivateData(REFGUID a, LPVOID b, DWORD c, DWORD d) 416 | { 417 | logf(this, "myIDDrawSurface7::SetPrivateData"); 418 | return m_pIDDrawSurface->SetPrivateData(a, b,c, d); 419 | } 420 | 421 | HRESULT __stdcall myIDDrawSurface7::GetPrivateData(REFGUID a, LPVOID b, LPDWORD c) 422 | { 423 | logf(this, "myIDDrawSurface7::GetPrivateData"); 424 | return m_pIDDrawSurface->GetPrivateData( a, b, c); 425 | } 426 | 427 | HRESULT __stdcall myIDDrawSurface7::FreePrivateData(REFGUID a) 428 | { 429 | logf(this, "myIDDrawSurface7::FreePrivateData"); 430 | return m_pIDDrawSurface->FreePrivateData(a); 431 | } 432 | 433 | HRESULT __stdcall myIDDrawSurface7::GetUniquenessValue(LPDWORD a) 434 | { 435 | logf(this, "myIDDrawSurface7::GetUniquenessValue"); 436 | return m_pIDDrawSurface->GetUniquenessValue(a); 437 | } 438 | 439 | HRESULT __stdcall myIDDrawSurface7::ChangeUniquenessValue() 440 | { 441 | logf(this, "myIDDrawSurface7::ChangeUniquenessValue"); 442 | return m_pIDDrawSurface->ChangeUniquenessValue(); 443 | } 444 | 445 | HRESULT __stdcall myIDDrawSurface7::SetPriority(DWORD a) 446 | { 447 | logf(this, "myIDDrawSurface7::SetPriority"); 448 | return m_pIDDrawSurface->SetPriority(a); 449 | } 450 | 451 | HRESULT __stdcall myIDDrawSurface7::GetPriority(LPDWORD a) 452 | { 453 | logf(this, "myIDDrawSurface7::GetPriority"); 454 | return m_pIDDrawSurface->GetPriority(a); 455 | } 456 | 457 | HRESULT __stdcall myIDDrawSurface7::SetLOD(DWORD a) 458 | { 459 | logf(this, "myIDDrawSurface7::SetLOD"); 460 | return m_pIDDrawSurface->SetLOD(a); 461 | 462 | } 463 | 464 | HRESULT __stdcall myIDDrawSurface7:: GetLOD(LPDWORD a) 465 | { 466 | logf(this, "myIDDrawSurface7::GetLOD"); 467 | return m_pIDDrawSurface->GetLOD(a); 468 | } 469 | -------------------------------------------------------------------------------- /logger/stdafx.cpp: -------------------------------------------------------------------------------- 1 | // stdafx.cpp 2 | #include "stdafx.h" 3 | -------------------------------------------------------------------------------- /logger/stdafx.h: -------------------------------------------------------------------------------- 1 | // stdafx.h 2 | 3 | #pragma once 4 | 5 | #define WIN32_LEAN_AND_MEAN 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | #include "ddraw.h" 12 | #include "myIDDraw.h" 13 | #include "ddwrapper.h" 14 | 15 | void logf(void * thisptr, char *msg, ...); 16 | -------------------------------------------------------------------------------- /makefixed.py: -------------------------------------------------------------------------------- 1 | import xml.dom.minidom 2 | import re 3 | from PIL import Image 4 | 5 | print "#include " 6 | print 7 | print "static unsigned char *fixed_data[0x7f - 0x20];" 8 | print "static unsigned int fixed_width[0x7f - 0x20];" 9 | print "static unsigned int fixed_height[0x7f - 0x20];" 10 | print "static unsigned int fixed_aw[0x7f - 0x20];" 11 | print "static std::hash_map fixed_kernings;" 12 | print 13 | print "#define X 1," 14 | print "#define _ 0," 15 | print 16 | 17 | im = Image.open("test-0.png") 18 | doc = xml.dom.minidom.parse("test.xml") 19 | for i in doc.getElementsByTagName("glyph"): 20 | r = re.compile('[,x]') 21 | charcode = int(i.getAttribute("code"), 16) 22 | x, y = r.split(i.getAttribute("origin")) 23 | width, height = r.split(i.getAttribute("size")) 24 | x = int(x) 25 | y = int(y) 26 | width = int(width) 27 | height = int(height) 28 | aw = int(i.getAttribute("aw")) 29 | 30 | print "static unsigned char fixed_{:02x}_data[] = {{".format(charcode) 31 | for j in range(y, y + height): 32 | for k in range(x, x + width): 33 | pixel = im.getpixel((k, j)) 34 | if pixel == (0, 0, 0, 0): 35 | pixel = "_" 36 | else: 37 | pixel = "X" 38 | print "{}".format(pixel), 39 | print 40 | print "};" 41 | print "static unsigned int fixed_{:02x}_width = {};".format(charcode, width) 42 | print "static unsigned int fixed_{:02x}_height = {};".format(charcode, height) 43 | print "static unsigned int fixed_{:02x}_aw = {};".format(charcode, aw) 44 | print 45 | 46 | print "#undef X" 47 | print "#undef _" 48 | print 49 | print "void fixed_kernings_setup()" 50 | print "{" 51 | 52 | for i in range(0x20, 0x7f): 53 | print " fixed_data[{:#04x}] = fixed_{:02x}_data;".format(i - 0x20, i) 54 | print " fixed_width[{:#04x}] = fixed_{:02x}_width;".format(i - 0x20, i) 55 | print " fixed_height[{:#04x}] = fixed_{:02x}_height;".format(i - 0x20, i) 56 | print " fixed_aw[{:#04x}] = fixed_{:02x}_aw;".format(i - 0x20, i) 57 | 58 | print 59 | 60 | for i in doc.getElementsByTagName("kernpair"): 61 | left = ord(i.getAttribute("left")) 62 | right = ord(i.getAttribute("right")) 63 | adjust = int(i.getAttribute("adjust")) 64 | kerncode = left | (right << 8) 65 | print " fixed_kernings[{:#06x}] = {};".format(kerncode, adjust) 66 | 67 | print "}" 68 | --------------------------------------------------------------------------------