├── .gitattributes ├── .gitignore ├── classfactory.cpp ├── clipper.cpp ├── color.cpp ├── dd.cpp ├── dds.cpp ├── ddwrapper.vcproj ├── dllmain.cpp ├── exports.def ├── gamma.cpp ├── header.h ├── license.txt ├── log.cpp ├── log.h ├── palette.cpp ├── unknwn.cpp ├── wine ├── d3d.h ├── d3dcaps.h └── d3dtypes.h ├── wrap.cpp └── wrap.h /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | *.sln merge=union 7 | *.csproj merge=union 8 | *.vbproj merge=union 9 | *.fsproj merge=union 10 | *.dbproj merge=union 11 | 12 | # Standard to msysgit 13 | *.doc diff=astextplain 14 | *.DOC diff=astextplain 15 | *.docx diff=astextplain 16 | *.DOCX diff=astextplain 17 | *.dot diff=astextplain 18 | *.DOT diff=astextplain 19 | *.pdf diff=astextplain 20 | *.PDF diff=astextplain 21 | *.rtf diff=astextplain 22 | *.RTF diff=astextplain 23 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ################# 2 | ## Eclipse 3 | ################# 4 | 5 | *.pydevproject 6 | .project 7 | .metadata 8 | bin/ 9 | tmp/ 10 | *.tmp 11 | *.bak 12 | *.swp 13 | *~.nib 14 | local.properties 15 | .classpath 16 | .settings/ 17 | .loadpath 18 | 19 | # External tool builders 20 | .externalToolBuilders/ 21 | 22 | # Locally stored "Eclipse launch configurations" 23 | *.launch 24 | 25 | # CDT-specific 26 | .cproject 27 | 28 | # PDT-specific 29 | .buildpath 30 | 31 | 32 | ################# 33 | ## Visual Studio 34 | ################# 35 | 36 | ## Ignore Visual Studio temporary files, build results, and 37 | ## files generated by popular Visual Studio add-ons. 38 | 39 | # User-specific files 40 | *.suo 41 | *.user 42 | *.sln.docstates 43 | 44 | # Build results 45 | [Dd]ebug/ 46 | [Rr]elease/ 47 | *_i.c 48 | *_p.c 49 | *.ilk 50 | *.meta 51 | *.obj 52 | *.pch 53 | *.pdb 54 | *.pgc 55 | *.pgd 56 | *.rsp 57 | *.sbr 58 | *.tlb 59 | *.tli 60 | *.tlh 61 | *.tmp 62 | *.vspscc 63 | .builds 64 | *.dotCover 65 | 66 | ## TODO: If you have NuGet Package Restore enabled, uncomment this 67 | #packages/ 68 | 69 | # Visual C++ cache files 70 | ipch/ 71 | *.aps 72 | *.ncb 73 | *.opensdf 74 | *.sdf 75 | 76 | # Visual Studio profiler 77 | *.psess 78 | *.vsp 79 | 80 | # ReSharper is a .NET coding add-in 81 | _ReSharper* 82 | 83 | # Installshield output folder 84 | [Ee]xpress 85 | 86 | # DocProject is a documentation generator add-in 87 | DocProject/buildhelp/ 88 | DocProject/Help/*.HxT 89 | DocProject/Help/*.HxC 90 | DocProject/Help/*.hhc 91 | DocProject/Help/*.hhk 92 | DocProject/Help/*.hhp 93 | DocProject/Help/Html2 94 | DocProject/Help/html 95 | 96 | # Click-Once directory 97 | publish 98 | 99 | # Others 100 | [Bb]in 101 | [Oo]bj 102 | sql 103 | TestResults 104 | *.Cache 105 | ClientBin 106 | stylecop.* 107 | ~$* 108 | *.dbmdl 109 | Generated_Code #added for RIA/Silverlight projects 110 | 111 | # Backup & report files from converting an old project file to a newer 112 | # Visual Studio version. Backup files are not needed, because we have git ;-) 113 | _UpgradeReport_Files/ 114 | Backup*/ 115 | UpgradeLog*.XML 116 | 117 | 118 | 119 | ############ 120 | ## Windows 121 | ############ 122 | 123 | # Windows image file caches 124 | Thumbs.db 125 | 126 | # Folder config file 127 | Desktop.ini 128 | 129 | 130 | ############# 131 | ## Python 132 | ############# 133 | 134 | *.py[co] 135 | 136 | # Packages 137 | *.egg 138 | *.egg-info 139 | dist 140 | build 141 | eggs 142 | parts 143 | bin 144 | var 145 | sdist 146 | develop-eggs 147 | .installed.cfg 148 | 149 | # Installer logs 150 | pip-log.txt 151 | 152 | # Unit test / coverage reports 153 | .coverage 154 | .tox 155 | 156 | #Translations 157 | *.mo 158 | 159 | #Mr Developer 160 | .mr.developer.cfg 161 | 162 | # Mac crap 163 | .DS_Store 164 | -------------------------------------------------------------------------------- /classfactory.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | namespace classfactory 4 | { 5 | struct XVTBL 6 | { 7 | HRESULT (__stdcall * QueryInterface)( WRAP* This, const IID& riid, void** ppvObject ); 8 | ULONG (__stdcall * AddRef)( WRAP* This ); 9 | ULONG (__stdcall * Release)( WRAP* This ); 10 | HRESULT (__stdcall * CreateInstance)( WRAP* This, IUnknown *pUnkOuter, REFIID riid, void **ppvObject ); 11 | HRESULT (__stdcall * LockServer)( WRAP* This, BOOL fLock ); 12 | }; 13 | 14 | HRESULT __stdcall QueryInterface( WRAP* This, const IID& riid, void** ppvObject ) 15 | { 16 | PROLOGUE; 17 | HRESULT hResult = This->cf->lpVtbl->QueryInterface( This->cf, riid, ppvObject ); 18 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 19 | EPILOGUE( hResult ); 20 | } 21 | 22 | ULONG __stdcall AddRef( WRAP* This ) 23 | { 24 | PROLOGUE; 25 | ULONG dwCount = This->cf->lpVtbl->AddRef( This->cf ); 26 | EPILOGUE( dwCount ); 27 | } 28 | 29 | ULONG __stdcall Release( WRAP* This ) 30 | { 31 | PROLOGUE; 32 | ULONG dwCount = WrapRelease( This ); 33 | EPILOGUE( dwCount ); 34 | } 35 | 36 | HRESULT __stdcall CreateInstance( WRAP* This, IUnknown *pUnkOuter, REFIID riid, void **ppvObject ) 37 | { 38 | PROLOGUE; 39 | HRESULT hResult = This->cf->lpVtbl->CreateInstance( This->cf, pUnkOuter, riid, ppvObject ); 40 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 41 | EPILOGUE( hResult ); 42 | } 43 | 44 | HRESULT __stdcall LockServer( WRAP* This, BOOL fLock ) 45 | { 46 | PROLOGUE; 47 | HRESULT hResult = This->cf->lpVtbl->LockServer( This->cf, fLock ); 48 | EPILOGUE( hResult ); 49 | } 50 | 51 | const XVTBL xVtbl = 52 | { 53 | QueryInterface, // 0x00 54 | AddRef, // 0x04 55 | Release, // 0x08 56 | CreateInstance, // 0x0C 57 | LockServer // 0x10 58 | }; 59 | }; -------------------------------------------------------------------------------- /clipper.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | namespace clipper 4 | { 5 | struct XVTBL 6 | { 7 | HRESULT (__stdcall * QueryInterface)( WRAP* This, const IID& riid, void** ppvObject ); 8 | ULONG (__stdcall * AddRef)( WRAP* This ); 9 | ULONG (__stdcall * Release)( WRAP* This ); 10 | HRESULT (__stdcall * GetClipList)( WRAP* This, LPRECT lpRect, LPRGNDATA lpClipList, LPDWORD lpdwSize ); 11 | HRESULT (__stdcall * GetHWnd)( WRAP* This, HWND* lphWnd ); 12 | HRESULT (__stdcall * Initialize)( WRAP* This, LPDIRECTDRAW lpDD, DWORD dwFlags ); 13 | HRESULT (__stdcall * IsClipListChanged)( WRAP* This, BOOL* lpbChanged ); 14 | HRESULT (__stdcall * SetClipList)( WRAP* This, LPRGNDATA lpClipList, DWORD dwFlags ); 15 | HRESULT (__stdcall * SetHWnd)( WRAP* This, DWORD dwFlags, HWND hWnd ); 16 | }; 17 | 18 | HRESULT __stdcall QueryInterface( WRAP* This, const IID& riid, void** ppvObject ) 19 | { 20 | PROLOGUE; 21 | HRESULT hResult = This->clip->lpVtbl->QueryInterface( This->clip, riid, ppvObject ); 22 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 23 | EPILOGUE( hResult ); 24 | } 25 | 26 | ULONG __stdcall AddRef( WRAP* This ) 27 | { 28 | PROLOGUE; 29 | ULONG dwCount = This->clip->lpVtbl->AddRef( This->clip ); 30 | EPILOGUE( dwCount ); 31 | } 32 | 33 | ULONG __stdcall Release( WRAP* This ) 34 | { 35 | PROLOGUE; 36 | ULONG dwCount = WrapRelease( This ); 37 | EPILOGUE( dwCount ); 38 | } 39 | 40 | HRESULT __stdcall GetClipList( WRAP* This, LPRECT lpRect, LPRGNDATA lpClipList, LPDWORD lpdwSize ) 41 | { 42 | PROLOGUE; 43 | HRESULT hResult = This->clip->lpVtbl->GetClipList( This->clip, lpRect, lpClipList, lpdwSize ); 44 | EPILOGUE( hResult ); 45 | } 46 | 47 | HRESULT __stdcall GetHWnd( WRAP* This, HWND* lphWnd ) 48 | { 49 | PROLOGUE; 50 | HRESULT hResult = This->clip->lpVtbl->GetHWnd( This->clip, lphWnd ); 51 | EPILOGUE( hResult ); 52 | } 53 | 54 | HRESULT __stdcall Initialize( WRAP* This, LPDIRECTDRAW lpDD, DWORD dwFlags ) 55 | { 56 | PROLOGUE; 57 | HRESULT hResult = This->clip->lpVtbl->Initialize( This->clip, GetInnerInterface( lpDD ), dwFlags ); 58 | EPILOGUE( hResult ); 59 | } 60 | 61 | HRESULT __stdcall IsClipListChanged( WRAP* This, BOOL* lpbChanged ) 62 | { 63 | PROLOGUE; 64 | HRESULT hResult = This->clip->lpVtbl->IsClipListChanged( This->clip, lpbChanged ); 65 | EPILOGUE( hResult ); 66 | } 67 | 68 | HRESULT __stdcall SetClipList( WRAP* This, LPRGNDATA lpClipList, DWORD dwFlags ) 69 | { 70 | PROLOGUE; 71 | HRESULT hResult = This->clip->lpVtbl->SetClipList( This->clip, lpClipList, dwFlags ); 72 | EPILOGUE( hResult ); 73 | } 74 | 75 | HRESULT __stdcall SetHWnd( WRAP* This, DWORD dwFlags, HWND hWnd ) 76 | { 77 | PROLOGUE; 78 | HRESULT hResult = This->clip->lpVtbl->SetHWnd( This->clip, dwFlags, hWnd ); 79 | EPILOGUE( hResult ); 80 | } 81 | 82 | const XVTBL xVtbl = 83 | { 84 | QueryInterface, // 0x00 85 | AddRef, // 0x04 86 | Release, // 0x08 87 | GetClipList, // 0x0C 88 | GetHWnd, // 0x10 89 | Initialize, // 0x14 90 | IsClipListChanged, // 0x18 91 | SetClipList, // 0x1C 92 | SetHWnd // 0x20 93 | }; 94 | }; 95 | -------------------------------------------------------------------------------- /color.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | namespace color 4 | { 5 | struct XVTBL 6 | { 7 | HRESULT (__stdcall * QueryInterface)( WRAP* This, const IID& riid, void** ppvObject ); 8 | ULONG (__stdcall * AddRef)( WRAP* This ); 9 | ULONG (__stdcall * Release)( WRAP* This ); 10 | HRESULT (__stdcall * GetColorControls)( WRAP* This, LPDDCOLORCONTROL lpColorControl ); 11 | HRESULT (__stdcall * SetColorControls)( WRAP* This, LPDDCOLORCONTROL lpColorControl ); 12 | }; 13 | 14 | HRESULT __stdcall QueryInterface( WRAP* This, const IID& riid, void** ppvObject ) 15 | { 16 | PROLOGUE; 17 | HRESULT hResult = This->color->lpVtbl->QueryInterface( This->color, riid, ppvObject ); 18 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 19 | EPILOGUE( hResult ); 20 | } 21 | 22 | ULONG __stdcall AddRef( WRAP* This ) 23 | { 24 | PROLOGUE; 25 | ULONG dwCount = This->color->lpVtbl->AddRef( This->color ); 26 | EPILOGUE( dwCount ); 27 | } 28 | 29 | ULONG __stdcall Release( WRAP* This ) 30 | { 31 | PROLOGUE; 32 | ULONG dwCount = WrapRelease( This ); 33 | EPILOGUE( dwCount ); 34 | } 35 | 36 | HRESULT __stdcall GetColorControls( WRAP* This, LPDDCOLORCONTROL lpColorControl ) 37 | { 38 | PROLOGUE; 39 | HRESULT hResult = This->color->lpVtbl->GetColorControls( This->color, lpColorControl ); 40 | EPILOGUE( hResult ); 41 | } 42 | 43 | HRESULT __stdcall SetColorControls( WRAP* This, LPDDCOLORCONTROL lpColorControl ) 44 | { 45 | PROLOGUE; 46 | HRESULT hResult = This->color->lpVtbl->SetColorControls( This->color, lpColorControl ); 47 | EPILOGUE( hResult ); 48 | } 49 | 50 | const XVTBL xVtbl = 51 | { 52 | QueryInterface, // 0x00 53 | AddRef, // 0x04 54 | Release, // 0x08 55 | GetColorControls, // 0x0C 56 | SetColorControls, // 0x10 57 | }; 58 | }; -------------------------------------------------------------------------------- /dd.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | namespace dd 4 | { 5 | struct XVTBL 6 | { 7 | HRESULT (__stdcall * QueryInterface)( WRAP* This, const IID& riid, void** ppvObject ); 8 | ULONG (__stdcall * AddRef)( WRAP* This ); 9 | ULONG (__stdcall * Release)( WRAP* This ); 10 | HRESULT (__stdcall * Compact)( WRAP* This ); 11 | HRESULT (__stdcall * CreateClipper)( WRAP* This, DWORD dwFlags, LPDIRECTDRAWCLIPPER *lplpDDClipper, IUnknown *pUnkOuter); 12 | HRESULT (__stdcall * CreatePalette)( WRAP* This, DWORD dwFlags, LPPALETTEENTRY lpColorTable, LPDIRECTDRAWPALETTE *lplpDDPalette, IUnknown *pUnkOuter); 13 | HRESULT (__stdcall * CreateSurface)( WRAP* This, LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE *lplpDDSurface, IUnknown *pUnkOuter ); 14 | HRESULT (__stdcall * DuplicateSurface)( WRAP* This, LPDIRECTDRAWSURFACE lpDDSurface, LPDIRECTDRAWSURFACE *lplpDupDDSurface ); 15 | HRESULT (__stdcall * EnumDisplayModes)( WRAP* This, DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext, LPDDENUMMODESCALLBACK lpEnumModesCallback ); 16 | HRESULT (__stdcall * EnumSurfaces)( WRAP* This, DWORD dwFlags, LPDDSURFACEDESC lpDDSD, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback ); 17 | HRESULT (__stdcall * FlipToGDISurface)( WRAP* This ); 18 | HRESULT (__stdcall * GetCaps)( WRAP* This, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps ); 19 | HRESULT (__stdcall * GetDisplayMode)( WRAP* This, LPDDSURFACEDESC lpDDSurfaceDesc ); 20 | HRESULT (__stdcall * GetFourCCCodes)( WRAP* This, LPDWORD lpNumCodes, LPDWORD lpCodes ); 21 | HRESULT (__stdcall * GetGDISurface)( WRAP* This, LPDIRECTDRAWSURFACE *lplpGDIDDSurface ); 22 | HRESULT (__stdcall * GetMonitorFrequency)( WRAP* This, LPDWORD lpdwFrequency ); 23 | HRESULT (__stdcall * GetScanLine)( WRAP* This, LPDWORD lpdwScanLine ); 24 | HRESULT (__stdcall * GetVerticalBlankStatus)( WRAP* This, BOOL *lpbIsInVB ); 25 | HRESULT (__stdcall * Initialize)( WRAP* This, GUID *lpGUID ); 26 | HRESULT (__stdcall * RestoreDisplayMode)( WRAP* This ); 27 | HRESULT (__stdcall * SetCooperativeLevel)( WRAP* This, HWND hWnd, DWORD dwFlags ); 28 | union 29 | { 30 | LPVOID dummy; // for use with an initializer list... 31 | HRESULT (__stdcall * SetDisplayMode1)( WRAP* This, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP ); 32 | HRESULT (__stdcall * SetDisplayMode2)( WRAP* This, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP, DWORD dwRefreshRate, DWORD dwFlags ); 33 | }; 34 | HRESULT (__stdcall * WaitForVerticalBlank)( WRAP* This, DWORD dwFlags, HANDLE hEvent ); 35 | // v2 36 | HRESULT (__stdcall * GetAvailableVidMem)( WRAP* This, LPDDSCAPS lpDDCaps, LPDWORD lpdwTotal, LPDWORD lpdwFree ); 37 | // v4 38 | HRESULT (__stdcall * GetSurfaceFromDC)( WRAP* This, HDC hdc, LPDIRECTDRAWSURFACE4* lplpDDSurface ); 39 | HRESULT (__stdcall * RestoreAllSurfaces)( WRAP* This ); 40 | HRESULT (__stdcall * TestCooperativeLevel)( WRAP* This ); 41 | HRESULT (__stdcall * GetDeviceIdentifier)( WRAP* This, LPDDDEVICEIDENTIFIER pDDDI, DWORD dwFlags ); 42 | // v7 43 | HRESULT (__stdcall * StartModeTest)( WRAP* This, LPSIZE pModes, DWORD dwNumModes, DWORD dwFlags ); 44 | HRESULT (__stdcall * EvaluateMode)( WRAP* This, DWORD dwFlags, DWORD *pTimeout ); 45 | }; 46 | 47 | HRESULT __stdcall QueryInterface( WRAP* This, const IID& riid, void** ppvObject ) 48 | { 49 | PROLOGUE; 50 | HRESULT hResult = This->dd1->lpVtbl->QueryInterface( This->dd1, riid, ppvObject ); 51 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 52 | EPILOGUE( hResult ); 53 | } 54 | 55 | ULONG __stdcall AddRef( WRAP* This ) 56 | { 57 | PROLOGUE; 58 | ULONG dwCount = This->dd1->lpVtbl->AddRef( This->dd1 ); 59 | EPILOGUE( dwCount ); 60 | } 61 | 62 | ULONG __stdcall Release( WRAP* This ) 63 | { 64 | PROLOGUE; 65 | ULONG dwCount = WrapRelease( This ); 66 | EPILOGUE( dwCount ); 67 | } 68 | 69 | HRESULT __stdcall Compact( WRAP* This ) 70 | { 71 | PROLOGUE; 72 | HRESULT hResult = This->dd1->lpVtbl->Compact( This->dd1 ); 73 | EPILOGUE( hResult ); 74 | } 75 | 76 | HRESULT __stdcall CreateClipper( WRAP* This, DWORD dwFlags, LPDIRECTDRAWCLIPPER *lplpDDClipper, IUnknown *pUnkOuter ) 77 | { 78 | PROLOGUE; 79 | HRESULT hResult = This->dd1->lpVtbl->CreateClipper( This->dd1, dwFlags, lplpDDClipper, pUnkOuter ); 80 | if( SUCCEEDED( hResult ) ) 81 | { 82 | Wrap( This->dd_parent, iid_to_vtbl( IID_IDirectDrawClipper ), (void**)lplpDDClipper ); 83 | } 84 | EPILOGUE( hResult ); 85 | } 86 | 87 | HRESULT __stdcall CreatePalette( WRAP* This, DWORD dwFlags, LPPALETTEENTRY lpColorTable, LPDIRECTDRAWPALETTE *lplpDDPalette, IUnknown *pUnkOuter ) 88 | { 89 | PROLOGUE; 90 | HRESULT hResult = This->dd1->lpVtbl->CreatePalette( This->dd1, dwFlags, lpColorTable, lplpDDPalette, pUnkOuter ); 91 | if( SUCCEEDED( hResult ) ) 92 | { 93 | Wrap( This->dd_parent, iid_to_vtbl( IID_IDirectDrawPalette ), (void**)lplpDDPalette ); 94 | } 95 | EPILOGUE( hResult ); 96 | } 97 | 98 | HRESULT __stdcall CreateSurface( WRAP* This, LPDDSURFACEDESC lpDDSurfaceDesc, LPDIRECTDRAWSURFACE *lplpDDSurface, IUnknown *pUnkOuter ) 99 | { 100 | PROLOGUE; 101 | HRESULT hResult = This->dd1->lpVtbl->CreateSurface( This->dd1, lpDDSurfaceDesc, lplpDDSurface, pUnkOuter ); 102 | if( SUCCEEDED( hResult ) ) 103 | { 104 | Wrap( This->dd_parent, dd_to_dds_vtbl( This ), (void**)lplpDDSurface ); 105 | } 106 | EPILOGUE( hResult ); 107 | } 108 | 109 | HRESULT __stdcall DuplicateSurface( WRAP* This, LPDIRECTDRAWSURFACE lpDDSurface, LPDIRECTDRAWSURFACE *lplpDupDDSurface ) 110 | { 111 | PROLOGUE; 112 | HRESULT hResult = This->dd1->lpVtbl->DuplicateSurface( This->dd1, GetInnerInterface( lpDDSurface ), lplpDupDDSurface ); 113 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, dd_to_dds_vtbl( This ), (void**)lplpDupDDSurface ); 114 | EPILOGUE( hResult ); 115 | } 116 | 117 | HRESULT __stdcall EnumDisplayModes( WRAP* This, DWORD dwFlags, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext, LPDDENUMMODESCALLBACK lpEnumModesCallback ) 118 | { 119 | PROLOGUE; 120 | HRESULT hResult = This->dd1->lpVtbl->EnumDisplayModes( This->dd1, dwFlags, lpDDSurfaceDesc, lpContext, lpEnumModesCallback ); 121 | EPILOGUE( hResult ); 122 | } 123 | 124 | HRESULT __stdcall EnumSurfaces( WRAP* This, DWORD dwFlags, LPDDSURFACEDESC lpDDSD, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback ) 125 | { 126 | PROLOGUE; 127 | EnumStruct e; 128 | e.callback = lpEnumSurfacesCallback; 129 | e.context = lpContext; 130 | e.dd_parent = This->dd_parent; 131 | e.xVtbl = dd_to_dds_vtbl( This ); 132 | e.must_exist = ( dwFlags & DDENUMSURFACES_DOESEXIST ) ? true : false; 133 | HRESULT hResult = This->dd1->lpVtbl->EnumSurfaces( This->dd1, dwFlags, lpDDSD, &e, &WrapEnumSurfacesCallback ); 134 | EPILOGUE( hResult ); 135 | } 136 | 137 | HRESULT __stdcall FlipToGDISurface( WRAP* This ) 138 | { 139 | PROLOGUE; 140 | HRESULT hResult = This->dd1->lpVtbl->FlipToGDISurface( This->dd1 ); 141 | EPILOGUE( hResult ); 142 | } 143 | 144 | HRESULT __stdcall GetCaps( WRAP* This, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps ) 145 | { 146 | PROLOGUE; 147 | HRESULT hResult = This->dd1->lpVtbl->GetCaps( This->dd1, lpDDDriverCaps, lpDDHELCaps ); 148 | EPILOGUE( hResult ); 149 | } 150 | 151 | HRESULT __stdcall GetDisplayMode( WRAP* This, LPDDSURFACEDESC lpDDSurfaceDesc ) 152 | { 153 | PROLOGUE; 154 | HRESULT hResult = This->dd1->lpVtbl->GetDisplayMode( This->dd1, lpDDSurfaceDesc ); 155 | EPILOGUE( hResult ); 156 | } 157 | 158 | HRESULT __stdcall GetFourCCCodes( WRAP* This, LPDWORD lpNumCodes, LPDWORD lpCodes ) 159 | { 160 | PROLOGUE; 161 | HRESULT hResult = This->dd1->lpVtbl->GetFourCCCodes( This->dd1, lpNumCodes, lpCodes ); 162 | EPILOGUE( hResult ); 163 | } 164 | 165 | HRESULT __stdcall GetGDISurface( WRAP* This, LPDIRECTDRAWSURFACE *lplpGDIDDSurface ) 166 | { 167 | PROLOGUE; 168 | HRESULT hResult = This->dd1->lpVtbl->GetGDISurface( This->dd1, lplpGDIDDSurface ); 169 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, dd_to_dds_vtbl( This ), (void**)lplpGDIDDSurface ); 170 | EPILOGUE( hResult ); 171 | } 172 | 173 | HRESULT __stdcall GetMonitorFrequency( WRAP* This, LPDWORD lpdwFrequency ) 174 | { 175 | PROLOGUE; 176 | HRESULT hResult = This->dd1->lpVtbl->GetMonitorFrequency( This->dd1, lpdwFrequency ); 177 | EPILOGUE( hResult ); 178 | } 179 | 180 | HRESULT __stdcall GetScanLine( WRAP* This, LPDWORD lpdwScanLine ) 181 | { 182 | PROLOGUE; 183 | HRESULT hResult = This->dd1->lpVtbl->GetScanLine( This->dd1, lpdwScanLine ); 184 | EPILOGUE( hResult ); 185 | } 186 | 187 | HRESULT __stdcall GetVerticalBlankStatus( WRAP* This, BOOL *lpbIsInVB ) 188 | { 189 | PROLOGUE; 190 | HRESULT hResult = This->dd1->lpVtbl->GetVerticalBlankStatus( This->dd1, lpbIsInVB ); 191 | EPILOGUE( hResult ); 192 | } 193 | 194 | HRESULT __stdcall Initialize( WRAP* This, GUID *lpGUID ) 195 | { 196 | PROLOGUE; 197 | HRESULT hResult = This->dd1->lpVtbl->Initialize( This->dd1, lpGUID ); 198 | EPILOGUE( hResult ); 199 | } 200 | 201 | HRESULT __stdcall RestoreDisplayMode( WRAP* This ) 202 | { 203 | PROLOGUE; 204 | HRESULT hResult = This->dd1->lpVtbl->RestoreDisplayMode( This->dd1 ); 205 | EPILOGUE( hResult ); 206 | } 207 | 208 | HRESULT __stdcall SetCooperativeLevel( WRAP* This, HWND hWnd, DWORD dwFlags ) 209 | { 210 | PROLOGUE; 211 | HRESULT hResult = This->dd1->lpVtbl->SetCooperativeLevel( This->dd1, hWnd, dwFlags ); 212 | EPILOGUE( hResult ); 213 | } 214 | 215 | // The signature of SetDisplayMode is different between v1 and v2 216 | HRESULT __stdcall SetDisplayMode1( WRAP* This, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP ) 217 | { 218 | PROLOGUE; 219 | HRESULT hResult = This->dd1->lpVtbl->SetDisplayMode( This->dd1, dwWidth, dwHeight, dwBPP ); 220 | EPILOGUE( hResult ); 221 | } 222 | HRESULT __stdcall SetDisplayMode2( WRAP* This, DWORD dwWidth, DWORD dwHeight, DWORD dwBPP, DWORD dwRefreshRate, DWORD dwFlags ) 223 | { 224 | PROLOGUE; 225 | HRESULT hResult = This->dd2->lpVtbl->SetDisplayMode( This->dd2, dwWidth, dwHeight, dwBPP, dwRefreshRate, dwFlags ); 226 | EPILOGUE( hResult ); 227 | } 228 | //// 229 | 230 | HRESULT __stdcall WaitForVerticalBlank( WRAP* This, DWORD dwFlags, HANDLE hEvent) 231 | { 232 | PROLOGUE; 233 | HRESULT hResult = This->dd1->lpVtbl->WaitForVerticalBlank( This->dd1, dwFlags, hEvent ); 234 | EPILOGUE( hResult ); 235 | } 236 | 237 | // v2 // 238 | 239 | HRESULT __stdcall GetAvailableVidMem( WRAP* This, LPDDSCAPS lpDDCaps, LPDWORD lpdwTotal, LPDWORD lpdwFree ) 240 | { 241 | PROLOGUE; 242 | HRESULT hResult = This->dd2->lpVtbl->GetAvailableVidMem( This->dd2, lpDDCaps, lpdwTotal, lpdwFree ); 243 | EPILOGUE( hResult ); 244 | } 245 | 246 | // v4 // 247 | 248 | HRESULT __stdcall GetSurfaceFromDC( WRAP* This, HDC hdc, LPDIRECTDRAWSURFACE4* lplpDDSurface ) 249 | { 250 | PROLOGUE; 251 | HRESULT hResult = This->dd4->lpVtbl->GetSurfaceFromDC( This->dd4, hdc, lplpDDSurface ); 252 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, dd_to_dds_vtbl( This ), (void**)lplpDDSurface ); 253 | EPILOGUE( hResult ); 254 | } 255 | 256 | HRESULT __stdcall RestoreAllSurfaces( WRAP* This ) 257 | { 258 | PROLOGUE; 259 | HRESULT hResult = This->dd4->lpVtbl->RestoreAllSurfaces( This->dd4 ); 260 | EPILOGUE( hResult ); 261 | } 262 | 263 | HRESULT __stdcall TestCooperativeLevel( WRAP* This ) 264 | { 265 | PROLOGUE; 266 | HRESULT hResult = This->dd4->lpVtbl->TestCooperativeLevel( This->dd4 ); 267 | EPILOGUE( hResult ); 268 | } 269 | 270 | HRESULT __stdcall GetDeviceIdentifier( WRAP* This, LPDDDEVICEIDENTIFIER pDDDI, DWORD dwFlags ) 271 | { 272 | PROLOGUE; 273 | HRESULT hResult = This->dd4->lpVtbl->GetDeviceIdentifier( This->dd4, pDDDI, dwFlags ); 274 | EPILOGUE( hResult ); 275 | } 276 | 277 | // v7 // 278 | 279 | HRESULT __stdcall StartModeTest( WRAP* This, LPSIZE pModes, DWORD dwNumModes, DWORD dwFlags) 280 | { 281 | PROLOGUE; 282 | HRESULT hResult = This->dd7->lpVtbl->StartModeTest( This->dd7, pModes, dwNumModes, dwFlags ); 283 | EPILOGUE( hResult ); 284 | } 285 | 286 | HRESULT __stdcall EvaluateMode( WRAP* This, DWORD dwFlags, DWORD* pTimeout ) 287 | { 288 | PROLOGUE; 289 | HRESULT hResult = This->dd7->lpVtbl->EvaluateMode( This->dd7, dwFlags, pTimeout ); 290 | EPILOGUE( hResult ); 291 | } 292 | 293 | const XVTBL xVtbl1 = { 294 | QueryInterface, // 0x00 295 | AddRef, // 0x04 296 | Release, // 0x08 297 | Compact, // 0x0C 298 | CreateClipper, // 0x10 299 | CreatePalette, // 0x14 300 | CreateSurface, // 0x18 301 | DuplicateSurface, // 0x1C 302 | EnumDisplayModes, // 0x20 303 | EnumSurfaces, // 0x24 304 | FlipToGDISurface, // 0x28 305 | GetCaps, // 0x2C 306 | GetDisplayMode, // 0x30 307 | GetFourCCCodes, // 0x34 308 | GetGDISurface, // 0x38 309 | GetMonitorFrequency, // 0x3C 310 | GetScanLine, // 0x40 311 | GetVerticalBlankStatus, // 0x44 312 | Initialize, // 0x48 313 | RestoreDisplayMode, // 0x4C 314 | SetCooperativeLevel, // 0x50 315 | SetDisplayMode1, // 0x54 316 | WaitForVerticalBlank, // 0x58 317 | 0, // 0x5C 318 | 0, // 0x60 319 | 0, // 0x64 320 | 0, // 0x68 321 | 0, // 0x6C 322 | 0, // 0x70 323 | 0 // 0x74 324 | }; 325 | 326 | const XVTBL xVtbl2 = { 327 | QueryInterface, // 0x00 328 | AddRef, // 0x04 329 | Release, // 0x08 330 | Compact, // 0x0C 331 | CreateClipper, // 0x10 332 | CreatePalette, // 0x14 333 | CreateSurface, // 0x18 334 | DuplicateSurface, // 0x1C 335 | EnumDisplayModes, // 0x20 336 | EnumSurfaces, // 0x24 337 | FlipToGDISurface, // 0x28 338 | GetCaps, // 0x2C 339 | GetDisplayMode, // 0x30 340 | GetFourCCCodes, // 0x34 341 | GetGDISurface, // 0x38 342 | GetMonitorFrequency, // 0x3C 343 | GetScanLine, // 0x40 344 | GetVerticalBlankStatus, // 0x44 345 | Initialize, // 0x48 346 | RestoreDisplayMode, // 0x4C 347 | SetCooperativeLevel, // 0x50 348 | SetDisplayMode2, // 0x54 349 | WaitForVerticalBlank, // 0x58 350 | GetAvailableVidMem, // 0x5C 351 | 0, // 0x60 352 | 0, // 0x64 353 | 0, // 0x68 354 | 0, // 0x6C 355 | 0, // 0x70 356 | 0 // 0x74 357 | }; 358 | 359 | const XVTBL xVtbl4 = { 360 | QueryInterface, // 0x00 361 | AddRef, // 0x04 362 | Release, // 0x08 363 | Compact, // 0x0C 364 | CreateClipper, // 0x10 365 | CreatePalette, // 0x14 366 | CreateSurface, // 0x18 367 | DuplicateSurface, // 0x1C 368 | EnumDisplayModes, // 0x20 369 | EnumSurfaces, // 0x24 370 | FlipToGDISurface, // 0x28 371 | GetCaps, // 0x2C 372 | GetDisplayMode, // 0x30 373 | GetFourCCCodes, // 0x34 374 | GetGDISurface, // 0x38 375 | GetMonitorFrequency, // 0x3C 376 | GetScanLine, // 0x40 377 | GetVerticalBlankStatus, // 0x44 378 | Initialize, // 0x48 379 | RestoreDisplayMode, // 0x4C 380 | SetCooperativeLevel, // 0x50 381 | SetDisplayMode2, // 0x54 382 | WaitForVerticalBlank, // 0x58 383 | GetAvailableVidMem, // 0x5C 384 | GetSurfaceFromDC, // 0x60 385 | RestoreAllSurfaces, // 0x64 386 | TestCooperativeLevel, // 0x68 387 | GetDeviceIdentifier, // 0x6C 388 | 0, // 0x70 389 | 0 // 0x74 390 | }; 391 | 392 | const XVTBL xVtbl7 = { 393 | QueryInterface, // 0x00 394 | AddRef, // 0x04 395 | Release, // 0x08 396 | Compact, // 0x0C 397 | CreateClipper, // 0x10 398 | CreatePalette, // 0x14 399 | CreateSurface, // 0x18 400 | DuplicateSurface, // 0x1C 401 | EnumDisplayModes, // 0x20 402 | EnumSurfaces, // 0x24 403 | FlipToGDISurface, // 0x28 404 | GetCaps, // 0x2C 405 | GetDisplayMode, // 0x30 406 | GetFourCCCodes, // 0x34 407 | GetGDISurface, // 0x38 408 | GetMonitorFrequency, // 0x3C 409 | GetScanLine, // 0x40 410 | GetVerticalBlankStatus, // 0x44 411 | Initialize, // 0x48 412 | RestoreDisplayMode, // 0x4C 413 | SetCooperativeLevel, // 0x50 414 | SetDisplayMode2, // 0x54 415 | WaitForVerticalBlank, // 0x58 416 | GetAvailableVidMem, // 0x5C 417 | GetSurfaceFromDC, // 0x60 418 | RestoreAllSurfaces, // 0x64 419 | TestCooperativeLevel, // 0x68 420 | GetDeviceIdentifier, // 0x6C 421 | StartModeTest, // 0x70 422 | EvaluateMode // 0x74 423 | }; 424 | }; 425 | -------------------------------------------------------------------------------- /dds.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | namespace dds 4 | { 5 | struct XVTBL 6 | { 7 | HRESULT (__stdcall * QueryInterface)( WRAP* This, const IID& riid, void** ppvObject ); 8 | ULONG (__stdcall * AddRef)( WRAP* This ); 9 | ULONG (__stdcall * Release)( WRAP* This ); 10 | HRESULT (__stdcall * AddAttachedSurface)( WRAP* This, LPDIRECTDRAWSURFACE lpDDSAttachedSurface ); 11 | HRESULT (__stdcall * AddOverlayDirtyRect)( WRAP* This, LPRECT lpRect ); 12 | HRESULT (__stdcall * Blt)( WRAP* This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx ); 13 | HRESULT (__stdcall * BltBatch)( WRAP* This, LPDDBLTBATCH lpDDBltBatch, DWORD dwCount, DWORD dwFlags ); 14 | HRESULT (__stdcall * BltFast)( WRAP* This, DWORD dwX, DWORD dwY, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwTrans ); 15 | HRESULT (__stdcall * DeleteAttachedSurface)( WRAP* This, DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSAttachedSurface ); 16 | HRESULT (__stdcall * EnumAttachedSurfaces)( WRAP* This, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback ); 17 | HRESULT (__stdcall * EnumOverlayZOrders)( WRAP* This, DWORD dwFlags, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpfnCallback ); 18 | HRESULT (__stdcall * Flip)( WRAP* This, LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DWORD dwFlags ); 19 | HRESULT (__stdcall * GetAttachedSurface)( WRAP* This, LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE *lplpDDAttachedSurface ); 20 | HRESULT (__stdcall * GetBltStatus)( WRAP* This, DWORD dwFlags ); 21 | HRESULT (__stdcall * GetCaps)( WRAP* This, LPDDSCAPS lpDDSCaps ); 22 | HRESULT (__stdcall * GetClipper)( WRAP* This, LPDIRECTDRAWCLIPPER *lplpDDClipper ); 23 | HRESULT (__stdcall * GetColorKey)( WRAP* This, DWORD dwFlags, LPDDCOLORKEY lpDDColorKey ); 24 | HRESULT (__stdcall * GetDC)( WRAP* This, HDC *lphDC ); 25 | HRESULT (__stdcall * GetFlipStatus)( WRAP* This, DWORD dwFlags ); 26 | HRESULT (__stdcall * GetOverlayPosition)( WRAP* This, LPLONG lplX, LPLONG lplY ); 27 | HRESULT (__stdcall * GetPalette)( WRAP* This, LPDIRECTDRAWPALETTE *lplpDDPalette ); 28 | HRESULT (__stdcall * GetPixelFormat)( WRAP* This, LPDDPIXELFORMAT lpDDPixelFormat ); 29 | HRESULT (__stdcall * GetSurfaceDesc)( WRAP* This, LPDDSURFACEDESC lpDDSurfaceDesc ); 30 | HRESULT (__stdcall * Initialize)( WRAP* This, LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc ); 31 | HRESULT (__stdcall * IsLost)( WRAP* This ); 32 | HRESULT (__stdcall * Lock)( WRAP* This, LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent ); 33 | HRESULT (__stdcall * ReleaseDC)( WRAP* This, HDC hDC ); 34 | HRESULT (__stdcall * Restore)( WRAP* This ); 35 | HRESULT (__stdcall * SetClipper)( WRAP* This, LPDIRECTDRAWCLIPPER lpDDClipper ); 36 | HRESULT (__stdcall * SetColorKey)( WRAP* This, DWORD dwFlags, LPDDCOLORKEY lpDDColorKey ); 37 | HRESULT (__stdcall * SetOverlayPosition)( WRAP* This, LONG lX, LONG lY ); 38 | HRESULT (__stdcall * SetPalette)( WRAP* This, LPDIRECTDRAWPALETTE lpDDPalette ); 39 | HRESULT (__stdcall * Unlock)( WRAP* This, LPVOID lpRect ); 40 | HRESULT (__stdcall * UpdateOverlay)( WRAP* This, LPRECT lpSrcRect, LPDIRECTDRAWSURFACE lpDDDestSurface, LPRECT lpDestRect, DWORD dwFlags, LPDDOVERLAYFX lpDDOverlayFx ); 41 | HRESULT (__stdcall * UpdateOverlayDisplay)( WRAP* This, DWORD dwFlags ); 42 | HRESULT (__stdcall * UpdateOverlayZOrder)( WRAP* This, DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSReference ); 43 | // added in v2 44 | HRESULT (__stdcall * GetDDInterface)( WRAP* This, LPVOID *lplpDD ); 45 | HRESULT (__stdcall * PageLock)( WRAP* This, DWORD dwFlags ); 46 | HRESULT (__stdcall * PageUnlock)( WRAP* This, DWORD dwFlags ); 47 | // added in v3 48 | HRESULT (__stdcall * SetSurfaceDesc)( WRAP* This, LPDDSURFACEDESC lpDDSD, DWORD dwFlags ); 49 | // added in v4 50 | HRESULT (__stdcall * SetPrivateData)( WRAP* This, const GUID & tag, LPVOID pData, DWORD cbSize, DWORD dwFlags ); 51 | HRESULT (__stdcall * GetPrivateData)( WRAP* This, const GUID & tag, LPVOID pBuffer, LPDWORD pcbBufferSize ); 52 | HRESULT (__stdcall * FreePrivateData)( WRAP* This, const GUID & tag ); 53 | HRESULT (__stdcall * GetUniquenessValue)( WRAP* This, LPDWORD pValue ); 54 | HRESULT (__stdcall * ChangeUniquenessValue)( WRAP* This ); 55 | // added in v7 56 | HRESULT (__stdcall * SetPriority)( WRAP* This, DWORD prio ); 57 | HRESULT (__stdcall * GetPriority)( WRAP* This, LPDWORD prio ); 58 | HRESULT (__stdcall * SetLOD)( WRAP* This, DWORD lod ); 59 | HRESULT (__stdcall * GetLOD)( WRAP* This, LPDWORD lod ); 60 | }; 61 | 62 | HRESULT __stdcall QueryInterface( WRAP* This, const IID& riid, void** ppvObject ) 63 | { 64 | PROLOGUE; 65 | HRESULT hResult = This->dds1->lpVtbl->QueryInterface( This->dds1, riid, ppvObject ); 66 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 67 | EPILOGUE( hResult ); 68 | } 69 | 70 | ULONG __stdcall AddRef( WRAP* This ) 71 | { 72 | PROLOGUE; 73 | ULONG dwCount = This->dds1->lpVtbl->AddRef( This->dds1 ); 74 | EPILOGUE( dwCount ); 75 | } 76 | 77 | ULONG __stdcall Release( WRAP* This ) 78 | { 79 | PROLOGUE; 80 | ULONG dwCount = WrapRelease( This ); 81 | EPILOGUE( dwCount ); 82 | } 83 | 84 | HRESULT __stdcall AddAttachedSurface( WRAP* This, LPDIRECTDRAWSURFACE lpDDSAttachedSurface ) 85 | { 86 | PROLOGUE; 87 | HRESULT hResult = This->dds1->lpVtbl->AddAttachedSurface( This->dds1, GetInnerInterface( lpDDSAttachedSurface ) ); 88 | if( SUCCEEDED( hResult ) ) 89 | { 90 | lpDDSAttachedSurface->lpVtbl->AddRef( lpDDSAttachedSurface ); 91 | } 92 | EPILOGUE( hResult ); 93 | } 94 | 95 | HRESULT __stdcall AddOverlayDirtyRect( WRAP* This, LPRECT lpRect ) 96 | { 97 | PROLOGUE; 98 | HRESULT hResult = This->dds1->lpVtbl->AddOverlayDirtyRect( This->dds1, lpRect ); 99 | EPILOGUE( hResult ); 100 | } 101 | 102 | 103 | HRESULT __stdcall Blt( WRAP* This, LPRECT lpDestRect, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx ) 104 | { 105 | PROLOGUE; 106 | 107 | // note: 108 | // dwDDROP is ignored as "no such ROPs are currently defined" 109 | // dwROP is assumed to be a rop3 with redundant low-word ignored 110 | 111 | // unwrap interfaces in the DDBLTFX structure if used // 112 | DDBLTFX fx; 113 | bool UsesPattern = ( dwFlags & DDBLT_ROP ) ? ( ((lpDDBltFx->dwROP & 0x00F00000) >> 4) != (lpDDBltFx->dwROP & 0x000F0000) ) : false; 114 | if( ( UsesPattern != false ) || ( dwFlags & ( DDBLT_ALPHADESTSURFACEOVERRIDE | DDBLT_ALPHASRCSURFACEOVERRIDE | DDBLT_ZBUFFERDESTOVERRIDE | DDBLT_ZBUFFERSRCOVERRIDE )) ) 115 | { 116 | if( ( lpDDBltFx != NULL ) && ( sizeof( fx ) <= lpDDBltFx->dwSize ) ) 117 | { 118 | memcpy( &fx, lpDDBltFx, sizeof(fx) ); 119 | if( dwFlags & DDBLT_ALPHADESTSURFACEOVERRIDE ) fx.lpDDSAlphaDest = GetInnerInterface( fx.lpDDSAlphaDest ); 120 | if( dwFlags & DDBLT_ALPHASRCSURFACEOVERRIDE ) fx.lpDDSAlphaSrc = GetInnerInterface( fx.lpDDSAlphaSrc ); 121 | if( dwFlags & DDBLT_ZBUFFERDESTOVERRIDE ) fx.lpDDSZBufferDest = GetInnerInterface( fx.lpDDSZBufferDest ); 122 | if( dwFlags & DDBLT_ZBUFFERSRCOVERRIDE ) fx.lpDDSZBufferSrc = GetInnerInterface( fx.lpDDSZBufferSrc ); 123 | if( UsesPattern != false ) fx.lpDDSPattern = GetInnerInterface( fx.lpDDSPattern ); 124 | lpDDBltFx = &fx; 125 | } 126 | } 127 | 128 | // unwrap lpDDSrcSurface only if used // 129 | bool UsesSource = ( dwFlags & DDBLT_ROP ) ? ( ((lpDDBltFx->dwROP & 0x00F00000) % 0x00500000) || ((lpDDBltFx->dwROP & 0x000F0000) % 0x00050000) ) : true; 130 | if( ( UsesSource != false ) || ( ! ( dwFlags & ( DDBLT_COLORFILL | DDBLT_DEPTHFILL ) ) ) ) 131 | { 132 | lpDDSrcSurface = GetInnerInterface( lpDDSrcSurface ); 133 | } 134 | 135 | // 136 | HRESULT hResult = This->dds1->lpVtbl->Blt( This->dds1, lpDestRect, lpDDSrcSurface, lpSrcRect, dwFlags, lpDDBltFx ); 137 | EPILOGUE( hResult ); 138 | } 139 | 140 | HRESULT __stdcall BltBatch( WRAP* This, LPDDBLTBATCH lpDDBltBatch, DWORD dwCount, DWORD dwFlags ) 141 | { // This method was never implemented by ddraw? 142 | PROLOGUE; 143 | UNREFERENCED_PARAMETER( This ); 144 | UNREFERENCED_PARAMETER( lpDDBltBatch ); 145 | UNREFERENCED_PARAMETER( dwCount ); 146 | UNREFERENCED_PARAMETER( dwFlags ); 147 | WARN( "E_NOTIMPL" ); 148 | EPILOGUE( E_NOTIMPL ); 149 | } 150 | 151 | HRESULT __stdcall BltFast( WRAP* This, DWORD dwX, DWORD dwY, LPDIRECTDRAWSURFACE lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwTrans ) 152 | { 153 | PROLOGUE; 154 | HRESULT hResult = This->dds1->lpVtbl->BltFast( This->dds1, dwX, dwY, GetInnerInterface( lpDDSrcSurface ), lpSrcRect, dwTrans ); 155 | EPILOGUE( hResult ); 156 | } 157 | 158 | HRESULT __stdcall DeleteAttachedSurface( WRAP* This, DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSAttachedSurface) 159 | { 160 | PROLOGUE; 161 | HRESULT hResult = This->dds1->lpVtbl->DeleteAttachedSurface( This->dds1, dwFlags, GetInnerInterface( lpDDSAttachedSurface ) ); 162 | if( SUCCEEDED( hResult ) ) 163 | { 164 | lpDDSAttachedSurface->lpVtbl->Release( lpDDSAttachedSurface ); 165 | } 166 | EPILOGUE( hResult ); 167 | } 168 | 169 | 170 | HRESULT __stdcall EnumAttachedSurfaces( WRAP* This, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpEnumSurfacesCallback ) 171 | { 172 | PROLOGUE; 173 | EnumStruct e; 174 | e.callback = lpEnumSurfacesCallback; 175 | e.context = lpContext; 176 | e.dd_parent = This->dd_parent; 177 | e.xVtbl = This->xVtbl; 178 | e.must_exist = true; 179 | HRESULT hResult = This->dds1->lpVtbl->EnumAttachedSurfaces( This->dds1, &e, &WrapEnumSurfacesCallback ); 180 | EPILOGUE( hResult ); 181 | } 182 | 183 | HRESULT __stdcall EnumOverlayZOrders( WRAP* This, DWORD dwFlags, LPVOID lpContext, LPDDENUMSURFACESCALLBACK lpfnCallback ) 184 | { 185 | PROLOGUE; 186 | EnumStruct e; 187 | e.callback = lpfnCallback; 188 | e.context = lpContext; 189 | e.dd_parent = This->dd_parent; 190 | e.xVtbl = This->xVtbl; 191 | e.must_exist = true; 192 | HRESULT hResult = This->dds1->lpVtbl->EnumOverlayZOrders( This->dds1, dwFlags, &e, &WrapEnumSurfacesCallback ); 193 | EPILOGUE( hResult ); 194 | } 195 | 196 | HRESULT __stdcall Flip( WRAP* This, LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride, DWORD dwFlags ) 197 | { 198 | PROLOGUE; 199 | HRESULT hResult = This->dds1->lpVtbl->Flip( This->dds1, GetInnerInterface( lpDDSurfaceTargetOverride ), dwFlags ); 200 | EPILOGUE( hResult ); 201 | } 202 | 203 | HRESULT __stdcall GetAttachedSurface( WRAP* This, LPDDSCAPS lpDDSCaps, LPDIRECTDRAWSURFACE* lplpDDAttachedSurface ) 204 | { 205 | PROLOGUE; 206 | HRESULT hResult = This->dds1->lpVtbl->GetAttachedSurface( This->dds1, lpDDSCaps, lplpDDAttachedSurface ); 207 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, This->xVtbl, (void**)lplpDDAttachedSurface ); 208 | EPILOGUE( hResult ); 209 | } 210 | 211 | HRESULT __stdcall GetBltStatus( WRAP* This, DWORD dwFlags ) 212 | { 213 | PROLOGUE; 214 | HRESULT hResult = This->dds1->lpVtbl->GetBltStatus( This->dds1, dwFlags ); 215 | EPILOGUE( hResult ); 216 | } 217 | 218 | HRESULT __stdcall GetCaps( WRAP* This, LPDDSCAPS lpDDSCaps ) 219 | { 220 | PROLOGUE; 221 | HRESULT hResult = This->dds1->lpVtbl->GetCaps( This->dds1, lpDDSCaps ); 222 | EPILOGUE( hResult ); 223 | } 224 | 225 | HRESULT __stdcall GetClipper( WRAP* This, LPDIRECTDRAWCLIPPER *lplpDDClipper ) 226 | { 227 | PROLOGUE; 228 | HRESULT hResult = This->dds1->lpVtbl->GetClipper( This->dds1, lplpDDClipper ); 229 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( IID_IDirectDrawClipper ), (void**)lplpDDClipper ); 230 | EPILOGUE( hResult ); 231 | } 232 | 233 | HRESULT __stdcall GetColorKey( WRAP* This, DWORD dwFlags, LPDDCOLORKEY lpDDColorKey ) 234 | { 235 | PROLOGUE; 236 | HRESULT hResult = This->dds1->lpVtbl->GetColorKey( This->dds1, dwFlags, lpDDColorKey ); 237 | EPILOGUE( hResult ); 238 | } 239 | 240 | HRESULT __stdcall GetDC( WRAP* This, HDC *lphDC ) 241 | { 242 | PROLOGUE; 243 | HRESULT hResult = This->dds1->lpVtbl->GetDC( This->dds1, lphDC ); 244 | EPILOGUE( hResult ); 245 | } 246 | 247 | HRESULT __stdcall GetFlipStatus( WRAP* This, DWORD dwFlags ) 248 | { 249 | PROLOGUE; 250 | HRESULT hResult = This->dds1->lpVtbl->GetFlipStatus( This->dds1, dwFlags ); 251 | EPILOGUE( hResult ); 252 | } 253 | 254 | HRESULT __stdcall GetOverlayPosition( WRAP* This, LPLONG lplX, LPLONG lplY ) 255 | { 256 | PROLOGUE; 257 | HRESULT hResult = This->dds1->lpVtbl->GetOverlayPosition( This->dds1, lplX, lplY ); 258 | EPILOGUE( hResult ); 259 | } 260 | 261 | HRESULT __stdcall GetPalette( WRAP* This, LPDIRECTDRAWPALETTE *lplpDDPalette ) 262 | { 263 | PROLOGUE; 264 | HRESULT hResult = This->dds1->lpVtbl->GetPalette( This->dds1, lplpDDPalette ); 265 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( IID_IDirectDrawPalette ), (void**)lplpDDPalette ); 266 | EPILOGUE( hResult ); 267 | } 268 | 269 | HRESULT __stdcall GetPixelFormat( WRAP* This, LPDDPIXELFORMAT lpDDPixelFormat ) 270 | { 271 | PROLOGUE; 272 | HRESULT hResult = This->dds1->lpVtbl->GetPixelFormat( This->dds1, lpDDPixelFormat ); 273 | EPILOGUE( hResult ); 274 | } 275 | 276 | HRESULT __stdcall GetSurfaceDesc( WRAP* This, LPDDSURFACEDESC lpDDSurfaceDesc ) 277 | { 278 | PROLOGUE; 279 | HRESULT hResult = This->dds1->lpVtbl->GetSurfaceDesc( This->dds1, lpDDSurfaceDesc ); 280 | EPILOGUE( hResult ); 281 | } 282 | 283 | HRESULT __stdcall Initialize( WRAP* This, LPDIRECTDRAW lpDD, LPDDSURFACEDESC lpDDSurfaceDesc ) 284 | { 285 | PROLOGUE; 286 | HRESULT hResult = This->dds1->lpVtbl->Initialize( This->dds1, GetInnerInterface( lpDD ), lpDDSurfaceDesc ); 287 | EPILOGUE( hResult ); 288 | } 289 | 290 | HRESULT __stdcall IsLost( WRAP* This ) 291 | { 292 | PROLOGUE; 293 | HRESULT hResult = This->dds1->lpVtbl->IsLost( This->dds1 ); 294 | EPILOGUE( hResult ); 295 | } 296 | 297 | HRESULT __stdcall Lock( WRAP* This, LPRECT lpDestRect, LPDDSURFACEDESC lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent ) 298 | { 299 | PROLOGUE; 300 | HRESULT hResult = This->dds1->lpVtbl->Lock( This->dds1, lpDestRect, lpDDSurfaceDesc, dwFlags, hEvent ); 301 | EPILOGUE( hResult ); 302 | } 303 | 304 | HRESULT __stdcall ReleaseDC( WRAP* This, HDC hDC ) 305 | { 306 | PROLOGUE; 307 | HRESULT hResult = This->dds1->lpVtbl->ReleaseDC( This->dds1, hDC ); 308 | EPILOGUE( hResult ); 309 | } 310 | 311 | HRESULT __stdcall Restore( WRAP* This ) 312 | { 313 | PROLOGUE; 314 | HRESULT hResult = This->dds1->lpVtbl->Restore( This->dds1 ); 315 | EPILOGUE( hResult ); 316 | } 317 | 318 | HRESULT __stdcall SetClipper( WRAP* This, LPDIRECTDRAWCLIPPER lpDDClipper ) 319 | { 320 | PROLOGUE; 321 | HRESULT hResult; 322 | LPDIRECTDRAWCLIPPER old_clipper = NULL; 323 | hResult = This->dds1->lpVtbl->GetClipper( This->dds1, &old_clipper ); 324 | if( SUCCEEDED( hResult ) ) 325 | { 326 | Wrap( This->dd_parent, iid_to_vtbl( IID_IDirectDrawClipper ), (void**)&old_clipper ); 327 | } 328 | hResult = This->dds1->lpVtbl->SetClipper( This->dds1, GetInnerInterface( lpDDClipper ) ); 329 | if( old_clipper != NULL ) 330 | { 331 | old_clipper->lpVtbl->Release( old_clipper ); 332 | } 333 | EPILOGUE( hResult ); 334 | } 335 | 336 | HRESULT __stdcall SetColorKey( WRAP* This, DWORD dwFlags, LPDDCOLORKEY lpDDColorKey ) 337 | { 338 | PROLOGUE; 339 | HRESULT hResult = This->dds1->lpVtbl->SetColorKey( This->dds1, dwFlags, lpDDColorKey ); 340 | EPILOGUE( hResult ); 341 | } 342 | 343 | HRESULT __stdcall SetOverlayPosition( WRAP* This, LONG lX, LONG lY ) 344 | { 345 | PROLOGUE; 346 | HRESULT hResult = This->dds1->lpVtbl->SetOverlayPosition( This->dds1, lX, lY ); 347 | EPILOGUE( hResult ); 348 | } 349 | 350 | HRESULT __stdcall SetPalette( WRAP* This, LPDIRECTDRAWPALETTE lpDDPalette ) 351 | { 352 | PROLOGUE; 353 | HRESULT hResult; 354 | LPDIRECTDRAWPALETTE old_palette = NULL; 355 | hResult = This->dds1->lpVtbl->GetPalette( This->dds1, &old_palette ); 356 | if( SUCCEEDED( hResult ) ) 357 | { 358 | Wrap( This->dd_parent, iid_to_vtbl( IID_IDirectDrawPalette ), (void**)&old_palette ); 359 | } 360 | hResult = This->dds1->lpVtbl->SetPalette( This->dds1, GetInnerInterface( lpDDPalette ) ); 361 | if( old_palette != NULL ) 362 | { 363 | old_palette->lpVtbl->Release( old_palette ); 364 | } 365 | EPILOGUE( hResult ); 366 | } 367 | 368 | // lpData is ddsd.lpSurface in version 1, 2, and 3 369 | // lpData is lpRect in versions 4 and 7 370 | HRESULT __stdcall Unlock( WRAP* This, LPVOID lpData ) 371 | { 372 | PROLOGUE; 373 | HRESULT hResult = This->dds1->lpVtbl->Unlock( This->dds1, lpData ); 374 | EPILOGUE( hResult ); 375 | } 376 | 377 | HRESULT __stdcall UpdateOverlay( WRAP* This, LPRECT lpSrcRect, LPDIRECTDRAWSURFACE lpDDDestSurface, LPRECT lpDestRect, DWORD dwFlags, LPDDOVERLAYFX lpDDOverlayFx ) 378 | { 379 | PROLOGUE; 380 | DDOVERLAYFX fx; 381 | 382 | // unwrap interfaces in the DDOVERLAYFX structure if used // 383 | if( dwFlags & ( DDOVER_ALPHADESTSURFACEOVERRIDE | DDOVER_ALPHASRCSURFACEOVERRIDE ) ) 384 | { 385 | if( ( lpDDOverlayFx != NULL ) && ( sizeof( fx ) <= lpDDOverlayFx->dwSize ) ) 386 | { 387 | memcpy( &fx, lpDDOverlayFx, sizeof(fx) ); 388 | if( dwFlags & DDOVER_ALPHADESTSURFACEOVERRIDE ) fx.lpDDSAlphaDest = GetInnerInterface( fx.lpDDSAlphaDest ); 389 | if( dwFlags & DDOVER_ALPHASRCSURFACEOVERRIDE ) fx.lpDDSAlphaSrc = GetInnerInterface( fx.lpDDSAlphaSrc ); 390 | lpDDOverlayFx = &fx; 391 | } 392 | } 393 | 394 | // 395 | HRESULT hResult = This->dds1->lpVtbl->UpdateOverlay( This->dds1, lpSrcRect, GetInnerInterface( lpDDDestSurface ), lpDestRect, dwFlags, lpDDOverlayFx ); 396 | EPILOGUE( hResult ); 397 | } 398 | 399 | HRESULT __stdcall UpdateOverlayDisplay( WRAP* This, DWORD dwFlags ) 400 | { 401 | PROLOGUE; 402 | HRESULT hResult = This->dds1->lpVtbl->UpdateOverlayDisplay( This->dds1, dwFlags ); 403 | EPILOGUE( hResult ); 404 | } 405 | 406 | HRESULT __stdcall UpdateOverlayZOrder( WRAP* This, DWORD dwFlags, LPDIRECTDRAWSURFACE lpDDSReference ) 407 | { 408 | PROLOGUE; 409 | if( dwFlags & ( DDOVERZ_INSERTINBACKOF | DDOVERZ_INSERTINFRONTOF ) ) lpDDSReference = GetInnerInterface( lpDDSReference ); 410 | HRESULT hResult = This->dds1->lpVtbl->UpdateOverlayZOrder( This->dds1, dwFlags, lpDDSReference ); 411 | EPILOGUE( hResult ); 412 | } 413 | 414 | // v2 // 415 | 416 | HRESULT __stdcall GetDDInterface( WRAP* This, LPVOID* lplpDD ) 417 | { 418 | // theoretically returns IUnknown but some programs may cast it to a different interface pointer... 419 | // instead of querying for the interface. 420 | PROLOGUE; 421 | HRESULT hResult = This->dds2->lpVtbl->GetDDInterface( This->dds2, lplpDD ); 422 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, dds_to_dd_vtbl( This ), (void**)lplpDD ); 423 | EPILOGUE( hResult ); 424 | } 425 | 426 | HRESULT __stdcall PageLock( WRAP* This, DWORD dwFlags ) 427 | { 428 | PROLOGUE; 429 | HRESULT hResult = This->dds2->lpVtbl->PageLock( This->dds2, dwFlags ); 430 | EPILOGUE( hResult ); 431 | } 432 | 433 | HRESULT __stdcall PageUnlock( WRAP* This, DWORD dwFlags ) 434 | { 435 | PROLOGUE; 436 | HRESULT hResult = This->dds2->lpVtbl->PageUnlock( This->dds2, dwFlags ); 437 | EPILOGUE( hResult ); 438 | } 439 | 440 | // v3 // 441 | 442 | HRESULT __stdcall SetSurfaceDesc( WRAP* This, LPDDSURFACEDESC lpDDSD, DWORD dwFlags ) 443 | { 444 | PROLOGUE; 445 | HRESULT hResult = This->dds3->lpVtbl->SetSurfaceDesc( This->dds3, lpDDSD, dwFlags ); 446 | EPILOGUE( hResult ); 447 | } 448 | 449 | // v4 // 450 | 451 | HRESULT __stdcall SetPrivateData( WRAP* This, const GUID & tag, LPVOID pData, DWORD cbSize, DWORD dwFlags ) 452 | { 453 | PROLOGUE; 454 | HRESULT hResult = This->dds4->lpVtbl->SetPrivateData( This->dds4, tag, pData, cbSize, dwFlags ); 455 | EPILOGUE( hResult ); 456 | } 457 | 458 | HRESULT __stdcall GetPrivateData( WRAP* This, const GUID & tag, LPVOID pBuffer, LPDWORD pcbBufferSize ) 459 | { 460 | PROLOGUE; 461 | HRESULT hResult = This->dds4->lpVtbl->GetPrivateData( This->dds4, tag, pBuffer, pcbBufferSize ); 462 | EPILOGUE( hResult ); 463 | } 464 | 465 | HRESULT __stdcall FreePrivateData( WRAP* This, const GUID & tag ) 466 | { 467 | PROLOGUE; 468 | HRESULT hResult = This->dds4->lpVtbl->FreePrivateData( This->dds4, tag ); 469 | EPILOGUE( hResult ); 470 | } 471 | 472 | HRESULT __stdcall GetUniquenessValue( WRAP* This, LPDWORD pValue ) 473 | { 474 | PROLOGUE; 475 | HRESULT hResult = This->dds4->lpVtbl->GetUniquenessValue( This->dds4, pValue ); 476 | EPILOGUE( hResult ); 477 | } 478 | 479 | HRESULT __stdcall ChangeUniquenessValue( WRAP* This ) 480 | { 481 | PROLOGUE; 482 | HRESULT hResult = This->dds4->lpVtbl->ChangeUniquenessValue( This->dds4 ); 483 | EPILOGUE( hResult ); 484 | } 485 | 486 | // v7 // 487 | 488 | HRESULT __stdcall SetPriority( WRAP* This, DWORD prio ) 489 | { 490 | PROLOGUE; 491 | HRESULT hResult = This->dds7->lpVtbl->SetPriority( This->dds7, prio ); 492 | EPILOGUE( hResult ); 493 | } 494 | 495 | HRESULT __stdcall GetPriority( WRAP* This, LPDWORD prio ) 496 | { 497 | PROLOGUE; 498 | HRESULT hResult = This->dds7->lpVtbl->GetPriority( This->dds7, prio ); 499 | EPILOGUE( hResult ); 500 | } 501 | 502 | HRESULT __stdcall SetLOD( WRAP* This, DWORD lod ) 503 | { 504 | PROLOGUE; 505 | HRESULT hResult = This->dds7->lpVtbl->SetLOD( This->dds7, lod ); 506 | EPILOGUE( hResult ); 507 | } 508 | 509 | HRESULT __stdcall GetLOD( WRAP* This, LPDWORD lod ) 510 | { 511 | PROLOGUE; 512 | HRESULT hResult = This->dds7->lpVtbl->GetLOD( This->dds7, lod ); 513 | EPILOGUE( hResult ); 514 | } 515 | 516 | const XVTBL xVtbl1 = { 517 | QueryInterface, // 0x00 518 | AddRef, // 0x04 519 | Release, // 0x08 520 | AddAttachedSurface, // 0x0C 521 | AddOverlayDirtyRect, // 0x10 522 | Blt, // 0x14 523 | BltBatch, // 0x18 524 | BltFast, // 0x1C 525 | DeleteAttachedSurface, // 0x20 526 | EnumAttachedSurfaces, // 0x24 527 | EnumOverlayZOrders, // 0x28 528 | Flip, // 0x2C 529 | GetAttachedSurface, // 0x30 530 | GetBltStatus, // 0x34 531 | GetCaps, // 0x38 532 | GetClipper, // 0x3C 533 | GetColorKey, // 0x40 534 | GetDC, // 0x44 535 | GetFlipStatus, // 0x48 536 | GetOverlayPosition, // 0x4C 537 | GetPalette, // 0x50 538 | GetPixelFormat, // 0x54 539 | GetSurfaceDesc, // 0x58 540 | Initialize, // 0x5C 541 | IsLost, // 0x60 542 | Lock, // 0x64 543 | ReleaseDC, // 0x68 544 | Restore, // 0x6C 545 | SetClipper, // 0x70 546 | SetColorKey, // 0x74 547 | SetOverlayPosition, // 0x78 548 | SetPalette, // 0x7C 549 | Unlock, // 0x80 550 | UpdateOverlay, // 0x84 551 | UpdateOverlayDisplay, // 0x88 552 | UpdateOverlayZOrder, // 0x8C 553 | 0, // 0x90 554 | 0, // 0x94 555 | 0, // 0x98 556 | 0, // 0x9C 557 | 0, // 0xA0 558 | 0, // 0xA4 559 | 0, // 0xA8 560 | 0, // 0xAC 561 | 0, // 0xB0 562 | 0, // 0xB4 563 | 0, // 0xB8 564 | 0, // 0xBC 565 | 0 // 0xC0 566 | }; 567 | 568 | const XVTBL xVtbl2 = { 569 | QueryInterface, // 0x00 570 | AddRef, // 0x04 571 | Release, // 0x08 572 | AddAttachedSurface, // 0x0C 573 | AddOverlayDirtyRect, // 0x10 574 | Blt, // 0x14 575 | BltBatch, // 0x18 576 | BltFast, // 0x1C 577 | DeleteAttachedSurface, // 0x20 578 | EnumAttachedSurfaces, // 0x24 579 | EnumOverlayZOrders, // 0x28 580 | Flip, // 0x2C 581 | GetAttachedSurface, // 0x30 582 | GetBltStatus, // 0x34 583 | GetCaps, // 0x38 584 | GetClipper, // 0x3C 585 | GetColorKey, // 0x40 586 | GetDC, // 0x44 587 | GetFlipStatus, // 0x48 588 | GetOverlayPosition, // 0x4C 589 | GetPalette, // 0x50 590 | GetPixelFormat, // 0x54 591 | GetSurfaceDesc, // 0x58 592 | Initialize, // 0x5C 593 | IsLost, // 0x60 594 | Lock, // 0x64 595 | ReleaseDC, // 0x68 596 | Restore, // 0x6C 597 | SetClipper, // 0x70 598 | SetColorKey, // 0x74 599 | SetOverlayPosition, // 0x78 600 | SetPalette, // 0x7C 601 | Unlock, // 0x80 602 | UpdateOverlay, // 0x84 603 | UpdateOverlayDisplay, // 0x88 604 | UpdateOverlayZOrder, // 0x8C 605 | GetDDInterface, // 0x90 606 | PageLock, // 0x94 607 | PageUnlock, // 0x98 608 | 0, // 0x9C 609 | 0, // 0xA0 610 | 0, // 0xA4 611 | 0, // 0xA8 612 | 0, // 0xAC 613 | 0, // 0xB0 614 | 0, // 0xB4 615 | 0, // 0xB8 616 | 0, // 0xBC 617 | 0 // 0xC0 618 | }; 619 | 620 | const XVTBL xVtbl3 = { 621 | QueryInterface, // 0x00 622 | AddRef, // 0x04 623 | Release, // 0x08 624 | AddAttachedSurface, // 0x0C 625 | AddOverlayDirtyRect, // 0x10 626 | Blt, // 0x14 627 | BltBatch, // 0x18 628 | BltFast, // 0x1C 629 | DeleteAttachedSurface, // 0x20 630 | EnumAttachedSurfaces, // 0x24 631 | EnumOverlayZOrders, // 0x28 632 | Flip, // 0x2C 633 | GetAttachedSurface, // 0x30 634 | GetBltStatus, // 0x34 635 | GetCaps, // 0x38 636 | GetClipper, // 0x3C 637 | GetColorKey, // 0x40 638 | GetDC, // 0x44 639 | GetFlipStatus, // 0x48 640 | GetOverlayPosition, // 0x4C 641 | GetPalette, // 0x50 642 | GetPixelFormat, // 0x54 643 | GetSurfaceDesc, // 0x58 644 | Initialize, // 0x5C 645 | IsLost, // 0x60 646 | Lock, // 0x64 647 | ReleaseDC, // 0x68 648 | Restore, // 0x6C 649 | SetClipper, // 0x70 650 | SetColorKey, // 0x74 651 | SetOverlayPosition, // 0x78 652 | SetPalette, // 0x7C 653 | Unlock, // 0x80 654 | UpdateOverlay, // 0x84 655 | UpdateOverlayDisplay, // 0x88 656 | UpdateOverlayZOrder, // 0x8C 657 | GetDDInterface, // 0x90 658 | PageLock, // 0x94 659 | PageUnlock, // 0x98 660 | SetSurfaceDesc, // 0x9C 661 | 0, // 0xA0 662 | 0, // 0xA4 663 | 0, // 0xA8 664 | 0, // 0xAC 665 | 0, // 0xB0 666 | 0, // 0xB4 667 | 0, // 0xB8 668 | 0, // 0xBC 669 | 0 // 0xC0 670 | }; 671 | 672 | const XVTBL xVtbl4 = { 673 | QueryInterface, // 0x00 674 | AddRef, // 0x04 675 | Release, // 0x08 676 | AddAttachedSurface, // 0x0C 677 | AddOverlayDirtyRect, // 0x10 678 | Blt, // 0x14 679 | BltBatch, // 0x18 680 | BltFast, // 0x1C 681 | DeleteAttachedSurface, // 0x20 682 | EnumAttachedSurfaces, // 0x24 683 | EnumOverlayZOrders, // 0x28 684 | Flip, // 0x2C 685 | GetAttachedSurface, // 0x30 686 | GetBltStatus, // 0x34 687 | GetCaps, // 0x38 688 | GetClipper, // 0x3C 689 | GetColorKey, // 0x40 690 | GetDC, // 0x44 691 | GetFlipStatus, // 0x48 692 | GetOverlayPosition, // 0x4C 693 | GetPalette, // 0x50 694 | GetPixelFormat, // 0x54 695 | GetSurfaceDesc, // 0x58 696 | Initialize, // 0x5C 697 | IsLost, // 0x60 698 | Lock, // 0x64 699 | ReleaseDC, // 0x68 700 | Restore, // 0x6C 701 | SetClipper, // 0x70 702 | SetColorKey, // 0x74 703 | SetOverlayPosition, // 0x78 704 | SetPalette, // 0x7C 705 | Unlock, // 0x80 706 | UpdateOverlay, // 0x84 707 | UpdateOverlayDisplay, // 0x88 708 | UpdateOverlayZOrder, // 0x8C 709 | GetDDInterface, // 0x90 710 | PageLock, // 0x94 711 | PageUnlock, // 0x98 712 | SetSurfaceDesc, // 0x9C 713 | SetPrivateData, // 0xA0 714 | GetPrivateData, // 0xA4 715 | FreePrivateData, // 0xA8 716 | GetUniquenessValue, // 0xAC 717 | ChangeUniquenessValue, // 0xB0 718 | 0, // 0xB4 719 | 0, // 0xB8 720 | 0, // 0xBC 721 | 0 // 0xC0 722 | }; 723 | 724 | const XVTBL xVtbl7 = { 725 | QueryInterface, // 0x00 726 | AddRef, // 0x04 727 | Release, // 0x08 728 | AddAttachedSurface, // 0x0C 729 | AddOverlayDirtyRect, // 0x10 730 | Blt, // 0x14 731 | BltBatch, // 0x18 732 | BltFast, // 0x1C 733 | DeleteAttachedSurface, // 0x20 734 | EnumAttachedSurfaces, // 0x24 735 | EnumOverlayZOrders, // 0x28 736 | Flip, // 0x2C 737 | GetAttachedSurface, // 0x30 738 | GetBltStatus, // 0x34 739 | GetCaps, // 0x38 740 | GetClipper, // 0x3C 741 | GetColorKey, // 0x40 742 | GetDC, // 0x44 743 | GetFlipStatus, // 0x48 744 | GetOverlayPosition, // 0x4C 745 | GetPalette, // 0x50 746 | GetPixelFormat, // 0x54 747 | GetSurfaceDesc, // 0x58 748 | Initialize, // 0x5C 749 | IsLost, // 0x60 750 | Lock, // 0x64 751 | ReleaseDC, // 0x68 752 | Restore, // 0x6C 753 | SetClipper, // 0x70 754 | SetColorKey, // 0x74 755 | SetOverlayPosition, // 0x78 756 | SetPalette, // 0x7C 757 | Unlock, // 0x80 758 | UpdateOverlay, // 0x84 759 | UpdateOverlayDisplay, // 0x88 760 | UpdateOverlayZOrder, // 0x8C 761 | GetDDInterface, // 0x90 762 | PageLock, // 0x94 763 | PageUnlock, // 0x98 764 | SetSurfaceDesc, // 0x9C 765 | SetPrivateData, // 0xA0 766 | GetPrivateData, // 0xA4 767 | FreePrivateData, // 0xA8 768 | GetUniquenessValue, // 0xAC 769 | ChangeUniquenessValue, // 0xB0 770 | SetPriority, // 0xB4 771 | GetPriority, // 0xB8 772 | SetLOD, // 0xBC 773 | GetLOD // 0xC0 774 | }; 775 | }; 776 | -------------------------------------------------------------------------------- /ddwrapper.vcproj: -------------------------------------------------------------------------------- 1 | 2 | 11 | 12 | 15 | 16 | 17 | 18 | 19 | 26 | 29 | 32 | 35 | 38 | 41 | 54 | 57 | 60 | 63 | 78 | 81 | 84 | 87 | 90 | 93 | 96 | 99 | 100 | 108 | 111 | 114 | 117 | 120 | 123 | 141 | 144 | 147 | 150 | 167 | 170 | 173 | 176 | 179 | 182 | 185 | 188 | 189 | 190 | 191 | 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 | 241 | 244 | 245 | 248 | 249 | 252 | 253 | 254 | 255 | 256 | 257 | -------------------------------------------------------------------------------- /dllmain.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/aqrit/ddwrapper/afa9c472c556f6f29a20a63085945624c86e0e83/dllmain.cpp -------------------------------------------------------------------------------- /exports.def: -------------------------------------------------------------------------------- 1 | LIBRARY "DDRAW" 2 | 3 | EXPORTS 4 | AcquireDDThreadLock @1 5 | CompleteCreateSysmemSurface @2 6 | D3DParseUnknownCommand @3 7 | DDGetAttachedSurfaceLcl @4 8 | DDInternalLock @5 9 | DDInternalUnlock @6 10 | DSoundHelp @7 11 | DirectDrawCreate @8 12 | DirectDrawCreateClipper @9 13 | DirectDrawCreateEx @10 14 | DirectDrawEnumerateA @11 15 | DirectDrawEnumerateExA @12 16 | DirectDrawEnumerateExW @13 17 | DirectDrawEnumerateW @14 18 | DllCanUnloadNow PRIVATE 19 | DllGetClassObject PRIVATE 20 | GetDDSurfaceLocal @17 21 | GetOLEThunkData @18 22 | GetSurfaceFromDC = GetSurfaceFromDC_export @19 23 | RegisterSpecialCase @20 24 | ReleaseDDThreadLock @21 25 | SetAppCompatData @22 26 | -------------------------------------------------------------------------------- /gamma.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | namespace gamma 4 | { 5 | struct XVTBL 6 | { 7 | HRESULT (__stdcall * QueryInterface)( WRAP* This, const IID& riid, void** ppvObject ); 8 | ULONG (__stdcall * AddRef)( WRAP* This ); 9 | ULONG (__stdcall * Release)( WRAP* This ); 10 | HRESULT (__stdcall * GetGammaRamp)( WRAP* This, DWORD dwFlags, LPDDGAMMARAMP lpRampData ); 11 | HRESULT (__stdcall * SetGammaRamp)( WRAP* This, DWORD dwFlags, LPDDGAMMARAMP lpRampData ); 12 | }; 13 | 14 | HRESULT __stdcall QueryInterface( WRAP* This, const IID& riid, void** ppvObject ) 15 | { 16 | PROLOGUE; 17 | HRESULT hResult = This->gamma->lpVtbl->QueryInterface( This->gamma, riid, ppvObject ); 18 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 19 | EPILOGUE( hResult ); 20 | } 21 | 22 | ULONG __stdcall AddRef( WRAP* This ) 23 | { 24 | PROLOGUE; 25 | ULONG dwCount = This->gamma->lpVtbl->AddRef( This->gamma ); 26 | EPILOGUE( dwCount ); 27 | } 28 | 29 | ULONG __stdcall Release( WRAP* This ) 30 | { 31 | PROLOGUE; 32 | ULONG dwCount = WrapRelease( This ); 33 | EPILOGUE( dwCount ); 34 | } 35 | 36 | HRESULT __stdcall GetGammaRamp( WRAP* This, DWORD dwFlags, LPDDGAMMARAMP lpRampData ) 37 | { 38 | PROLOGUE; 39 | HRESULT hResult = This->gamma->lpVtbl->GetGammaRamp( This->gamma, dwFlags, lpRampData ); 40 | EPILOGUE( hResult ); 41 | } 42 | 43 | HRESULT __stdcall SetGammaRamp( WRAP* This, DWORD dwFlags, LPDDGAMMARAMP lpRampData ) 44 | { 45 | PROLOGUE; 46 | HRESULT hResult = This->gamma->lpVtbl->SetGammaRamp( This->gamma, dwFlags, lpRampData ); 47 | EPILOGUE( hResult ); 48 | } 49 | 50 | const XVTBL xVtbl = 51 | { 52 | QueryInterface, // 0x00 53 | AddRef, // 0x04 54 | Release, // 0x08 55 | GetGammaRamp, // 0x0C 56 | SetGammaRamp, // 0x10 57 | }; 58 | }; -------------------------------------------------------------------------------- /header.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define INITGUID 4 | #define CINTERFACE 5 | 6 | #include 7 | #include 8 | #include 9 | #include "wine/d3d.h" 10 | 11 | #include "wrap.h" 12 | #include "log.h" 13 | 14 | namespace dd { struct XVTBL; extern const XVTBL xVtbl1; extern const XVTBL xVtbl2; extern const XVTBL xVtbl4; extern const XVTBL xVtbl7; }; 15 | namespace dds { struct XVTBL; extern const XVTBL xVtbl1; extern const XVTBL xVtbl2; extern const XVTBL xVtbl3; extern const XVTBL xVtbl4; extern const XVTBL xVtbl7; }; 16 | namespace classfactory { struct XVTBL; extern const XVTBL xVtbl; }; 17 | namespace clipper { struct XVTBL; extern const XVTBL xVtbl; }; 18 | namespace palette { struct XVTBL; extern const XVTBL xVtbl; }; 19 | namespace color { struct XVTBL; extern const XVTBL xVtbl; }; 20 | namespace gamma { struct XVTBL; extern const XVTBL xVtbl; }; 21 | namespace unknwn { struct XVTBL; extern const XVTBL xVtbl; }; 22 | 23 | -------------------------------------------------------------------------------- /license.txt: -------------------------------------------------------------------------------- 1 | For non-commerical use: do anything you want. 2 | For commerical use: email mike@bitpatch.com with the game title, publisher, and distributors, then do anything you want. 3 | 4 | Enjoy! 5 | -------------------------------------------------------------------------------- /log.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | // defines from 4 | DEFINE_GUID( _IID_IDDVideoPortContainer, 0x6C142760,0xA733,0x11CE,0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60 ); 5 | DEFINE_GUID( _IID_IDirectDrawVideoPort, 0xB36D93E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56 ); 6 | DEFINE_GUID( _IID_IDirectDrawVideoPortNotify, 0xA655FB94,0x0589,0x4E57,0xB3,0x33,0x56,0x7A,0x89,0x46,0x8C,0x88); 7 | 8 | 9 | HANDLE file = INVALID_HANDLE_VALUE; 10 | CRITICAL_SECTION log_lock; 11 | 12 | // todo: this function needs to be replaced 13 | void __cdecl Log( char* fmt, ...) 14 | { 15 | static char buf[1024]; 16 | static size_t pos = 0; 17 | OVERLAPPED ol; 18 | int len; 19 | DWORD bytes_written; 20 | 21 | if( file == INVALID_HANDLE_VALUE ) 22 | { 23 | InitializeCriticalSection(&log_lock); 24 | EnterCriticalSection(&log_lock); 25 | if( file == INVALID_HANDLE_VALUE ) 26 | { 27 | file = CreateFile("ddwrapper.log", GENERIC_WRITE, 28 | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0 29 | ); 30 | LeaveCriticalSection(&log_lock); 31 | if( file == INVALID_HANDLE_VALUE ){ return; } 32 | } 33 | } 34 | 35 | EnterCriticalSection(&log_lock); 36 | 37 | va_list args; 38 | va_start(args,fmt); 39 | len = wvsprintf( buf, fmt, args ); 40 | va_end(args); 41 | 42 | ol.Offset = pos; 43 | ol.OffsetHigh = 0; 44 | ol.hEvent = NULL; 45 | 46 | if( WriteFile(file, buf, len, &bytes_written, &ol) ) 47 | { 48 | pos += bytes_written; 49 | } 50 | else 51 | { 52 | // GetLastError(); 53 | } 54 | LeaveCriticalSection(&log_lock); 55 | } 56 | 57 | 58 | void dds32_to_bmp( IDirectDrawSurface* pDDSurface, char* szFileName ) 59 | { 60 | BITMAPFILEHEADER bmfh; 61 | BITMAPINFO bmi; 62 | HANDLE hFile; 63 | OVERLAPPED ol; 64 | 65 | DDSURFACEDESC ddsd; 66 | ddsd.dwSize = sizeof( ddsd ); 67 | if( FAILED( pDDSurface->lpVtbl->Lock( pDDSurface, NULL, &ddsd, DDLOCK_WAIT, NULL) ) ) return; 68 | 69 | bmfh.bfType = 0x4d42; // "BM" 70 | bmfh.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFO) + ( ddsd.dwWidth * ddsd.dwHeight * 4 ); // 4 bytes per pixel 71 | bmfh.bfReserved1 = 0; 72 | bmfh.bfReserved2 = 0; 73 | bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFO); 74 | 75 | RtlSecureZeroMemory( &bmi, sizeof( bmi ) ); 76 | 77 | bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 78 | bmi.bmiHeader.biWidth = ddsd.dwWidth; 79 | bmi.bmiHeader.biHeight = -((signed long)ddsd.dwHeight); // origin is the upper left corner 80 | bmi.bmiHeader.biPlanes = 1; 81 | bmi.bmiHeader.biBitCount = 32; 82 | bmi.bmiHeader.biCompression = BI_RGB; 83 | 84 | hFile = CreateFile( szFileName, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0); 85 | if( hFile != NULL ) 86 | { 87 | ol.Offset = 0; 88 | ol.OffsetHigh = 0; 89 | ol.hEvent = NULL; 90 | WriteFile( hFile, &bmfh, sizeof( bmfh ), NULL, &ol); 91 | ol.Offset = sizeof( bmfh ); 92 | WriteFile( hFile, &bmi, sizeof( bmi ), NULL, &ol); 93 | ol.Offset += sizeof( bmi ); 94 | for( DWORD y = 0; y < ddsd.dwHeight; y++ ) 95 | { 96 | WriteFile( hFile, (void*)(((uintptr_t)ddsd.lpSurface) + ( ddsd.lPitch * y )), ddsd.dwWidth * 4, NULL, &ol ); 97 | ol.Offset += ( ddsd.dwWidth * 4 ); // 4 bytes per pixel 98 | } 99 | CloseHandle(hFile); 100 | } 101 | 102 | pDDSurface->lpVtbl->Unlock( pDDSurface, NULL ); 103 | } 104 | 105 | 106 | void LogDDSD( LPDDSURFACEDESC lpDDSurfaceDesc ) 107 | { 108 | if( lpDDSurfaceDesc->dwSize >= sizeof( DDSURFACEDESC2 ) ) Log( "DDSD2:\r\n"); 109 | else Log( "DDSD:\r\n"); 110 | 111 | DWORD dwKnownFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_BACKBUFFERCOUNT | DDSD_ZBUFFERBITDEPTH | 112 | DDSD_ALPHABITDEPTH | DDSD_LPSURFACE | DDSD_PIXELFORMAT | DDSD_CKDESTOVERLAY | DDSD_CKDESTBLT | DDSD_CKSRCOVERLAY | DDSD_CKSRCBLT | 113 | DDSD_MIPMAPCOUNT | DDSD_REFRESHRATE | DDSD_LINEARSIZE | DDSD_TEXTURESTAGE | DDSD_FVF | DDSD_SRCVBHANDLE | DDSD_DEPTH; 114 | Log( " Flags{ 0x%08X", lpDDSurfaceDesc->dwFlags ); 115 | if( ( lpDDSurfaceDesc->dwFlags & DDSD_ALL ) == DDSD_ALL ) Log( ", DDSD_ALL" ); 116 | else{ 117 | if( lpDDSurfaceDesc->dwFlags & DDSD_CAPS ) Log( ", DDSD_CAPS" ); 118 | if( lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT ) Log( ", DDSD_HEIGHT" ); 119 | if( lpDDSurfaceDesc->dwFlags & DDSD_WIDTH ) Log( ", DDSD_WIDTH" ); 120 | if( lpDDSurfaceDesc->dwFlags & DDSD_PITCH ) Log( ", DDSD_PITCH" ); 121 | if( lpDDSurfaceDesc->dwFlags & DDSD_BACKBUFFERCOUNT ) Log( ", DDSD_BACKBUFFERCOUNT" ); 122 | if( lpDDSurfaceDesc->dwFlags & DDSD_ZBUFFERBITDEPTH ) Log( ", DDSD_ZBUFFERBITDEPTH" ); 123 | if( lpDDSurfaceDesc->dwFlags & DDSD_ALPHABITDEPTH ) Log( ", DDSD_ALPHABITDEPTH" ); 124 | if( lpDDSurfaceDesc->dwFlags & DDSD_LPSURFACE ) Log( ", DDSD_LPSURFACE" ); 125 | if( lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT ) Log( ", DDSD_PIXELFORMAT" ); 126 | if( lpDDSurfaceDesc->dwFlags & DDSD_CKDESTOVERLAY ) Log( ", DDSD_CKDESTOVERLAY" ); 127 | if( lpDDSurfaceDesc->dwFlags & DDSD_CKDESTBLT ) Log( ", DDSD_CKDESTBLT" ); 128 | if( lpDDSurfaceDesc->dwFlags & DDSD_CKSRCOVERLAY ) Log( ", DDSD_CKSRCOVERLAY" ); 129 | if( lpDDSurfaceDesc->dwFlags & DDSD_CKSRCBLT ) Log( ", DDSD_CKSRCBLT" ); 130 | if( lpDDSurfaceDesc->dwFlags & DDSD_MIPMAPCOUNT ) Log( ", DDSD_MIPMAPCOUNT" ); 131 | if( lpDDSurfaceDesc->dwFlags & DDSD_REFRESHRATE ) Log( ", DDSD_REFRESHRATE" ); 132 | if( lpDDSurfaceDesc->dwFlags & DDSD_LINEARSIZE ) Log( ", DDSD_LINEARSIZE" ); 133 | if( lpDDSurfaceDesc->dwFlags & DDSD_TEXTURESTAGE ) Log( ", DDSD_TEXTURESTAGE" ); 134 | if( lpDDSurfaceDesc->dwFlags & DDSD_FVF ) Log( ", DDSD_FVF" ); 135 | if( lpDDSurfaceDesc->dwFlags & DDSD_SRCVBHANDLE ) Log( ", DDSD_SRCVBHANDLE" ); 136 | if( lpDDSurfaceDesc->dwFlags & DDSD_DEPTH ) Log( ", DDSD_DEPTH" ); 137 | if( lpDDSurfaceDesc->dwFlags & ~( dwKnownFlags ) ) Log( ", UNKNOWN!! 0x%08X", (lpDDSurfaceDesc->dwFlags & ~( dwKnownFlags )) ); 138 | } 139 | Log( " }\r\n" ); 140 | 141 | if( ( lpDDSurfaceDesc->dwFlags & DDSD_CAPS ) || ( lpDDSurfaceDesc->dwFlags == DDSD_ALL ) ) 142 | { 143 | Log( " Caps1{ 0x%08X", lpDDSurfaceDesc->ddsCaps.dwCaps ); 144 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_RESERVED1 ) Log( ", DDSCAPS_RESERVED1" ); 145 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_ALPHA ) Log( ", DDSCAPS_ALPHA" ); 146 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_BACKBUFFER ) Log( ", DDSCAPS_BACKBUFFER" ); 147 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_COMPLEX ) Log( ", DDSCAPS_COMPLEX" ); 148 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_FLIP ) Log( ", DDSCAPS_FLIP" ); 149 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_FRONTBUFFER ) Log( ", DDSCAPS_FRONTBUFFER" ); 150 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN ) Log( ", DDSCAPS_OFFSCREENPLAIN" ); 151 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_OVERLAY ) Log( ", DDSCAPS_OVERLAY" ); 152 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PALETTE ) Log( ", DDSCAPS_PALETTE" ); 153 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE ) Log( ", DDSCAPS_PRIMARYSURFACE" ); 154 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_RESERVED3 ) Log( ", DDSCAPS_RESERVED3" ); 155 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY ) Log( ", DDSCAPS_SYSTEMMEMORY" ); 156 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_TEXTURE ) Log( ", DDSCAPS_TEXTURE" ); 157 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE ) Log( ", DDSCAPS_3DDEVICE" ); 158 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY ) Log( ", DDSCAPS_VIDEOMEMORY" ); 159 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_VISIBLE ) Log( ", DDSCAPS_VISIBLE" ); 160 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_WRITEONLY ) Log( ", DDSCAPS_WRITEONLY" ); 161 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER ) Log( ", DDSCAPS_ZBUFFER" ); 162 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_OWNDC ) Log( ", DDSCAPS_OWNDC" ); 163 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_LIVEVIDEO ) Log( ", DDSCAPS_LIVEVIDEO" ); 164 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_HWCODEC ) Log( ", DDSCAPS_HWCODEC" ); 165 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_MODEX ) Log( ", DDSCAPS_MODEX" ); 166 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_MIPMAP ) Log( ", DDSCAPS_MIPMAP" ); 167 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_RESERVED2 ) Log( ", DDSCAPS_RESERVED2" ); 168 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_ALLOCONLOAD ) Log( ", DDSCAPS_ALLOCONLOAD" ); 169 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_VIDEOPORT ) Log( ", DDSCAPS_VIDEOPORT" ); 170 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_LOCALVIDMEM ) Log( ", DDSCAPS_LOCALVIDMEM" ); 171 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_NONLOCALVIDMEM ) Log( ", DDSCAPS_NONLOCALVIDMEM" ); 172 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_STANDARDVGAMODE ) Log( ", DDSCAPS_STANDARDVGAMODE" ); 173 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & DDSCAPS_OPTIMIZED ) Log( ", DDSCAPS_OPTIMIZED" ); 174 | if( lpDDSurfaceDesc->ddsCaps.dwCaps & 0x03000000 ) Log( ", UNKNOWN!! 0x%08X", ( lpDDSurfaceDesc->ddsCaps.dwCaps & 0x03000000 ) ); 175 | Log( " }\r\n" ); 176 | } 177 | 178 | Log( " " ); 179 | if( ( lpDDSurfaceDesc->dwFlags & DDSD_WIDTH ) || ( lpDDSurfaceDesc->dwFlags == DDSD_ALL ) ) 180 | Log( "width: %d ", lpDDSurfaceDesc->dwWidth ); 181 | 182 | if( ( lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT ) || ( lpDDSurfaceDesc->dwFlags == DDSD_ALL ) ) 183 | Log( "height: %d ", lpDDSurfaceDesc->dwHeight ); 184 | 185 | if( ( lpDDSurfaceDesc->dwFlags & DDSD_BACKBUFFERCOUNT ) || ( lpDDSurfaceDesc->dwFlags == DDSD_ALL ) ) 186 | Log( "backbuffers: %d ", lpDDSurfaceDesc->dwBackBufferCount ); 187 | Log( "\r\n" ); 188 | 189 | if( ( lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT ) || ( lpDDSurfaceDesc->dwFlags == DDSD_ALL ) ) 190 | { 191 | Log( " DDPF:\r\n" ); 192 | Log( " Flags{ 0x%08X", lpDDSurfaceDesc->ddpfPixelFormat.dwFlags ); 193 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS ) Log( ", DDPF_ALPHAPIXELS" ); 194 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ALPHA ) Log( ", DDPF_ALPHA" ); 195 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_FOURCC ) Log( ", DDPF_FOURCC" ); 196 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED4 ) Log( ", DDPF_PALETTEINDEXED4" ); 197 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXEDTO8 ) Log( ", DDPF_PALETTEINDEXEDTO8" ); 198 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8 ) Log( ", DDPF_PALETTEINDEXED8" ); 199 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_RGB ) Log( ", DDPF_RGB" ); 200 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_COMPRESSED ) Log( ", DDPF_COMPRESSED" ); 201 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_RGBTOYUV ) Log( ", DDPF_RGBTOYUV" ); 202 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_YUV ) Log( ", DDPF_YUV" ); 203 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ZBUFFER ) Log( ", DDPF_ZBUFFER" ); 204 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED1 ) Log( ", DDPF_PALETTEINDEXED1" ); 205 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED2 ) Log( ", DDPF_PALETTEINDEXED2" ); 206 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ZPIXELS ) Log( ", DDPF_ZPIXELS" ); 207 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_STENCILBUFFER ) Log( ", DDPF_STENCILBUFFER" ); 208 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_ALPHAPREMULT ) Log( ", DDPF_ALPHAPREMULT" ); 209 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_LUMINANCE ) Log( ", DDPF_LUMINANCE" ); 210 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_BUMPLUMINANCE ) Log( ", DDPF_BUMPLUMINANCE" ); 211 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_BUMPDUDV ) Log( ", DDPF_BUMPDUDV" ); 212 | if( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & 0xFFF10000 ) Log( ", UNKNOWN!! 0x%08X", ( lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & 0xFFF10000 ) ); 213 | Log( " }\r\n" ); 214 | } 215 | } 216 | 217 | 218 | void LogGUID(const GUID& riid) 219 | { 220 | if ( riid == IID_IUnknown ) Log( "IID_IUnknown\r\n" ); 221 | else if ( riid == IID_IClassFactory ) Log( "IID_IClassFactory\r\n" ); 222 | else if ( riid == IID_IDirectDraw ) Log( "IID_IDirectDraw\r\n" ); 223 | else if ( riid == IID_IDirectDraw2 ) Log( "IID_IDirectDraw2\r\n" ); 224 | else if ( riid == IID_IDirectDraw4 ) Log( "IID_IDirectDraw4\r\n" ); 225 | else if ( riid == IID_IDirectDraw7 ) Log( "IID_IDirectDraw7\r\n" ); 226 | else if ( riid == IID_IDirectDrawSurface ) Log( "IID_IDirectDrawSurface\r\n" ); 227 | else if ( riid == IID_IDirectDrawSurface2 ) Log( "IID_IDirectDrawSurface2\r\n" ); 228 | else if ( riid == IID_IDirectDrawSurface3 ) Log( "IID_IDirectDrawSurface3\r\n" ); 229 | else if ( riid == IID_IDirectDrawSurface4 ) Log( "IID_IDirectDrawSurface4\r\n" ); 230 | else if ( riid == IID_IDirectDrawSurface7 ) Log( "IID_IDirectDrawSurface7\r\n" ); 231 | else if ( riid == IID_IDirectDrawClipper ) Log( "IID_IDirectDrawClipper\r\n" ); 232 | else if ( riid == IID_IDirectDrawPalette ) Log( "IID_IDirectDrawPalette\r\n" ); 233 | else if ( riid == IID_IDirectDrawColorControl ) Log( "IID_IDirectDrawColorControl\r\n" ); 234 | else if ( riid == IID_IDirectDrawGammaControl ) Log( "IID_IDirectDrawGammaControl\r\n" ); 235 | 236 | // unsupported // 237 | else if ( riid == _IID_IDDVideoPortContainer ) Log( "IID_IDDVideoPortContainer\r\n" ); 238 | else if ( riid == _IID_IDirectDrawVideoPort ) Log( "IID_IDirectDrawVideoPort\r\n" ); 239 | else if ( riid == _IID_IDirectDrawVideoPortNotify ) Log( "IID_IDirectDrawVideoPortNotify\r\n" ); 240 | else if ( riid == IID_IDirect3D ) Log( "IID_IDirect3D\r\n" ); 241 | else if ( riid == IID_IDirect3D2 ) Log( "IID_IDirect3D2\r\n" ); 242 | else if ( riid == IID_IDirect3D3 ) Log( "IID_IDirect3D3\r\n" ); 243 | else if ( riid == IID_IDirect3D7 ) Log( "IID_IDirect3D7\r\n" ); 244 | else if ( riid == IID_IDirect3DTexture ) Log( "IID_IDirect3DTexture\r\n" ); 245 | else if ( riid == IID_IDirect3DTexture2 ) Log( "IID_IDirect3DTexture2\r\n" ); 246 | else if ( riid == IID_IDirect3DRampDevice ) Log( "IID_IDirect3DRampDevice\r\n" ); 247 | else if ( riid == IID_IDirect3DRGBDevice ) Log( "IID_IDirect3DRGBDevice\r\n" ); 248 | else if ( riid == IID_IDirect3DHALDevice ) Log( "IID_IDirect3DHALDevice\r\n" ); 249 | else if ( riid == IID_IDirect3DMMXDevice ) Log( "IID_IDirect3DMMXDevice\r\n" ); 250 | else if ( riid == IID_IDirect3DRefDevice ) Log( "IID_IDirect3DRefDevice\r\n" ); 251 | else if ( riid == IID_IDirect3DNullDevice ) Log( "IID_IDirect3DNullDevice\r\n" ); 252 | else if ( riid == IID_IDirect3DTnLHalDevice ) Log( "IID_IDirect3DTnLHalDevice\r\n" ); 253 | else if ( riid == IID_IDirect3DDevice ) Log( "IID_IDirect3DDevice\r\n" ); 254 | else if ( riid == IID_IDirect3DDevice2 ) Log( "IID_IDirect3DDevice2\r\n" ); 255 | else if ( riid == IID_IDirect3DDevice3 ) Log( "IID_IDirect3DDevice3\r\n" ); 256 | else if ( riid == IID_IDirect3DDevice7 ) Log( "IID_IDirect3DDevice7\r\n" ); 257 | else if ( riid == IID_IDirect3DLight ) Log( "IID_IDirect3DLight\r\n" ); 258 | else if ( riid == IID_IDirect3DMaterial ) Log( "IID_IDirect3DMaterial\r\n" ); 259 | else if ( riid == IID_IDirect3DMaterial2 ) Log( "IID_IDirect3DMaterial2\r\n" ); 260 | else if ( riid == IID_IDirect3DMaterial3 ) Log( "IID_IDirect3DMaterial3\r\n" ); 261 | else if ( riid == IID_IDirect3DExecuteBuffer ) Log( "IID_IDirect3DExecuteBuffer\r\n" ); 262 | else if ( riid == IID_IDirect3DViewport ) Log( "IID_IDirect3DViewport\r\n" ); 263 | else if ( riid == IID_IDirect3DViewport2 ) Log( "IID_IDirect3DViewport2\r\n" ); 264 | else if ( riid == IID_IDirect3DViewport3 ) Log( "IID_IDirect3DViewport3\r\n" ); 265 | else if ( riid == IID_IDirect3DVertexBuffer ) Log( "IID_IDirect3DVertexBuffer\r\n" ); 266 | else if ( riid == IID_IDirect3DVertexBuffer7 ) Log( "IID_IDirect3DVertexBuffer7\r\n" ); 267 | else 268 | { 269 | Log( ">>>> Unknown GUID: 0x%08X,0x%04X,0x%04X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X <<<<\r\n", 270 | riid.Data1, riid.Data2, riid.Data3, riid.Data4[0], riid.Data4[1], riid.Data4[2], riid.Data4[3], riid.Data4[4], 271 | riid.Data4[5], riid.Data4[6], riid.Data4[7] 272 | ); 273 | } 274 | } 275 | 276 | 277 | -------------------------------------------------------------------------------- /log.h: -------------------------------------------------------------------------------- 1 | /* 2 | all hookprocs start with PROLOGUE and end with EPILOGUE(x) macros 3 | those macros can be redefined for logging... 4 | 5 | internal functions are sprinkled with TRACE macros 6 | 7 | lets say we want to log only failed IDirectDrawClipper calls then 8 | we'd paste the "log light" section (below) in clipper.cpp after the #include(s) 9 | 10 | if instead we want to log failed calls for all interfaces then 11 | just uncomment the "log light" section in this header file 12 | 13 | LogDDSD and dds32_to_bmp are currently not used anywhere 14 | they exist in case someone wants them for debugging 15 | */ 16 | 17 | extern "C" void * _ReturnAddress( void ); 18 | #pragma intrinsic( _ReturnAddress ) 19 | 20 | void __cdecl Log( char* fmt, ... ); 21 | void LogDDSD( LPDDSURFACEDESC lpDDSurfaceDesc ); 22 | void LogGUID( const GUID& riid ); 23 | void dds32_to_bmp( IDirectDrawSurface* pDDSurface, char* szFileName ); 24 | 25 | // log nothing 26 | #define EPILOGUE(x) return(x) 27 | #define LOG_GUID(x) 28 | #define PROLOGUE 29 | #define TRACE(x) 30 | #define WARN(x) 31 | 32 | /* 33 | // log light ( warnings, failed iface calls, some iface ids ) 34 | #undef EPILOGUE 35 | #undef LOG_GUID 36 | #undef WARN 37 | #define EPILOGUE(x) if(FAILED(x)){Log( "%08X %08X %s\r\n", x, _ReturnAddress(), __FUNCTION__ );} return(x); 38 | #define LOG_GUID(x) LogGUID( x ); 39 | #define WARN(x) Log( "WARNING: %s\r\n", x ); 40 | */ 41 | 42 | /* 43 | // log heavy 44 | #undef EPILOGUE 45 | #undef LOG_GUID 46 | #undef PROLOGUE 47 | #undef TRACE 48 | #undef WARN 49 | #define EPILOGUE(x) Log( "%08X %s\r\n", x, __FUNCTION__ ); return(x); 50 | #define LOG_GUID(x) LogGUID( x ); 51 | #define PROLOGUE Log( "> %08X %s\r\n", _ReturnAddress(), __FUNCTION__ ); 52 | #define TRACE(x) Log( "TRACE: %s %s\r\n", __FUNCTION__, x ); 53 | #define WARN(x) Log( "WARNING: %s %s\r\n", __FUNCTION__, x ); 54 | */ 55 | 56 | 57 | -------------------------------------------------------------------------------- /palette.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | namespace palette 4 | { 5 | struct XVTBL 6 | { 7 | HRESULT (__stdcall * QueryInterface)( WRAP* This, const IID& riid, void** ppvObject ); 8 | ULONG (__stdcall * AddRef)( WRAP* This ); 9 | ULONG (__stdcall * Release)( WRAP* This ); 10 | HRESULT (__stdcall * GetCaps)( WRAP* This, LPDWORD lpdwCaps ); 11 | HRESULT (__stdcall * GetEntries)( WRAP* This, DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries ); 12 | HRESULT (__stdcall * Initialize)( WRAP* This, LPDIRECTDRAW lpDD, DWORD dwFlags, LPPALETTEENTRY lpDDColorTable ); 13 | HRESULT (__stdcall * SetEntries)( WRAP* This, DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries ); 14 | }; 15 | 16 | HRESULT __stdcall QueryInterface( WRAP* This, const IID& riid, void** ppvObject ) 17 | { 18 | PROLOGUE; 19 | HRESULT hResult = This->pal->lpVtbl->QueryInterface( This->pal, riid, ppvObject ); 20 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 21 | EPILOGUE( hResult ); 22 | } 23 | 24 | ULONG __stdcall AddRef( WRAP* This ) 25 | { 26 | PROLOGUE; 27 | ULONG dwCount = This->pal->lpVtbl->AddRef( This->pal ); 28 | EPILOGUE( dwCount ); 29 | } 30 | 31 | ULONG __stdcall Release( WRAP* This ) 32 | { 33 | PROLOGUE; 34 | ULONG dwCount = WrapRelease( This ); 35 | EPILOGUE( dwCount ); 36 | } 37 | 38 | HRESULT __stdcall GetCaps( WRAP* This, LPDWORD lpdwCaps ) 39 | { 40 | PROLOGUE; 41 | HRESULT hResult = This->pal->lpVtbl->GetCaps( This->pal, lpdwCaps ); 42 | EPILOGUE( hResult ); 43 | } 44 | 45 | HRESULT __stdcall GetEntries( WRAP* This, DWORD dwFlags, DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries ) 46 | { 47 | PROLOGUE; 48 | HRESULT hResult = This->pal->lpVtbl->GetEntries( This->pal, dwFlags, dwBase, dwNumEntries, lpEntries ); 49 | EPILOGUE( hResult ); 50 | } 51 | 52 | HRESULT __stdcall Initialize( WRAP* This, LPDIRECTDRAW lpDD, DWORD dwFlags, LPPALETTEENTRY lpDDColorTable ) 53 | { 54 | PROLOGUE; 55 | HRESULT hResult = This->pal->lpVtbl->Initialize( This->pal, GetInnerInterface( lpDD ), dwFlags, lpDDColorTable ); 56 | EPILOGUE( hResult ); 57 | } 58 | 59 | HRESULT __stdcall SetEntries( WRAP* This, DWORD dwFlags, DWORD dwStartingEntry, DWORD dwCount, LPPALETTEENTRY lpEntries ) 60 | { 61 | PROLOGUE; 62 | HRESULT hResult = This->pal->lpVtbl->SetEntries( This->pal, dwFlags, dwStartingEntry, dwCount, lpEntries ); 63 | EPILOGUE( hResult ); 64 | } 65 | 66 | const XVTBL xVtbl = 67 | { 68 | QueryInterface, // 0x00 69 | AddRef, // 0x04 70 | Release, // 0x08 71 | GetCaps, // 0x0C 72 | GetEntries, // 0x10 73 | Initialize, // 0x14 74 | SetEntries // 0x18 75 | }; 76 | }; 77 | -------------------------------------------------------------------------------- /unknwn.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | namespace unknwn 4 | { 5 | struct XVTBL 6 | { 7 | HRESULT (__stdcall * QueryInterface)( WRAP* This, const IID& riid, void** ppvObject ); 8 | ULONG (__stdcall * AddRef)( WRAP* This ); 9 | ULONG (__stdcall * Release)( WRAP* This ); 10 | }; 11 | 12 | HRESULT __stdcall QueryInterface( WRAP* This, const IID& riid, void** ppvObject ) 13 | { 14 | PROLOGUE; 15 | HRESULT hResult = This->color->lpVtbl->QueryInterface( This->color, riid, ppvObject ); 16 | if( SUCCEEDED( hResult ) ) Wrap( This->dd_parent, iid_to_vtbl( riid ), ppvObject ); 17 | EPILOGUE( hResult ); 18 | } 19 | 20 | ULONG __stdcall AddRef( WRAP* This ) 21 | { 22 | PROLOGUE; 23 | ULONG dwCount = This->color->lpVtbl->AddRef( This->color ); 24 | EPILOGUE( dwCount ); 25 | } 26 | 27 | ULONG __stdcall Release( WRAP* This ) 28 | { 29 | PROLOGUE; 30 | ULONG dwCount = WrapRelease( This ); 31 | EPILOGUE( dwCount ); 32 | } 33 | 34 | const XVTBL xVtbl = 35 | { 36 | QueryInterface, // 0x00 37 | AddRef, // 0x04 38 | Release // 0x08 39 | }; 40 | }; -------------------------------------------------------------------------------- /wine/d3dcaps.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2000 Peter Hunnisett 3 | * 4 | * This library is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * This library is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with this library; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 | */ 18 | 19 | #ifndef __WINE_D3DCAPS_H 20 | #define __WINE_D3DCAPS_H 21 | 22 | #include 23 | 24 | #ifdef __i386__ 25 | #include 26 | #endif 27 | 28 | typedef struct _D3DTRANSFORMCAPS { 29 | DWORD dwSize; 30 | DWORD dwCaps; 31 | } D3DTRANSFORMCAPS, *LPD3DTRANSFORMCAPS; 32 | 33 | #define D3DTRANSFORMCAPS_CLIP __MSABI_LONG(0x00000001) 34 | 35 | typedef struct _D3DLIGHTINGCAPS { 36 | DWORD dwSize; 37 | DWORD dwCaps; 38 | DWORD dwLightingModel; 39 | DWORD dwNumLights; 40 | } D3DLIGHTINGCAPS, *LPD3DLIGHTINGCAPS; 41 | 42 | #define D3DLIGHTINGMODEL_RGB 0x00000001 43 | #define D3DLIGHTINGMODEL_MONO 0x00000002 44 | 45 | #define D3DLIGHTCAPS_POINT 0x00000001 46 | #define D3DLIGHTCAPS_SPOT 0x00000002 47 | #define D3DLIGHTCAPS_DIRECTIONAL 0x00000004 48 | #define D3DLIGHTCAPS_PARALLELPOINT 0x00000008 49 | #define D3DLIGHTCAPS_GLSPOT 0x00000010 50 | 51 | typedef struct _D3dPrimCaps { 52 | DWORD dwSize; 53 | DWORD dwMiscCaps; 54 | DWORD dwRasterCaps; 55 | DWORD dwZCmpCaps; 56 | DWORD dwSrcBlendCaps; 57 | DWORD dwDestBlendCaps; 58 | DWORD dwAlphaCmpCaps; 59 | DWORD dwShadeCaps; 60 | DWORD dwTextureCaps; 61 | DWORD dwTextureFilterCaps; 62 | DWORD dwTextureBlendCaps; 63 | DWORD dwTextureAddressCaps; 64 | DWORD dwStippleWidth; 65 | DWORD dwStippleHeight; 66 | } D3DPRIMCAPS, *LPD3DPRIMCAPS; 67 | 68 | #define D3DPMISCCAPS_MASKPLANES 0x00000001 69 | #define D3DPMISCCAPS_MASKZ 0x00000002 70 | #define D3DPMISCCAPS_LINEPATTERNREP 0x00000004 71 | #define D3DPMISCCAPS_CONFORMANT 0x00000008 72 | #define D3DPMISCCAPS_CULLNONE 0x00000010 73 | #define D3DPMISCCAPS_CULLCW 0x00000020 74 | #define D3DPMISCCAPS_CULLCCW 0x00000040 75 | 76 | #define D3DPRASTERCAPS_DITHER 0x00000001 77 | #define D3DPRASTERCAPS_ROP2 0x00000002 78 | #define D3DPRASTERCAPS_XOR 0x00000004 79 | #define D3DPRASTERCAPS_PAT 0x00000008 80 | #define D3DPRASTERCAPS_ZTEST 0x00000010 81 | #define D3DPRASTERCAPS_SUBPIXEL 0x00000020 82 | #define D3DPRASTERCAPS_SUBPIXELX 0x00000040 83 | #define D3DPRASTERCAPS_FOGVERTEX 0x00000080 84 | #define D3DPRASTERCAPS_FOGTABLE 0x00000100 85 | #define D3DPRASTERCAPS_STIPPLE 0x00000200 86 | #define D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT 0x00000400 87 | #define D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT 0x00000800 88 | #define D3DPRASTERCAPS_ANTIALIASEDGES 0x00001000 89 | #define D3DPRASTERCAPS_MIPMAPLODBIAS 0x00002000 90 | #define D3DPRASTERCAPS_ZBIAS 0x00004000 91 | #define D3DPRASTERCAPS_ZBUFFERLESSHSR 0x00008000 92 | #define D3DPRASTERCAPS_FOGRANGE 0x00010000 93 | #define D3DPRASTERCAPS_ANISOTROPY 0x00020000 94 | #define D3DPRASTERCAPS_WBUFFER 0x00040000 95 | #define D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT 0x00080000 96 | #define D3DPRASTERCAPS_WFOG 0x00100000 97 | #define D3DPRASTERCAPS_ZFOG 0x00200000 98 | 99 | #define D3DPCMPCAPS_NEVER 0x00000001 100 | #define D3DPCMPCAPS_LESS 0x00000002 101 | #define D3DPCMPCAPS_EQUAL 0x00000004 102 | #define D3DPCMPCAPS_LESSEQUAL 0x00000008 103 | #define D3DPCMPCAPS_GREATER 0x00000010 104 | #define D3DPCMPCAPS_NOTEQUAL 0x00000020 105 | #define D3DPCMPCAPS_GREATEREQUAL 0x00000040 106 | #define D3DPCMPCAPS_ALWAYS 0x00000080 107 | 108 | #define D3DPBLENDCAPS_ZERO 0x00000001 109 | #define D3DPBLENDCAPS_ONE 0x00000002 110 | #define D3DPBLENDCAPS_SRCCOLOR 0x00000004 111 | #define D3DPBLENDCAPS_INVSRCCOLOR 0x00000008 112 | #define D3DPBLENDCAPS_SRCALPHA 0x00000010 113 | #define D3DPBLENDCAPS_INVSRCALPHA 0x00000020 114 | #define D3DPBLENDCAPS_DESTALPHA 0x00000040 115 | #define D3DPBLENDCAPS_INVDESTALPHA 0x00000080 116 | #define D3DPBLENDCAPS_DESTCOLOR 0x00000100 117 | #define D3DPBLENDCAPS_INVDESTCOLOR 0x00000200 118 | #define D3DPBLENDCAPS_SRCALPHASAT 0x00000400 119 | #define D3DPBLENDCAPS_BOTHSRCALPHA 0x00000800 120 | #define D3DPBLENDCAPS_BOTHINVSRCALPHA 0x00001000 121 | 122 | #define D3DPSHADECAPS_COLORFLATMONO 0x00000001 123 | #define D3DPSHADECAPS_COLORFLATRGB 0x00000002 124 | #define D3DPSHADECAPS_COLORGOURAUDMONO 0x00000004 125 | #define D3DPSHADECAPS_COLORGOURAUDRGB 0x00000008 126 | #define D3DPSHADECAPS_COLORPHONGMONO 0x00000010 127 | #define D3DPSHADECAPS_COLORPHONGRGB 0x00000020 128 | 129 | #define D3DPSHADECAPS_SPECULARFLATMONO 0x00000040 130 | #define D3DPSHADECAPS_SPECULARFLATRGB 0x00000080 131 | #define D3DPSHADECAPS_SPECULARGOURAUDMONO 0x00000100 132 | #define D3DPSHADECAPS_SPECULARGOURAUDRGB 0x00000200 133 | #define D3DPSHADECAPS_SPECULARPHONGMONO 0x00000400 134 | #define D3DPSHADECAPS_SPECULARPHONGRGB 0x00000800 135 | 136 | #define D3DPSHADECAPS_ALPHAFLATBLEND 0x00001000 137 | #define D3DPSHADECAPS_ALPHAFLATSTIPPLED 0x00002000 138 | #define D3DPSHADECAPS_ALPHAGOURAUDBLEND 0x00004000 139 | #define D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED 0x00008000 140 | #define D3DPSHADECAPS_ALPHAPHONGBLEND 0x00010000 141 | #define D3DPSHADECAPS_ALPHAPHONGSTIPPLED 0x00020000 142 | 143 | #define D3DPSHADECAPS_FOGFLAT 0x00040000 144 | #define D3DPSHADECAPS_FOGGOURAUD 0x00080000 145 | #define D3DPSHADECAPS_FOGPHONG 0x00100000 146 | 147 | #define D3DPTEXTURECAPS_PERSPECTIVE 0x00000001 148 | #define D3DPTEXTURECAPS_POW2 0x00000002 149 | #define D3DPTEXTURECAPS_ALPHA 0x00000004 150 | #define D3DPTEXTURECAPS_TRANSPARENCY 0x00000008 151 | #define D3DPTEXTURECAPS_BORDER 0x00000010 152 | #define D3DPTEXTURECAPS_SQUAREONLY 0x00000020 153 | #define D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE 0x00000040 154 | #define D3DPTEXTURECAPS_ALPHAPALETTE 0x00000080 155 | #define D3DPTEXTURECAPS_NONPOW2CONDITIONAL __MSABI_LONG(0x00000100) 156 | /* yes actually 0x00000200 is unused - or at least unreleased */ 157 | #define D3DPTEXTURECAPS_PROJECTED 0x00000400 158 | #define D3DPTEXTURECAPS_CUBEMAP 0x00000800 159 | #define D3DPTEXTURECAPS_COLORKEYBLEND 0x00001000 160 | 161 | #define D3DPTFILTERCAPS_NEAREST 0x00000001 162 | #define D3DPTFILTERCAPS_LINEAR 0x00000002 163 | #define D3DPTFILTERCAPS_MIPNEAREST 0x00000004 164 | #define D3DPTFILTERCAPS_MIPLINEAR 0x00000008 165 | #define D3DPTFILTERCAPS_LINEARMIPNEAREST 0x00000010 166 | #define D3DPTFILTERCAPS_LINEARMIPLINEAR 0x00000020 167 | /* yes - missing numbers */ 168 | #define D3DPTFILTERCAPS_MINFPOINT 0x00000100 169 | #define D3DPTFILTERCAPS_MINFLINEAR 0x00000200 170 | #define D3DPTFILTERCAPS_MINFANISOTROPIC 0x00000400 171 | /* yes - missing numbers */ 172 | #define D3DPTFILTERCAPS_MIPFPOINT 0x00010000 173 | #define D3DPTFILTERCAPS_MIPFLINEAR 0x00020000 174 | /* yes - missing numbers */ 175 | #define D3DPTFILTERCAPS_MAGFPOINT 0x01000000 176 | #define D3DPTFILTERCAPS_MAGFLINEAR 0x02000000 177 | #define D3DPTFILTERCAPS_MAGFANISOTROPIC 0x04000000 178 | #define D3DPTFILTERCAPS_MAGFAFLATCUBIC 0x08000000 179 | #define D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC 0x10000000 180 | 181 | #define D3DPTBLENDCAPS_DECAL 0x00000001 182 | #define D3DPTBLENDCAPS_MODULATE 0x00000002 183 | #define D3DPTBLENDCAPS_DECALALPHA 0x00000004 184 | #define D3DPTBLENDCAPS_MODULATEALPHA 0x00000008 185 | #define D3DPTBLENDCAPS_DECALMASK 0x00000010 186 | #define D3DPTBLENDCAPS_MODULATEMASK 0x00000020 187 | #define D3DPTBLENDCAPS_COPY 0x00000040 188 | #define D3DPTBLENDCAPS_ADD 0x00000080 189 | 190 | #define D3DPTADDRESSCAPS_WRAP 0x00000001 191 | #define D3DPTADDRESSCAPS_MIRROR 0x00000002 192 | #define D3DPTADDRESSCAPS_CLAMP 0x00000004 193 | #define D3DPTADDRESSCAPS_BORDER 0x00000008 194 | #define D3DPTADDRESSCAPS_INDEPENDENTUV 0x00000010 195 | 196 | 197 | typedef struct _D3DDeviceDesc { 198 | DWORD dwSize; 199 | DWORD dwFlags; 200 | D3DCOLORMODEL dcmColorModel; 201 | DWORD dwDevCaps; 202 | D3DTRANSFORMCAPS dtcTransformCaps; 203 | BOOL bClipping; 204 | D3DLIGHTINGCAPS dlcLightingCaps; 205 | D3DPRIMCAPS dpcLineCaps; 206 | D3DPRIMCAPS dpcTriCaps; 207 | DWORD dwDeviceRenderBitDepth; 208 | DWORD dwDeviceZBufferBitDepth; 209 | DWORD dwMaxBufferSize; 210 | DWORD dwMaxVertexCount; 211 | 212 | DWORD dwMinTextureWidth,dwMinTextureHeight; 213 | DWORD dwMaxTextureWidth,dwMaxTextureHeight; 214 | DWORD dwMinStippleWidth,dwMaxStippleWidth; 215 | DWORD dwMinStippleHeight,dwMaxStippleHeight; 216 | 217 | DWORD dwMaxTextureRepeat; 218 | DWORD dwMaxTextureAspectRatio; 219 | DWORD dwMaxAnisotropy; 220 | 221 | D3DVALUE dvGuardBandLeft; 222 | D3DVALUE dvGuardBandTop; 223 | D3DVALUE dvGuardBandRight; 224 | D3DVALUE dvGuardBandBottom; 225 | 226 | D3DVALUE dvExtentsAdjust; 227 | DWORD dwStencilCaps; 228 | 229 | DWORD dwFVFCaps; 230 | DWORD dwTextureOpCaps; 231 | WORD wMaxTextureBlendStages; 232 | WORD wMaxSimultaneousTextures; 233 | } D3DDEVICEDESC,*LPD3DDEVICEDESC; 234 | #define D3DDEVICEDESCSIZE (sizeof(D3DDEVICEDESC)) 235 | 236 | typedef struct _D3DDeviceDesc7 { 237 | DWORD dwDevCaps; 238 | D3DPRIMCAPS dpcLineCaps; 239 | D3DPRIMCAPS dpcTriCaps; 240 | DWORD dwDeviceRenderBitDepth; 241 | DWORD dwDeviceZBufferBitDepth; 242 | 243 | DWORD dwMinTextureWidth, dwMinTextureHeight; 244 | DWORD dwMaxTextureWidth, dwMaxTextureHeight; 245 | 246 | DWORD dwMaxTextureRepeat; 247 | DWORD dwMaxTextureAspectRatio; 248 | DWORD dwMaxAnisotropy; 249 | 250 | D3DVALUE dvGuardBandLeft; 251 | D3DVALUE dvGuardBandTop; 252 | D3DVALUE dvGuardBandRight; 253 | D3DVALUE dvGuardBandBottom; 254 | 255 | D3DVALUE dvExtentsAdjust; 256 | DWORD dwStencilCaps; 257 | DWORD dwFVFCaps; 258 | DWORD dwTextureOpCaps; 259 | WORD wMaxTextureBlendStages; 260 | WORD wMaxSimultaneousTextures; 261 | 262 | DWORD dwMaxActiveLights; 263 | D3DVALUE dvMaxVertexW; 264 | GUID deviceGUID; 265 | 266 | WORD wMaxUserClipPlanes; 267 | WORD wMaxVertexBlendMatrices; 268 | 269 | DWORD dwVertexProcessingCaps; 270 | 271 | DWORD dwReserved1; 272 | DWORD dwReserved2; 273 | DWORD dwReserved3; 274 | DWORD dwReserved4; 275 | } D3DDEVICEDESC7, *LPD3DDEVICEDESC7; 276 | #define D3DDEVICEDESC7SIZE (sizeof(D3DDEVICEDESC7)) 277 | 278 | #define D3DDD_COLORMODEL 0x00000001 279 | #define D3DDD_DEVCAPS 0x00000002 280 | #define D3DDD_TRANSFORMCAPS 0x00000004 281 | #define D3DDD_LIGHTINGCAPS 0x00000008 282 | #define D3DDD_BCLIPPING 0x00000010 283 | #define D3DDD_LINECAPS 0x00000020 284 | #define D3DDD_TRICAPS 0x00000040 285 | #define D3DDD_DEVICERENDERBITDEPTH 0x00000080 286 | #define D3DDD_DEVICEZBUFFERBITDEPTH 0x00000100 287 | #define D3DDD_MAXBUFFERSIZE 0x00000200 288 | #define D3DDD_MAXVERTEXCOUNT 0x00000400 289 | 290 | #define D3DDEVCAPS_FLOATTLVERTEX 0x00000001 291 | #define D3DDEVCAPS_SORTINCREASINGZ 0x00000002 292 | #define D3DDEVCAPS_SORTDECREASINGZ 0X00000004 293 | #define D3DDEVCAPS_SORTEXACT 0x00000008 294 | #define D3DDEVCAPS_EXECUTESYSTEMMEMORY 0x00000010 295 | #define D3DDEVCAPS_EXECUTEVIDEOMEMORY 0x00000020 296 | #define D3DDEVCAPS_TLVERTEXSYSTEMMEMORY 0x00000040 297 | #define D3DDEVCAPS_TLVERTEXVIDEOMEMORY 0x00000080 298 | #define D3DDEVCAPS_TEXTURESYSTEMMEMORY 0x00000100 299 | #define D3DDEVCAPS_TEXTUREVIDEOMEMORY 0x00000200 300 | #define D3DDEVCAPS_DRAWPRIMTLVERTEX 0x00000400 301 | #define D3DDEVCAPS_CANRENDERAFTERFLIP 0x00000800 302 | #define D3DDEVCAPS_TEXTURENONLOCALVIDMEM 0x00001000 303 | #define D3DDEVCAPS_DRAWPRIMITIVES2 0x00002000 304 | #define D3DDEVCAPS_SEPARATETEXTUREMEMORIES 0x00004000 305 | #define D3DDEVCAPS_DRAWPRIMITIVES2EX 0x00008000 306 | #define D3DDEVCAPS_HWTRANSFORMANDLIGHT 0x00010000 307 | #define D3DDEVCAPS_CANBLTSYSTONONLOCAL 0x00020000 308 | #define D3DDEVCAPS_HWRASTERIZATION 0x00080000 309 | 310 | #define D3DSTENCILCAPS_KEEP 0x00000001 311 | #define D3DSTENCILCAPS_ZERO 0x00000002 312 | #define D3DSTENCILCAPS_REPLACE 0x00000004 313 | #define D3DSTENCILCAPS_INCRSAT 0x00000008 314 | #define D3DSTENCILCAPS_DECRSAT 0x00000010 315 | #define D3DSTENCILCAPS_INVERT 0x00000020 316 | #define D3DSTENCILCAPS_INCR 0x00000040 317 | #define D3DSTENCILCAPS_DECR 0x00000080 318 | 319 | #define D3DTEXOPCAPS_DISABLE 0x00000001 320 | #define D3DTEXOPCAPS_SELECTARG1 0x00000002 321 | #define D3DTEXOPCAPS_SELECTARG2 0x00000004 322 | #define D3DTEXOPCAPS_MODULATE 0x00000008 323 | #define D3DTEXOPCAPS_MODULATE2X 0x00000010 324 | #define D3DTEXOPCAPS_MODULATE4X 0x00000020 325 | #define D3DTEXOPCAPS_ADD 0x00000040 326 | #define D3DTEXOPCAPS_ADDSIGNED 0x00000080 327 | #define D3DTEXOPCAPS_ADDSIGNED2X 0x00000100 328 | #define D3DTEXOPCAPS_SUBTRACT 0x00000200 329 | #define D3DTEXOPCAPS_ADDSMOOTH 0x00000400 330 | #define D3DTEXOPCAPS_BLENDDIFFUSEALPHA 0x00000800 331 | #define D3DTEXOPCAPS_BLENDTEXTUREALPHA 0x00001000 332 | #define D3DTEXOPCAPS_BLENDFACTORALPHA 0x00002000 333 | #define D3DTEXOPCAPS_BLENDTEXTUREALPHAPM 0x00004000 334 | #define D3DTEXOPCAPS_BLENDCURRENTALPHA 0x00008000 335 | #define D3DTEXOPCAPS_PREMODULATE 0x00010000 336 | #define D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR 0x00020000 337 | #define D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA 0x00040000 338 | #define D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR 0x00080000 339 | #define D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA 0x00100000 340 | #define D3DTEXOPCAPS_BUMPENVMAP 0x00200000 341 | #define D3DTEXOPCAPS_BUMPENVMAPLUMINANCE 0x00400000 342 | #define D3DTEXOPCAPS_DOTPRODUCT3 0x00800000 343 | 344 | #define D3DFVFCAPS_TEXCOORDCOUNTMASK 0x0000FFFF 345 | #define D3DFVFCAPS_DONOTSTRIPELEMENTS 0x00080000 346 | 347 | #define D3DVTXPCAPS_TEXGEN 0x00000001 348 | #define D3DVTXPCAPS_MATERIALSOURCE7 0x00000002 349 | #define D3DVTXPCAPS_VERTEXFOG 0x00000004 350 | #define D3DVTXPCAPS_DIRECTIONALLIGHTS 0x00000008 351 | #define D3DVTXPCAPS_POSITIONALLIGHTS 0x00000010 352 | #define D3DVTXPCAPS_LOCALVIEWER 0x00000020 353 | 354 | typedef HRESULT (CALLBACK *LPD3DENUMDEVICESCALLBACK)(GUID *guid, char *description, char *name, 355 | D3DDEVICEDESC *hal_desc, D3DDEVICEDESC *hel_desc, void *ctx); 356 | typedef HRESULT (CALLBACK *LPD3DENUMDEVICESCALLBACK7)(char *description, char *name, D3DDEVICEDESC7 *desc, void *ctx); 357 | 358 | #define D3DFDS_COLORMODEL 0x00000001 359 | #define D3DFDS_GUID 0x00000002 360 | #define D3DFDS_HARDWARE 0x00000004 361 | #define D3DFDS_TRIANGLES 0x00000008 362 | #define D3DFDS_LINES 0x00000010 363 | #define D3DFDS_MISCCAPS 0x00000020 364 | #define D3DFDS_RASTERCAPS 0x00000040 365 | #define D3DFDS_ZCMPCAPS 0x00000080 366 | #define D3DFDS_ALPHACMPCAPS 0x00000100 367 | #define D3DFDS_SRCBLENDCAPS 0x00000200 368 | #define D3DFDS_DSTBLENDCAPS 0x00000400 369 | #define D3DFDS_SHADECAPS 0x00000800 370 | #define D3DFDS_TEXTURECAPS 0x00001000 371 | #define D3DFDS_TEXTUREFILTERCAPS 0x00002000 372 | #define D3DFDS_TEXTUREBLENDCAPS 0x00004000 373 | #define D3DFDS_TEXTUREADDRESSCAPS 0x00008000 374 | 375 | typedef struct _D3DFINDDEVICESEARCH { 376 | DWORD dwSize; 377 | DWORD dwFlags; 378 | BOOL bHardware; 379 | D3DCOLORMODEL dcmColorModel; 380 | GUID guid; 381 | DWORD dwCaps; 382 | D3DPRIMCAPS dpcPrimCaps; 383 | } D3DFINDDEVICESEARCH,*LPD3DFINDDEVICESEARCH; 384 | 385 | typedef struct _D3DFINDDEVICERESULT { 386 | DWORD dwSize; 387 | GUID guid; 388 | D3DDEVICEDESC ddHwDesc; 389 | D3DDEVICEDESC ddSwDesc; 390 | } D3DFINDDEVICERESULT,*LPD3DFINDDEVICERESULT; 391 | 392 | typedef struct _D3DExecuteBufferDesc { 393 | DWORD dwSize; 394 | DWORD dwFlags; 395 | DWORD dwCaps; 396 | DWORD dwBufferSize; 397 | void *lpData; 398 | } D3DEXECUTEBUFFERDESC, *LPD3DEXECUTEBUFFERDESC; 399 | 400 | #define D3DDEB_BUFSIZE 0x00000001 401 | #define D3DDEB_CAPS 0x00000002 402 | #define D3DDEB_LPDATA 0x00000004 403 | 404 | #define D3DDEBCAPS_SYSTEMMEMORY 0x00000001 405 | #define D3DDEBCAPS_VIDEOMEMORY 0x00000002 406 | #define D3DDEBCAPS_MEM (D3DDEBCAPS_SYSTEMMEMORY|D3DDEBCAPS_VIDEOMEMORY) /* = 0x3 */ 407 | 408 | typedef struct _D3DDEVINFO_TEXTUREMANAGER { 409 | BOOL bThrashing; 410 | DWORD dwApproxBytesDownloaded; 411 | DWORD dwNumEvicts; 412 | DWORD dwNumVidCreates; 413 | DWORD dwNumTexturesUsed; 414 | DWORD dwNumUsedTexInVid; 415 | DWORD dwWorkingSet; 416 | DWORD dwWorkingSetBytes; 417 | DWORD dwTotalManaged; 418 | DWORD dwTotalBytes; 419 | DWORD dwLastPri; 420 | } D3DDEVINFO_TEXTUREMANAGER, *LPD3DDEVINFO_TEXTUREMANAGER; 421 | 422 | typedef struct _D3DDEVINFO_TEXTURING { 423 | DWORD dwNumLoads; 424 | DWORD dwApproxBytesLoaded; 425 | DWORD dwNumPreLoads; 426 | DWORD dwNumSet; 427 | DWORD dwNumCreates; 428 | DWORD dwNumDestroys; 429 | DWORD dwNumSetPriorities; 430 | DWORD dwNumSetLODs; 431 | DWORD dwNumLocks; 432 | DWORD dwNumGetDCs; 433 | } D3DDEVINFO_TEXTURING, *LPD3DDEVINFO_TEXTURING; 434 | 435 | #ifdef __i386__ 436 | #include 437 | #endif 438 | 439 | #endif 440 | -------------------------------------------------------------------------------- /wine/d3dtypes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2000 Peter Hunnisett 3 | * 4 | * This library is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * This library is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with this library; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 17 | */ 18 | 19 | /* FIXME: Need to add C++ code for certain structs for headers - this is going to be a problem 20 | if WINE continues to only use C code - I suppose that we could always inline in 21 | the header file to get around that little problem... */ 22 | /* FIXME: We need to implement versioning on everything directx 5 and up if these headers 23 | are going to be generically useful for directx stuff */ 24 | 25 | #ifndef __WINE_D3DTYPES_H 26 | #define __WINE_D3DTYPES_H 27 | 28 | #include 29 | #include 30 | #include 31 | 32 | #ifdef __i386__ 33 | #include 34 | #endif 35 | 36 | #define D3DVALP(val, prec) ((float)(val)) 37 | #define D3DVAL(val) ((float)(val)) 38 | #define D3DDivide(a, b) (float)((double) (a) / (double) (b)) 39 | #define D3DMultiply(a, b) ((a) * (b)) 40 | 41 | typedef LONG D3DFIXED; 42 | 43 | 44 | #ifndef RGB_MAKE 45 | #define CI_GETALPHA(ci) ((ci) >> 24) 46 | #define CI_GETINDEX(ci) (((ci) >> 8) & 0xffff) 47 | #define CI_GETFRACTION(ci) ((ci) & 0xff) 48 | #define CI_ROUNDINDEX(ci) CI_GETINDEX((ci) + 0x80) 49 | #define CI_MASKALPHA(ci) ((ci) & 0xffffff) 50 | #define CI_MAKE(a, i, f) (((a) << 24) | ((i) << 8) | (f)) 51 | 52 | #define RGBA_GETALPHA(rgb) ((rgb) >> 24) 53 | #define RGBA_GETRED(rgb) (((rgb) >> 16) & 0xff) 54 | #define RGBA_GETGREEN(rgb) (((rgb) >> 8) & 0xff) 55 | #define RGBA_GETBLUE(rgb) ((rgb) & 0xff) 56 | #define RGBA_MAKE(r, g, b, a) ((D3DCOLOR) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))) 57 | 58 | #define D3DRGB(r, g, b) \ 59 | (0xff000000 | ( ((LONG)((r) * 255)) << 16) | (((LONG)((g) * 255)) << 8) | (LONG)((b) * 255)) 60 | #define D3DRGBA(r, g, b, a) \ 61 | ( (((LONG)((a) * 255)) << 24) | (((LONG)((r) * 255)) << 16) \ 62 | | (((LONG)((g) * 255)) << 8) | (LONG)((b) * 255) \ 63 | ) 64 | 65 | #define RGB_GETRED(rgb) (((rgb) >> 16) & 0xff) 66 | #define RGB_GETGREEN(rgb) (((rgb) >> 8) & 0xff) 67 | #define RGB_GETBLUE(rgb) ((rgb) & 0xff) 68 | #define RGBA_SETALPHA(rgba, x) (((x) << 24) | ((rgba) & 0x00ffffff)) 69 | #define RGB_MAKE(r, g, b) ((D3DCOLOR) (((r) << 16) | ((g) << 8) | (b))) 70 | #define RGBA_TORGB(rgba) ((D3DCOLOR) ((rgba) & 0xffffff)) 71 | #define RGB_TORGBA(rgb) ((D3DCOLOR) ((rgb) | 0xff000000)) 72 | 73 | #endif 74 | 75 | #define D3DENUMRET_CANCEL DDENUMRET_CANCEL 76 | #define D3DENUMRET_OK DDENUMRET_OK 77 | 78 | typedef HRESULT (CALLBACK *LPD3DVALIDATECALLBACK)(void *ctx, DWORD offset); 79 | typedef HRESULT (CALLBACK *LPD3DENUMTEXTUREFORMATSCALLBACK)(DDSURFACEDESC *surface_desc, void *ctx); 80 | typedef HRESULT (CALLBACK *LPD3DENUMPIXELFORMATSCALLBACK)(DDPIXELFORMAT *format, void *ctx); 81 | 82 | #ifndef DX_SHARED_DEFINES 83 | 84 | typedef float D3DVALUE,*LPD3DVALUE; 85 | 86 | #ifndef D3DCOLOR_DEFINED 87 | typedef DWORD D3DCOLOR, *LPD3DCOLOR; 88 | #define D3DCOLOR_DEFINED 89 | #endif 90 | 91 | #ifndef D3DVECTOR_DEFINED 92 | typedef struct _D3DVECTOR { 93 | union { 94 | D3DVALUE x; 95 | D3DVALUE dvX; 96 | } DUMMYUNIONNAME1; 97 | union { 98 | D3DVALUE y; 99 | D3DVALUE dvY; 100 | } DUMMYUNIONNAME2; 101 | union { 102 | D3DVALUE z; 103 | D3DVALUE dvZ; 104 | } DUMMYUNIONNAME3; 105 | #if defined(__cplusplus) && defined(D3D_OVERLOADS) 106 | /* the definitions for these methods are in d3dvec.inl */ 107 | public: 108 | /*** constructors ***/ 109 | _D3DVECTOR() {} 110 | _D3DVECTOR(D3DVALUE f); 111 | _D3DVECTOR(D3DVALUE _x, D3DVALUE _y, D3DVALUE _z); 112 | _D3DVECTOR(const D3DVALUE f[3]); 113 | 114 | /*** assignment operators ***/ 115 | _D3DVECTOR& operator += (const _D3DVECTOR& v); 116 | _D3DVECTOR& operator -= (const _D3DVECTOR& v); 117 | _D3DVECTOR& operator *= (const _D3DVECTOR& v); 118 | _D3DVECTOR& operator /= (const _D3DVECTOR& v); 119 | _D3DVECTOR& operator *= (D3DVALUE s); 120 | _D3DVECTOR& operator /= (D3DVALUE s); 121 | 122 | /*** unary operators ***/ 123 | friend _D3DVECTOR operator + (const _D3DVECTOR& v); 124 | friend _D3DVECTOR operator - (const _D3DVECTOR& v); 125 | 126 | /*** binary operators ***/ 127 | friend _D3DVECTOR operator + (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 128 | friend _D3DVECTOR operator - (const _D3DVECTOR& v1, const _D3DVECTOR& v2); 129 | 130 | friend _D3DVECTOR operator * (const _D3DVECTOR& v, D3DVALUE s); 131 | friend _D3DVECTOR operator * (D3DVALUE s, const _D3DVECTOR& v); 132 | friend _D3DVECTOR operator / (const _D3DVECTOR& v, D3DVALUE s); 133 | 134 | friend D3DVALUE SquareMagnitude(const _D3DVECTOR& v); 135 | friend D3DVALUE Magnitude(const _D3DVECTOR& v); 136 | 137 | friend _D3DVECTOR Normalize(const _D3DVECTOR& v); 138 | 139 | friend D3DVALUE DotProduct(const _D3DVECTOR& v1, const _D3DVECTOR& v2); 140 | friend _D3DVECTOR CrossProduct(const _D3DVECTOR& v1, const _D3DVECTOR& v2); 141 | #endif 142 | } D3DVECTOR,*LPD3DVECTOR; 143 | #define D3DVECTOR_DEFINED 144 | #endif 145 | 146 | #define DX_SHARED_DEFINES 147 | #endif /* DX_SHARED_DEFINES */ 148 | 149 | typedef DWORD D3DMATERIALHANDLE, *LPD3DMATERIALHANDLE; 150 | typedef DWORD D3DTEXTUREHANDLE, *LPD3DTEXTUREHANDLE; 151 | typedef DWORD D3DMATRIXHANDLE, *LPD3DMATRIXHANDLE; 152 | 153 | typedef struct _D3DCOLORVALUE { 154 | union { 155 | D3DVALUE r; 156 | D3DVALUE dvR; 157 | } DUMMYUNIONNAME1; 158 | union { 159 | D3DVALUE g; 160 | D3DVALUE dvG; 161 | } DUMMYUNIONNAME2; 162 | union { 163 | D3DVALUE b; 164 | D3DVALUE dvB; 165 | } DUMMYUNIONNAME3; 166 | union { 167 | D3DVALUE a; 168 | D3DVALUE dvA; 169 | } DUMMYUNIONNAME4; 170 | } D3DCOLORVALUE,*LPD3DCOLORVALUE; 171 | 172 | typedef struct _D3DRECT { 173 | union { 174 | LONG x1; 175 | LONG lX1; 176 | } DUMMYUNIONNAME1; 177 | union { 178 | LONG y1; 179 | LONG lY1; 180 | } DUMMYUNIONNAME2; 181 | union { 182 | LONG x2; 183 | LONG lX2; 184 | } DUMMYUNIONNAME3; 185 | union { 186 | LONG y2; 187 | LONG lY2; 188 | } DUMMYUNIONNAME4; 189 | } D3DRECT, *LPD3DRECT; 190 | 191 | typedef struct _D3DHVERTEX { 192 | DWORD dwFlags; 193 | union { 194 | D3DVALUE hx; 195 | D3DVALUE dvHX; 196 | } DUMMYUNIONNAME1; 197 | union { 198 | D3DVALUE hy; 199 | D3DVALUE dvHY; 200 | } DUMMYUNIONNAME2; 201 | union { 202 | D3DVALUE hz; 203 | D3DVALUE dvHZ; 204 | } DUMMYUNIONNAME3; 205 | } D3DHVERTEX, *LPD3DHVERTEX; 206 | 207 | /* 208 | * Transformed/lit vertices 209 | */ 210 | typedef struct _D3DTLVERTEX { 211 | union { 212 | D3DVALUE sx; 213 | D3DVALUE dvSX; 214 | } DUMMYUNIONNAME1; 215 | union { 216 | D3DVALUE sy; 217 | D3DVALUE dvSY; 218 | } DUMMYUNIONNAME2; 219 | union { 220 | D3DVALUE sz; 221 | D3DVALUE dvSZ; 222 | } DUMMYUNIONNAME3; 223 | union { 224 | D3DVALUE rhw; 225 | D3DVALUE dvRHW; 226 | } DUMMYUNIONNAME4; 227 | union { 228 | D3DCOLOR color; 229 | D3DCOLOR dcColor; 230 | } DUMMYUNIONNAME5; 231 | union { 232 | D3DCOLOR specular; 233 | D3DCOLOR dcSpecular; 234 | } DUMMYUNIONNAME6; 235 | union { 236 | D3DVALUE tu; 237 | D3DVALUE dvTU; 238 | } DUMMYUNIONNAME7; 239 | union { 240 | D3DVALUE tv; 241 | D3DVALUE dvTV; 242 | } DUMMYUNIONNAME8; 243 | #if defined(__cplusplus) && defined(D3D_OVERLOADS) 244 | public: 245 | _D3DTLVERTEX() {} 246 | _D3DTLVERTEX(const D3DVECTOR& v, float _rhw, D3DCOLOR _color, D3DCOLOR _specular, float _tu, float _tv) { 247 | sx = v.x; sy = v.y; sz = v.z; rhw = _rhw; 248 | color = _color; specular = _specular; 249 | tu = _tu; tv = _tv; 250 | } 251 | #endif 252 | } D3DTLVERTEX, *LPD3DTLVERTEX; 253 | 254 | typedef struct _D3DLVERTEX { 255 | union { 256 | D3DVALUE x; 257 | D3DVALUE dvX; 258 | } DUMMYUNIONNAME1; 259 | union { 260 | D3DVALUE y; 261 | D3DVALUE dvY; 262 | } DUMMYUNIONNAME2; 263 | union { 264 | D3DVALUE z; 265 | D3DVALUE dvZ; 266 | } DUMMYUNIONNAME3; 267 | DWORD dwReserved; 268 | union { 269 | D3DCOLOR color; 270 | D3DCOLOR dcColor; 271 | } DUMMYUNIONNAME4; 272 | union { 273 | D3DCOLOR specular; 274 | D3DCOLOR dcSpecular; 275 | } DUMMYUNIONNAME5; 276 | union { 277 | D3DVALUE tu; 278 | D3DVALUE dvTU; 279 | } DUMMYUNIONNAME6; 280 | union { 281 | D3DVALUE tv; 282 | D3DVALUE dvTV; 283 | } DUMMYUNIONNAME7; 284 | } D3DLVERTEX, *LPD3DLVERTEX; 285 | 286 | typedef struct _D3DVERTEX { 287 | union { 288 | D3DVALUE x; 289 | D3DVALUE dvX; 290 | } DUMMYUNIONNAME1; 291 | union { 292 | D3DVALUE y; 293 | D3DVALUE dvY; 294 | } DUMMYUNIONNAME2; 295 | union { 296 | D3DVALUE z; 297 | D3DVALUE dvZ; 298 | } DUMMYUNIONNAME3; 299 | union { 300 | D3DVALUE nx; 301 | D3DVALUE dvNX; 302 | } DUMMYUNIONNAME4; 303 | union { 304 | D3DVALUE ny; 305 | D3DVALUE dvNY; 306 | } DUMMYUNIONNAME5; 307 | union { 308 | D3DVALUE nz; 309 | D3DVALUE dvNZ; 310 | } DUMMYUNIONNAME6; 311 | union { 312 | D3DVALUE tu; 313 | D3DVALUE dvTU; 314 | } DUMMYUNIONNAME7; 315 | union { 316 | D3DVALUE tv; 317 | D3DVALUE dvTV; 318 | } DUMMYUNIONNAME8; 319 | #if defined(__cplusplus) && defined(D3D_OVERLOADS) 320 | public: 321 | _D3DVERTEX() {} 322 | _D3DVERTEX(const D3DVECTOR& v, const D3DVECTOR& n, float _tu, float _tv) { 323 | x = v.x; y = v.y; z = v.z; 324 | nx = n.x; ny = n.y; nz = n.z; 325 | tu = _tu; tv = _tv; 326 | } 327 | #endif 328 | } D3DVERTEX, *LPD3DVERTEX; 329 | 330 | typedef struct _D3DMATRIX { 331 | D3DVALUE _11, _12, _13, _14; 332 | D3DVALUE _21, _22, _23, _24; 333 | D3DVALUE _31, _32, _33, _34; 334 | D3DVALUE _41, _42, _43, _44; 335 | #if defined(__cplusplus) && defined(D3D_OVERLOADS) 336 | _D3DMATRIX() { } 337 | 338 | /* This is different from MS, but avoids anonymous structs. */ 339 | D3DVALUE &operator () (int r, int c) 340 | { return (&_11)[r*4 + c]; } 341 | const D3DVALUE &operator() (int r, int c) const 342 | { return (&_11)[r*4 + c]; } 343 | #endif 344 | } D3DMATRIX, *LPD3DMATRIX; 345 | 346 | #if defined(__cplusplus) && defined(D3D_OVERLOADS) 347 | #include 348 | #endif 349 | 350 | typedef struct _D3DVIEWPORT { 351 | DWORD dwSize; 352 | DWORD dwX; 353 | DWORD dwY; 354 | DWORD dwWidth; 355 | DWORD dwHeight; 356 | D3DVALUE dvScaleX; 357 | D3DVALUE dvScaleY; 358 | D3DVALUE dvMaxX; 359 | D3DVALUE dvMaxY; 360 | D3DVALUE dvMinZ; 361 | D3DVALUE dvMaxZ; 362 | } D3DVIEWPORT, *LPD3DVIEWPORT; 363 | 364 | typedef struct _D3DVIEWPORT2 { 365 | DWORD dwSize; 366 | DWORD dwX; 367 | DWORD dwY; 368 | DWORD dwWidth; 369 | DWORD dwHeight; 370 | D3DVALUE dvClipX; 371 | D3DVALUE dvClipY; 372 | D3DVALUE dvClipWidth; 373 | D3DVALUE dvClipHeight; 374 | D3DVALUE dvMinZ; 375 | D3DVALUE dvMaxZ; 376 | } D3DVIEWPORT2, *LPD3DVIEWPORT2; 377 | 378 | typedef struct _D3DVIEWPORT7 { 379 | DWORD dwX; 380 | DWORD dwY; 381 | DWORD dwWidth; 382 | DWORD dwHeight; 383 | D3DVALUE dvMinZ; 384 | D3DVALUE dvMaxZ; 385 | } D3DVIEWPORT7, *LPD3DVIEWPORT7; 386 | 387 | #define D3DMAXUSERCLIPPLANES 32 388 | 389 | #define D3DCLIPPLANE0 (1 << 0) 390 | #define D3DCLIPPLANE1 (1 << 1) 391 | #define D3DCLIPPLANE2 (1 << 2) 392 | #define D3DCLIPPLANE3 (1 << 3) 393 | #define D3DCLIPPLANE4 (1 << 4) 394 | #define D3DCLIPPLANE5 (1 << 5) 395 | 396 | #define D3DCLIP_LEFT 0x00000001 397 | #define D3DCLIP_RIGHT 0x00000002 398 | #define D3DCLIP_TOP 0x00000004 399 | #define D3DCLIP_BOTTOM 0x00000008 400 | #define D3DCLIP_FRONT 0x00000010 401 | #define D3DCLIP_BACK 0x00000020 402 | #define D3DCLIP_GEN0 0x00000040 403 | #define D3DCLIP_GEN1 0x00000080 404 | #define D3DCLIP_GEN2 0x00000100 405 | #define D3DCLIP_GEN3 0x00000200 406 | #define D3DCLIP_GEN4 0x00000400 407 | #define D3DCLIP_GEN5 0x00000800 408 | 409 | #define D3DSTATUS_CLIPUNIONLEFT D3DCLIP_LEFT 410 | #define D3DSTATUS_CLIPUNIONRIGHT D3DCLIP_RIGHT 411 | #define D3DSTATUS_CLIPUNIONTOP D3DCLIP_TOP 412 | #define D3DSTATUS_CLIPUNIONBOTTOM D3DCLIP_BOTTOM 413 | #define D3DSTATUS_CLIPUNIONFRONT D3DCLIP_FRONT 414 | #define D3DSTATUS_CLIPUNIONBACK D3DCLIP_BACK 415 | #define D3DSTATUS_CLIPUNIONGEN0 D3DCLIP_GEN0 416 | #define D3DSTATUS_CLIPUNIONGEN1 D3DCLIP_GEN1 417 | #define D3DSTATUS_CLIPUNIONGEN2 D3DCLIP_GEN2 418 | #define D3DSTATUS_CLIPUNIONGEN3 D3DCLIP_GEN3 419 | #define D3DSTATUS_CLIPUNIONGEN4 D3DCLIP_GEN4 420 | #define D3DSTATUS_CLIPUNIONGEN5 D3DCLIP_GEN5 421 | 422 | #define D3DSTATUS_CLIPINTERSECTIONLEFT 0x00001000 423 | #define D3DSTATUS_CLIPINTERSECTIONRIGHT 0x00002000 424 | #define D3DSTATUS_CLIPINTERSECTIONTOP 0x00004000 425 | #define D3DSTATUS_CLIPINTERSECTIONBOTTOM 0x00008000 426 | #define D3DSTATUS_CLIPINTERSECTIONFRONT 0x00010000 427 | #define D3DSTATUS_CLIPINTERSECTIONBACK 0x00020000 428 | #define D3DSTATUS_CLIPINTERSECTIONGEN0 0x00040000 429 | #define D3DSTATUS_CLIPINTERSECTIONGEN1 0x00080000 430 | #define D3DSTATUS_CLIPINTERSECTIONGEN2 0x00100000 431 | #define D3DSTATUS_CLIPINTERSECTIONGEN3 0x00200000 432 | #define D3DSTATUS_CLIPINTERSECTIONGEN4 0x00400000 433 | #define D3DSTATUS_CLIPINTERSECTIONGEN5 0x00800000 434 | #define D3DSTATUS_ZNOTVISIBLE 0x01000000 435 | 436 | #define D3DSTATUS_CLIPUNIONALL ( \ 437 | D3DSTATUS_CLIPUNIONLEFT | \ 438 | D3DSTATUS_CLIPUNIONRIGHT | \ 439 | D3DSTATUS_CLIPUNIONTOP | \ 440 | D3DSTATUS_CLIPUNIONBOTTOM | \ 441 | D3DSTATUS_CLIPUNIONFRONT | \ 442 | D3DSTATUS_CLIPUNIONBACK | \ 443 | D3DSTATUS_CLIPUNIONGEN0 | \ 444 | D3DSTATUS_CLIPUNIONGEN1 | \ 445 | D3DSTATUS_CLIPUNIONGEN2 | \ 446 | D3DSTATUS_CLIPUNIONGEN3 | \ 447 | D3DSTATUS_CLIPUNIONGEN4 | \ 448 | D3DSTATUS_CLIPUNIONGEN5 \ 449 | ) 450 | 451 | #define D3DSTATUS_CLIPINTERSECTIONALL ( \ 452 | D3DSTATUS_CLIPINTERSECTIONLEFT | \ 453 | D3DSTATUS_CLIPINTERSECTIONRIGHT | \ 454 | D3DSTATUS_CLIPINTERSECTIONTOP | \ 455 | D3DSTATUS_CLIPINTERSECTIONBOTTOM | \ 456 | D3DSTATUS_CLIPINTERSECTIONFRONT | \ 457 | D3DSTATUS_CLIPINTERSECTIONBACK | \ 458 | D3DSTATUS_CLIPINTERSECTIONGEN0 | \ 459 | D3DSTATUS_CLIPINTERSECTIONGEN1 | \ 460 | D3DSTATUS_CLIPINTERSECTIONGEN2 | \ 461 | D3DSTATUS_CLIPINTERSECTIONGEN3 | \ 462 | D3DSTATUS_CLIPINTERSECTIONGEN4 | \ 463 | D3DSTATUS_CLIPINTERSECTIONGEN5 \ 464 | ) 465 | 466 | #define D3DSTATUS_DEFAULT ( \ 467 | D3DSTATUS_CLIPINTERSECTIONALL | \ 468 | D3DSTATUS_ZNOTVISIBLE) 469 | 470 | #define D3DTRANSFORM_CLIPPED 0x00000001 471 | #define D3DTRANSFORM_UNCLIPPED 0x00000002 472 | 473 | typedef struct _D3DTRANSFORMDATA { 474 | DWORD dwSize; 475 | void *lpIn; 476 | DWORD dwInSize; 477 | void *lpOut; 478 | DWORD dwOutSize; 479 | D3DHVERTEX *lpHOut; 480 | DWORD dwClip; 481 | DWORD dwClipIntersection; 482 | DWORD dwClipUnion; 483 | D3DRECT drExtent; 484 | } D3DTRANSFORMDATA, *LPD3DTRANSFORMDATA; 485 | 486 | typedef struct _D3DLIGHTINGELEMENT { 487 | D3DVECTOR dvPosition; 488 | D3DVECTOR dvNormal; 489 | } D3DLIGHTINGELEMENT, *LPD3DLIGHTINGELEMENT; 490 | 491 | typedef struct _D3DMATERIAL { 492 | DWORD dwSize; 493 | union { 494 | D3DCOLORVALUE diffuse; 495 | D3DCOLORVALUE dcvDiffuse; 496 | } DUMMYUNIONNAME; 497 | union { 498 | D3DCOLORVALUE ambient; 499 | D3DCOLORVALUE dcvAmbient; 500 | } DUMMYUNIONNAME1; 501 | union { 502 | D3DCOLORVALUE specular; 503 | D3DCOLORVALUE dcvSpecular; 504 | } DUMMYUNIONNAME2; 505 | union { 506 | D3DCOLORVALUE emissive; 507 | D3DCOLORVALUE dcvEmissive; 508 | } DUMMYUNIONNAME3; 509 | union { 510 | D3DVALUE power; 511 | D3DVALUE dvPower; 512 | } DUMMYUNIONNAME4; 513 | D3DTEXTUREHANDLE hTexture; 514 | DWORD dwRampSize; 515 | } D3DMATERIAL, *LPD3DMATERIAL; 516 | 517 | typedef struct _D3DMATERIAL7 { 518 | union { 519 | D3DCOLORVALUE diffuse; 520 | D3DCOLORVALUE dcvDiffuse; 521 | } DUMMYUNIONNAME; 522 | union { 523 | D3DCOLORVALUE ambient; 524 | D3DCOLORVALUE dcvAmbient; 525 | } DUMMYUNIONNAME1; 526 | union { 527 | D3DCOLORVALUE specular; 528 | D3DCOLORVALUE dcvSpecular; 529 | } DUMMYUNIONNAME2; 530 | union { 531 | D3DCOLORVALUE emissive; 532 | D3DCOLORVALUE dcvEmissive; 533 | } DUMMYUNIONNAME3; 534 | union { 535 | D3DVALUE power; 536 | D3DVALUE dvPower; 537 | } DUMMYUNIONNAME4; 538 | } D3DMATERIAL7, *LPD3DMATERIAL7; 539 | 540 | typedef enum { 541 | D3DLIGHT_POINT = 1, 542 | D3DLIGHT_SPOT = 2, 543 | D3DLIGHT_DIRECTIONAL = 3, 544 | D3DLIGHT_PARALLELPOINT = 4, 545 | D3DLIGHT_GLSPOT = 5, 546 | D3DLIGHT_FORCE_DWORD = 0x7fffffff 547 | } D3DLIGHTTYPE; 548 | 549 | typedef struct _D3DLIGHT { 550 | DWORD dwSize; 551 | D3DLIGHTTYPE dltType; 552 | D3DCOLORVALUE dcvColor; 553 | D3DVECTOR dvPosition; 554 | D3DVECTOR dvDirection; 555 | D3DVALUE dvRange; 556 | D3DVALUE dvFalloff; 557 | D3DVALUE dvAttenuation0; 558 | D3DVALUE dvAttenuation1; 559 | D3DVALUE dvAttenuation2; 560 | D3DVALUE dvTheta; 561 | D3DVALUE dvPhi; 562 | } D3DLIGHT,*LPD3DLIGHT; 563 | 564 | typedef struct _D3DLIGHT7 { 565 | D3DLIGHTTYPE dltType; 566 | D3DCOLORVALUE dcvDiffuse; 567 | D3DCOLORVALUE dcvSpecular; 568 | D3DCOLORVALUE dcvAmbient; 569 | D3DVECTOR dvPosition; 570 | D3DVECTOR dvDirection; 571 | D3DVALUE dvRange; 572 | D3DVALUE dvFalloff; 573 | D3DVALUE dvAttenuation0; 574 | D3DVALUE dvAttenuation1; 575 | D3DVALUE dvAttenuation2; 576 | D3DVALUE dvTheta; 577 | D3DVALUE dvPhi; 578 | } D3DLIGHT7, *LPD3DLIGHT7; 579 | 580 | #define D3DLIGHT_ACTIVE 0x00000001 581 | #define D3DLIGHT_NO_SPECULAR 0x00000002 582 | #define D3DLIGHT_ALL (D3DLIGHT_ACTIVE | D3DLIGHT_NO_SPECULAR) /* 0x3 */ 583 | 584 | #define D3DLIGHT_RANGE_MAX ((float)sqrt(FLT_MAX)) 585 | 586 | typedef struct _D3DLIGHT2 { 587 | DWORD dwSize; 588 | D3DLIGHTTYPE dltType; 589 | D3DCOLORVALUE dcvColor; 590 | D3DVECTOR dvPosition; 591 | D3DVECTOR dvDirection; 592 | D3DVALUE dvRange; 593 | D3DVALUE dvFalloff; 594 | D3DVALUE dvAttenuation0; 595 | D3DVALUE dvAttenuation1; 596 | D3DVALUE dvAttenuation2; 597 | D3DVALUE dvTheta; 598 | D3DVALUE dvPhi; 599 | DWORD dwFlags; 600 | } D3DLIGHT2, *LPD3DLIGHT2; 601 | 602 | typedef struct _D3DLIGHTDATA { 603 | DWORD dwSize; 604 | D3DLIGHTINGELEMENT *lpIn; 605 | DWORD dwInSize; 606 | D3DTLVERTEX *lpOut; 607 | DWORD dwOutSize; 608 | } D3DLIGHTDATA, *LPD3DLIGHTDATA; 609 | 610 | #define D3DCOLOR_MONO 1 611 | #define D3DCOLOR_RGB 2 612 | 613 | typedef DWORD D3DCOLORMODEL; 614 | 615 | 616 | #define D3DCLEAR_TARGET 0x00000001 617 | #define D3DCLEAR_ZBUFFER 0x00000002 618 | #define D3DCLEAR_STENCIL 0x00000004 619 | 620 | typedef enum _D3DOPCODE { 621 | D3DOP_POINT = 1, 622 | D3DOP_LINE = 2, 623 | D3DOP_TRIANGLE = 3, 624 | D3DOP_MATRIXLOAD = 4, 625 | D3DOP_MATRIXMULTIPLY = 5, 626 | D3DOP_STATETRANSFORM = 6, 627 | D3DOP_STATELIGHT = 7, 628 | D3DOP_STATERENDER = 8, 629 | D3DOP_PROCESSVERTICES = 9, 630 | D3DOP_TEXTURELOAD = 10, 631 | D3DOP_EXIT = 11, 632 | D3DOP_BRANCHFORWARD = 12, 633 | D3DOP_SPAN = 13, 634 | D3DOP_SETSTATUS = 14, 635 | 636 | D3DOP_FORCE_DWORD = 0x7fffffff 637 | } D3DOPCODE; 638 | 639 | typedef struct _D3DINSTRUCTION { 640 | BYTE bOpcode; 641 | BYTE bSize; 642 | WORD wCount; 643 | } D3DINSTRUCTION, *LPD3DINSTRUCTION; 644 | 645 | typedef struct _D3DTEXTURELOAD { 646 | D3DTEXTUREHANDLE hDestTexture; 647 | D3DTEXTUREHANDLE hSrcTexture; 648 | } D3DTEXTURELOAD, *LPD3DTEXTURELOAD; 649 | 650 | typedef struct _D3DPICKRECORD { 651 | BYTE bOpcode; 652 | BYTE bPad; 653 | DWORD dwOffset; 654 | D3DVALUE dvZ; 655 | } D3DPICKRECORD, *LPD3DPICKRECORD; 656 | 657 | typedef enum { 658 | D3DSHADE_FLAT = 1, 659 | D3DSHADE_GOURAUD = 2, 660 | D3DSHADE_PHONG = 3, 661 | D3DSHADE_FORCE_DWORD = 0x7fffffff 662 | } D3DSHADEMODE; 663 | 664 | typedef enum { 665 | D3DFILL_POINT = 1, 666 | D3DFILL_WIREFRAME = 2, 667 | D3DFILL_SOLID = 3, 668 | D3DFILL_FORCE_DWORD = 0x7fffffff 669 | } D3DFILLMODE; 670 | 671 | typedef struct _D3DLINEPATTERN { 672 | WORD wRepeatFactor; 673 | WORD wLinePattern; 674 | } D3DLINEPATTERN; 675 | 676 | typedef enum { 677 | D3DFILTER_NEAREST = 1, 678 | D3DFILTER_LINEAR = 2, 679 | D3DFILTER_MIPNEAREST = 3, 680 | D3DFILTER_MIPLINEAR = 4, 681 | D3DFILTER_LINEARMIPNEAREST = 5, 682 | D3DFILTER_LINEARMIPLINEAR = 6, 683 | D3DFILTER_FORCE_DWORD = 0x7fffffff 684 | } D3DTEXTUREFILTER; 685 | 686 | typedef enum { 687 | D3DBLEND_ZERO = 1, 688 | D3DBLEND_ONE = 2, 689 | D3DBLEND_SRCCOLOR = 3, 690 | D3DBLEND_INVSRCCOLOR = 4, 691 | D3DBLEND_SRCALPHA = 5, 692 | D3DBLEND_INVSRCALPHA = 6, 693 | D3DBLEND_DESTALPHA = 7, 694 | D3DBLEND_INVDESTALPHA = 8, 695 | D3DBLEND_DESTCOLOR = 9, 696 | D3DBLEND_INVDESTCOLOR = 10, 697 | D3DBLEND_SRCALPHASAT = 11, 698 | D3DBLEND_BOTHSRCALPHA = 12, 699 | D3DBLEND_BOTHINVSRCALPHA = 13, 700 | D3DBLEND_FORCE_DWORD = 0x7fffffff 701 | } D3DBLEND; 702 | 703 | typedef enum { 704 | D3DTBLEND_DECAL = 1, 705 | D3DTBLEND_MODULATE = 2, 706 | D3DTBLEND_DECALALPHA = 3, 707 | D3DTBLEND_MODULATEALPHA = 4, 708 | D3DTBLEND_DECALMASK = 5, 709 | D3DTBLEND_MODULATEMASK = 6, 710 | D3DTBLEND_COPY = 7, 711 | D3DTBLEND_ADD = 8, 712 | D3DTBLEND_FORCE_DWORD = 0x7fffffff 713 | } D3DTEXTUREBLEND; 714 | 715 | typedef enum _D3DTEXTUREADDRESS { 716 | D3DTADDRESS_WRAP = 1, 717 | D3DTADDRESS_MIRROR = 2, 718 | D3DTADDRESS_CLAMP = 3, 719 | D3DTADDRESS_BORDER = 4, 720 | D3DTADDRESS_FORCE_DWORD = 0x7fffffff 721 | } D3DTEXTUREADDRESS; 722 | 723 | typedef enum { 724 | D3DCULL_NONE = 1, 725 | D3DCULL_CW = 2, 726 | D3DCULL_CCW = 3, 727 | D3DCULL_FORCE_DWORD = 0x7fffffff 728 | } D3DCULL; 729 | 730 | typedef enum { 731 | D3DCMP_NEVER = 1, 732 | D3DCMP_LESS = 2, 733 | D3DCMP_EQUAL = 3, 734 | D3DCMP_LESSEQUAL = 4, 735 | D3DCMP_GREATER = 5, 736 | D3DCMP_NOTEQUAL = 6, 737 | D3DCMP_GREATEREQUAL = 7, 738 | D3DCMP_ALWAYS = 8, 739 | D3DCMP_FORCE_DWORD = 0x7fffffff 740 | } D3DCMPFUNC; 741 | 742 | typedef enum _D3DSTENCILOP { 743 | D3DSTENCILOP_KEEP = 1, 744 | D3DSTENCILOP_ZERO = 2, 745 | D3DSTENCILOP_REPLACE = 3, 746 | D3DSTENCILOP_INCRSAT = 4, 747 | D3DSTENCILOP_DECRSAT = 5, 748 | D3DSTENCILOP_INVERT = 6, 749 | D3DSTENCILOP_INCR = 7, 750 | D3DSTENCILOP_DECR = 8, 751 | D3DSTENCILOP_FORCE_DWORD = 0x7fffffff 752 | } D3DSTENCILOP; 753 | 754 | typedef enum _D3DFOGMODE { 755 | D3DFOG_NONE = 0, 756 | D3DFOG_EXP = 1, 757 | D3DFOG_EXP2 = 2, 758 | D3DFOG_LINEAR = 3, 759 | D3DFOG_FORCE_DWORD = 0x7fffffff 760 | } D3DFOGMODE; 761 | 762 | typedef enum _D3DZBUFFERTYPE { 763 | D3DZB_FALSE = 0, 764 | D3DZB_TRUE = 1, 765 | D3DZB_USEW = 2, 766 | D3DZB_FORCE_DWORD = 0x7fffffff 767 | } D3DZBUFFERTYPE; 768 | 769 | typedef enum _D3DANTIALIASMODE { 770 | D3DANTIALIAS_NONE = 0, 771 | D3DANTIALIAS_SORTDEPENDENT = 1, 772 | D3DANTIALIAS_SORTINDEPENDENT = 2, 773 | D3DANTIALIAS_FORCE_DWORD = 0x7fffffff 774 | } D3DANTIALIASMODE; 775 | 776 | typedef enum { 777 | D3DVT_VERTEX = 1, 778 | D3DVT_LVERTEX = 2, 779 | D3DVT_TLVERTEX = 3, 780 | D3DVT_FORCE_DWORD = 0x7fffffff 781 | } D3DVERTEXTYPE; 782 | 783 | typedef enum { 784 | D3DPT_POINTLIST = 1, 785 | D3DPT_LINELIST = 2, 786 | D3DPT_LINESTRIP = 3, 787 | D3DPT_TRIANGLELIST = 4, 788 | D3DPT_TRIANGLESTRIP = 5, 789 | D3DPT_TRIANGLEFAN = 6, 790 | D3DPT_FORCE_DWORD = 0x7fffffff 791 | } D3DPRIMITIVETYPE; 792 | 793 | #define D3DSTATE_OVERRIDE_BIAS 256 794 | 795 | #define D3DSTATE_OVERRIDE(type) (D3DRENDERSTATETYPE)(((DWORD) (type) + D3DSTATE_OVERRIDE_BIAS)) 796 | 797 | typedef enum _D3DTRANSFORMSTATETYPE { 798 | D3DTRANSFORMSTATE_WORLD = 1, 799 | D3DTRANSFORMSTATE_VIEW = 2, 800 | D3DTRANSFORMSTATE_PROJECTION = 3, 801 | D3DTRANSFORMSTATE_WORLD1 = 4, 802 | D3DTRANSFORMSTATE_WORLD2 = 5, 803 | D3DTRANSFORMSTATE_WORLD3 = 6, 804 | D3DTRANSFORMSTATE_TEXTURE0 = 16, 805 | D3DTRANSFORMSTATE_TEXTURE1 = 17, 806 | D3DTRANSFORMSTATE_TEXTURE2 = 18, 807 | D3DTRANSFORMSTATE_TEXTURE3 = 19, 808 | D3DTRANSFORMSTATE_TEXTURE4 = 20, 809 | D3DTRANSFORMSTATE_TEXTURE5 = 21, 810 | D3DTRANSFORMSTATE_TEXTURE6 = 22, 811 | D3DTRANSFORMSTATE_TEXTURE7 = 23, 812 | D3DTRANSFORMSTATE_FORCE_DWORD = 0x7fffffff 813 | } D3DTRANSFORMSTATETYPE; 814 | 815 | typedef enum { 816 | D3DLIGHTSTATE_MATERIAL = 1, 817 | D3DLIGHTSTATE_AMBIENT = 2, 818 | D3DLIGHTSTATE_COLORMODEL = 3, 819 | D3DLIGHTSTATE_FOGMODE = 4, 820 | D3DLIGHTSTATE_FOGSTART = 5, 821 | D3DLIGHTSTATE_FOGEND = 6, 822 | D3DLIGHTSTATE_FOGDENSITY = 7, 823 | D3DLIGHTSTATE_COLORVERTEX = 8, 824 | D3DLIGHTSTATE_FORCE_DWORD = 0x7fffffff 825 | } D3DLIGHTSTATETYPE; 826 | 827 | typedef enum { 828 | D3DRENDERSTATE_TEXTUREHANDLE = 1, 829 | D3DRENDERSTATE_ANTIALIAS = 2, 830 | D3DRENDERSTATE_TEXTUREADDRESS = 3, 831 | D3DRENDERSTATE_TEXTUREPERSPECTIVE = 4, 832 | D3DRENDERSTATE_WRAPU = 5, 833 | D3DRENDERSTATE_WRAPV = 6, 834 | D3DRENDERSTATE_ZENABLE = 7, 835 | D3DRENDERSTATE_FILLMODE = 8, 836 | D3DRENDERSTATE_SHADEMODE = 9, 837 | D3DRENDERSTATE_LINEPATTERN = 10, 838 | D3DRENDERSTATE_MONOENABLE = 11, 839 | D3DRENDERSTATE_ROP2 = 12, 840 | D3DRENDERSTATE_PLANEMASK = 13, 841 | D3DRENDERSTATE_ZWRITEENABLE = 14, 842 | D3DRENDERSTATE_ALPHATESTENABLE = 15, 843 | D3DRENDERSTATE_LASTPIXEL = 16, 844 | D3DRENDERSTATE_TEXTUREMAG = 17, 845 | D3DRENDERSTATE_TEXTUREMIN = 18, 846 | D3DRENDERSTATE_SRCBLEND = 19, 847 | D3DRENDERSTATE_DESTBLEND = 20, 848 | D3DRENDERSTATE_TEXTUREMAPBLEND = 21, 849 | D3DRENDERSTATE_CULLMODE = 22, 850 | D3DRENDERSTATE_ZFUNC = 23, 851 | D3DRENDERSTATE_ALPHAREF = 24, 852 | D3DRENDERSTATE_ALPHAFUNC = 25, 853 | D3DRENDERSTATE_DITHERENABLE = 26, 854 | D3DRENDERSTATE_ALPHABLENDENABLE = 27, 855 | D3DRENDERSTATE_FOGENABLE = 28, 856 | D3DRENDERSTATE_SPECULARENABLE = 29, 857 | D3DRENDERSTATE_ZVISIBLE = 30, 858 | D3DRENDERSTATE_SUBPIXEL = 31, 859 | D3DRENDERSTATE_SUBPIXELX = 32, 860 | D3DRENDERSTATE_STIPPLEDALPHA = 33, 861 | D3DRENDERSTATE_FOGCOLOR = 34, 862 | D3DRENDERSTATE_FOGTABLEMODE = 35, 863 | D3DRENDERSTATE_FOGTABLESTART = 36, 864 | D3DRENDERSTATE_FOGTABLEEND = 37, 865 | D3DRENDERSTATE_FOGTABLEDENSITY = 38, 866 | D3DRENDERSTATE_FOGSTART = 36, 867 | D3DRENDERSTATE_FOGEND = 37, 868 | D3DRENDERSTATE_FOGDENSITY = 38, 869 | D3DRENDERSTATE_STIPPLEENABLE = 39, 870 | D3DRENDERSTATE_EDGEANTIALIAS = 40, 871 | D3DRENDERSTATE_COLORKEYENABLE = 41, 872 | D3DRENDERSTATE_BORDERCOLOR = 43, 873 | D3DRENDERSTATE_TEXTUREADDRESSU = 44, 874 | D3DRENDERSTATE_TEXTUREADDRESSV = 45, 875 | D3DRENDERSTATE_MIPMAPLODBIAS = 46, 876 | D3DRENDERSTATE_ZBIAS = 47, 877 | D3DRENDERSTATE_RANGEFOGENABLE = 48, 878 | D3DRENDERSTATE_ANISOTROPY = 49, 879 | D3DRENDERSTATE_FLUSHBATCH = 50, 880 | D3DRENDERSTATE_TRANSLUCENTSORTINDEPENDENT = 51, 881 | 882 | D3DRENDERSTATE_STENCILENABLE = 52, 883 | D3DRENDERSTATE_STENCILFAIL = 53, 884 | D3DRENDERSTATE_STENCILZFAIL = 54, 885 | D3DRENDERSTATE_STENCILPASS = 55, 886 | D3DRENDERSTATE_STENCILFUNC = 56, 887 | D3DRENDERSTATE_STENCILREF = 57, 888 | D3DRENDERSTATE_STENCILMASK = 58, 889 | D3DRENDERSTATE_STENCILWRITEMASK = 59, 890 | D3DRENDERSTATE_TEXTUREFACTOR = 60, 891 | 892 | D3DRENDERSTATE_STIPPLEPATTERN00 = 64, 893 | D3DRENDERSTATE_STIPPLEPATTERN01 = 65, 894 | D3DRENDERSTATE_STIPPLEPATTERN02 = 66, 895 | D3DRENDERSTATE_STIPPLEPATTERN03 = 67, 896 | D3DRENDERSTATE_STIPPLEPATTERN04 = 68, 897 | D3DRENDERSTATE_STIPPLEPATTERN05 = 69, 898 | D3DRENDERSTATE_STIPPLEPATTERN06 = 70, 899 | D3DRENDERSTATE_STIPPLEPATTERN07 = 71, 900 | D3DRENDERSTATE_STIPPLEPATTERN08 = 72, 901 | D3DRENDERSTATE_STIPPLEPATTERN09 = 73, 902 | D3DRENDERSTATE_STIPPLEPATTERN10 = 74, 903 | D3DRENDERSTATE_STIPPLEPATTERN11 = 75, 904 | D3DRENDERSTATE_STIPPLEPATTERN12 = 76, 905 | D3DRENDERSTATE_STIPPLEPATTERN13 = 77, 906 | D3DRENDERSTATE_STIPPLEPATTERN14 = 78, 907 | D3DRENDERSTATE_STIPPLEPATTERN15 = 79, 908 | D3DRENDERSTATE_STIPPLEPATTERN16 = 80, 909 | D3DRENDERSTATE_STIPPLEPATTERN17 = 81, 910 | D3DRENDERSTATE_STIPPLEPATTERN18 = 82, 911 | D3DRENDERSTATE_STIPPLEPATTERN19 = 83, 912 | D3DRENDERSTATE_STIPPLEPATTERN20 = 84, 913 | D3DRENDERSTATE_STIPPLEPATTERN21 = 85, 914 | D3DRENDERSTATE_STIPPLEPATTERN22 = 86, 915 | D3DRENDERSTATE_STIPPLEPATTERN23 = 87, 916 | D3DRENDERSTATE_STIPPLEPATTERN24 = 88, 917 | D3DRENDERSTATE_STIPPLEPATTERN25 = 89, 918 | D3DRENDERSTATE_STIPPLEPATTERN26 = 90, 919 | D3DRENDERSTATE_STIPPLEPATTERN27 = 91, 920 | D3DRENDERSTATE_STIPPLEPATTERN28 = 92, 921 | D3DRENDERSTATE_STIPPLEPATTERN29 = 93, 922 | D3DRENDERSTATE_STIPPLEPATTERN30 = 94, 923 | D3DRENDERSTATE_STIPPLEPATTERN31 = 95, 924 | 925 | D3DRENDERSTATE_WRAP0 = 128, 926 | D3DRENDERSTATE_WRAP1 = 129, 927 | D3DRENDERSTATE_WRAP2 = 130, 928 | D3DRENDERSTATE_WRAP3 = 131, 929 | D3DRENDERSTATE_WRAP4 = 132, 930 | D3DRENDERSTATE_WRAP5 = 133, 931 | D3DRENDERSTATE_WRAP6 = 134, 932 | D3DRENDERSTATE_WRAP7 = 135, 933 | D3DRENDERSTATE_CLIPPING = 136, 934 | D3DRENDERSTATE_LIGHTING = 137, 935 | D3DRENDERSTATE_EXTENTS = 138, 936 | D3DRENDERSTATE_AMBIENT = 139, 937 | D3DRENDERSTATE_FOGVERTEXMODE = 140, 938 | D3DRENDERSTATE_COLORVERTEX = 141, 939 | D3DRENDERSTATE_LOCALVIEWER = 142, 940 | D3DRENDERSTATE_NORMALIZENORMALS = 143, 941 | D3DRENDERSTATE_COLORKEYBLENDENABLE = 144, 942 | D3DRENDERSTATE_DIFFUSEMATERIALSOURCE = 145, 943 | D3DRENDERSTATE_SPECULARMATERIALSOURCE = 146, 944 | D3DRENDERSTATE_AMBIENTMATERIALSOURCE = 147, 945 | D3DRENDERSTATE_EMISSIVEMATERIALSOURCE = 148, 946 | D3DRENDERSTATE_VERTEXBLEND = 151, 947 | D3DRENDERSTATE_CLIPPLANEENABLE = 152, 948 | 949 | D3DRENDERSTATE_FORCE_DWORD = 0x7fffffff 950 | 951 | /* FIXME: We have some retired values that are being reused for DirectX 7 */ 952 | } D3DRENDERSTATETYPE; 953 | 954 | typedef enum _D3DMATERIALCOLORSOURCE 955 | { 956 | D3DMCS_MATERIAL = 0, 957 | D3DMCS_COLOR1 = 1, 958 | D3DMCS_COLOR2 = 2, 959 | D3DMCS_FORCE_DWORD = 0x7fffffff 960 | } D3DMATERIALCOLORSOURCE; 961 | 962 | #define D3DRENDERSTATE_BLENDENABLE D3DRENDERSTATE_ALPHABLENDENABLE 963 | #define D3DRENDERSTATE_WRAPBIAS __MSABI_LONG(128U) 964 | #define D3DWRAP_U __MSABI_LONG(0x00000001) 965 | #define D3DWRAP_V __MSABI_LONG(0x00000002) 966 | 967 | #define D3DWRAPCOORD_0 __MSABI_LONG(0x00000001) 968 | #define D3DWRAPCOORD_1 __MSABI_LONG(0x00000002) 969 | #define D3DWRAPCOORD_2 __MSABI_LONG(0x00000004) 970 | #define D3DWRAPCOORD_3 __MSABI_LONG(0x00000008) 971 | 972 | #define D3DRENDERSTATE_STIPPLEPATTERN(y) (D3DRENDERSTATE_STIPPLEPATTERN00 + (y)) 973 | 974 | typedef struct _D3DSTATE { 975 | union { 976 | D3DTRANSFORMSTATETYPE dtstTransformStateType; 977 | D3DLIGHTSTATETYPE dlstLightStateType; 978 | D3DRENDERSTATETYPE drstRenderStateType; 979 | } DUMMYUNIONNAME1; 980 | union { 981 | DWORD dwArg[1]; 982 | D3DVALUE dvArg[1]; 983 | } DUMMYUNIONNAME2; 984 | } D3DSTATE, *LPD3DSTATE; 985 | 986 | typedef struct _D3DMATRIXLOAD { 987 | D3DMATRIXHANDLE hDestMatrix; 988 | D3DMATRIXHANDLE hSrcMatrix; 989 | } D3DMATRIXLOAD, *LPD3DMATRIXLOAD; 990 | 991 | typedef struct _D3DMATRIXMULTIPLY { 992 | D3DMATRIXHANDLE hDestMatrix; 993 | D3DMATRIXHANDLE hSrcMatrix1; 994 | D3DMATRIXHANDLE hSrcMatrix2; 995 | } D3DMATRIXMULTIPLY, *LPD3DMATRIXMULTIPLY; 996 | 997 | typedef struct _D3DPROCESSVERTICES { 998 | DWORD dwFlags; 999 | WORD wStart; 1000 | WORD wDest; 1001 | DWORD dwCount; 1002 | DWORD dwReserved; 1003 | } D3DPROCESSVERTICES, *LPD3DPROCESSVERTICES; 1004 | 1005 | #define D3DPROCESSVERTICES_TRANSFORMLIGHT __MSABI_LONG(0x00000000) 1006 | #define D3DPROCESSVERTICES_TRANSFORM __MSABI_LONG(0x00000001) 1007 | #define D3DPROCESSVERTICES_COPY __MSABI_LONG(0x00000002) 1008 | #define D3DPROCESSVERTICES_OPMASK __MSABI_LONG(0x00000007) 1009 | 1010 | #define D3DPROCESSVERTICES_UPDATEEXTENTS __MSABI_LONG(0x00000008) 1011 | #define D3DPROCESSVERTICES_NOCOLOR __MSABI_LONG(0x00000010) 1012 | 1013 | typedef enum _D3DTEXTURESTAGESTATETYPE 1014 | { 1015 | D3DTSS_COLOROP = 1, 1016 | D3DTSS_COLORARG1 = 2, 1017 | D3DTSS_COLORARG2 = 3, 1018 | D3DTSS_ALPHAOP = 4, 1019 | D3DTSS_ALPHAARG1 = 5, 1020 | D3DTSS_ALPHAARG2 = 6, 1021 | D3DTSS_BUMPENVMAT00 = 7, 1022 | D3DTSS_BUMPENVMAT01 = 8, 1023 | D3DTSS_BUMPENVMAT10 = 9, 1024 | D3DTSS_BUMPENVMAT11 = 10, 1025 | D3DTSS_TEXCOORDINDEX = 11, 1026 | D3DTSS_ADDRESS = 12, 1027 | D3DTSS_ADDRESSU = 13, 1028 | D3DTSS_ADDRESSV = 14, 1029 | D3DTSS_BORDERCOLOR = 15, 1030 | D3DTSS_MAGFILTER = 16, 1031 | D3DTSS_MINFILTER = 17, 1032 | D3DTSS_MIPFILTER = 18, 1033 | D3DTSS_MIPMAPLODBIAS = 19, 1034 | D3DTSS_MAXMIPLEVEL = 20, 1035 | D3DTSS_MAXANISOTROPY = 21, 1036 | D3DTSS_BUMPENVLSCALE = 22, 1037 | D3DTSS_BUMPENVLOFFSET = 23, 1038 | D3DTSS_TEXTURETRANSFORMFLAGS = 24, 1039 | D3DTSS_FORCE_DWORD = 0x7fffffff 1040 | } D3DTEXTURESTAGESTATETYPE; 1041 | 1042 | #define D3DTSS_TCI_PASSTHRU 0x00000000 1043 | #define D3DTSS_TCI_CAMERASPACENORMAL 0x00010000 1044 | #define D3DTSS_TCI_CAMERASPACEPOSITION 0x00020000 1045 | #define D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR 0x00030000 1046 | 1047 | typedef enum _D3DTEXTUREOP 1048 | { 1049 | D3DTOP_DISABLE = 1, 1050 | D3DTOP_SELECTARG1 = 2, 1051 | D3DTOP_SELECTARG2 = 3, 1052 | 1053 | D3DTOP_MODULATE = 4, 1054 | D3DTOP_MODULATE2X = 5, 1055 | D3DTOP_MODULATE4X = 6, 1056 | 1057 | D3DTOP_ADD = 7, 1058 | D3DTOP_ADDSIGNED = 8, 1059 | D3DTOP_ADDSIGNED2X = 9, 1060 | D3DTOP_SUBTRACT = 10, 1061 | D3DTOP_ADDSMOOTH = 11, 1062 | 1063 | D3DTOP_BLENDDIFFUSEALPHA = 12, 1064 | D3DTOP_BLENDTEXTUREALPHA = 13, 1065 | D3DTOP_BLENDFACTORALPHA = 14, 1066 | D3DTOP_BLENDTEXTUREALPHAPM = 15, 1067 | D3DTOP_BLENDCURRENTALPHA = 16, 1068 | 1069 | D3DTOP_PREMODULATE = 17, 1070 | D3DTOP_MODULATEALPHA_ADDCOLOR = 18, 1071 | D3DTOP_MODULATECOLOR_ADDALPHA = 19, 1072 | D3DTOP_MODULATEINVALPHA_ADDCOLOR = 20, 1073 | D3DTOP_MODULATEINVCOLOR_ADDALPHA = 21, 1074 | 1075 | D3DTOP_BUMPENVMAP = 22, 1076 | D3DTOP_BUMPENVMAPLUMINANCE = 23, 1077 | D3DTOP_DOTPRODUCT3 = 24, 1078 | 1079 | D3DTOP_FORCE_DWORD = 0x7fffffff 1080 | } D3DTEXTUREOP; 1081 | 1082 | #define D3DTA_SELECTMASK 0x0000000f 1083 | #define D3DTA_DIFFUSE 0x00000000 1084 | #define D3DTA_CURRENT 0x00000001 1085 | #define D3DTA_TEXTURE 0x00000002 1086 | #define D3DTA_TFACTOR 0x00000003 1087 | #define D3DTA_SPECULAR 0x00000004 1088 | #define D3DTA_COMPLEMENT 0x00000010 1089 | #define D3DTA_ALPHAREPLICATE 0x00000020 1090 | 1091 | typedef enum _D3DTEXTUREMAGFILTER 1092 | { 1093 | D3DTFG_POINT = 1, 1094 | D3DTFG_LINEAR = 2, 1095 | D3DTFG_FLATCUBIC = 3, 1096 | D3DTFG_GAUSSIANCUBIC = 4, 1097 | D3DTFG_ANISOTROPIC = 5, 1098 | D3DTFG_FORCE_DWORD = 0x7fffffff 1099 | } D3DTEXTUREMAGFILTER; 1100 | 1101 | typedef enum _D3DTEXTUREMINFILTER 1102 | { 1103 | D3DTFN_POINT = 1, 1104 | D3DTFN_LINEAR = 2, 1105 | D3DTFN_ANISOTROPIC = 3, 1106 | D3DTFN_FORCE_DWORD = 0x7fffffff 1107 | } D3DTEXTUREMINFILTER; 1108 | 1109 | typedef enum _D3DTEXTUREMIPFILTER 1110 | { 1111 | D3DTFP_NONE = 1, 1112 | D3DTFP_POINT = 2, 1113 | D3DTFP_LINEAR = 3, 1114 | D3DTFP_FORCE_DWORD = 0x7fffffff 1115 | } D3DTEXTUREMIPFILTER; 1116 | 1117 | #define D3DTRIFLAG_START __MSABI_LONG(0x00000000) 1118 | #define D3DTRIFLAG_STARTFLAT(len) (len) 1119 | #define D3DTRIFLAG_ODD __MSABI_LONG(0x0000001e) 1120 | #define D3DTRIFLAG_EVEN __MSABI_LONG(0x0000001f) 1121 | 1122 | #define D3DTRIFLAG_EDGEENABLE1 __MSABI_LONG(0x00000100) 1123 | #define D3DTRIFLAG_EDGEENABLE2 __MSABI_LONG(0x00000200) 1124 | #define D3DTRIFLAG_EDGEENABLE3 __MSABI_LONG(0x00000400) 1125 | #define D3DTRIFLAG_EDGEENABLETRIANGLE \ 1126 | (D3DTRIFLAG_EDGEENABLE1 | D3DTRIFLAG_EDGEENABLE2 | D3DTRIFLAG_EDGEENABLE3) 1127 | 1128 | typedef struct _D3DTRIANGLE { 1129 | union { 1130 | WORD v1; 1131 | WORD wV1; 1132 | } DUMMYUNIONNAME1; 1133 | union { 1134 | WORD v2; 1135 | WORD wV2; 1136 | } DUMMYUNIONNAME2; 1137 | union { 1138 | WORD v3; 1139 | WORD wV3; 1140 | } DUMMYUNIONNAME3; 1141 | WORD wFlags; 1142 | } D3DTRIANGLE, *LPD3DTRIANGLE; 1143 | 1144 | typedef struct _D3DLINE { 1145 | union { 1146 | WORD v1; 1147 | WORD wV1; 1148 | } DUMMYUNIONNAME1; 1149 | union { 1150 | WORD v2; 1151 | WORD wV2; 1152 | } DUMMYUNIONNAME2; 1153 | } D3DLINE, *LPD3DLINE; 1154 | 1155 | typedef struct _D3DSPAN { 1156 | WORD wCount; 1157 | WORD wFirst; 1158 | } D3DSPAN, *LPD3DSPAN; 1159 | 1160 | typedef struct _D3DPOINT { 1161 | WORD wCount; 1162 | WORD wFirst; 1163 | } D3DPOINT, *LPD3DPOINT; 1164 | 1165 | typedef struct _D3DBRANCH { 1166 | DWORD dwMask; 1167 | DWORD dwValue; 1168 | BOOL bNegate; 1169 | DWORD dwOffset; 1170 | } D3DBRANCH, *LPD3DBRANCH; 1171 | 1172 | typedef struct _D3DSTATUS { 1173 | DWORD dwFlags; 1174 | DWORD dwStatus; 1175 | D3DRECT drExtent; 1176 | } D3DSTATUS, *LPD3DSTATUS; 1177 | 1178 | #define D3DSETSTATUS_STATUS __MSABI_LONG(0x00000001) 1179 | #define D3DSETSTATUS_EXTENTS __MSABI_LONG(0x00000002) 1180 | #define D3DSETSTATUS_ALL (D3DSETSTATUS_STATUS | D3DSETSTATUS_EXTENTS) 1181 | 1182 | typedef struct _D3DCLIPSTATUS { 1183 | DWORD dwFlags; 1184 | DWORD dwStatus; 1185 | float minx, maxx; 1186 | float miny, maxy; 1187 | float minz, maxz; 1188 | } D3DCLIPSTATUS, *LPD3DCLIPSTATUS; 1189 | 1190 | #define D3DCLIPSTATUS_STATUS __MSABI_LONG(0x00000001) 1191 | #define D3DCLIPSTATUS_EXTENTS2 __MSABI_LONG(0x00000002) 1192 | #define D3DCLIPSTATUS_EXTENTS3 __MSABI_LONG(0x00000004) 1193 | 1194 | typedef struct { 1195 | DWORD dwSize; 1196 | DWORD dwTrianglesDrawn; 1197 | DWORD dwLinesDrawn; 1198 | DWORD dwPointsDrawn; 1199 | DWORD dwSpansDrawn; 1200 | DWORD dwVerticesProcessed; 1201 | } D3DSTATS, *LPD3DSTATS; 1202 | 1203 | #define D3DEXECUTE_CLIPPED __MSABI_LONG(0x00000001) 1204 | #define D3DEXECUTE_UNCLIPPED __MSABI_LONG(0x00000002) 1205 | 1206 | typedef struct _D3DEXECUTEDATA { 1207 | DWORD dwSize; 1208 | DWORD dwVertexOffset; 1209 | DWORD dwVertexCount; 1210 | DWORD dwInstructionOffset; 1211 | DWORD dwInstructionLength; 1212 | DWORD dwHVertexOffset; 1213 | D3DSTATUS dsStatus; 1214 | } D3DEXECUTEDATA, *LPD3DEXECUTEDATA; 1215 | 1216 | #define D3DPAL_FREE 0x00 1217 | #define D3DPAL_READONLY 0x40 1218 | #define D3DPAL_RESERVED 0x80 1219 | 1220 | typedef struct _D3DVERTEXBUFFERDESC { 1221 | DWORD dwSize; 1222 | DWORD dwCaps; 1223 | DWORD dwFVF; 1224 | DWORD dwNumVertices; 1225 | } D3DVERTEXBUFFERDESC, *LPD3DVERTEXBUFFERDESC; 1226 | 1227 | #define D3DVBCAPS_SYSTEMMEMORY __MSABI_LONG(0x00000800) 1228 | #define D3DVBCAPS_WRITEONLY __MSABI_LONG(0x00010000) 1229 | #define D3DVBCAPS_OPTIMIZED __MSABI_LONG(0x80000000) 1230 | #define D3DVBCAPS_DONOTCLIP __MSABI_LONG(0x00000001) 1231 | 1232 | #define D3DVOP_LIGHT (1 << 10) 1233 | #define D3DVOP_TRANSFORM (1 << 0) 1234 | #define D3DVOP_CLIP (1 << 2) 1235 | #define D3DVOP_EXTENTS (1 << 3) 1236 | 1237 | #define D3DMAXNUMVERTICES ((1<<16) - 1) 1238 | 1239 | #define D3DMAXNUMPRIMITIVES ((1<<16) - 1) 1240 | 1241 | #define D3DPV_DONOTCOPYDATA (1 << 0) 1242 | 1243 | #define D3DFVF_RESERVED0 0x001 1244 | #define D3DFVF_POSITION_MASK 0x00E 1245 | #define D3DFVF_XYZ 0x002 1246 | #define D3DFVF_XYZRHW 0x004 1247 | #define D3DFVF_XYZB1 0x006 1248 | #define D3DFVF_XYZB2 0x008 1249 | #define D3DFVF_XYZB3 0x00a 1250 | #define D3DFVF_XYZB4 0x00c 1251 | #define D3DFVF_XYZB5 0x00e 1252 | 1253 | #define D3DFVF_NORMAL 0x010 1254 | #define D3DFVF_RESERVED1 0x020 1255 | #define D3DFVF_DIFFUSE 0x040 1256 | #define D3DFVF_SPECULAR 0x080 1257 | #define D3DFVF_TEXCOUNT_MASK 0xf00 1258 | #define D3DFVF_TEXCOUNT_SHIFT 8 1259 | #define D3DFVF_TEX0 0x000 1260 | #define D3DFVF_TEX1 0x100 1261 | #define D3DFVF_TEX2 0x200 1262 | #define D3DFVF_TEX3 0x300 1263 | #define D3DFVF_TEX4 0x400 1264 | #define D3DFVF_TEX5 0x500 1265 | #define D3DFVF_TEX6 0x600 1266 | #define D3DFVF_TEX7 0x700 1267 | #define D3DFVF_TEX8 0x800 1268 | 1269 | #define D3DFVF_RESERVED2 0xf000 1270 | 1271 | #define D3DFVF_VERTEX ( D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 ) 1272 | #define D3DFVF_LVERTEX ( D3DFVF_XYZ | D3DFVF_RESERVED1 | D3DFVF_DIFFUSE | \ 1273 | D3DFVF_SPECULAR | D3DFVF_TEX1 ) 1274 | #define D3DFVF_TLVERTEX ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | \ 1275 | D3DFVF_TEX1 ) 1276 | 1277 | typedef struct _D3DDP_PTRSTRIDE 1278 | { 1279 | void *lpvData; 1280 | DWORD dwStride; 1281 | } D3DDP_PTRSTRIDE; 1282 | 1283 | #define D3DDP_MAXTEXCOORD 8 1284 | 1285 | typedef struct _D3DDRAWPRIMITIVESTRIDEDDATA { 1286 | D3DDP_PTRSTRIDE position; 1287 | D3DDP_PTRSTRIDE normal; 1288 | D3DDP_PTRSTRIDE diffuse; 1289 | D3DDP_PTRSTRIDE specular; 1290 | D3DDP_PTRSTRIDE textureCoords[D3DDP_MAXTEXCOORD]; 1291 | } D3DDRAWPRIMITIVESTRIDEDDATA ,*LPD3DDRAWPRIMITIVESTRIDEDDATA; 1292 | 1293 | #define D3DVIS_INSIDE_FRUSTUM 0 1294 | #define D3DVIS_INTERSECT_FRUSTUM 1 1295 | #define D3DVIS_OUTSIDE_FRUSTUM 2 1296 | #define D3DVIS_INSIDE_LEFT 0 1297 | #define D3DVIS_INTERSECT_LEFT (1 << 2) 1298 | #define D3DVIS_OUTSIDE_LEFT (2 << 2) 1299 | #define D3DVIS_INSIDE_RIGHT 0 1300 | #define D3DVIS_INTERSECT_RIGHT (1 << 4) 1301 | #define D3DVIS_OUTSIDE_RIGHT (2 << 4) 1302 | #define D3DVIS_INSIDE_TOP 0 1303 | #define D3DVIS_INTERSECT_TOP (1 << 6) 1304 | #define D3DVIS_OUTSIDE_TOP (2 << 6) 1305 | #define D3DVIS_INSIDE_BOTTOM 0 1306 | #define D3DVIS_INTERSECT_BOTTOM (1 << 8) 1307 | #define D3DVIS_OUTSIDE_BOTTOM (2 << 8) 1308 | #define D3DVIS_INSIDE_NEAR 0 1309 | #define D3DVIS_INTERSECT_NEAR (1 << 10) 1310 | #define D3DVIS_OUTSIDE_NEAR (2 << 10) 1311 | #define D3DVIS_INSIDE_FAR 0 1312 | #define D3DVIS_INTERSECT_FAR (1 << 12) 1313 | #define D3DVIS_OUTSIDE_FAR (2 << 12) 1314 | 1315 | #define D3DVIS_MASK_FRUSTUM (3 << 0) 1316 | #define D3DVIS_MASK_LEFT (3 << 2) 1317 | #define D3DVIS_MASK_RIGHT (3 << 4) 1318 | #define D3DVIS_MASK_TOP (3 << 6) 1319 | #define D3DVIS_MASK_BOTTOM (3 << 8) 1320 | #define D3DVIS_MASK_NEAR (3 << 10) 1321 | #define D3DVIS_MASK_FAR (3 << 12) 1322 | 1323 | #define D3DDEVINFOID_TEXTUREMANAGER 1 1324 | #define D3DDEVINFOID_D3DTEXTUREMANAGER 2 1325 | #define D3DDEVINFOID_TEXTURING 3 1326 | 1327 | typedef enum _D3DSTATEBLOCKTYPE 1328 | { 1329 | D3DSBT_ALL = 1, 1330 | D3DSBT_PIXELSTATE = 2, 1331 | D3DSBT_VERTEXSTATE = 3, 1332 | D3DSBT_FORCE_DWORD = 0xffffffff 1333 | } D3DSTATEBLOCKTYPE; 1334 | 1335 | typedef enum _D3DVERTEXBLENDFLAGS 1336 | { 1337 | D3DVBLEND_DISABLE = 0, 1338 | D3DVBLEND_1WEIGHT = 1, 1339 | D3DVBLEND_2WEIGHTS = 2, 1340 | D3DVBLEND_3WEIGHTS = 3, 1341 | } D3DVERTEXBLENDFLAGS; 1342 | 1343 | typedef enum _D3DTEXTURETRANSFORMFLAGS { 1344 | D3DTTFF_DISABLE = 0, 1345 | D3DTTFF_COUNT1 = 1, 1346 | D3DTTFF_COUNT2 = 2, 1347 | D3DTTFF_COUNT3 = 3, 1348 | D3DTTFF_COUNT4 = 4, 1349 | D3DTTFF_PROJECTED = 256, 1350 | D3DTTFF_FORCE_DWORD = 0x7fffffff 1351 | } D3DTEXTURETRANSFORMFLAGS; 1352 | 1353 | #define D3DFVF_TEXTUREFORMAT2 0 1354 | #define D3DFVF_TEXTUREFORMAT1 3 1355 | #define D3DFVF_TEXTUREFORMAT3 1 1356 | #define D3DFVF_TEXTUREFORMAT4 2 1357 | 1358 | #define D3DFVF_TEXCOORDSIZE3(CoordIndex) (D3DFVF_TEXTUREFORMAT3 << (CoordIndex*2 + 16)) 1359 | #define D3DFVF_TEXCOORDSIZE2(CoordIndex) (D3DFVF_TEXTUREFORMAT2) 1360 | #define D3DFVF_TEXCOORDSIZE4(CoordIndex) (D3DFVF_TEXTUREFORMAT4 << (CoordIndex*2 + 16)) 1361 | #define D3DFVF_TEXCOORDSIZE1(CoordIndex) (D3DFVF_TEXTUREFORMAT1 << (CoordIndex*2 + 16)) 1362 | 1363 | #ifdef __i386__ 1364 | #include 1365 | #endif 1366 | 1367 | #endif 1368 | -------------------------------------------------------------------------------- /wrap.cpp: -------------------------------------------------------------------------------- 1 | #include "header.h" 2 | 3 | SYSTEM_INFO sSysInfo; 4 | WRAP* wrap_list; 5 | WRAP* wrap_freelist; 6 | DD_LIFETIME* ddlt_list; 7 | DD_LIFETIME* ddlt_freelist; 8 | CRITICAL_SECTION cs; 9 | 10 | 11 | const void* iid_to_vtbl( const GUID& riid ) 12 | { 13 | TRACE( ">" ); 14 | LOG_GUID( riid ); 15 | const void* xVtbl; 16 | if ( riid == IID_IUnknown ) xVtbl = &unknwn::xVtbl; 17 | else if ( riid == IID_IClassFactory ) xVtbl = &classfactory::xVtbl; 18 | else if ( riid == IID_IDirectDraw ) xVtbl = &dd::xVtbl1; 19 | else if ( riid == IID_IDirectDraw2 ) xVtbl = &dd::xVtbl2; 20 | else if ( riid == IID_IDirectDraw4 ) xVtbl = &dd::xVtbl4; 21 | else if ( riid == IID_IDirectDraw7 ) xVtbl = &dd::xVtbl7; 22 | else if ( riid == IID_IDirectDrawSurface ) xVtbl = &dds::xVtbl1; 23 | else if ( riid == IID_IDirectDrawSurface2 ) xVtbl = &dds::xVtbl2; 24 | else if ( riid == IID_IDirectDrawSurface3 ) xVtbl = &dds::xVtbl3; 25 | else if ( riid == IID_IDirectDrawSurface4 ) xVtbl = &dds::xVtbl4; 26 | else if ( riid == IID_IDirectDrawSurface7 ) xVtbl = &dds::xVtbl7; 27 | else if ( riid == IID_IDirectDrawClipper ) xVtbl = &clipper::xVtbl; 28 | else if ( riid == IID_IDirectDrawPalette ) xVtbl = &palette::xVtbl; 29 | else if ( riid == IID_IDirectDrawColorControl ) xVtbl = &color::xVtbl; 30 | else if ( riid == IID_IDirectDrawGammaControl ) xVtbl = &gamma::xVtbl; 31 | else xVtbl = NULL; 32 | return xVtbl; 33 | } 34 | 35 | // simple way to get small amounts of memory on demand... 36 | // will not span page boundries 37 | // will not consider alignment 38 | // allocated memory can not be freed 39 | // not thread safe 40 | void* micro_alloc( int size ) 41 | { 42 | TRACE( ">" ); 43 | static BYTE* end_region = 0; 44 | static BYTE* end_page = 0; 45 | static BYTE* alloc_ptr = 0; 46 | 47 | if( ( alloc_ptr + size ) >= end_page ) 48 | { 49 | alloc_ptr = end_page; 50 | 51 | if( alloc_ptr == end_region ) 52 | { 53 | TRACE( "reserve a new memory region" ); 54 | alloc_ptr = (BYTE*) VirtualAlloc( NULL, sSysInfo.dwAllocationGranularity, MEM_RESERVE, PAGE_NOACCESS ); 55 | end_region = alloc_ptr + sSysInfo.dwAllocationGranularity; 56 | } 57 | 58 | if( alloc_ptr != NULL ) 59 | { 60 | TRACE( "commit a page of the reserved region" ); 61 | alloc_ptr = (BYTE*) VirtualAlloc( alloc_ptr, sSysInfo.dwPageSize, MEM_COMMIT, PAGE_READWRITE ); 62 | end_page = alloc_ptr + sSysInfo.dwPageSize; 63 | } 64 | 65 | if( alloc_ptr == NULL ) 66 | { 67 | WARN( "Allocation FAILED" ); 68 | end_region = 0; 69 | end_page = 0; 70 | } 71 | } 72 | 73 | // "bump the pointer" 74 | void* p = alloc_ptr; 75 | alloc_ptr += size; 76 | return p; 77 | } 78 | 79 | 80 | // find existing or add a new wrapper for *ppvInterface 81 | // returns true if a new wrapper is created 82 | bool Wrap( DD_LIFETIME* dd_parent, const void* xVtbl, void** ppvInterface ) 83 | { 84 | TRACE( ">" ); 85 | WRAP* w; 86 | bool bNew = false; 87 | 88 | // validate args 89 | if( ( xVtbl != NULL ) && ( ppvInterface != NULL ) && ( *ppvInterface != NULL ) ) 90 | { 91 | EnterCriticalSection( &cs ); 92 | 93 | // search list 94 | for( w = wrap_list; ( w != NULL ) && ( w->inner_iface != *ppvInterface ); w = w->next ); 95 | if( w != NULL ) 96 | { 97 | TRACE( "found existing wrapper" ); 98 | if( w->xVtbl != xVtbl ){ WARN("existing wrapper is for a different type"); } 99 | *((WRAP**)ppvInterface) = w; 100 | } 101 | else 102 | { 103 | TRACE( "creating new wrapper" ); 104 | if( wrap_freelist != NULL ) 105 | { 106 | // pop 107 | w = wrap_freelist; 108 | wrap_freelist = w->next; 109 | } 110 | else 111 | { 112 | w = (WRAP*) micro_alloc( sizeof( WRAP ) ); 113 | } 114 | if( w != NULL ) 115 | { 116 | 117 | // dd obj lifetime tracker // 118 | if( ( dd_parent != NULL )) 119 | { 120 | if( ( ( xVtbl == &unknwn::xVtbl ) && ( dd_parent->obj == ((IUnknown*)(*ppvInterface)) ) ) || 121 | ( ( xVtbl == &dd::xVtbl1 ) || ( xVtbl == &dd::xVtbl2 ) || ( xVtbl == &dd::xVtbl4 ) || ( xVtbl == &dd::xVtbl7 ) ) ) 122 | { 123 | TRACE( "new interface of existing dd obj" ); 124 | dd_parent->iface_cnt++; 125 | } 126 | } 127 | else 128 | { 129 | if( ( xVtbl == &dd::xVtbl1 ) || ( xVtbl == &dd::xVtbl2 ) || ( xVtbl == &dd::xVtbl4 ) || ( xVtbl == &dd::xVtbl7 ) ) 130 | { 131 | TRACE( "new dd obj" ); 132 | if( ddlt_freelist != NULL ) 133 | { 134 | // pop 135 | dd_parent = ddlt_freelist; 136 | ddlt_freelist = dd_parent->next; 137 | } 138 | else 139 | { 140 | dd_parent = (DD_LIFETIME*) micro_alloc( sizeof( DD_LIFETIME ) ); 141 | } 142 | if( dd_parent != NULL ) 143 | { 144 | ((IUnknown*)(*ppvInterface))->lpVtbl->QueryInterface( ((IUnknown*)(*ppvInterface)), IID_IUnknown, (void**)&dd_parent->obj ); 145 | dd_parent->obj->lpVtbl->Release( dd_parent->obj ); 146 | dd_parent->iface_cnt = 1; 147 | dd_parent->next = ddlt_list; 148 | ddlt_list = dd_parent; // push 149 | } 150 | } 151 | } 152 | 153 | // construct 154 | w->xVtbl = xVtbl; 155 | w->inner_iface = *ppvInterface; 156 | w->dd_parent = dd_parent; 157 | w->next = wrap_list; 158 | wrap_list = w; // push 159 | *((WRAP**)ppvInterface) = w; // hook it ! 160 | bNew = true; 161 | } 162 | } 163 | LeaveCriticalSection( &cs ); 164 | } 165 | return bNew; 166 | } 167 | 168 | 169 | ULONG WrapRelease( WRAP* This ) 170 | { 171 | TRACE( ">" ); 172 | EnterCriticalSection( &cs ); 173 | ULONG dwCount = This->unknwn->lpVtbl->Release( This->unknwn ); 174 | if( dwCount == 0 ) 175 | { 176 | TRACE( "interface destroyed" ); 177 | WRAP* w = wrap_list; 178 | WRAP* prev = NULL; 179 | DD_LIFETIME* dd_parent = This->dd_parent; 180 | 181 | // if dd interface was destroyed 182 | if( ( dd_parent != NULL ) && 183 | ( (( This->xVtbl == &unknwn::xVtbl ) && ( This->unknwn == dd_parent->obj )) || 184 | ( This->xVtbl == &dd::xVtbl1 ) || ( This->xVtbl == &dd::xVtbl2 ) || 185 | ( This->xVtbl == &dd::xVtbl4 ) || ( This->xVtbl == &dd::xVtbl7 ) ) ) 186 | { 187 | dd_parent->iface_cnt--; 188 | if( dd_parent->iface_cnt == 0 ) 189 | { 190 | TRACE( "dd obj destroyed" ); 191 | // destroy ALL wraps that have a matching dd_parent 192 | while( w != NULL ) 193 | { 194 | if( w->dd_parent == dd_parent ) // if match 195 | { 196 | TRACE( "destroyed child\n" ); 197 | // move to freelist 198 | if( prev != NULL ) 199 | { 200 | prev->next = w->next; 201 | w->next = wrap_freelist; 202 | wrap_freelist = w; // push 203 | w = prev->next; // continue 204 | } 205 | else 206 | { 207 | wrap_list = w->next; 208 | w->next = wrap_freelist; 209 | wrap_freelist = w; // push 210 | w = wrap_list; // continue 211 | } 212 | } 213 | else // else continue search 214 | { 215 | prev = w; 216 | w = w->next; 217 | } 218 | } 219 | 220 | // move dd_parent to the freelist 221 | DD_LIFETIME* d_prev = NULL; 222 | DD_LIFETIME* d; 223 | for( d = ddlt_list; ( d != NULL ) && ( d != dd_parent ); d = d->next ) d_prev = d; // find previons link 224 | if( d == NULL ){ WARN( "wrap not in list" ); } 225 | else 226 | { 227 | if( d_prev != NULL ) d_prev->next = d->next; 228 | else ddlt_list = d->next; 229 | d->next = ddlt_freelist; 230 | ddlt_freelist = d; 231 | } 232 | } 233 | } 234 | else 235 | { 236 | // move This to the freelist 237 | for( w = wrap_list; ( w != NULL ) && ( w != This ); w = w->next ) prev = w; // find previons link 238 | if( w == NULL ){ WARN( "wrap not in list" ); } 239 | else 240 | { 241 | if( prev != NULL ) prev->next = w->next; 242 | else wrap_list = w->next; 243 | w->next = wrap_freelist; 244 | wrap_freelist = w; 245 | } 246 | } 247 | } 248 | LeaveCriticalSection( &cs ); 249 | return dwCount; 250 | } 251 | 252 | 253 | HRESULT __stdcall WrapEnumSurfacesCallback( LPDIRECTDRAWSURFACE lpDDSurface, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext ) 254 | { 255 | PROLOGUE; 256 | EnumStruct* e = (EnumStruct*)lpContext; 257 | bool bNew = Wrap( e->dd_parent, e->xVtbl, (void**)&lpDDSurface ); 258 | if( ( bNew != false ) && ( e->must_exist != false ) ){ WARN( "interface was not wrapped" ); } 259 | HRESULT hResult = ((LPDDENUMSURFACESCALLBACK) e->callback)( lpDDSurface, lpDDSurfaceDesc, e->context ); 260 | EPILOGUE( hResult ); 261 | } 262 | 263 | 264 | // all versions of dd interfaces share the same functions ... ( for ease-of-use ) // 265 | // all versions of dds interfaces share the same functions ... ( for ease-of-use ) // 266 | // ... so a little extra work is needed to distinguish between different versions // 267 | const void* dd_to_dds_vtbl( WRAP* This ) 268 | { 269 | TRACE( ">" ); 270 | if( This->xVtbl == &dd::xVtbl7 ) return &dds::xVtbl7; 271 | else if( This->xVtbl == &dd::xVtbl4 ) return &dds::xVtbl4; 272 | return &dds::xVtbl1; 273 | } 274 | 275 | const void* dds_to_dd_vtbl( WRAP* This ) 276 | { 277 | TRACE( ">" ); 278 | if( This->xVtbl == &dds::xVtbl7 ) return &dd::xVtbl7; 279 | else if( This->xVtbl == &dds::xVtbl4 ) return &dd::xVtbl4; 280 | return &dd::xVtbl2; 281 | } 282 | 283 | 284 | // There are no guarantees that an interface passed as argument is wrapped or not NULL // 285 | IDirectDraw* GetInnerInterface( IDirectDraw* iface ) 286 | { 287 | TRACE( "dd" ); 288 | if( iface != NULL ) 289 | { 290 | if( ( ((WRAP*)iface)->xVtbl == &dd::xVtbl1 ) || 291 | ( ((WRAP*)iface)->xVtbl == &dd::xVtbl2 ) || 292 | ( ((WRAP*)iface)->xVtbl == &dd::xVtbl4 ) || 293 | ( ((WRAP*)iface)->xVtbl == &dd::xVtbl7 ) ) 294 | { 295 | return ((WRAP*)iface)->dd1; 296 | } 297 | else WARN( "interface not wrapped" ); 298 | } 299 | return iface; 300 | } 301 | 302 | IDirectDrawSurface* GetInnerInterface( IDirectDrawSurface* iface ) 303 | { 304 | TRACE( "dds" ); 305 | if( iface != NULL ) 306 | { 307 | if( ( ((WRAP*)iface)->xVtbl == &dds::xVtbl1 ) || 308 | ( ((WRAP*)iface)->xVtbl == &dds::xVtbl2 ) || 309 | ( ((WRAP*)iface)->xVtbl == &dds::xVtbl3 ) || 310 | ( ((WRAP*)iface)->xVtbl == &dds::xVtbl4 ) || 311 | ( ((WRAP*)iface)->xVtbl == &dds::xVtbl7 ) ) 312 | { 313 | return ((WRAP*)iface)->dds1; 314 | } 315 | else WARN( "interface not wrapped" ); 316 | } 317 | return iface; 318 | } 319 | 320 | IDirectDrawClipper* GetInnerInterface( IDirectDrawClipper* iface ) 321 | { 322 | TRACE( "clip" ); 323 | if( iface != NULL ) 324 | { 325 | if( ((WRAP*)iface)->xVtbl == &clipper::xVtbl ) 326 | { 327 | return ((WRAP*)iface)->clip; 328 | } 329 | else WARN( "interface not wrapped" ); 330 | } 331 | return iface; 332 | } 333 | 334 | IDirectDrawPalette* GetInnerInterface( IDirectDrawPalette* iface ) 335 | { 336 | TRACE( "pal" ); 337 | if( iface != NULL ) 338 | { 339 | if( ((WRAP*)iface)->xVtbl == &palette::xVtbl ) 340 | { 341 | return ((WRAP*)iface)->pal; 342 | } 343 | else WARN( "interface not wrapped" ); 344 | } 345 | return iface; 346 | } 347 | 348 | 349 | -------------------------------------------------------------------------------- /wrap.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // when a dd object is destroyed all children are also destroyed ( surfaces, etc. ) 4 | // we've got no good way to known if an dd obj is destroyed 5 | // a dd obj is destroyed when it has no active interfaces... 6 | // a dd object can have many interfaces at once... IDirectDraw, IDirectDraw2, IDirectDraw4, IDirectDraw7 and IUnknown 7 | struct DD_LIFETIME 8 | { 9 | IUnknown* obj; 10 | unsigned long iface_cnt; 11 | DD_LIFETIME* next; 12 | }; 13 | 14 | struct WRAP 15 | { 16 | const void* xVtbl; // new vtbl 17 | union // original interface 18 | { 19 | void* inner_iface; 20 | IUnknown* unknwn; 21 | IClassFactory* cf; 22 | IDirectDraw* dd1; 23 | IDirectDraw2* dd2; 24 | IDirectDraw4* dd4; 25 | IDirectDraw7* dd7; 26 | IDirectDrawSurface* dds1; 27 | IDirectDrawSurface2* dds2; 28 | IDirectDrawSurface3* dds3; 29 | IDirectDrawSurface4* dds4; 30 | IDirectDrawSurface7* dds7; 31 | IDirectDrawClipper* clip; 32 | IDirectDrawPalette* pal; 33 | IDirectDrawColorControl* color; 34 | IDirectDrawGammaControl* gamma; 35 | }; 36 | DD_LIFETIME* dd_parent; 37 | WRAP* next; // for use in unordered hash map 38 | }; 39 | 40 | 41 | struct EnumStruct 42 | { 43 | const void* xVtbl; 44 | DD_LIFETIME* dd_parent; 45 | bool must_exist; 46 | void* callback; 47 | void* context; 48 | }; 49 | 50 | extern CRITICAL_SECTION cs; 51 | extern SYSTEM_INFO sSysInfo; 52 | 53 | bool Wrap( DD_LIFETIME* dd_parent, const void* xVtbl, void** ppvInterface ); 54 | const void* dd_to_dds_vtbl( WRAP* This ); 55 | const void* dds_to_dd_vtbl( WRAP* This ); 56 | const void* iid_to_vtbl( const GUID& riid ); 57 | ULONG WrapRelease( WRAP* This ); 58 | HRESULT __stdcall WrapEnumSurfacesCallback( LPDIRECTDRAWSURFACE lpDDSurface, LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID lpContext ); 59 | // 60 | IDirectDraw* GetInnerInterface( IDirectDraw* iface ); 61 | IDirectDrawSurface* GetInnerInterface( IDirectDrawSurface* iface ); 62 | IDirectDrawClipper* GetInnerInterface( IDirectDrawClipper* iface ); 63 | IDirectDrawPalette* GetInnerInterface( IDirectDrawPalette* iface ); 64 | 65 | 66 | --------------------------------------------------------------------------------