José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 1 | ########################################################################## |
| 2 | # |
| 3 | # Copyright 2011 Jose Fonseca |
| 4 | # All Rights Reserved. |
| 5 | # |
| 6 | # Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | # of this software and associated documentation files (the "Software"), to deal |
| 8 | # in the Software without restriction, including without limitation the rights |
| 9 | # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 10 | # copies of the Software, and to permit persons to whom the Software is |
| 11 | # furnished to do so, subject to the following conditions: |
| 12 | # |
| 13 | # The above copyright notice and this permission notice shall be included in |
| 14 | # all copies or substantial portions of the Software. |
| 15 | # |
| 16 | # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 19 | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 22 | # THE SOFTWARE. |
| 23 | # |
| 24 | ##########################################################################/ |
| 25 | |
| 26 | |
| 27 | """D3D retracer generator.""" |
| 28 | |
| 29 | |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 30 | import sys |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 31 | from dllretrace import DllRetracer as Retracer |
José Fonseca | 75cbb8c | 2013-02-12 16:19:23 +0000 | [diff] [blame] | 32 | import specs.dxgi |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 33 | from specs.stdapi import API |
José Fonseca | 3be2c67 | 2015-02-06 15:36:40 +0000 | [diff] [blame] | 34 | from specs.winapi import LPCSTR |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 35 | from specs.dxgi import dxgi |
Jose Fonseca | a92e0c4 | 2015-03-14 10:49:23 +0000 | [diff] [blame] | 36 | from specs.d3d10 import d3d10, d3d10_1 |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 37 | from specs.d3d11 import d3d11 |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 38 | |
| 39 | |
| 40 | class D3DRetracer(Retracer): |
| 41 | |
José Fonseca | e381485 | 2012-11-11 09:45:06 +0000 | [diff] [blame] | 42 | def retraceApi(self, api): |
José Fonseca | 6ca2008 | 2014-10-07 21:39:43 +0100 | [diff] [blame] | 43 | print '// Swizzling mapping for lock addresses, mapping a (pDeviceContext, pResource, Subresource) -> void *' |
| 44 | print 'typedef std::pair< IUnknown *, UINT > SubresourceKey;' |
| 45 | print 'static std::map< IUnknown *, std::map< SubresourceKey, void * > > g_Maps;' |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 46 | print |
José Fonseca | 73341c2 | 2012-11-24 13:04:42 +0000 | [diff] [blame] | 47 | self.table_name = 'd3dretrace::dxgi_callbacks' |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 48 | |
José Fonseca | e381485 | 2012-11-11 09:45:06 +0000 | [diff] [blame] | 49 | Retracer.retraceApi(self, api) |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 50 | |
José Fonseca | 4f49d21 | 2012-11-14 14:02:35 +0000 | [diff] [blame] | 51 | createDeviceFunctionNames = [ |
| 52 | "D3D10CreateDevice", |
| 53 | "D3D10CreateDeviceAndSwapChain", |
| 54 | "D3D10CreateDevice1", |
| 55 | "D3D10CreateDeviceAndSwapChain1", |
| 56 | "D3D11CreateDevice", |
| 57 | "D3D11CreateDeviceAndSwapChain", |
| 58 | ] |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 59 | |
José Fonseca | 4f49d21 | 2012-11-14 14:02:35 +0000 | [diff] [blame] | 60 | def invokeFunction(self, function): |
| 61 | if function.name in self.createDeviceFunctionNames: |
| 62 | # create windows as neccessary |
| 63 | if 'pSwapChainDesc' in function.argNames(): |
José Fonseca | 1e309b4 | 2014-09-18 11:08:09 +0100 | [diff] [blame] | 64 | print r' d3dretrace::createWindowForSwapChain(pSwapChainDesc);' |
José Fonseca | 4f49d21 | 2012-11-14 14:02:35 +0000 | [diff] [blame] | 65 | |
José Fonseca | 4f49d21 | 2012-11-14 14:02:35 +0000 | [diff] [blame] | 66 | # Compensate for the fact we don't trace DXGI object creation |
| 67 | if function.name.startswith('D3D11CreateDevice'): |
| 68 | print r' if (DriverType == D3D_DRIVER_TYPE_UNKNOWN && !pAdapter) {' |
| 69 | print r' DriverType = D3D_DRIVER_TYPE_HARDWARE;' |
| 70 | print r' }' |
José Fonseca | ea79919 | 2012-11-13 21:37:24 +0000 | [diff] [blame] | 71 | |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 72 | if function.name.startswith('D3D10CreateDevice'): |
José Fonseca | 7bcc96c | 2012-12-05 19:28:22 +0000 | [diff] [blame] | 73 | # Toggle debugging |
| 74 | print r' Flags &= ~D3D10_CREATE_DEVICE_DEBUG;' |
| 75 | print r' if (retrace::debug) {' |
José Fonseca | 83d3391 | 2014-12-03 13:17:57 +0000 | [diff] [blame] | 76 | print r' HMODULE hD3d10SdkLayers = LoadLibraryA("d3d10sdklayers");' |
| 77 | print r' if (hD3d10SdkLayers) {' |
| 78 | print r' FreeLibrary(hD3d10SdkLayers);' |
José Fonseca | 7bcc96c | 2012-12-05 19:28:22 +0000 | [diff] [blame] | 79 | print r' Flags |= D3D10_CREATE_DEVICE_DEBUG;' |
José Fonseca | 83d3391 | 2014-12-03 13:17:57 +0000 | [diff] [blame] | 80 | print r' } else {' |
| 81 | print r' retrace::warning(call) << "Direct3D 10.x SDK Debug Layer (d3d10sdklayers.dll) not available, continuing without debug output\n";' |
José Fonseca | 7bcc96c | 2012-12-05 19:28:22 +0000 | [diff] [blame] | 82 | print r' }' |
| 83 | print r' }' |
| 84 | |
| 85 | # Force driver |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 86 | self.forceDriver('D3D10_DRIVER_TYPE') |
José Fonseca | 7bcc96c | 2012-12-05 19:28:22 +0000 | [diff] [blame] | 87 | |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 88 | if function.name.startswith('D3D11CreateDevice'): |
José Fonseca | 7bcc96c | 2012-12-05 19:28:22 +0000 | [diff] [blame] | 89 | # Toggle debugging |
| 90 | print r' Flags &= ~D3D11_CREATE_DEVICE_DEBUG;' |
| 91 | print r' if (retrace::debug) {' |
José Fonseca | 83d3391 | 2014-12-03 13:17:57 +0000 | [diff] [blame] | 92 | print r' HRESULT hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_NULL, 0, D3D11_CREATE_DEVICE_DEBUG, NULL, 0, D3D11_SDK_VERSION, NULL, NULL, NULL);' |
| 93 | print r' if (SUCCEEDED(hr)) {' |
José Fonseca | 7bcc96c | 2012-12-05 19:28:22 +0000 | [diff] [blame] | 94 | print r' Flags |= D3D11_CREATE_DEVICE_DEBUG;' |
José Fonseca | 83d3391 | 2014-12-03 13:17:57 +0000 | [diff] [blame] | 95 | print r' } else {' |
| 96 | print r' retrace::warning(call) << "Direct3D 11.x SDK Debug Layer (d3d11*sdklayers.dll) not available, continuing without debug output\n";' |
José Fonseca | 7bcc96c | 2012-12-05 19:28:22 +0000 | [diff] [blame] | 97 | print r' }' |
| 98 | print r' }' |
| 99 | |
| 100 | # Force driver |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 101 | self.forceDriver('D3D_DRIVER_TYPE') |
| 102 | |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 103 | Retracer.invokeFunction(self, function) |
| 104 | |
Jose Fonseca | 5c487ec | 2015-06-02 22:16:52 +0100 | [diff] [blame] | 105 | def checkResult(self, interface, methodOrFunction): |
| 106 | # Catch when device is removed, and report the reason. |
| 107 | if str(methodOrFunction.type) == 'HRESULT': |
| 108 | if interface is not None: |
| 109 | getDeviceRemovedReasonMethod = interface.getMethodByName("GetDeviceRemovedReason") |
| 110 | if getDeviceRemovedReasonMethod is not None: |
| 111 | print r' if (FAILED(_result)) {' |
| 112 | print r' retrace::failed(call, _result);' |
| 113 | print r' if (_result == DXGI_ERROR_DEVICE_REMOVED) {' |
| 114 | print r' HRESULT _reason = _this->GetDeviceRemovedReason();' |
| 115 | print r' retrace::failed(call, _reason);' |
| 116 | print r' exit(1);' |
| 117 | print r' }' |
| 118 | print r' return;' |
| 119 | print r' }' |
| 120 | return |
| 121 | |
| 122 | Retracer.checkResult(self, interface, methodOrFunction) |
| 123 | |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 124 | def forceDriver(self, enum): |
José Fonseca | 82ea89d | 2012-12-05 19:34:26 +0000 | [diff] [blame] | 125 | # This can only work when pAdapter is NULL. For non-NULL pAdapter we |
| 126 | # need to override inside the EnumAdapters call below |
| 127 | print r' if (pAdapter == NULL) {' |
| 128 | print r' switch (retrace::driver) {' |
| 129 | print r' case retrace::DRIVER_HARDWARE:' |
| 130 | print r' DriverType = %s_HARDWARE;' % enum |
| 131 | print r' Software = NULL;' |
| 132 | print r' break;' |
| 133 | print r' case retrace::DRIVER_SOFTWARE:' |
| 134 | print r' DriverType = %s_WARP;' % enum |
| 135 | print r' Software = NULL;' |
| 136 | print r' break;' |
| 137 | print r' case retrace::DRIVER_REFERENCE:' |
| 138 | print r' DriverType = %s_REFERENCE;' % enum |
| 139 | print r' Software = NULL;' |
| 140 | print r' break;' |
| 141 | print r' case retrace::DRIVER_NULL:' |
| 142 | print r' DriverType = %s_NULL;' % enum |
| 143 | print r' Software = NULL;' |
| 144 | print r' break;' |
| 145 | print r' case retrace::DRIVER_MODULE:' |
| 146 | print r' DriverType = %s_SOFTWARE;' % enum |
| 147 | print r' Software = LoadLibraryA(retrace::driverModule);' |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 148 | print r' if (!Software) {' |
José Fonseca | 82ea89d | 2012-12-05 19:34:26 +0000 | [diff] [blame] | 149 | print r' retrace::warning(call) << "failed to load " << retrace::driverModule << "\n";' |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 150 | print r' }' |
José Fonseca | 82ea89d | 2012-12-05 19:34:26 +0000 | [diff] [blame] | 151 | print r' break;' |
| 152 | print r' default:' |
| 153 | print r' assert(0);' |
| 154 | print r' /* fall-through */' |
| 155 | print r' case retrace::DRIVER_DEFAULT:' |
| 156 | print r' if (DriverType == %s_SOFTWARE) {' % enum |
| 157 | print r' Software = LoadLibraryA("d3d10warp");' |
| 158 | print r' if (!Software) {' |
| 159 | print r' retrace::warning(call) << "failed to load d3d10warp.dll\n";' |
| 160 | print r' }' |
| 161 | print r' }' |
| 162 | print r' break;' |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 163 | print r' }' |
José Fonseca | 82ea89d | 2012-12-05 19:34:26 +0000 | [diff] [blame] | 164 | print r' } else {' |
| 165 | print r' Software = NULL;' |
José Fonseca | 42b89fc | 2012-11-27 12:19:45 +0000 | [diff] [blame] | 166 | print r' }' |
| 167 | |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 168 | def invokeInterfaceMethod(self, interface, method): |
| 169 | # keep track of the last used device for state dumping |
José Fonseca | 944088e | 2012-11-20 14:47:03 +0000 | [diff] [blame] | 170 | if interface.name in ('ID3D10Device', 'ID3D10Device1'): |
| 171 | if method.name == 'Release': |
José Fonseca | db62f0f | 2013-06-27 16:15:01 +0100 | [diff] [blame] | 172 | print r' if (call.ret->toUInt() == 0) {' |
| 173 | print r' d3d10Dumper.unbindDevice(_this);' |
| 174 | print r' }' |
José Fonseca | 944088e | 2012-11-20 14:47:03 +0000 | [diff] [blame] | 175 | else: |
| 176 | print r' d3d10Dumper.bindDevice(_this);' |
Jeff Muizelaar | 53b0195 | 2013-03-12 16:31:17 -0400 | [diff] [blame] | 177 | if interface.name in ('ID3D11DeviceContext', 'ID3D11DeviceContext1'): |
José Fonseca | 5773beb | 2012-11-14 11:46:58 +0000 | [diff] [blame] | 178 | if method.name == 'Release': |
José Fonseca | db62f0f | 2013-06-27 16:15:01 +0100 | [diff] [blame] | 179 | print r' if (call.ret->toUInt() == 0) {' |
| 180 | print r' d3d11Dumper.unbindDevice(_this);' |
| 181 | print r' }' |
José Fonseca | 5773beb | 2012-11-14 11:46:58 +0000 | [diff] [blame] | 182 | else: |
José Fonseca | 0dc448e | 2013-06-13 15:51:48 +0100 | [diff] [blame] | 183 | print r' if (_this->GetType() == D3D11_DEVICE_CONTEXT_IMMEDIATE) {' |
| 184 | print r' d3d11Dumper.bindDevice(_this);' |
| 185 | print r' }' |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 186 | |
José Fonseca | 1e309b4 | 2014-09-18 11:08:09 +0100 | [diff] [blame] | 187 | # intercept private interfaces |
José Fonseca | d59843c | 2014-08-22 16:59:25 +0100 | [diff] [blame] | 188 | if method.name == 'QueryInterface': |
José Fonseca | c44c62c | 2014-09-22 13:42:42 +0100 | [diff] [blame] | 189 | print r' if (!d3dretrace::overrideQueryInterface(_this, riid, ppvObj, &_result)) {' |
José Fonseca | 75cbb8c | 2013-02-12 16:19:23 +0000 | [diff] [blame] | 190 | Retracer.invokeInterfaceMethod(self, interface, method) |
| 191 | print r' }' |
| 192 | return |
| 193 | |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 194 | # create windows as neccessary |
| 195 | if method.name == 'CreateSwapChain': |
José Fonseca | 1e309b4 | 2014-09-18 11:08:09 +0100 | [diff] [blame] | 196 | print r' d3dretrace::createWindowForSwapChain(pDesc);' |
José Fonseca | e23a6be | 2014-09-14 20:30:00 +0100 | [diff] [blame] | 197 | if method.name == 'CreateSwapChainForComposition': |
| 198 | print r' HWND hWnd = d3dretrace::createWindow(pDesc->Width, pDesc->Height);' |
| 199 | print r' _result = _this->CreateSwapChainForHwnd(pDevice, hWnd, pDesc, NULL, pRestrictToOutput, ppSwapChain);' |
Jose Fonseca | 5c487ec | 2015-06-02 22:16:52 +0100 | [diff] [blame] | 200 | self.checkResult(interface, method) |
José Fonseca | e23a6be | 2014-09-14 20:30:00 +0100 | [diff] [blame] | 201 | return |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 202 | |
José Fonseca | 7618cb9 | 2014-08-28 16:00:48 +0100 | [diff] [blame] | 203 | if method.name == 'SetFullscreenState': |
| 204 | print r' if (retrace::forceWindowed) {' |
| 205 | print r' Fullscreen = FALSE;' |
José Fonseca | 693382a | 2014-10-03 14:27:59 +0100 | [diff] [blame] | 206 | print r' pTarget = NULL;' |
José Fonseca | 7618cb9 | 2014-08-28 16:00:48 +0100 | [diff] [blame] | 207 | print r' }' |
| 208 | |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 209 | # notify frame has been completed |
| 210 | if method.name == 'Present': |
José Fonseca | 29d4bda | 2014-02-28 17:50:24 +0000 | [diff] [blame] | 211 | if interface.name == 'IDXGISwapChainDWM': |
José Fonseca | 1e309b4 | 2014-09-18 11:08:09 +0100 | [diff] [blame] | 212 | print r' com_ptr<IDXGISwapChain> pSwapChain;' |
| 213 | print r' if (SUCCEEDED(_this->QueryInterface(IID_IDXGISwapChain, (void **) &pSwapChain))) {' |
| 214 | print r' dxgiDumper.bindDevice(pSwapChain);' |
| 215 | print r' } else {' |
| 216 | print r' assert(0);' |
| 217 | print r' }' |
José Fonseca | 29d4bda | 2014-02-28 17:50:24 +0000 | [diff] [blame] | 218 | else: |
| 219 | print r' dxgiDumper.bindDevice(_this);' |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 220 | print r' retrace::frameComplete(call);' |
| 221 | |
| 222 | if 'pSharedResource' in method.argNames(): |
| 223 | print r' if (pSharedResource) {' |
| 224 | print r' retrace::warning(call) << "shared surfaces unsupported\n";' |
| 225 | print r' pSharedResource = NULL;' |
| 226 | print r' }' |
| 227 | |
José Fonseca | 82ea89d | 2012-12-05 19:34:26 +0000 | [diff] [blame] | 228 | # Force driver |
José Fonseca | ad6f60f | 2013-09-16 14:58:34 +0100 | [diff] [blame] | 229 | if interface.name.startswith('IDXGIFactory') and method.name.startswith('EnumAdapters'): |
José Fonseca | 82ea89d | 2012-12-05 19:34:26 +0000 | [diff] [blame] | 230 | print r' const char *szSoftware = NULL;' |
| 231 | print r' switch (retrace::driver) {' |
| 232 | print r' case retrace::DRIVER_REFERENCE:' |
| 233 | print r' case retrace::DRIVER_SOFTWARE:' |
| 234 | print r' szSoftware = "d3d10warp.dll";' |
| 235 | print r' break;' |
| 236 | print r' case retrace::DRIVER_MODULE:' |
| 237 | print r' szSoftware = retrace::driverModule;' |
| 238 | print r' break;' |
| 239 | print r' default:' |
| 240 | print r' break;' |
| 241 | print r' }' |
| 242 | print r' HMODULE hSoftware = NULL;' |
| 243 | print r' if (szSoftware) {' |
| 244 | print r' hSoftware = LoadLibraryA(szSoftware);' |
| 245 | print r' if (!hSoftware) {' |
| 246 | print r' retrace::warning(call) << "failed to load " << szSoftware << "\n";' |
| 247 | print r' }' |
| 248 | print r' }' |
| 249 | print r' if (hSoftware) {' |
José Fonseca | ad6f60f | 2013-09-16 14:58:34 +0100 | [diff] [blame] | 250 | print r' _result = _this->CreateSoftwareAdapter(hSoftware, reinterpret_cast<IDXGIAdapter **>(ppAdapter));' |
José Fonseca | 82ea89d | 2012-12-05 19:34:26 +0000 | [diff] [blame] | 251 | print r' } else {' |
| 252 | Retracer.invokeInterfaceMethod(self, interface, method) |
| 253 | print r' }' |
| 254 | return |
| 255 | |
José Fonseca | e23a6be | 2014-09-14 20:30:00 +0100 | [diff] [blame] | 256 | if interface.name.startswith('ID3D10Device') and method.name.startswith('OpenSharedResource'): |
José Fonseca | 75cbb8c | 2013-02-12 16:19:23 +0000 | [diff] [blame] | 257 | print r' retrace::warning(call) << "replacing shared resource with checker pattern\n";' |
| 258 | print r' D3D10_TEXTURE2D_DESC Desc;' |
| 259 | print r' memset(&Desc, 0, sizeof Desc);' |
| 260 | print r' Desc.Width = 8;' |
| 261 | print r' Desc.Height = 8;' |
| 262 | print r' Desc.MipLevels = 1;' |
| 263 | print r' Desc.ArraySize = 1;' |
| 264 | print r' Desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;' |
| 265 | print r' Desc.SampleDesc.Count = 1;' |
| 266 | print r' Desc.SampleDesc.Quality = 0;' |
| 267 | print r' Desc.Usage = D3D10_USAGE_DEFAULT;' |
| 268 | print r' Desc.BindFlags = D3D10_BIND_SHADER_RESOURCE | D3D10_BIND_RENDER_TARGET;' |
| 269 | print r' Desc.CPUAccessFlags = 0x0;' |
| 270 | print r' Desc.MiscFlags = 0 /* D3D10_RESOURCE_MISC_SHARED */;' |
Jose Fonseca | 65b6789 | 2015-07-16 16:59:30 +0100 | [diff] [blame] | 271 | print r' Desc.MiscFlags |= D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX;' |
José Fonseca | 75cbb8c | 2013-02-12 16:19:23 +0000 | [diff] [blame] | 272 | print r''' |
José Fonseca | a15929f | 2014-05-03 21:54:37 +0100 | [diff] [blame] | 273 | static const DWORD Checker[8][8] = { |
| 274 | { 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U }, |
| 275 | {~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U }, |
| 276 | { 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U }, |
| 277 | {~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U }, |
| 278 | { 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U }, |
| 279 | {~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U }, |
| 280 | { 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U }, |
| 281 | {~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U } |
José Fonseca | 75cbb8c | 2013-02-12 16:19:23 +0000 | [diff] [blame] | 282 | }; |
José Fonseca | a15929f | 2014-05-03 21:54:37 +0100 | [diff] [blame] | 283 | static const D3D10_SUBRESOURCE_DATA InitialData = {Checker, sizeof Checker[0], sizeof Checker}; |
José Fonseca | 75cbb8c | 2013-02-12 16:19:23 +0000 | [diff] [blame] | 284 | ''' |
José Fonseca | 0f7792c | 2014-09-26 14:20:32 +0100 | [diff] [blame] | 285 | print r' com_ptr<ID3D10Texture2D> pResource;' |
| 286 | print r' _result = _this->CreateTexture2D(&Desc, &InitialData, &pResource);' |
| 287 | print r' if (SUCCEEDED(_result)) {' |
| 288 | print r' _result = pResource->QueryInterface(ReturnedInterface, ppResource);' |
| 289 | print r' }' |
Jose Fonseca | 5c487ec | 2015-06-02 22:16:52 +0100 | [diff] [blame] | 290 | self.checkResult(interface, method) |
José Fonseca | 999284f | 2013-02-19 13:29:26 +0000 | [diff] [blame] | 291 | return |
José Fonseca | 2b66b93 | 2014-07-30 17:31:52 +0100 | [diff] [blame] | 292 | if interface.name.startswith('ID3D11Device') and method.name.startswith('OpenSharedResource'): |
| 293 | print r' retrace::warning(call) << "replacing shared resource with checker pattern\n";' |
| 294 | print |
| 295 | if method.name == 'OpenSharedResourceByName': |
| 296 | print r' (void)lpName;' |
| 297 | print r' (void)dwDesiredAccess;' |
| 298 | print |
| 299 | print r' D3D11_TEXTURE2D_DESC Desc;' |
| 300 | print r' memset(&Desc, 0, sizeof Desc);' |
| 301 | print r' Desc.Width = 8;' |
| 302 | print r' Desc.Height = 8;' |
| 303 | print r' Desc.MipLevels = 1;' |
| 304 | print r' Desc.ArraySize = 1;' |
| 305 | print r' Desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;' |
| 306 | print r' Desc.SampleDesc.Count = 1;' |
| 307 | print r' Desc.SampleDesc.Quality = 0;' |
| 308 | print r' Desc.Usage = D3D11_USAGE_DEFAULT;' |
| 309 | print r' Desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET;' |
| 310 | print r' Desc.CPUAccessFlags = 0x0;' |
| 311 | print r' Desc.MiscFlags = 0 /* D3D11_RESOURCE_MISC_SHARED */;' |
Jose Fonseca | 65b6789 | 2015-07-16 16:59:30 +0100 | [diff] [blame] | 312 | print r' Desc.MiscFlags |= D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX;' |
José Fonseca | 2b66b93 | 2014-07-30 17:31:52 +0100 | [diff] [blame] | 313 | print r''' |
| 314 | static const DWORD Checker[8][8] = { |
| 315 | { 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U }, |
| 316 | {~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U }, |
| 317 | { 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U }, |
| 318 | {~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U }, |
| 319 | { 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U }, |
| 320 | {~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U }, |
| 321 | { 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U }, |
| 322 | {~0U, 0U, ~0U, 0U, ~0U, 0U, ~0U, 0U } |
| 323 | }; |
| 324 | static const D3D11_SUBRESOURCE_DATA InitialData = {Checker, sizeof Checker[0], sizeof Checker}; |
| 325 | ''' |
José Fonseca | 0f7792c | 2014-09-26 14:20:32 +0100 | [diff] [blame] | 326 | print r' com_ptr<ID3D11Texture2D> pResource;' |
| 327 | print r' _result = _this->CreateTexture2D(&Desc, &InitialData, &pResource);' |
| 328 | print r' if (SUCCEEDED(_result)) {' |
| 329 | print r' _result = pResource->QueryInterface(ReturnedInterface, ppResource);' |
| 330 | print r' }' |
Jose Fonseca | 5c487ec | 2015-06-02 22:16:52 +0100 | [diff] [blame] | 331 | self.checkResult(interface, method) |
José Fonseca | 2b66b93 | 2014-07-30 17:31:52 +0100 | [diff] [blame] | 332 | return |
José Fonseca | 999284f | 2013-02-19 13:29:26 +0000 | [diff] [blame] | 333 | |
| 334 | if method.name == 'Map': |
| 335 | # Reset _DO_NOT_WAIT flags. Otherwise they may fail, and we have no |
| 336 | # way to cope with it (other than retry). |
| 337 | mapFlagsArg = method.getArgByName('MapFlags') |
| 338 | for flag in mapFlagsArg.type.values: |
| 339 | if flag.endswith('_MAP_FLAG_DO_NOT_WAIT'): |
| 340 | print r' MapFlags &= ~%s;' % flag |
| 341 | |
José Fonseca | 7af569a | 2014-09-04 19:08:45 +0100 | [diff] [blame] | 342 | if method.name.startswith('UpdateSubresource'): |
José Fonseca | c9cc24e | 2014-06-13 19:06:51 +0100 | [diff] [blame] | 343 | # The D3D10 debug layer is buggy (or at least inconsistent with the |
| 344 | # runtime), as it seems to estimate and enforce the data size based on the |
| 345 | # SrcDepthPitch, even for non 3D textures, but in some traces |
| 346 | # SrcDepthPitch is garbagge for non 3D textures. |
| 347 | # XXX: It also seems to expect padding bytes at the end of the last |
| 348 | # row, but we never record (or allocate) those... |
| 349 | print r' if (retrace::debug && pDstBox && pDstBox->front == 0 && pDstBox->back == 1) {' |
| 350 | print r' SrcDepthPitch = 0;' |
| 351 | print r' }' |
| 352 | |
José Fonseca | 0688d2e | 2014-08-19 20:43:21 +0100 | [diff] [blame] | 353 | if method.name == 'SetGammaControl': |
| 354 | # This method is only supported while in full-screen mode |
| 355 | print r' if (retrace::forceWindowed) {' |
| 356 | print r' return;' |
| 357 | print r' }' |
| 358 | |
José Fonseca | 999284f | 2013-02-19 13:29:26 +0000 | [diff] [blame] | 359 | Retracer.invokeInterfaceMethod(self, interface, method) |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 360 | |
Jose Fonseca | 4d5cfa4 | 2015-07-17 16:21:05 +0100 | [diff] [blame^] | 361 | if method.name in ('AcquireSync', 'ReleaseSync'): |
| 362 | print r' if (SUCCEEDED(_result) && _result != S_OK) {' |
| 363 | print r' retrace::warning(call) << " returned " << _result << "\n";' |
| 364 | print r' }' |
| 365 | |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 366 | # process events after presents |
| 367 | if method.name == 'Present': |
| 368 | print r' d3dretrace::processEvents();' |
| 369 | |
José Fonseca | 6ca2008 | 2014-10-07 21:39:43 +0100 | [diff] [blame] | 370 | if method.name in ('Map', 'Unmap'): |
| 371 | if interface.name.startswith('ID3D11DeviceContext'): |
| 372 | print ' void * & _pbData = g_Maps[_this][SubresourceKey(pResource, Subresource)];' |
| 373 | else: |
| 374 | subresourceArg = method.getArgByName('Subresource') |
| 375 | if subresourceArg is None: |
| 376 | print ' UINT Subresource = 0;' |
| 377 | print ' void * & _pbData = g_Maps[0][SubresourceKey(_this, Subresource)];' |
| 378 | |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 379 | if method.name == 'Map': |
José Fonseca | 003b8be | 2013-05-29 19:59:40 +0100 | [diff] [blame] | 380 | print ' _MAP_DESC _MapDesc;' |
| 381 | print ' _getMapDesc(_this, %s, _MapDesc);' % ', '.join(method.argNames()) |
| 382 | print ' size_t _MappedSize = _MapDesc.Size;' |
| 383 | print ' if (_MapDesc.Size) {' |
José Fonseca | 6ca2008 | 2014-10-07 21:39:43 +0100 | [diff] [blame] | 384 | print ' _pbData = _MapDesc.pData;' |
Jeff Muizelaar | 97244f9 | 2013-11-19 15:17:45 -0500 | [diff] [blame] | 385 | if interface.name.startswith('ID3D11DeviceContext'): |
José Fonseca | e907463 | 2014-09-26 14:23:19 +0100 | [diff] [blame] | 386 | # XXX: Unforunately this cause many false warnings on 1D and 2D |
| 387 | # resources, since the pitches are junk there... |
| 388 | #self.checkPitchMismatch(method) |
José Fonseca | 6ca2008 | 2014-10-07 21:39:43 +0100 | [diff] [blame] | 389 | pass |
Jeff Muizelaar | 97244f9 | 2013-11-19 15:17:45 -0500 | [diff] [blame] | 390 | else: |
José Fonseca | 6ca2008 | 2014-10-07 21:39:43 +0100 | [diff] [blame] | 391 | print ' _pbData = _MapDesc.pData;' |
José Fonseca | e907463 | 2014-09-26 14:23:19 +0100 | [diff] [blame] | 392 | self.checkPitchMismatch(method) |
José Fonseca | 4f49d21 | 2012-11-14 14:02:35 +0000 | [diff] [blame] | 393 | print ' } else {' |
| 394 | print ' return;' |
| 395 | print ' }' |
José Fonseca | 610942b | 2012-11-08 10:46:03 +0000 | [diff] [blame] | 396 | |
| 397 | if method.name == 'Unmap': |
José Fonseca | 6ca2008 | 2014-10-07 21:39:43 +0100 | [diff] [blame] | 398 | print ' if (_pbData) {' |
| 399 | print ' retrace::delRegionByPointer(_pbData);' |
| 400 | print ' _pbData = 0;' |
| 401 | print ' }' |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 402 | |
José Fonseca | 1d4fd14 | 2012-11-28 15:06:22 +0000 | [diff] [blame] | 403 | # Attach shader byte code for lookup |
| 404 | if 'pShaderBytecode' in method.argNames(): |
| 405 | ppShader = method.args[-1] |
| 406 | assert ppShader.output |
| 407 | print r' if (retrace::dumpingState && SUCCEEDED(_result)) {' |
| 408 | print r' (*%s)->SetPrivateData(d3dstate::GUID_D3DSTATE, BytecodeLength, pShaderBytecode);' % ppShader.name |
| 409 | print r' }' |
| 410 | |
José Fonseca | 3be2c67 | 2015-02-06 15:36:40 +0000 | [diff] [blame] | 411 | def extractArg(self, function, arg, arg_type, lvalue, rvalue): |
| 412 | # Set object names |
| 413 | if function.name == 'SetPrivateData' and arg.name == 'pData': |
| 414 | iid = function.args[0].name |
| 415 | print r' if (%s != WKPDID_D3DDebugObjectName) {' % iid |
| 416 | print r' return;' |
| 417 | print r' }' |
| 418 | # Interpret argument as string |
| 419 | Retracer.extractArg(self, function, arg, LPCSTR, lvalue, rvalue) |
| 420 | print r' assert(pData);' |
| 421 | print r' assert(DataSize == strlen((const char *)pData));' |
| 422 | return |
| 423 | |
| 424 | Retracer.extractArg(self, function, arg, arg_type, lvalue, rvalue) |
| 425 | |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 426 | |
| 427 | def main(): |
José Fonseca | 75cbb8c | 2013-02-12 16:19:23 +0000 | [diff] [blame] | 428 | print r'#define INITGUID' |
| 429 | print |
José Fonseca | 73341c2 | 2012-11-24 13:04:42 +0000 | [diff] [blame] | 430 | print r'#include <string.h>' |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 431 | print |
| 432 | print r'#include <iostream>' |
| 433 | print |
| 434 | print r'#include "d3dretrace.hpp"' |
José Fonseca | 89b697f | 2014-06-17 20:26:38 +0100 | [diff] [blame] | 435 | print r'#include "os_version.hpp"' |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 436 | print |
José Fonseca | 50bee95 | 2015-02-07 22:32:19 +0000 | [diff] [blame] | 437 | print r'#include "d3dretrace_dxgi.hpp"' |
| 438 | print r'#include "d3d10imports.hpp"' |
| 439 | print r'#include "d3d10size.hpp"' |
| 440 | print r'#include "d3d10state.hpp"' |
| 441 | print r'#include "d3d11imports.hpp"' |
| 442 | print r'#include "d3d11size.hpp"' |
| 443 | print r'#include "d3dstate.hpp"' |
| 444 | print |
| 445 | print '''static d3dretrace::D3DDumper<IDXGISwapChain> dxgiDumper;''' |
| 446 | print '''static d3dretrace::D3DDumper<ID3D10Device> d3d10Dumper;''' |
| 447 | print '''static d3dretrace::D3DDumper<ID3D11DeviceContext> d3d11Dumper;''' |
| 448 | print |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 449 | |
| 450 | api = API() |
José Fonseca | 50bee95 | 2015-02-07 22:32:19 +0000 | [diff] [blame] | 451 | api.addModule(dxgi) |
| 452 | api.addModule(d3d10) |
| 453 | api.addModule(d3d10_1) |
| 454 | api.addModule(d3d11) |
José Fonseca | fc58d05 | 2014-06-13 12:47:19 +0100 | [diff] [blame] | 455 | |
José Fonseca | 6f81033 | 2012-11-11 10:05:09 +0000 | [diff] [blame] | 456 | retracer = D3DRetracer() |
| 457 | retracer.retraceApi(api) |
| 458 | |
| 459 | |
| 460 | if __name__ == '__main__': |
| 461 | main() |