From: José Fonseca Date: Sat, 1 Dec 2012 10:08:33 +0000 (+0000) Subject: Merge branch 'master' into trim-auto X-Git-Url: https://git.cworth.org/git?a=commitdiff_plain;h=77373c35010d89e5ab3f030e4c60f8f6e3fdbe82;hp=6e4768b0714ceb189621e75af8511629a6c8a5e4;p=apitrace Merge branch 'master' into trim-auto --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 3d97b1e..2ace8ac 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -338,7 +338,9 @@ set_target_properties (common PROPERTIES ) if (ANDROID) - target_link_libraries (common log) + target_link_libraries (common + log + ) endif () @@ -346,6 +348,7 @@ endif () # Sub-directories add_subdirectory (dispatch) +add_subdirectory (helpers) add_subdirectory (wrappers) add_subdirectory (retrace) @@ -354,7 +357,7 @@ add_subdirectory (retrace) # CLI if (ENABLE_CLI) - add_subdirectory(cli) + add_subdirectory (cli) endif () ############################################################################## diff --git a/common/image.hpp b/common/image.hpp index e930512..7dd18c1 100644 --- a/common/image.hpp +++ b/common/image.hpp @@ -94,16 +94,21 @@ public: return true; } - bool writePNG(const char *filename) const; + bool + writePNG(std::ostream &os) const; + + inline bool + writePNG(const char *filename) const { + std::ofstream os(filename, std::ofstream::binary); + if (!os) { + return false; + } + return writePNG(os); + } double compare(Image &ref); }; -bool writePixelsToBuffer(unsigned char *pixels, - unsigned w, unsigned h, unsigned numChannels, - bool flipped, - char **buffer, - int *size); Image * readPNG(const char *filename); @@ -111,6 +116,7 @@ readPNG(const char *filename); const char * readPNMHeader(const char *buffer, size_t size, unsigned *channels, unsigned *width, unsigned *height); + } /* namespace image */ diff --git a/common/image_png.cpp b/common/image_png.cpp index cc6d3f2..dba07d4 100644 --- a/common/image_png.cpp +++ b/common/image_png.cpp @@ -43,34 +43,20 @@ namespace image { static const int png_compression_level = Z_BEST_SPEED; +static void +pngWriteCallback(png_structp png_ptr, png_bytep data, png_size_t length) +{ + std::ostream *os = (std::ostream *) png_get_io_ptr(png_ptr); + os->write((const char *)data, length); +} + bool -Image::writePNG(const char *filename) const { - FILE *fp; +Image::writePNG(std::ostream &os) const +{ png_structp png_ptr; png_infop info_ptr; - - fp = fopen(filename, "wb"); - if (!fp) - goto no_fp; - - png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); - if (!png_ptr) - goto no_png; - - info_ptr = png_create_info_struct(png_ptr); - if (!info_ptr) { - png_destroy_write_struct(&png_ptr, NULL); - goto no_png; - } - - if (setjmp(png_jmpbuf(png_ptr))) { - png_destroy_write_struct(&png_ptr, &info_ptr); - goto no_png; - } - - png_init_io(png_ptr, fp); - int color_type; + switch (channels) { case 4: color_type = PNG_COLOR_TYPE_RGB_ALPHA; @@ -86,11 +72,29 @@ Image::writePNG(const char *filename) const { break; default: assert(0); - return false; + goto no_png; } - png_set_IHDR(png_ptr, info_ptr, width, height, 8, color_type, - PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); + png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); + if (!png_ptr) + goto no_png; + + info_ptr = png_create_info_struct(png_ptr); + if (!info_ptr) { + png_destroy_write_struct(&png_ptr, NULL); + goto no_png; + } + + if (setjmp(png_jmpbuf(png_ptr))) { + png_destroy_write_struct(&png_ptr, &info_ptr); + goto no_png; + } + + png_set_write_fn(png_ptr, &os, pngWriteCallback, NULL); + + png_set_IHDR(png_ptr, info_ptr, width, height, 8, + color_type, PNG_INTERLACE_NONE, + PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); png_set_compression_level(png_ptr, png_compression_level); @@ -112,12 +116,9 @@ Image::writePNG(const char *filename) const { png_write_end(png_ptr, info_ptr); png_destroy_write_struct(&png_ptr, &info_ptr); - fclose(fp); return true; no_png: - fclose(fp); -no_fp: return false; } @@ -201,115 +202,5 @@ no_fp: } -struct png_tmp_buffer -{ - char *buffer; - size_t size; -}; - -static void -pngWriteCallback(png_structp png_ptr, png_bytep data, png_size_t length) -{ - struct png_tmp_buffer *buf = (struct png_tmp_buffer*) png_get_io_ptr(png_ptr); - size_t nsize = buf->size + length; - - /* allocate or grow buffer */ - if (buf->buffer) - buf->buffer = (char*)realloc(buf->buffer, nsize); - else - buf->buffer = (char*)malloc(nsize); - - if (!buf->buffer) - png_error(png_ptr, "Buffer allocation error"); - - memcpy(buf->buffer + buf->size, data, length); - buf->size += length; -} - -bool writePixelsToBuffer(unsigned char *pixels, - unsigned width, unsigned height, unsigned numChannels, - bool flipped, - char **buffer, - int *size) -{ - struct png_tmp_buffer png_mem; - png_structp png_ptr; - png_infop info_ptr; - int type; - - png_mem.buffer = NULL; - png_mem.size = 0; - - switch (numChannels) { - case 4: - type = PNG_COLOR_TYPE_RGB_ALPHA; - break; - case 3: - type = PNG_COLOR_TYPE_RGB; - break; - case 2: - type = PNG_COLOR_TYPE_GRAY_ALPHA; - break; - case 1: - type = PNG_COLOR_TYPE_GRAY; - break; - default: - goto no_png; - } - - png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); - if (!png_ptr) - goto no_png; - - info_ptr = png_create_info_struct(png_ptr); - if (!info_ptr) { - png_destroy_write_struct(&png_ptr, NULL); - goto no_png; - } - - if (setjmp(png_jmpbuf(png_ptr))) { - png_destroy_write_struct(&png_ptr, &info_ptr); - goto no_png; - } - - png_set_write_fn(png_ptr, &png_mem, pngWriteCallback, NULL); - - png_set_IHDR(png_ptr, info_ptr, width, height, 8, - type, PNG_INTERLACE_NONE, - PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); - - png_set_compression_level(png_ptr, png_compression_level); - - png_write_info(png_ptr, info_ptr); - - if (!flipped) { - for (unsigned y = 0; y < height; ++y) { - png_bytep row = (png_bytep)(pixels + y*width*numChannels); - png_write_rows(png_ptr, &row, 1); - } - } else { - unsigned y = height; - while (y--) { - png_bytep row = (png_bytep)(pixels + y*width*numChannels); - png_write_rows(png_ptr, &row, 1); - } - } - - png_write_end(png_ptr, info_ptr); - png_destroy_write_struct(&png_ptr, &info_ptr); - - *buffer = png_mem.buffer; - *size = png_mem.size; - - return true; - -no_png: - *buffer = NULL; - *size = 0; - - if (png_mem.buffer) - free(png_mem.buffer); - return false; -} } /* namespace image */ diff --git a/common/os.hpp b/common/os.hpp index cc72a0e..91c819f 100644 --- a/common/os.hpp +++ b/common/os.hpp @@ -42,6 +42,9 @@ #ifndef vsnprintf #define vsnprintf _vsnprintf #endif +#ifndef strcasecmp +#define strcasecmp stricmp +#endif #endif /* !_WIN32 */ namespace os { diff --git a/common/trace_tools_trace.cpp b/common/trace_tools_trace.cpp index 387e2e2..4c0082d 100644 --- a/common/trace_tools_trace.cpp +++ b/common/trace_tools_trace.cpp @@ -52,13 +52,83 @@ namespace trace { #endif +static inline bool +copyWrapper(const os::String & wrapperPath, + const char *programPath, + bool verbose) +{ + os::String wrapperFilename(wrapperPath); + wrapperFilename.trimDirectory(); + + os::String tmpWrapper(programPath); + tmpWrapper.trimFilename(); + tmpWrapper.join(wrapperFilename); + + if (verbose) { + std::cerr << wrapperPath << " -> " << tmpWrapper << "\n"; + } + + if (tmpWrapper.exists()) { + std::cerr << "error: not overwriting " << tmpWrapper << "\n"; + return false; + } + + if (!os::copyFile(wrapperPath, tmpWrapper, false)) { + std::cerr << "error: failed to copy " << wrapperPath << " into " << tmpWrapper << "\n"; + return false; + } + + return true; +} + + +static const char *glWrappers[] = { + GL_TRACE_WRAPPER, + NULL +}; + +#ifdef EGL_TRACE_WRAPPER +static const char *eglWrappers[] = { + EGL_TRACE_WRAPPER, + NULL +}; +#endif + +#ifdef _WIN32 +static const char *d3d7Wrappers[] = { + "ddraw.dll", + NULL +}; + +static const char *d3d8Wrappers[] = { + "d3d8.dll", + NULL +}; + +static const char *d3d9Wrappers[] = { + "d3d9.dll", + NULL +}; + +static const char *dxgiWrappers[] = { + "dxgitrace.dll", + //"dxgi.dll", + "d3d10.dll", + "d3d10_1.dll", + "d3d11.dll", + NULL +}; +#endif + int traceProgram(API api, char * const *argv, const char *output, bool verbose) { - const char *wrapperFilename; + const char **wrapperFilenames; + unsigned numWrappers; + int status = 1; /* * TODO: simplify code @@ -66,31 +136,27 @@ traceProgram(API api, switch (api) { case API_GL: - wrapperFilename = GL_TRACE_WRAPPER; + wrapperFilenames = glWrappers; break; #ifdef EGL_TRACE_WRAPPER case API_EGL: - wrapperFilename = EGL_TRACE_WRAPPER; + wrapperFilenames = eglWrappers; break; #endif #ifdef _WIN32 case API_D3D7: - wrapperFilename = "ddraw.dll"; + wrapperFilenames = d3d7Wrappers; break; case API_D3D8: - wrapperFilename = "d3d8.dll"; + wrapperFilenames = d3d8Wrappers; break; case API_D3D9: - wrapperFilename = "d3d9.dll"; + wrapperFilenames = d3d9Wrappers; break; case API_D3D10: - wrapperFilename = "d3d10.dll"; - break; case API_D3D10_1: - wrapperFilename = "d3d10_1.dll"; - break; case API_D3D11: - wrapperFilename = "d3d11.dll"; + wrapperFilenames = dxgiWrappers; break; #endif default: @@ -98,48 +164,45 @@ traceProgram(API api, return 1; } - os::String wrapperPath = findWrapper(wrapperFilename); - - if (!wrapperPath.length()) { - std::cerr << "error: failed to find " << wrapperFilename << "\n"; - return 1; + numWrappers = 0; + while (wrapperFilenames[numWrappers]) { + ++numWrappers; } -#if defined(_WIN32) - /* On Windows copy the wrapper to the program directory. - */ - os::String tmpWrapper(argv[0]); - tmpWrapper.trimFilename(); - tmpWrapper.join(wrapperFilename); + unsigned i; + for (i = 0; i < numWrappers; ++i) { + const char *wrapperFilename = wrapperFilenames[i]; - if (verbose) { - std::cerr << wrapperPath << " -> " << tmpWrapper << "\n"; - } + os::String wrapperPath = findWrapper(wrapperFilename); - if (tmpWrapper.exists()) { - std::cerr << "error: not overwriting " << tmpWrapper << "\n"; - return 1; - } + if (!wrapperPath.length()) { + std::cerr << "error: failed to find " << wrapperFilename << "\n"; + goto exit; + } - if (!os::copyFile(wrapperPath, tmpWrapper, false)) { - std::cerr << "error: failed to copy " << wrapperPath << " into " << tmpWrapper << "\n"; - return 1; - } +#if defined(_WIN32) + /* On Windows copy the wrapper to the program directory. + */ + if (!copyWrapper(wrapperPath, argv[0], verbose)) { + goto exit; + } #endif /* _WIN32 */ #if defined(__APPLE__) - /* On Mac OS X, using DYLD_LIBRARY_PATH, we actually set the - * directory, not the file. */ - wrapperPath.trimFilename(); + /* On Mac OS X, using DYLD_LIBRARY_PATH, we actually set the + * directory, not the file. */ + wrapperPath.trimFilename(); #endif #if defined(TRACE_VARIABLE) - if (verbose) { - std::cerr << TRACE_VARIABLE << "=" << wrapperPath.str() << "\n"; - } - /* FIXME: Don't modify the current environment */ - os::setEnvironment(TRACE_VARIABLE, wrapperPath.str()); + assert(numWrappers == 1); + if (verbose) { + std::cerr << TRACE_VARIABLE << "=" << wrapperPath.str() << "\n"; + } + /* FIXME: Don't modify the current environment */ + os::setEnvironment(TRACE_VARIABLE, wrapperPath.str()); #endif /* TRACE_VARIABLE */ + } if (output) { os::setEnvironment("TRACE_FILE", output); @@ -154,13 +217,20 @@ traceProgram(API api, std::cerr << "\n"; } - int status = os::execute(argv); + status = os::execute(argv); +exit: #if defined(TRACE_VARIABLE) os::unsetEnvironment(TRACE_VARIABLE); #endif #if defined(_WIN32) - os::removeFile(tmpWrapper); + for (unsigned j = 0; j < i; ++j) { + const char *wrapperFilename = wrapperFilenames[j]; + os::String tmpWrapper(argv[0]); + tmpWrapper.trimFilename(); + tmpWrapper.join(wrapperFilename); + os::removeFile(tmpWrapper); + } #endif if (output) { diff --git a/dispatch/d3d9imports.hpp b/dispatch/d3d9imports.hpp index 1a22a59..a07d768 100644 --- a/dispatch/d3d9imports.hpp +++ b/dispatch/d3d9imports.hpp @@ -35,7 +35,6 @@ #include "compat.h" #include -#include #ifndef D3DFMT_A2B10G10R10_XR_BIAS diff --git a/gui/apisurface.cpp b/gui/apisurface.cpp index bfc6cfd..d17560f 100644 --- a/gui/apisurface.cpp +++ b/gui/apisurface.cpp @@ -18,16 +18,6 @@ void ApiSurface::setSize(const QSize &size) m_size = size; } -int ApiSurface::numChannels() const -{ - return m_numChannels; -} - -void ApiSurface::setNumChannels(int numChannels) -{ - m_numChannels = numChannels; -} - void ApiSurface::contentsFromBase64(const QByteArray &base64) { QByteArray dataArray = QByteArray::fromBase64(base64); diff --git a/gui/apisurface.h b/gui/apisurface.h index bc403af..9f00001 100644 --- a/gui/apisurface.h +++ b/gui/apisurface.h @@ -13,9 +13,6 @@ public: QSize size() const; void setSize(const QSize &size); - int numChannels() const; - void setNumChannels(int numChannels); - int depth() const; void setDepth(int depth); diff --git a/gui/apitracecall.cpp b/gui/apitracecall.cpp index 907e10a..3377486 100644 --- a/gui/apitracecall.cpp +++ b/gui/apitracecall.cpp @@ -490,20 +490,11 @@ ApiTraceState::ApiTraceState(const QVariantMap &parsedJson) QSize size(image[QLatin1String("__width__")].toInt(), image[QLatin1String("__height__")].toInt()); QString cls = image[QLatin1String("__class__")].toString(); - QString type = image[QLatin1String("__type__")].toString(); - bool normalized = - image[QLatin1String("__normalized__")].toBool(); - int numChannels = - image[QLatin1String("__channels__")].toInt(); int depth = image[QLatin1String("__depth__")].toInt(); QString formatName = image[QLatin1String("__format__")].toString(); - Q_ASSERT(type == QLatin1String("uint8")); - Q_ASSERT(normalized == true); - Q_UNUSED(normalized); - QByteArray dataArray = image[QLatin1String("__data__")].toByteArray(); @@ -511,7 +502,6 @@ ApiTraceState::ApiTraceState(const QVariantMap &parsedJson) tex.setSize(size); tex.setDepth(depth); tex.setFormatName(formatName); - tex.setNumChannels(numChannels); tex.setLabel(itr.key()); tex.contentsFromBase64(dataArray); @@ -525,16 +515,9 @@ ApiTraceState::ApiTraceState(const QVariantMap &parsedJson) QSize size(buffer[QLatin1String("__width__")].toInt(), buffer[QLatin1String("__height__")].toInt()); QString cls = buffer[QLatin1String("__class__")].toString(); - QString type = buffer[QLatin1String("__type__")].toString(); - bool normalized = buffer[QLatin1String("__normalized__")].toBool(); - int numChannels = buffer[QLatin1String("__channels__")].toInt(); int depth = buffer[QLatin1String("__depth__")].toInt(); QString formatName = buffer[QLatin1String("__format__")].toString(); - Q_ASSERT(type == QLatin1String("uint8")); - Q_ASSERT(normalized == true); - Q_UNUSED(normalized); - QByteArray dataArray = buffer[QLatin1String("__data__")].toByteArray(); @@ -542,7 +525,6 @@ ApiTraceState::ApiTraceState(const QVariantMap &parsedJson) fbo.setSize(size); fbo.setDepth(depth); fbo.setFormatName(formatName); - fbo.setNumChannels(numChannels); fbo.setType(itr.key()); fbo.contentsFromBase64(dataArray); m_framebuffers.append(fbo); @@ -566,7 +548,10 @@ const QVariantMap & ApiTraceState::uniforms() const bool ApiTraceState::isEmpty() const { - return m_parameters.isEmpty(); + return m_parameters.isEmpty() && + m_shaderSources.isEmpty() && + m_textures.isEmpty() && + m_framebuffers.isEmpty(); } const QList & ApiTraceState::textures() const diff --git a/helpers/CMakeLists.txt b/helpers/CMakeLists.txt new file mode 100644 index 0000000..53a639f --- /dev/null +++ b/helpers/CMakeLists.txt @@ -0,0 +1,13 @@ +############################################################################## +# API helpers + + +if (WIN32) + add_library (d3dhelpers STATIC + d3dshader.cpp + ) + set_target_properties (d3dhelpers PROPERTIES + # Ensure it can be statically linked in shared libraries + COMPILE_FLAGS "${CMAKE_SHARED_LIBRARY_CXX_FLAGS}" + ) +endif () diff --git a/helpers/d3dshader.cpp b/helpers/d3dshader.cpp new file mode 100644 index 0000000..06a7135 --- /dev/null +++ b/helpers/d3dshader.cpp @@ -0,0 +1,184 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * Copyright 2008-2009 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include + +#include "d3dshader.hpp" +#include "os.hpp" + + +struct ID3DXBuffer : public IUnknown { + virtual LPVOID STDMETHODCALLTYPE GetBufferPointer(void) = 0; + virtual DWORD STDMETHODCALLTYPE GetBufferSize(void) = 0; +}; + +typedef HRESULT +(WINAPI *PD3DXDISASSEMBLESHADER)( + CONST DWORD *pShader, + BOOL EnableColorCode, + LPCSTR pComments, + ID3DXBuffer **ppDisassembly +); + + +HRESULT +DisassembleShader(const DWORD *tokens, IDisassemblyBuffer **ppDisassembly) +{ + static BOOL firsttime = TRUE; + + /* + * TODO: Consider using d3dcompile_xx.dll per + * http://msdn.microsoft.com/en-us/library/windows/desktop/ee663275.aspx + */ + + static HMODULE hD3DXModule = NULL; + static PD3DXDISASSEMBLESHADER pfnD3DXDisassembleShader = NULL; + + if (firsttime) { + if (!hD3DXModule) { + unsigned release; + int version; + for (release = 0; release <= 1; ++release) { + /* Version 41 corresponds to Mar 2009 version of DirectX Runtime / SDK */ + for (version = 41; version >= 0; --version) { + char filename[256]; + _snprintf(filename, sizeof(filename), + "d3dx9%s%s%u.dll", release ? "" : "d", version ? "_" : "", version); + hD3DXModule = LoadLibraryA(filename); + if (hD3DXModule) + goto found; + } + } +found: + ; + } + + if (hD3DXModule) { + if (!pfnD3DXDisassembleShader) { + pfnD3DXDisassembleShader = (PD3DXDISASSEMBLESHADER)GetProcAddress(hD3DXModule, "D3DXDisassembleShader"); + } + } + + firsttime = FALSE; + } + + HRESULT hr = E_FAIL; + if (pfnD3DXDisassembleShader) { + hr = pfnD3DXDisassembleShader(tokens, FALSE, NULL, + reinterpret_cast(ppDisassembly)); + } + return hr; +} + + +struct ID3D10Blob : public IUnknown { + virtual LPVOID STDMETHODCALLTYPE GetBufferPointer(void) = 0; + virtual SIZE_T STDMETHODCALLTYPE GetBufferSize(void) = 0; +}; + +typedef ID3D10Blob ID3DBlob; + +#define D3D_DISASM_ENABLE_COLOR_CODE 0x00000001 +#define D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS 0x00000002 +#define D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING 0x00000004 +#define D3D_DISASM_ENABLE_INSTRUCTION_CYCLE 0x00000008 +#define D3D_DISASM_DISABLE_DEBUG_INFO 0x00000010 +#define D3D_DISASM_ENABLE_INSTRUCTION_OFFSET 0x00000020 +#define D3D_DISASM_INSTRUCTION_ONLY 0x00000040 + +typedef HRESULT +(WINAPI *PFND3DDISASSEMBLE)( + LPCVOID pSrcData, + SIZE_T SrcDataSize, + UINT Flags, + LPCSTR szComments, + ID3DBlob **ppDisassembly +); + +static PFND3DDISASSEMBLE pfnD3DDisassemble = NULL; + +typedef HRESULT +(WINAPI *PFND3D10DISASSEMBLESHADER)( + const void *pShader, + SIZE_T BytecodeLength, + BOOL EnableColorCode, + LPCSTR pComments, + ID3D10Blob **ppDisassembly +); + +static PFND3D10DISASSEMBLESHADER pfnD3D10DisassembleShader = NULL; + + +HRESULT +DisassembleShader(const void *pShaderBytecode, SIZE_T BytecodeLength, IDisassemblyBuffer **ppDisassembly) +{ + static bool firsttime = true; + + if (firsttime) { + char szFilename[MAX_PATH]; + HMODULE hModule = NULL; + int version; + for (version = 44; version >= 33; --version) { + _snprintf(szFilename, sizeof(szFilename), "d3dcompiler_%i.dll", version); + hModule = LoadLibraryA(szFilename); + if (hModule) { + pfnD3DDisassemble = (PFND3DDISASSEMBLE) + GetProcAddress(hModule, "D3DDisassemble"); + if (pfnD3DDisassemble) { + break; + } + } + } + if (!pfnD3DDisassemble) { + /* + * Fallback to D3D10DisassembleShader, which should be always present. + */ + if (GetSystemDirectoryA(szFilename, MAX_PATH)) { + strcat(szFilename, "\\d3d10.dll"); + hModule = LoadLibraryA(szFilename); + if (hModule) { + pfnD3D10DisassembleShader = (PFND3D10DISASSEMBLESHADER) + GetProcAddress(hModule, "D3D10DisassembleShader"); + } + } + } + + firsttime = false; + } + + HRESULT hr = E_FAIL; + + if (pfnD3DDisassemble) { + hr = pfnD3DDisassemble(pShaderBytecode, BytecodeLength, 0, NULL, + reinterpret_cast(ppDisassembly)); + } else if (pfnD3D10DisassembleShader) { + hr = pfnD3D10DisassembleShader(pShaderBytecode, BytecodeLength, 0, NULL, + reinterpret_cast(ppDisassembly)); + } + + return hr; +} diff --git a/helpers/d3dshader.hpp b/helpers/d3dshader.hpp new file mode 100644 index 0000000..169785e --- /dev/null +++ b/helpers/d3dshader.hpp @@ -0,0 +1,51 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#ifndef _D3DSHADER_HPP_ +#define _D3DSHADER_HPP_ + + +#include + +// Matches ID3DXBuffer, ID3D10Blob, ID3DBlob +struct IDisassemblyBuffer : public IUnknown { + virtual LPVOID STDMETHODCALLTYPE GetBufferPointer(void) = 0; + + // XXX: ID3D10Blob, ID3DBlob actually return SIZE_T but DWORD should give + // the same results + virtual DWORD STDMETHODCALLTYPE GetBufferSize(void) = 0; +}; + + +// D3D9 and earlier +HRESULT +DisassembleShader(const DWORD *tokens, IDisassemblyBuffer **ppDisassembly); + +// D3D10 and higher +HRESULT +DisassembleShader(const void *pShader, SIZE_T BytecodeLength, IDisassemblyBuffer **ppDisassembly); + + +#endif /* _D3DSHADER_HPP_ */ diff --git a/retrace/.gitignore b/retrace/.gitignore index ebcad87..978f7a3 100644 --- a/retrace/.gitignore +++ b/retrace/.gitignore @@ -1,2 +1,4 @@ +d3dretrace_d3d9.cpp +d3dretrace_dxgi.cpp glretrace_gl.cpp glstate_params.cpp diff --git a/retrace/CMakeLists.txt b/retrace/CMakeLists.txt index 383417d..5a2a608 100644 --- a/retrace/CMakeLists.txt +++ b/retrace/CMakeLists.txt @@ -31,13 +31,13 @@ add_custom_command ( ${CMAKE_SOURCE_DIR}/specs/stdapi.py ) -add_library (retrace_common +add_library (retrace_common STATIC retrace.cpp retrace_main.cpp retrace_stdc.cpp retrace_swizzle.cpp + json.cpp ) - target_link_libraries (retrace_common common ${PNG_LIBRARIES} @@ -46,7 +46,7 @@ target_link_libraries (retrace_common ${GETOPT_LIBRARIES} ) -add_library (glretrace_common +add_library (glretrace_common STATIC glretrace_gl.cpp glretrace_cgl.cpp glretrace_glx.cpp @@ -60,8 +60,10 @@ add_library (glretrace_common glstate_shaders.cpp glws.cpp ) - add_dependencies (glretrace_common glproc) +target_link_libraries (glretrace_common + retrace_common +) if (WIN32 OR APPLE OR X11_FOUND) @@ -129,11 +131,37 @@ if (ENABLE_EGL AND X11_FOUND AND NOT WIN32 AND NOT APPLE) install (TARGETS eglretrace RUNTIME DESTINATION bin) endif () -if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3DX9_INCLUDE_DIR}) +if (WIN32) + if (DirectX_D3D8_INCLUDE_DIR) + include_directories (BEFORE SYSTEM ${DirectX_D3D8_INCLUDE_DIR}) + set (HAVE_D3D8 1) + else () + set (HAVE_D3D8 0) + endif () + add_custom_command ( + OUTPUT d3dretrace_d3d8.cpp + COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9retrace.py d3d8 ${HAVE_D3D8} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d8.cpp + DEPENDS + d3d9retrace.py + dllretrace.py + retrace.py + ${CMAKE_SOURCE_DIR}/dispatch/dispatch.py + ${CMAKE_SOURCE_DIR}/specs/d3d8.py + ${CMAKE_SOURCE_DIR}/specs/d3d8types.py + ${CMAKE_SOURCE_DIR}/specs/d3d8caps.py + ${CMAKE_SOURCE_DIR}/specs/winapi.py + ${CMAKE_SOURCE_DIR}/specs/stdapi.py + ) + + if (DirectX_D3D9_INCLUDE_DIR) + include_directories (BEFORE SYSTEM ${DirectX_D3D9_INCLUDE_DIR}) + set (HAVE_D3D9 1) + else () + set (HAVE_D3D9 0) + endif () add_custom_command ( OUTPUT d3dretrace_d3d9.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9retrace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d9.cpp + COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9retrace.py d3d9 ${HAVE_D3D9} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d9.cpp DEPENDS d3d9retrace.py dllretrace.py @@ -147,11 +175,11 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) ) if (DirectX_D3D10_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D10_INCLUDE_DIR}) - set (D3D10_MODULES d3d10) + include_directories (BEFORE SYSTEM ${DirectX_D3D10_INCLUDE_DIR}) + set (DXGI_MODULES d3d10) if (DirectX_D3D10_1_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D10_1_INCLUDE_DIR}) - set (D3D10_MODULES ${D3D10_MODULES} d3d10_1) + include_directories (BEFORE SYSTEM ${DirectX_D3D10_1_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d10_1) endif () set (D3DSTATE_SOURCES ${D3DSTATE_SOURCES} d3d10state.cpp @@ -160,11 +188,11 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) endif () if (DirectX_D3D11_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D11_INCLUDE_DIR}) - set (D3D10_MODULES ${D3D10_MODULES} d3d11) + include_directories (BEFORE SYSTEM ${DirectX_D3D11_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d11) if (DirectX_D3D11_1_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D11_1_INCLUDE_DIR}) - set (D3D10_MODULES ${D3D10_MODULES} d3d11_1) + include_directories (BEFORE SYSTEM ${DirectX_D3D11_1_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d11_1) endif () set (D3DSTATE_SOURCES ${D3DSTATE_SOURCES} d3d11state.cpp @@ -173,10 +201,10 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) endif () add_custom_command ( - OUTPUT d3dretrace_d3d10.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3dcommonretrace.py ${D3D10_MODULES} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d10.cpp + OUTPUT d3dretrace_dxgi.cpp + COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgiretrace.py ${DXGI_MODULES} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_dxgi.cpp DEPENDS - d3dcommonretrace.py + dxgiretrace.py dllretrace.py retrace.py ${CMAKE_SOURCE_DIR}/dispatch/dispatch.py @@ -187,8 +215,6 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) ${CMAKE_SOURCE_DIR}/specs/d3d10.py ${CMAKE_SOURCE_DIR}/specs/d3d10misc.py ${CMAKE_SOURCE_DIR}/specs/d3d10sdklayers.py - ${CMAKE_SOURCE_DIR}/specs/d3d10shader.py - ${CMAKE_SOURCE_DIR}/specs/d3d10effect.py ${CMAKE_SOURCE_DIR}/specs/d3dcommon.py ${CMAKE_SOURCE_DIR}/specs/dxgi.py ${CMAKE_SOURCE_DIR}/specs/dxgitype.py @@ -199,8 +225,9 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) add_executable (d3dretrace d3dretrace_main.cpp + d3dretrace_d3d8.cpp d3dretrace_d3d9.cpp - d3dretrace_d3d10.cpp + d3dretrace_dxgi.cpp d3dretrace_ws.cpp d3d9state.cpp d3d9state_images.cpp @@ -208,6 +235,7 @@ if (WIN32 AND DirectX_D3DX9_INCLUDE_DIR) ) target_link_libraries (d3dretrace retrace_common + d3dhelpers ) install (TARGETS d3dretrace RUNTIME DESTINATION bin) diff --git a/retrace/d3d10state.cpp b/retrace/d3d10state.cpp index fd0eb5b..15be6c4 100644 --- a/retrace/d3d10state.cpp +++ b/retrace/d3d10state.cpp @@ -30,17 +30,107 @@ #include "d3d11imports.hpp" #include "json.hpp" +#include "d3dshader.hpp" +#include "d3dstate.hpp" namespace d3dstate { +const GUID +GUID_D3DSTATE = {0x7D71CAC9,0x7F58,0x432C,{0xA9,0x75,0xA1,0x9F,0xCF,0xCE,0xFD,0x14}}; + + +template< class T > +inline void +dumpShader(JSONWriter &json, const char *name, T *pShader) { + if (!pShader) { + return; + } + + HRESULT hr; + + /* + * There is no method to get the shader byte code, so the creator is supposed to + * attach it via the SetPrivateData method. + */ + UINT BytecodeLength = 0; + char dummy; + hr = pShader->GetPrivateData(GUID_D3DSTATE, &BytecodeLength, &dummy); + if (hr != DXGI_ERROR_MORE_DATA) { + return; + } + + void *pShaderBytecode = malloc(BytecodeLength); + if (!pShaderBytecode) { + return; + } + + hr = pShader->GetPrivateData(GUID_D3DSTATE, &BytecodeLength, pShaderBytecode); + if (SUCCEEDED(hr)) { + IDisassemblyBuffer *pDisassembly = NULL; + hr = DisassembleShader(pShaderBytecode, BytecodeLength, &pDisassembly); + if (SUCCEEDED(hr)) { + json.beginMember(name); + json.writeString((const char *)pDisassembly->GetBufferPointer() /*, pDisassembly->GetBufferSize() */); + json.endMember(); + pDisassembly->Release(); + } + } + + free(pShaderBytecode); +} + +static void +dumpShaders(JSONWriter &json, ID3D10Device *pDevice) +{ + json.beginMember("shaders"); + json.beginObject(); + + ID3D10VertexShader *pVertexShader = NULL; + pDevice->VSGetShader(&pVertexShader); + if (pVertexShader) { + dumpShader(json, "VS", pVertexShader); + pVertexShader->Release(); + } + + ID3D10GeometryShader *pGeometryShader = NULL; + pDevice->GSGetShader(&pGeometryShader); + if (pGeometryShader) { + dumpShader(json, "GS", pGeometryShader); + pGeometryShader->Release(); + } + + ID3D10PixelShader *pPixelShader = NULL; + pDevice->PSGetShader(&pPixelShader); + if (pPixelShader) { + dumpShader(json, "PS", pPixelShader); + } + + json.endObject(); + json.endMember(); // shaders +} + + void dumpDevice(std::ostream &os, ID3D10Device *pDevice) { JSONWriter json(os); /* TODO */ + json.beginMember("parameters"); + json.beginObject(); + json.endObject(); + json.endMember(); // parameters + + dumpShaders(json, pDevice); + + json.beginMember("textures"); + json.beginObject(); + json.endObject(); + json.endMember(); // textures + + dumpFramebuffer(json, pDevice); } diff --git a/retrace/d3d10state_images.cpp b/retrace/d3d10state_images.cpp index 781f937..fa27fee 100644 --- a/retrace/d3d10state_images.cpp +++ b/retrace/d3d10state_images.cpp @@ -30,7 +30,9 @@ #include #include "image.hpp" +#include "json.hpp" #include "d3d10imports.hpp" +#include "d3dstate.hpp" namespace d3dstate { @@ -95,7 +97,7 @@ stageResource(ID3D10Device *pDevice, Desc.Usage = Usage; Desc.BindFlags = BindFlags; Desc.CPUAccessFlags = CPUAccessFlags; - Desc.MiscFlags &= ~D3D10_RESOURCE_MISC_TEXTURECUBE; + Desc.MiscFlags &= D3D10_RESOURCE_MISC_TEXTURECUBE; *pWidth = Desc.Width; *pHeight = Desc.Height; @@ -179,10 +181,10 @@ unmapResource(ID3D10Resource *pResource, UINT Subresource) { } } -image::Image * -getRenderTargetImage(ID3D10Device *pDevice) { +static image::Image * +getRenderTargetViewImage(ID3D10Device *pDevice, + ID3D10RenderTargetView *pRenderTargetView) { image::Image *image = NULL; - ID3D10RenderTargetView *pRenderTargetView = NULL; D3D10_RENDER_TARGET_VIEW_DESC Desc; ID3D10Resource *pResource = NULL; ID3D10Resource *pStagingResource = NULL; @@ -194,9 +196,8 @@ getRenderTargetImage(ID3D10Device *pDevice) { const unsigned char *src; unsigned char *dst; - pDevice->OMGetRenderTargets(1, &pRenderTargetView, NULL); if (!pRenderTargetView) { - goto no_rendertarget; + return NULL; } pRenderTargetView->GetResource(&pResource); @@ -300,12 +301,55 @@ no_staging: if (pResource) { pResource->Release(); } + return image; +} + + +image::Image * +getRenderTargetImage(ID3D10Device *pDevice) { + ID3D10RenderTargetView *pRenderTargetView = NULL; + pDevice->OMGetRenderTargets(1, &pRenderTargetView, NULL); + + image::Image *image = NULL; if (pRenderTargetView) { + image = getRenderTargetViewImage(pDevice, pRenderTargetView); pRenderTargetView->Release(); } -no_rendertarget: + return image; } +void +dumpFramebuffer(JSONWriter &json, ID3D10Device *pDevice) +{ + json.beginMember("framebuffer"); + json.beginObject(); + + ID3D10RenderTargetView *pRenderTargetViews[D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT]; + pDevice->OMGetRenderTargets(D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT, pRenderTargetViews, NULL); + + for (UINT i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i) { + if (!pRenderTargetViews[i]) { + continue; + } + + image::Image *image; + image = getRenderTargetViewImage(pDevice, pRenderTargetViews[i]); + if (image) { + char label[64]; + _snprintf(label, sizeof label, "RENDER_TARGET_%u", i); + json.beginMember(label); + json.writeImage(image, "UNKNOWN"); + json.endMember(); // RENDER_TARGET_* + } + + pRenderTargetViews[i]->Release(); + } + + json.endObject(); + json.endMember(); // framebuffer +} + + } /* namespace d3dstate */ diff --git a/retrace/d3d11state_images.cpp b/retrace/d3d11state_images.cpp index 6e0d7c9..9c6ff87 100644 --- a/retrace/d3d11state_images.cpp +++ b/retrace/d3d11state_images.cpp @@ -98,7 +98,7 @@ stageResource(ID3D11DeviceContext *pDeviceContext, Desc.Usage = Usage; Desc.BindFlags = BindFlags; Desc.CPUAccessFlags = CPUAccessFlags; - Desc.MiscFlags &= ~D3D11_RESOURCE_MISC_TEXTURECUBE; + Desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE; *pWidth = Desc.Width; *pHeight = Desc.Height; diff --git a/retrace/d3d9retrace.py b/retrace/d3d9retrace.py index 1b89b68..9bc9628 100644 --- a/retrace/d3d9retrace.py +++ b/retrace/d3d9retrace.py @@ -27,23 +27,18 @@ """D3D retracer generator.""" +import sys from dllretrace import DllRetracer as Retracer from specs.stdapi import API -from specs.d3d9 import * class D3DRetracer(Retracer): def retraceApi(self, api): - print '''static d3dretrace::D3DDumper d3d9Dumper;''' - print - print '// Swizzling mapping for lock addresses' print 'static std::map _maps;' print - self.table_name = 'd3dretrace::d3d9_callbacks' - Retracer.retraceApi(self, api) def invokeFunction(self, function): @@ -101,30 +96,59 @@ class D3DRetracer(Retracer): print ' VOID *_pbData = NULL;' print ' size_t _MappedSize = 0;' print ' _getMapInfo(_this, %s, _pbData, _MappedSize);' % ', '.join(method.argNames()[:-1]) - print ' _maps[_this] = _pbData;' + print ' if (_MappedSize) {' + print ' _maps[_this] = _pbData;' + print ' } else {' + print ' return;' + print ' }' if method.name in ('Unlock', 'UnlockRect', 'UnlockBox'): print ' VOID *_pbData = 0;' print ' _pbData = _maps[_this];' print ' if (_pbData) {' print ' retrace::delRegionByPointer(_pbData);' + print ' _maps[_this] = 0;' print ' }' -if __name__ == '__main__': - print r''' -#include - -#include +def main(): + print r'#include ' + print + print r'#include ' + print + print r'#include "d3dretrace.hpp"' + print -#include "d3d9imports.hpp" -#include "d3d9size.hpp" -#include "d3dretrace.hpp" -#include "d3dstate.hpp" - -''' + moduleName = sys.argv[1] + support = int(sys.argv[2]) api = API() - api.addModule(d3d9) + + if support: + if moduleName == 'd3d9': + from specs.d3d9 import d3d9 + print r'#include "d3d9imports.hpp"' + print r'#include "d3d9size.hpp"' + api.addModule(d3d9) + print + print '''static d3dretrace::D3DDumper d3d9Dumper;''' + print + elif moduleName == 'd3d8': + from specs.d3d8 import d3d8 + print r'#include ' + print r'#include ' + print r'#include "d3d8size.hpp"' + api.addModule(d3d8) + print + #print '''static d3dretrace::D3DDumper d3d8Dumper;''' + print + else: + assert False + retracer = D3DRetracer() + retracer.table_name = 'd3dretrace::%s_callbacks' % moduleName retracer.retraceApi(api) + + +if __name__ == '__main__': + main() diff --git a/retrace/d3d9state.cpp b/retrace/d3d9state.cpp index 73746e7..99cb603 100644 --- a/retrace/d3d9state.cpp +++ b/retrace/d3d9state.cpp @@ -29,70 +29,13 @@ #include #include "d3d9imports.hpp" +#include "d3dshader.hpp" #include "json.hpp" namespace d3dstate { -typedef HRESULT -(WINAPI *PD3DXDISASSEMBLESHADER)( - CONST DWORD *pShader, - BOOL EnableColorCode, - LPCSTR pComments, - LPD3DXBUFFER *ppDisassembly -); - - -HRESULT -disassembleShader(const DWORD *tokens, LPD3DXBUFFER *ppDisassembly) -{ - static BOOL firsttime = TRUE; - - /* - * TODO: Consider using d3dcompile_xx.dll per - * http://msdn.microsoft.com/en-us/library/windows/desktop/ee663275.aspx - */ - - static HMODULE hD3DXModule = NULL; - static PD3DXDISASSEMBLESHADER pfnD3DXDisassembleShader = NULL; - - if (firsttime) { - if (!hD3DXModule) { - unsigned release; - int version; - for (release = 0; release <= 1; ++release) { - /* Version 41 corresponds to Mar 2009 version of DirectX Runtime / SDK */ - for (version = 41; version >= 0; --version) { - char filename[256]; - _snprintf(filename, sizeof(filename), - "d3dx9%s%s%u.dll", release ? "" : "d", version ? "_" : "", version); - hD3DXModule = LoadLibraryA(filename); - if (hD3DXModule) - goto found; - } - } -found: - ; - } - - if (hD3DXModule) { - if (!pfnD3DXDisassembleShader) { - pfnD3DXDisassembleShader = (PD3DXDISASSEMBLESHADER)GetProcAddress(hD3DXModule, "D3DXDisassembleShader"); - } - } - - firsttime = FALSE; - } - - if (!pfnD3DXDisassembleShader) { - return E_FAIL; - } - - return pfnD3DXDisassembleShader(tokens, FALSE, NULL, ppDisassembly); -} - - template< class T > inline void dumpShader(JSONWriter &json, const char *name, T *pShader) { @@ -111,9 +54,8 @@ dumpShader(JSONWriter &json, const char *name, T *pShader) { if (pData) { hr = pShader->GetFunction(pData, &SizeOfData); if (SUCCEEDED(hr)) { - LPD3DXBUFFER pDisassembly; - - hr = disassembleShader((const DWORD *)pData, &pDisassembly); + IDisassemblyBuffer *pDisassembly = NULL; + hr = DisassembleShader((const DWORD *)pData, &pDisassembly); if (SUCCEEDED(hr)) { json.beginMember(name); json.writeString((const char *)pDisassembly->GetBufferPointer() /*, pDisassembly->GetBufferSize() */); @@ -125,6 +67,8 @@ dumpShader(JSONWriter &json, const char *name, T *pShader) { free(pData); } } + + pShader->Release(); } static void diff --git a/retrace/d3dcommonretrace.py b/retrace/d3dcommonretrace.py deleted file mode 100644 index 7a64d81..0000000 --- a/retrace/d3dcommonretrace.py +++ /dev/null @@ -1,181 +0,0 @@ -########################################################################## -# -# Copyright 2011 Jose Fonseca -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -"""D3D retracer generator.""" - - -import sys -from dllretrace import DllRetracer as Retracer -from specs.stdapi import API -from specs.dxgi import dxgi -from specs.d3d10 import d3d10 -from specs.d3d10_1 import d3d10_1 -from specs.d3d11 import d3d11 - - -class D3DRetracer(Retracer): - - def retraceApi(self, api): - print '// Swizzling mapping for lock addresses' - print 'static std::map _maps;' - print - - self.table_name = 'd3dretrace::d3d10_callbacks' - - Retracer.retraceApi(self, api) - - createDeviceFunctionNames = [ - "D3D10CreateDevice", - "D3D10CreateDeviceAndSwapChain", - "D3D10CreateDevice1", - "D3D10CreateDeviceAndSwapChain1", - "D3D11CreateDevice", - "D3D11CreateDeviceAndSwapChain", - ] - - def invokeFunction(self, function): - if function.name in self.createDeviceFunctionNames: - # create windows as neccessary - if 'pSwapChainDesc' in function.argNames(): - print r' pSwapChainDesc->OutputWindow = d3dretrace::createWindow(512, 512);' - - # Compensate for the fact we don't trace the software renderer - # module LoadLibrary call - if 'Software' in function.argNames(): - print r' if (Software) {' - print r' retrace::warning(call) << "using WARP for software device\n";' - print r' Software = LoadLibraryA("d3d10warp");' - print r' }' - - # Compensate for the fact we don't trace DXGI object creation - if function.name.startswith('D3D11CreateDevice'): - print r' if (DriverType == D3D_DRIVER_TYPE_UNKNOWN && !pAdapter) {' - print r' DriverType = D3D_DRIVER_TYPE_HARDWARE;' - print r' }' - - Retracer.invokeFunction(self, function) - - - def invokeInterfaceMethod(self, interface, method): - # keep track of the last used device for state dumping - if interface.name in ('ID3D10Device', 'ID3D10Device1'): - if method.name == 'Release': - print r' d3d10Dumper.unbindDevice(_this);' - else: - print r' d3d10Dumper.bindDevice(_this);' - if interface.name in ('ID3D11DeviceContext',): - if method.name == 'Release': - print r' d3d11Dumper.unbindDevice(_this);' - else: - print r' d3d11Dumper.bindDevice(_this);' - - # create windows as neccessary - if method.name == 'CreateSwapChain': - print r' pDesc->OutputWindow = d3dretrace::createWindow(512, 512);' - - # notify frame has been completed - if method.name == 'Present': - print r' retrace::frameComplete(call);' - - if 'pSharedResource' in method.argNames(): - print r' if (pSharedResource) {' - print r' retrace::warning(call) << "shared surfaces unsupported\n";' - print r' pSharedResource = NULL;' - print r' }' - - Retracer.invokeInterfaceMethod(self, interface, method) - - # process events after presents - if method.name == 'Present': - print r' d3dretrace::processEvents();' - - if method.name == 'Map': - print ' VOID *_pbData = NULL;' - print ' size_t _MappedSize = 0;' - print ' _getMapInfo(_this, %s, _pbData, _MappedSize);' % ', '.join(method.argNames()) - print ' if (_MappedSize) {' - print ' _maps[_this] = _pbData;' - print ' } else {' - print ' return;' - print ' }' - - if method.name == 'Unmap': - print ' VOID *_pbData = 0;' - print ' _pbData = _maps[_this];' - print ' if (_pbData) {' - print ' retrace::delRegionByPointer(_pbData);' - print ' _maps[_this] = 0;' - print ' }' - - -def main(): - print r'''#include ''' - print - print r'#include ' - print - print r'#include "d3dretrace.hpp"' - print - - moduleNames = sys.argv[1:] - - api = API() - - if moduleNames: - api.addModule(dxgi) - - if 'd3d10' in moduleNames: - if 'd3d10_1' in moduleNames: - print r'#include "d3d10_1imports.hpp"' - # D3D10CreateBlob is duplicated in d3d10 and d3d10_1 - d3d10_1.functions = [function for function in d3d10_1.functions if function.name != 'D3D10CreateBlob'] - api.addModule(d3d10_1) - else: - print r'#include "d3d10imports.hpp"' - print r'#include "d3d10size.hpp"' - api.addModule(d3d10) - print - print '''static d3dretrace::D3DDumper d3d10Dumper;''' - print - - if 'd3d11' in moduleNames: - print r'#include "d3d11imports.hpp"' - if 'd3d11_1' in moduleNames: - print '#include ' - import specs.d3d11_1 - print r'#include "d3d11size.hpp"' - print r'#include "d3dstate.hpp"' - api.addModule(d3d11) - - print - print '''static d3dretrace::D3DDumper d3d11Dumper;''' - print - - retracer = D3DRetracer() - retracer.retraceApi(api) - - -if __name__ == '__main__': - main() diff --git a/retrace/d3dretrace.hpp b/retrace/d3dretrace.hpp index 144a5c4..41cc1c5 100644 --- a/retrace/d3dretrace.hpp +++ b/retrace/d3dretrace.hpp @@ -36,8 +36,9 @@ namespace d3dretrace { +extern const retrace::Entry d3d8_callbacks[]; extern const retrace::Entry d3d9_callbacks[]; -extern const retrace::Entry d3d10_callbacks[]; +extern const retrace::Entry dxgi_callbacks[]; template< class Device > diff --git a/retrace/d3dretrace_main.cpp b/retrace/d3dretrace_main.cpp index e62b761..3de6daa 100644 --- a/retrace/d3dretrace_main.cpp +++ b/retrace/d3dretrace_main.cpp @@ -41,8 +41,9 @@ retrace::setUp(void) { void retrace::addCallbacks(retrace::Retracer &retracer) { + retracer.addCallbacks(d3dretrace::d3d8_callbacks); retracer.addCallbacks(d3dretrace::d3d9_callbacks); - retracer.addCallbacks(d3dretrace::d3d10_callbacks); + retracer.addCallbacks(d3dretrace::dxgi_callbacks); } diff --git a/retrace/d3dstate.hpp b/retrace/d3dstate.hpp index c21c361..09e82a2 100644 --- a/retrace/d3dstate.hpp +++ b/retrace/d3dstate.hpp @@ -29,12 +29,16 @@ #include +#include + struct IDirect3DDevice9; struct ID3D10Device; struct ID3D11DeviceContext; +class JSONWriter; + namespace image { class Image; } @@ -43,6 +47,9 @@ namespace image { namespace d3dstate { +extern const GUID GUID_D3DSTATE; + + image::Image * getRenderTargetImage(IDirect3DDevice9 *pDevice); @@ -53,6 +60,9 @@ dumpDevice(std::ostream &os, IDirect3DDevice9 *pDevice); image::Image * getRenderTargetImage(ID3D10Device *pDevice); +void +dumpFramebuffer(JSONWriter &json, ID3D10Device *pDevice); + void dumpDevice(std::ostream &os, ID3D10Device *pDevice); diff --git a/retrace/dxgiretrace.py b/retrace/dxgiretrace.py new file mode 100644 index 0000000..a412c3a --- /dev/null +++ b/retrace/dxgiretrace.py @@ -0,0 +1,245 @@ +########################################################################## +# +# Copyright 2011 Jose Fonseca +# All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +##########################################################################/ + + +"""D3D retracer generator.""" + + +import sys +from dllretrace import DllRetracer as Retracer +from specs.stdapi import API +from specs.dxgi import dxgi +from specs.d3d10 import d3d10 +from specs.d3d10_1 import d3d10_1 +from specs.d3d11 import d3d11 + + +class D3DRetracer(Retracer): + + def retraceApi(self, api): + print '// Swizzling mapping for lock addresses' + print 'static std::map _maps;' + print + print r''' +static void +createWindow(DXGI_SWAP_CHAIN_DESC *pSwapChainDesc) { + if (pSwapChainDesc->Windowed) { + UINT Width = pSwapChainDesc->BufferDesc.Width; + UINT Height = pSwapChainDesc->BufferDesc.Height; + if (!Width) Width = 1024; + if (!Height) Height = 768; + pSwapChainDesc->OutputWindow = d3dretrace::createWindow(Width, Height); + } +} +''' + + self.table_name = 'd3dretrace::dxgi_callbacks' + + Retracer.retraceApi(self, api) + + createDeviceFunctionNames = [ + "D3D10CreateDevice", + "D3D10CreateDeviceAndSwapChain", + "D3D10CreateDevice1", + "D3D10CreateDeviceAndSwapChain1", + "D3D11CreateDevice", + "D3D11CreateDeviceAndSwapChain", + ] + + def invokeFunction(self, function): + if function.name in self.createDeviceFunctionNames: + # create windows as neccessary + if 'pSwapChainDesc' in function.argNames(): + print r' createWindow(pSwapChainDesc);' + + # Compensate for the fact we don't trace the software renderer + # module LoadLibrary call + if 'Software' in function.argNames(): + print r' if (Software) {' + print r' retrace::warning(call) << "using WARP for software device\n";' + print r' Software = LoadLibraryA("d3d10warp");' + print r' }' + + # Compensate for the fact we don't trace DXGI object creation + if function.name.startswith('D3D11CreateDevice'): + print r' if (DriverType == D3D_DRIVER_TYPE_UNKNOWN && !pAdapter) {' + print r' DriverType = D3D_DRIVER_TYPE_HARDWARE;' + print r' }' + + if function.name.startswith('D3D10CreateDevice'): + self.forceDriver('D3D10_DRIVER_TYPE') + if function.name.startswith('D3D11CreateDevice'): + self.forceDriver('D3D_DRIVER_TYPE') + + Retracer.invokeFunction(self, function) + + def forceDriver(self, enum): + print r' switch (retrace::driver) {' + print r' case retrace::DRIVER_HARDWARE:' + print r' DriverType = %s_HARDWARE;' % enum + print r' Software = NULL;' + print r' break;' + print r' case retrace::DRIVER_SOFTWARE:' + print r' pAdapter = NULL;' + print r' DriverType = %s_WARP;' % enum + print r' Software = NULL;' + print r' break;' + print r' case retrace::DRIVER_REFERENCE:' + print r' pAdapter = NULL;' + print r' DriverType = %s_REFERENCE;' % enum + print r' Software = NULL;' + print r' break;' + print r' case retrace::DRIVER_NULL:' + print r' pAdapter = NULL;' + print r' DriverType = %s_NULL;' % enum + print r' Software = NULL;' + print r' break;' + print r' case retrace::DRIVER_MODULE:' + print r' pAdapter = NULL;' + print r' DriverType = %s_SOFTWARE;' % enum + print r' Software = LoadLibraryA(retrace::driverModule);' + print r' if (!Software) {' + print r' retrace::warning(call) << "failed to load " << retrace::driverModule << "\n";' + print r' }' + print r' break;' + print r' default:' + print r' assert(0);' + print r' /* fall-through */' + print r' case retrace::DRIVER_DEFAULT:' + print r' if (DriverType == %s_SOFTWARE) {' % enum + print r' Software = LoadLibraryA("d3d10warp");' + print r' if (!Software) {' + print r' retrace::warning(call) << "failed to load d3d10warp.dll\n";' + print r' }' + print r' }' + print r' break;' + print r' }' + + def invokeInterfaceMethod(self, interface, method): + # keep track of the last used device for state dumping + if interface.name in ('ID3D10Device', 'ID3D10Device1'): + if method.name == 'Release': + print r' d3d10Dumper.unbindDevice(_this);' + else: + print r' d3d10Dumper.bindDevice(_this);' + if interface.name in ('ID3D11DeviceContext',): + if method.name == 'Release': + print r' d3d11Dumper.unbindDevice(_this);' + else: + print r' d3d11Dumper.bindDevice(_this);' + + # create windows as neccessary + if method.name == 'CreateSwapChain': + print r' createWindow(pDesc);' + + # notify frame has been completed + if method.name == 'Present': + print r' retrace::frameComplete(call);' + + if 'pSharedResource' in method.argNames(): + print r' if (pSharedResource) {' + print r' retrace::warning(call) << "shared surfaces unsupported\n";' + print r' pSharedResource = NULL;' + print r' }' + + Retracer.invokeInterfaceMethod(self, interface, method) + + # process events after presents + if method.name == 'Present': + print r' d3dretrace::processEvents();' + + if method.name == 'Map': + print ' VOID *_pbData = NULL;' + print ' size_t _MappedSize = 0;' + print ' _getMapInfo(_this, %s, _pbData, _MappedSize);' % ', '.join(method.argNames()) + print ' if (_MappedSize) {' + print ' _maps[_this] = _pbData;' + print ' } else {' + print ' return;' + print ' }' + + if method.name == 'Unmap': + print ' VOID *_pbData = 0;' + print ' _pbData = _maps[_this];' + print ' if (_pbData) {' + print ' retrace::delRegionByPointer(_pbData);' + print ' _maps[_this] = 0;' + print ' }' + + # Attach shader byte code for lookup + if 'pShaderBytecode' in method.argNames(): + ppShader = method.args[-1] + assert ppShader.output + print r' if (retrace::dumpingState && SUCCEEDED(_result)) {' + print r' (*%s)->SetPrivateData(d3dstate::GUID_D3DSTATE, BytecodeLength, pShaderBytecode);' % ppShader.name + print r' }' + + +def main(): + print r'#include ' + print + print r'#include ' + print + print r'#include "d3dretrace.hpp"' + print + + moduleNames = sys.argv[1:] + + api = API() + + if moduleNames: + api.addModule(dxgi) + + if 'd3d10' in moduleNames: + if 'd3d10_1' in moduleNames: + print r'#include "d3d10_1imports.hpp"' + api.addModule(d3d10_1) + else: + print r'#include "d3d10imports.hpp"' + print r'#include "d3d10size.hpp"' + api.addModule(d3d10) + print + print '''static d3dretrace::D3DDumper d3d10Dumper;''' + print + + if 'd3d11' in moduleNames: + print r'#include "d3d11imports.hpp"' + if 'd3d11_1' in moduleNames: + print '#include ' + import specs.d3d11_1 + print r'#include "d3d11size.hpp"' + print r'#include "d3dstate.hpp"' + api.addModule(d3d11) + + print + print '''static d3dretrace::D3DDumper d3d11Dumper;''' + print + + retracer = D3DRetracer() + retracer.retraceApi(api) + + +if __name__ == '__main__': + main() diff --git a/retrace/glstate_images.cpp b/retrace/glstate_images.cpp index e5e1451..7b0a424 100644 --- a/retrace/glstate_images.cpp +++ b/retrace/glstate_images.cpp @@ -24,6 +24,7 @@ **************************************************************************/ +#include #include #include @@ -386,7 +387,6 @@ dumpActiveTextureLevel(JSONWriter &json, Context &context, GLenum target, GLint } char label[512]; - GLint active_texture = GL_TEXTURE0; glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture); snprintf(label, sizeof label, "%s, %s, level = %d", @@ -394,8 +394,6 @@ dumpActiveTextureLevel(JSONWriter &json, Context &context, GLenum target, GLint json.beginMember(label); - json.beginObject(); - GLuint channels; GLenum format; if (!context.ES && isDepthFormat(desc.internalFormat)) { @@ -406,43 +404,23 @@ dumpActiveTextureLevel(JSONWriter &json, Context &context, GLenum target, GLint channels = 4; } - // Tell the GUI this is no ordinary object, but an image - json.writeStringMember("__class__", "image"); - - json.writeIntMember("__width__", desc.width); - json.writeIntMember("__height__", desc.height); - json.writeIntMember("__depth__", desc.depth); - - json.writeStringMember("__format__", formatToString(desc.internalFormat)); - - // Hardcoded for now, but we could chose types more adequate to the - // texture internal format - json.writeStringMember("__type__", "uint8"); - json.writeBoolMember("__normalized__", true); - json.writeIntMember("__channels__", channels); - - GLubyte *pixels = new GLubyte[desc.depth*desc.width*desc.height*channels]; + image::Image *image = new image::Image(desc.width, desc.height*desc.depth, channels, true); context.resetPixelPackState(); if (context.ES) { - getTexImageOES(target, level, desc, pixels); + getTexImageOES(target, level, desc, image->pixels); } else { - glGetTexImage(target, level, format, GL_UNSIGNED_BYTE, pixels); + glGetTexImage(target, level, format, GL_UNSIGNED_BYTE, image->pixels); } context.restorePixelPackState(); - json.beginMember("__data__"); - char *pngBuffer; - int pngBufferSize; - image::writePixelsToBuffer(pixels, desc.width, desc.depth * desc.height, channels, true, &pngBuffer, &pngBufferSize); - json.writeBase64(pngBuffer, pngBufferSize); - free(pngBuffer); - json.endMember(); // __data__ + json.writeImage(image, formatToString(desc.internalFormat), desc.depth); - delete [] pixels; - json.endObject(); + delete image; + + json.endMember(); // label } @@ -854,23 +832,6 @@ dumpReadBufferImage(JSONWriter &json, GLint width, GLint height, GLenum format, Context context; - json.beginObject(); - - // Tell the GUI this is no ordinary object, but an image - json.writeStringMember("__class__", "image"); - - json.writeIntMember("__width__", width); - json.writeIntMember("__height__", height); - json.writeIntMember("__depth__", 1); - - json.writeStringMember("__format__", formatToString(internalFormat)); - - // Hardcoded for now, but we could chose types more adequate to the - // texture internal format - json.writeStringMember("__type__", "uint8"); - json.writeBoolMember("__normalized__", true); - json.writeIntMember("__channels__", channels); - GLenum type = GL_UNSIGNED_BYTE; #if DEPTH_AS_RGBA @@ -880,27 +841,18 @@ dumpReadBufferImage(JSONWriter &json, GLint width, GLint height, GLenum format, } #endif - GLubyte *pixels = new GLubyte[width*height*channels]; + image::Image *image = new image::Image(width, height, channels, true); // TODO: reset imaging state too context.resetPixelPackState(); - glReadPixels(0, 0, width, height, format, type, pixels); + glReadPixels(0, 0, width, height, format, type, image->pixels); context.restorePixelPackState(); - json.beginMember("__data__"); - char *pngBuffer; - int pngBufferSize; - image::writePixelsToBuffer(pixels, width, height, channels, true, &pngBuffer, &pngBufferSize); - //std::cerr <<" Before = "<<(width * height * channels * sizeof *pixels) - // <<", after = "< #include #include diff --git a/retrace/json.cpp b/retrace/json.cpp new file mode 100644 index 0000000..53a61a3 --- /dev/null +++ b/retrace/json.cpp @@ -0,0 +1,331 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +/* + * JSON writing functions. + */ + + +#include +#include + +#include + +#include "image.hpp" +#include "json.hpp" + + +void +JSONWriter::newline(void) { + os << "\n"; + for (int i = 0; i < level; ++i) + os << " "; +} + +void +JSONWriter::separator(void) { + if (value) { + os << ","; + switch (space) { + case '\0': + break; + case '\n': + newline(); + break; + default: + os << space; + break; + } + } else { + if (space == '\n') { + newline(); + } + } +} + +static void +escapeAsciiString(std::ostream &os, const char *str) { + os << "\""; + + const unsigned char *src = (const unsigned char *)str; + unsigned char c; + while ((c = *src++)) { + if ((c == '\"') || + (c == '\\')) { + // escape character + os << '\\' << (unsigned char)c; + } else if ((c >= 0x20 && c <= 0x7e) || + c == '\t' || + c == '\r' || + c == '\n') { + // pass-through character + os << (unsigned char)c; + } else { + assert(0); + os << "?"; + } + } + + os << "\""; +} + +static void +escapeUnicodeString(std::ostream &os, const char *str) { + os << "\""; + + const char *locale = setlocale(LC_CTYPE, ""); + const char *src = str; + mbstate_t state; + + memset(&state, 0, sizeof state); + + do { + // Convert characters one at a time in order to recover from + // conversion errors + wchar_t c; + size_t written = mbsrtowcs(&c, &src, 1, &state); + if (written == 0) { + // completed + break; + } if (written == (size_t)-1) { + // conversion error -- skip + os << "?"; + do { + ++src; + } while (*src & 0x80); + } else if ((c == '\"') || + (c == '\\')) { + // escape character + os << '\\' << (unsigned char)c; + } else if ((c >= 0x20 && c <= 0x7e) || + c == '\t' || + c == '\r' || + c == '\n') { + // pass-through character + os << (unsigned char)c; + } else { + // unicode + os << "\\u" << std::setfill('0') << std::hex << std::setw(4) << (unsigned)c; + os << std::dec; + } + } while (src); + + setlocale(LC_CTYPE, locale); + + os << "\""; +} + +static void +encodeBase64String(std::ostream &os, const unsigned char *bytes, size_t size) { + const char *table64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + unsigned char c0, c1, c2, c3; + char buf[4]; + unsigned written; + + os << "\""; + + written = 0; + while (size >= 3) { + c0 = bytes[0] >> 2; + c1 = ((bytes[0] & 0x03) << 4) | ((bytes[1] & 0xf0) >> 4); + c2 = ((bytes[1] & 0x0f) << 2) | ((bytes[2] & 0xc0) >> 6); + c3 = bytes[2] & 0x3f; + + buf[0] = table64[c0]; + buf[1] = table64[c1]; + buf[2] = table64[c2]; + buf[3] = table64[c3]; + + os.write(buf, 4); + + bytes += 3; + size -= 3; + ++written; + + if (written >= 76/4 && size) { + os << "\n"; + written = 0; + } + } + + if (size > 0) { + c0 = bytes[0] >> 2; + c1 = ((bytes[0] & 0x03) << 4); + buf[2] = '='; + buf[3] = '='; + + if (size > 1) { + c1 |= ((bytes[1] & 0xf0) >> 4); + c2 = ((bytes[1] & 0x0f) << 2); + if (size > 2) { + c2 |= ((bytes[2] & 0xc0) >> 6); + c3 = bytes[2] & 0x3f; + buf[3] = table64[c3]; + } + buf[2] = table64[c2]; + } + buf[1] = table64[c1]; + buf[0] = table64[c0]; + + os.write(buf, 4); + } + + os << "\""; +} + +JSONWriter::JSONWriter(std::ostream &_os) : + os(_os), + level(0), + value(false), + space(0) +{ + beginObject(); +} + +JSONWriter::~JSONWriter() { + endObject(); + newline(); +} + +void +JSONWriter::beginObject() { + separator(); + os << "{"; + ++level; + value = false; +} + +void +JSONWriter::endObject() { + --level; + if (value) + newline(); + os << "}"; + value = true; + space = '\n'; +} + +void +JSONWriter::beginMember(const char * name) { + space = 0; + separator(); + newline(); + escapeAsciiString(os, name); + os << ": "; + value = false; +} + +void +JSONWriter::endMember(void) { + assert(value); + value = true; + space = 0; +} + +void +JSONWriter::beginArray() { + separator(); + os << "["; + ++level; + value = false; + space = 0; +} + +void +JSONWriter::endArray(void) { + --level; + if (space == '\n') { + newline(); + } + os << "]"; + value = true; + space = '\n'; +} + +void +JSONWriter::writeString(const char *s) { + if (!s) { + writeNull(); + return; + } + + separator(); + escapeUnicodeString(os, s); + value = true; + space = ' '; +} + +void +JSONWriter::writeBase64(const void *bytes, size_t size) { + separator(); + encodeBase64String(os, (const unsigned char *)bytes, size); + value = true; + space = ' '; +} + +void +JSONWriter::writeNull(void) { + separator(); + os << "null"; + value = true; + space = ' '; +} + +void +JSONWriter::writeBool(bool b) { + separator(); + os << (b ? "true" : "false"); + value = true; + space = ' '; +} + +void +JSONWriter::writeImage(image::Image *image, const char *format, unsigned depth) +{ + if (!image) { + writeNull(); + return; + } + + beginObject(); + + // Tell the GUI this is no ordinary object, but an image + writeStringMember("__class__", "image"); + + writeIntMember("__width__", image->width); + writeIntMember("__height__", image->height / depth); + writeIntMember("__depth__", depth); + + writeStringMember("__format__", format); + + beginMember("__data__"); + std::stringstream ss; + image->writePNG(ss); + const std::string & s = ss.str(); + writeBase64(s.data(), s.size()); + endMember(); // __data__ + + endObject(); +} diff --git a/retrace/json.hpp b/retrace/json.hpp index 0431cf7..2c555db 100644 --- a/retrace/json.hpp +++ b/retrace/json.hpp @@ -24,13 +24,12 @@ **************************************************************************/ /* - * Trace writing functions. + * JSON writing functions. */ #ifndef _JSON_HPP_ #define _JSON_HPP_ -#include #include #include @@ -48,6 +47,11 @@ #include +namespace image { + class Image; +} + + class JSONWriter { private: @@ -57,277 +61,71 @@ private: bool value; char space; - void newline(void) { - os << "\n"; - for (int i = 0; i < level; ++i) - os << " "; - } - - void separator(void) { - if (value) { - os << ","; - switch (space) { - case '\0': - break; - case '\n': - newline(); - break; - default: - os << space; - break; - } - } else { - if (space == '\n') { - newline(); - } - } - } - - void escapeAsciiString(const char *str) { - os << "\""; - - const unsigned char *src = (const unsigned char *)str; - unsigned char c; - while ((c = *src++)) { - if ((c == '\"') || - (c == '\\')) { - // escape character - os << '\\' << (unsigned char)c; - } else if ((c >= 0x20 && c <= 0x7e) || - c == '\t' || - c == '\r' || - c == '\n') { - // pass-through character - os << (unsigned char)c; - } else { - assert(0); - os << "?"; - } - } - - os << "\""; - } + void + newline(void); - void escapeUnicodeString(const char *str) { - os << "\""; - - const char *locale = setlocale(LC_CTYPE, ""); - const char *src = str; - mbstate_t state; - - memset(&state, 0, sizeof state); - - do { - // Convert characters one at a time in order to recover from - // conversion errors - wchar_t c; - size_t written = mbsrtowcs(&c, &src, 1, &state); - if (written == 0) { - // completed - break; - } if (written == (size_t)-1) { - // conversion error -- skip - os << "?"; - do { - ++src; - } while (*src & 0x80); - } else if ((c == '\"') || - (c == '\\')) { - // escape character - os << '\\' << (unsigned char)c; - } else if ((c >= 0x20 && c <= 0x7e) || - c == '\t' || - c == '\r' || - c == '\n') { - // pass-through character - os << (unsigned char)c; - } else { - // unicode - os << "\\u" << std::setfill('0') << std::hex << std::setw(4) << (unsigned)c; - os << std::dec; - } - } while (src); - - setlocale(LC_CTYPE, locale); - - os << "\""; - } - - void encodeBase64String(const unsigned char *bytes, size_t size) { - const char *table64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - unsigned char c0, c1, c2, c3; - char buf[4]; - unsigned written; - - os << "\""; - - written = 0; - while (size >= 3) { - c0 = bytes[0] >> 2; - c1 = ((bytes[0] & 0x03) << 4) | ((bytes[1] & 0xf0) >> 4); - c2 = ((bytes[1] & 0x0f) << 2) | ((bytes[2] & 0xc0) >> 6); - c3 = bytes[2] & 0x3f; - - buf[0] = table64[c0]; - buf[1] = table64[c1]; - buf[2] = table64[c2]; - buf[3] = table64[c3]; - - os.write(buf, 4); - - bytes += 3; - size -= 3; - ++written; - - if (written >= 76/4 && size) { - os << "\n"; - written = 0; - } - } - - if (size > 0) { - c0 = bytes[0] >> 2; - c1 = ((bytes[0] & 0x03) << 4); - buf[2] = '='; - buf[3] = '='; - - if (size > 1) { - c1 |= ((bytes[1] & 0xf0) >> 4); - c2 = ((bytes[1] & 0x0f) << 2); - if (size > 2) { - c2 |= ((bytes[2] & 0xc0) >> 6); - c3 = bytes[2] & 0x3f; - buf[3] = table64[c3]; - } - buf[2] = table64[c2]; - } - buf[1] = table64[c1]; - buf[0] = table64[c0]; - - os.write(buf, 4); - } - - os << "\""; - } + void + separator(void); public: - JSONWriter(std::ostream &_os) : - os(_os), - level(0), - value(false), - space(0) - { - beginObject(); - } + JSONWriter(std::ostream &_os); - ~JSONWriter() { - endObject(); - newline(); - } + ~JSONWriter(); - inline void beginObject() { - separator(); - os << "{"; - ++level; - value = false; - } + void + beginObject(); - inline void endObject() { - --level; - if (value) - newline(); - os << "}"; - value = true; - space = '\n'; - } + void + endObject(); - inline void beginMember(const char * name) { - space = 0; - separator(); - newline(); - escapeAsciiString(name); - os << ": "; - value = false; - } + void + beginMember(const char * name); - inline void beginMember(const std::string &name) { + inline void + beginMember(const std::string &name) { beginMember(name.c_str()); } - inline void endMember(void) { - assert(value); - value = true; - space = 0; - } + void + endMember(void); - inline void beginArray() { - separator(); - os << "["; - ++level; - value = false; - space = 0; - } - - inline void endArray(void) { - --level; - if (space == '\n') { - newline(); - } - os << "]"; - value = true; - space = '\n'; - } + void + beginArray(); - inline void writeString(const char *s) { - if (!s) { - writeNull(); - return; - } + void + endArray(void); - separator(); - escapeUnicodeString(s); - value = true; - space = ' '; - } + void + writeString(const char *s); - inline void writeString(const std::string &s) { + inline void + writeString(const std::string &s) { writeString(s.c_str()); } - inline void writeBase64(const void *bytes, size_t size) { - separator(); - encodeBase64String((const unsigned char *)bytes, size); - value = true; - space = ' '; - } + void + writeBase64(const void *bytes, size_t size); - inline void writeNull(void) { - separator(); - os << "null"; - value = true; - space = ' '; - } - - inline void writeBool(bool b) { - separator(); - os << (b ? "true" : "false"); - value = true; - space = ' '; - } + void + writeNull(void); + void + writeBool(bool b); /** * Special case for char to prevent it to be written as a literal * character. */ - inline void writeInt(signed char n) { + inline void + writeInt(signed char n) { separator(); os << std::dec << static_cast(n); value = true; space = ' '; } - inline void writeInt(unsigned char n) { + inline void + writeInt(unsigned char n) { separator(); os << std::dec << static_cast(n); value = true; @@ -335,14 +133,17 @@ public: } template - inline void writeInt(T n) { + inline void + writeInt(T n) { separator(); os << std::dec << n; value = true; space = ' '; } + template - inline void writeFloat(T n) { + void + writeFloat(T n) { separator(); if (isnan(n)) { // NaN is non-standard but widely supported @@ -360,24 +161,30 @@ public: space = ' '; } - inline void writeStringMember(const char *name, const char *s) { + inline void + writeStringMember(const char *name, const char *s) { beginMember(name); writeString(s); endMember(); } - inline void writeBoolMember(const char *name, bool b) { + inline void + writeBoolMember(const char *name, bool b) { beginMember(name); writeBool(b); endMember(); } template - inline void writeIntMember(const char *name, T n) { + inline void + writeIntMember(const char *name, T n) { beginMember(name); writeInt(n); endMember(); } + + void + writeImage(image::Image *image, const char *format, unsigned depth = 1); }; #endif /* _JSON_HPP_ */ diff --git a/retrace/retrace.hpp b/retrace/retrace.hpp index ab1ba5c..228c813 100644 --- a/retrace/retrace.hpp +++ b/retrace/retrace.hpp @@ -60,6 +60,7 @@ private: uintptr_t next; public: + inline ScopedAllocator() : next(0) { } @@ -81,21 +82,14 @@ public: return static_cast(&buf[1]); } - template< class T > - inline T * - alloc(size_t n = 1) { - return static_cast(alloc(sizeof(T) * n)); - } - /** * Allocate an array with the same dimensions as the specified value. */ - template< class T > - inline T * - alloc(const trace::Value *value) { + inline void * + alloc(const trace::Value *value, size_t size) { const trace::Array *array = dynamic_cast(value); if (array) { - return alloc(array->size()); + return alloc(array->size() * size); } const trace::Null *null = dynamic_cast(value); if (null) { @@ -158,6 +152,18 @@ extern bool profilingPixelsDrawn; extern bool dumpingState; +enum Driver { + DRIVER_DEFAULT, + DRIVER_HARDWARE, // force hardware + DRIVER_SOFTWARE, + DRIVER_REFERENCE, + DRIVER_NULL, + DRIVER_MODULE, +}; + +extern Driver driver; +extern const char *driverModule; + extern bool doubleBuffer; extern bool coreProfile; diff --git a/retrace/retrace.py b/retrace/retrace.py index 1e39d42..cd5ef1d 100644 --- a/retrace/retrace.py +++ b/retrace/retrace.py @@ -66,10 +66,10 @@ class ValueAllocator(stdapi.Visitor): pass def visitArray(self, array, lvalue, rvalue): - print ' %s = _allocator.alloc<%s>(&%s);' % (lvalue, array.type, rvalue) + print ' %s = static_cast<%s *>(_allocator.alloc(&%s, sizeof *%s));' % (lvalue, array.type, rvalue, lvalue) def visitPointer(self, pointer, lvalue, rvalue): - print ' %s = _allocator.alloc<%s>(&%s);' % (lvalue, pointer.type, rvalue) + print ' %s = static_cast<%s *>(_allocator.alloc(&%s, sizeof *%s));' % (lvalue, pointer.type, rvalue, lvalue) def visitIntPointer(self, pointer, lvalue, rvalue): pass diff --git a/retrace/retrace_main.cpp b/retrace/retrace_main.cpp index 27ff2b4..63d3dab 100644 --- a/retrace/retrace_main.cpp +++ b/retrace/retrace_main.cpp @@ -61,6 +61,9 @@ int verbosity = 0; bool debug = true; bool dumpingState = false; +Driver driver = DRIVER_DEFAULT; +const char *driverModule = NULL; + bool doubleBuffer = true; bool coreProfile = false; @@ -106,6 +109,7 @@ takeSnapshot(unsigned call_no) { image::Image *src = dumper->getSnapshot(); if (!src) { + std::cout << "Failed to get snapshot\n"; return; } @@ -505,6 +509,7 @@ usage(const char *argv0) { " -C, --calls=CALLSET calls to compare (default is every frame)\n" " --core use core profile\n" " --db use a double buffer visual (default)\n" + " --driver=DRIVER force driver type (`hw`, `sw`, `ref`, `null`, or driver module name)\n" " --sb use a single buffer visual\n" " -s, --snapshot-prefix=PREFIX take snapshots; `-` for PNM stdout output\n" " -S, --snapshot=CALLSET calls to snapshot (default is every frame)\n" @@ -516,6 +521,7 @@ usage(const char *argv0) { enum { CORE_OPT = CHAR_MAX + 1, DB_OPT, + DRIVER_OPT, PCPU_OPT, PGPU_OPT, PPD_OPT, @@ -532,6 +538,7 @@ longOptions[] = { {"compare", required_argument, 0, 'c'}, {"core", no_argument, 0, CORE_OPT}, {"db", no_argument, 0, DB_OPT}, + {"driver", required_argument, 0, DRIVER_OPT}, {"dump-state", required_argument, 0, 'D'}, {"help", no_argument, 0, 'h'}, {"pcpu", no_argument, 0, PCPU_OPT}, @@ -545,6 +552,13 @@ longOptions[] = { {0, 0, 0, 0} }; + +static void exceptionCallback(void) +{ + std::cerr << retrace::callNo << ": error: caught an unhandled exception\n"; +} + + extern "C" int main(int argc, char **argv) { @@ -587,6 +601,20 @@ int main(int argc, char **argv) case DB_OPT: retrace::doubleBuffer = true; break; + case DRIVER_OPT: + if (strcasecmp(optarg, "hw") == 0) { + driver = DRIVER_HARDWARE; + } else if (strcasecmp(optarg, "sw") == 0) { + driver = DRIVER_SOFTWARE; + } else if (strcasecmp(optarg, "ref") == 0) { + driver = DRIVER_REFERENCE; + } else if (strcasecmp(optarg, "null") == 0) { + driver = DRIVER_NULL; + } else { + driver = DRIVER_MODULE; + driverModule = optarg; + } + break; case SB_OPT: retrace::doubleBuffer = false; break; @@ -645,6 +673,8 @@ int main(int argc, char **argv) retrace::profiler.setup(retrace::profilingCpuTimes, retrace::profilingGpuTimes, retrace::profilingPixelsDrawn); } + os::setExceptionCallback(exceptionCallback); + for (i = optind; i < argc; ++i) { if (!retrace::parser.open(argv[i])) { return 1; @@ -654,6 +684,8 @@ int main(int argc, char **argv) retrace::parser.close(); } + + os::resetExceptionCallback(); // XXX: X often hangs on XCloseDisplay //retrace::cleanUp(); diff --git a/retrace/retrace_swizzle.cpp b/retrace/retrace_swizzle.cpp index b487de1..2045f6b 100644 --- a/retrace/retrace_swizzle.cpp +++ b/retrace/retrace_swizzle.cpp @@ -259,7 +259,9 @@ addObj(trace::Call &call, trace::Value &value, void *obj) { unsigned long long address = value.toUIntPtr(); if (!address) { - assert(!obj); + if (obj) { + warning(call) << "unexpected non-null object\n"; + } return; } diff --git a/scripts/retracediff.py b/scripts/retracediff.py index d665c76..413ecac 100755 --- a/scripts/retracediff.py +++ b/scripts/retracediff.py @@ -58,6 +58,10 @@ class Setup: cmd = [ options.retrace, ] + args + self.args + if self.env: + for name, value in self.env.iteritems(): + sys.stderr.write('%s=%s ' % (name, value)) + sys.stderr.write(' '.join(cmd) + '\n') try: return subprocess.Popen(cmd, env=self.env, stdout=subprocess.PIPE, stderr=NULL) except OSError, ex: @@ -123,6 +127,9 @@ def read_pnm(stream): def parse_env(optparser, entries): '''Translate a list of NAME=VALUE entries into an environment dictionary.''' + if not entries: + return None + env = os.environ.copy() for entry in entries: try: @@ -147,6 +154,22 @@ def main(): '-r', '--retrace', metavar='PROGRAM', type='string', dest='retrace', default='glretrace', help='retrace command [default: %default]') + optparser.add_option( + '--ref-driver', metavar='DRIVER', + type='string', dest='ref_driver', default=None, + help='force reference driver') + optparser.add_option( + '--src-driver', metavar='DRIVER', + type='string', dest='src_driver', default=None, + help='force source driver') + optparser.add_option( + '--ref-arg', metavar='OPTION', + type='string', action='append', dest='ref_args', default=[], + help='pass argument to reference retrace') + optparser.add_option( + '--src-arg', metavar='OPTION', + type='string', action='append', dest='src_args', default=[], + help='pass argument to source retrace') optparser.add_option( '--ref-env', metavar='NAME=VALUE', type='string', action='append', dest='ref_env', default=[], @@ -177,9 +200,14 @@ def main(): src_env = parse_env(optparser, options.src_env) if not args: optparser.error("incorrect number of arguments") - - ref_setup = Setup(args, ref_env) - src_setup = Setup(args, src_env) + + if options.ref_driver: + options.ref_args.insert(0, '--driver=' + options.ref_driver) + if options.src_driver: + options.src_args.insert(0, '--driver=' + options.src_driver) + + ref_setup = Setup(options.ref_args + args, ref_env) + src_setup = Setup(options.src_args + args, src_env) if options.output: output = open(options.output, 'wt') diff --git a/specs/d3d.py b/specs/d3d.py index 1206300..61c8d04 100644 --- a/specs/d3d.py +++ b/specs/d3d.py @@ -335,12 +335,12 @@ IDirect3DDevice7.methods += [ StdMethod(HRESULT, "BeginStateBlock", []), StdMethod(HRESULT, "EndStateBlock", [Out(LPDWORD, "lpdwBlockHandle")]), StdMethod(HRESULT, "PreLoad", [(LPDIRECTDRAWSURFACE7, "lpddsTexture")]), - StdMethod(HRESULT, "DrawPrimitive", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (DWORD, "d3dvtVertexType"), (LPVOID, "lpvVertices"), (DWORD, "dwVertexCount"), (DWORD, "dwFlags")]), - StdMethod(HRESULT, "DrawIndexedPrimitive", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (DWORD, "d3dvtVertexType"), (LPVOID, "lpvVertices"), (DWORD, "dwVertexCount"), (LPWORD, "dwIndices"), (DWORD, "dwIndexCount"), (DWORD, "dwFlags")]), + StdMethod(HRESULT, "DrawPrimitive", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (D3DFVF, "d3dvtVertexType"), (LPVOID, "lpvVertices"), (DWORD, "dwVertexCount"), (DWORD, "dwFlags")]), + StdMethod(HRESULT, "DrawIndexedPrimitive", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (D3DFVF, "d3dvtVertexType"), (LPVOID, "lpvVertices"), (DWORD, "dwVertexCount"), (LPWORD, "dwIndices"), (DWORD, "dwIndexCount"), (DWORD, "dwFlags")]), StdMethod(HRESULT, "SetClipStatus", [(LPD3DCLIPSTATUS, "lpD3DClipStatus")]), StdMethod(HRESULT, "GetClipStatus", [Out(LPD3DCLIPSTATUS, "lpD3DClipStatus")]), - StdMethod(HRESULT, "DrawPrimitiveStrided", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (DWORD, "dwVertexType"), (LPD3DDRAWPRIMITIVESTRIDEDDATA, "lpD3DDrawPrimStrideData"), (DWORD, "dwVertexCount"), (DWORD, "dwFlags")]), - StdMethod(HRESULT, "DrawIndexedPrimitiveStrided", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (DWORD, "dwVertexType"), (LPD3DDRAWPRIMITIVESTRIDEDDATA, "lpD3DDrawPrimStrideData"), (DWORD, "dwVertexCount"), (LPWORD, "lpIndex"), (DWORD, "dwIndexCount"), (DWORD, "dwFlags")]), + StdMethod(HRESULT, "DrawPrimitiveStrided", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (D3DFVF, "dwVertexType"), (LPD3DDRAWPRIMITIVESTRIDEDDATA, "lpD3DDrawPrimStrideData"), (DWORD, "dwVertexCount"), (DWORD, "dwFlags")]), + StdMethod(HRESULT, "DrawIndexedPrimitiveStrided", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (D3DFVF, "dwVertexType"), (LPD3DDRAWPRIMITIVESTRIDEDDATA, "lpD3DDrawPrimStrideData"), (DWORD, "dwVertexCount"), (LPWORD, "lpIndex"), (DWORD, "dwIndexCount"), (DWORD, "dwFlags")]), StdMethod(HRESULT, "DrawPrimitiveVB", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (LPDIRECT3DVERTEXBUFFER7, "lpD3DVertexBuf"), (DWORD, "dwStartVertex"), (DWORD, "dwNumVertices"), (DWORD, "dwFlags")]), StdMethod(HRESULT, "DrawIndexedPrimitiveVB", [(D3DPRIMITIVETYPE, "d3dptPrimitiveType"), (LPDIRECT3DVERTEXBUFFER7, "lpD3DVertexBuf"), (DWORD, "dwStartVertex"), (DWORD, "dwNumVertices"), (LPWORD, "lpwIndices"), (DWORD, "dwIndexCount"), (DWORD, "dwFlags")]), StdMethod(HRESULT, "ComputeSphereVisibility", [(LPD3DVECTOR, "lpCenters"), (LPD3DVALUE, "lpRadii"), (DWORD, "dwNumSpheres"), (DWORD, "dwFlags"), (LPDWORD, "lpdwReturnValues")]), diff --git a/specs/d3d10.py b/specs/d3d10.py index 167e491..0bf2348 100644 --- a/specs/d3d10.py +++ b/specs/d3d10.py @@ -914,5 +914,3 @@ d3d10 = Module("d3d10") from d3d10sdklayers import * import d3d10misc -import d3d10shader -import d3d10effect diff --git a/specs/d3d10_1.py b/specs/d3d10_1.py index b107e56..2d549cf 100644 --- a/specs/d3d10_1.py +++ b/specs/d3d10_1.py @@ -106,7 +106,6 @@ d3d10_1 = Module("d3d10_1") d3d10_1.addFunctions([ StdFunction(HRESULT, "D3D10CreateDevice1", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (D3D10_FEATURE_LEVEL1, "HardwareLevel"), (UINT, "SDKVersion"), Out(Pointer(ObjPointer(ID3D10Device1)), "ppDevice")]), StdFunction(HRESULT, "D3D10CreateDeviceAndSwapChain1", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (D3D10_FEATURE_LEVEL1, "HardwareLevel"), (UINT, "SDKVersion"), (Pointer(DXGI_SWAP_CHAIN_DESC), "pSwapChainDesc"), Out(Pointer(ObjPointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(ObjPointer(ID3D10Device1)), "ppDevice")]), - StdFunction(HRESULT, "D3D10CreateBlob", [(SIZE_T, "NumBytes"), Out(Pointer(LPD3D10BLOB), "ppBuffer")]), ]) d3d10_1.addInterfaces([ diff --git a/specs/d3d10effect.py b/specs/d3d10effect.py deleted file mode 100644 index d88cdcd..0000000 --- a/specs/d3d10effect.py +++ /dev/null @@ -1,384 +0,0 @@ -########################################################################## -# -# Copyright 2012 Jose Fonseca -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -from d3d10 import * - -from d3d10shader import * - - -ID3D10StateBlock = Interface("ID3D10StateBlock", IUnknown) -ID3D10EffectType = Interface("ID3D10EffectType") -ID3D10EffectVariable = Interface("ID3D10EffectVariable") -ID3D10EffectScalarVariable = Interface("ID3D10EffectScalarVariable", ID3D10EffectVariable) -ID3D10EffectVectorVariable = Interface("ID3D10EffectVectorVariable", ID3D10EffectVariable) -ID3D10EffectMatrixVariable = Interface("ID3D10EffectMatrixVariable", ID3D10EffectVariable) -ID3D10EffectStringVariable = Interface("ID3D10EffectStringVariable", ID3D10EffectVariable) -ID3D10EffectShaderResourceVariable = Interface("ID3D10EffectShaderResourceVariable", ID3D10EffectVariable) -ID3D10EffectRenderTargetViewVariable = Interface("ID3D10EffectRenderTargetViewVariable", ID3D10EffectVariable) -ID3D10EffectDepthStencilViewVariable = Interface("ID3D10EffectDepthStencilViewVariable", ID3D10EffectVariable) -ID3D10EffectConstantBuffer = Interface("ID3D10EffectConstantBuffer", ID3D10EffectVariable) -ID3D10EffectShaderVariable = Interface("ID3D10EffectShaderVariable", ID3D10EffectVariable) -ID3D10EffectBlendVariable = Interface("ID3D10EffectBlendVariable", ID3D10EffectVariable) -ID3D10EffectDepthStencilVariable = Interface("ID3D10EffectDepthStencilVariable", ID3D10EffectVariable) -ID3D10EffectRasterizerVariable = Interface("ID3D10EffectRasterizerVariable", ID3D10EffectVariable) -ID3D10EffectSamplerVariable = Interface("ID3D10EffectSamplerVariable", ID3D10EffectVariable) -ID3D10EffectPass = Interface("ID3D10EffectPass") -ID3D10EffectTechnique = Interface("ID3D10EffectTechnique") -ID3D10Effect = Interface("ID3D10Effect", IUnknown) -ID3D10EffectPool = Interface("ID3D10EffectPool", IUnknown) - - -D3D10_DEVICE_STATE_TYPES = Enum("D3D10_DEVICE_STATE_TYPES", [ - "D3D10_DST_SO_BUFFERS", - "D3D10_DST_OM_RENDER_TARGETS", - "D3D10_DST_OM_DEPTH_STENCIL_STATE", - "D3D10_DST_OM_BLEND_STATE", - "D3D10_DST_VS", - "D3D10_DST_VS_SAMPLERS", - "D3D10_DST_VS_SHADER_RESOURCES", - "D3D10_DST_VS_CONSTANT_BUFFERS", - "D3D10_DST_GS", - "D3D10_DST_GS_SAMPLERS", - "D3D10_DST_GS_SHADER_RESOURCES", - "D3D10_DST_GS_CONSTANT_BUFFERS", - "D3D10_DST_PS", - "D3D10_DST_PS_SAMPLERS", - "D3D10_DST_PS_SHADER_RESOURCES", - "D3D10_DST_PS_CONSTANT_BUFFERS", - "D3D10_DST_IA_VERTEX_BUFFERS", - "D3D10_DST_IA_INDEX_BUFFER", - "D3D10_DST_IA_INPUT_LAYOUT", - "D3D10_DST_IA_PRIMITIVE_TOPOLOGY", - "D3D10_DST_RS_VIEWPORTS", - "D3D10_DST_RS_SCISSOR_RECTS", - "D3D10_DST_RS_RASTERIZER_STATE", - "D3D10_DST_PREDICATION", -]) - -D3D10_STATE_BLOCK_MASK = Struct("D3D10_STATE_BLOCK_MASK", [ - (BYTE, "VS"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)"), "VSSamplers"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)"), "VSShaderResources"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)"), "VSConstantBuffers"), - (BYTE, "GS"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)"), "GSSamplers"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)"), "GSShaderResources"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)"), "GSConstantBuffers"), - (BYTE, "PS"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT)"), "PSSamplers"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT)"), "PSShaderResources"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT)"), "PSConstantBuffers"), - (Array(BYTE, "D3D10_BYTES_FROM_BITS(D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT)"), "IAVertexBuffers"), - (BYTE, "IAIndexBuffer"), - (BYTE, "IAInputLayout"), - (BYTE, "IAPrimitiveTopology"), - (BYTE, "OMRenderTargets"), - (BYTE, "OMDepthStencilState"), - (BYTE, "OMBlendState"), - (BYTE, "RSViewports"), - (BYTE, "RSScissorRects"), - (BYTE, "RSRasterizerState"), - (BYTE, "SOBuffers"), - (BYTE, "Predication"), -]) - -ID3D10StateBlock.methods += [ - StdMethod(HRESULT, "Capture", []), - StdMethod(HRESULT, "Apply", []), - StdMethod(HRESULT, "ReleaseAllDeviceObjects", []), - StdMethod(HRESULT, "GetDevice", [Out(Pointer(ObjPointer(ID3D10Device)), "ppDevice")]), -] - -D3D10_EFFECT = Flags(UINT, [ - "D3D10_EFFECT_COMPILE_CHILD_EFFECT", - "D3D10_EFFECT_COMPILE_ALLOW_SLOW_OPS", - "D3D10_EFFECT_SINGLE_THREADED", - "D3D10_EFFECT_VARIABLE_POOLED", - "D3D10_EFFECT_VARIABLE_ANNOTATION", - "D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT", -]) - -D3D10_EFFECT_TYPE_DESC = Struct("D3D10_EFFECT_TYPE_DESC", [ - (LPCSTR, "TypeName"), - (D3D10_SHADER_VARIABLE_CLASS, "Class"), - (D3D10_SHADER_VARIABLE_TYPE, "Type"), - (UINT, "Elements"), - (UINT, "Members"), - (UINT, "Rows"), - (UINT, "Columns"), - (UINT, "PackedSize"), - (UINT, "UnpackedSize"), - (UINT, "Stride"), -]) - -ID3D10EffectType.methods += [ - StdMethod(BOOL, "IsValid", []), - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_EFFECT_TYPE_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10EffectType), "GetMemberTypeByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectType), "GetMemberTypeByName", [(LPCSTR, "Name")]), - StdMethod(ObjPointer(ID3D10EffectType), "GetMemberTypeBySemantic", [(LPCSTR, "Semantic")]), - StdMethod(LPCSTR, "GetMemberName", [(UINT, "Index")]), - StdMethod(LPCSTR, "GetMemberSemantic", [(UINT, "Index")]), -] - -D3D10_EFFECT_VARIABLE_DESC = Struct("D3D10_EFFECT_VARIABLE_DESC", [ - (LPCSTR, "Name"), - (LPCSTR, "Semantic"), - (UINT, "Flags"), - (UINT, "Annotations"), - (UINT, "BufferOffset"), - (UINT, "ExplicitBindPoint"), -]) - -ID3D10EffectVariable.methods += [ - StdMethod(BOOL, "IsValid", []), - StdMethod(ObjPointer(ID3D10EffectType), "GetType", []), - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_EFFECT_VARIABLE_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetAnnotationByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetAnnotationByName", [(LPCSTR, "Name")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetMemberByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetMemberByName", [(LPCSTR, "Name")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetMemberBySemantic", [(LPCSTR, "Semantic")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetElement", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectConstantBuffer), "GetParentConstantBuffer", []), - StdMethod(ObjPointer(ID3D10EffectScalarVariable), "AsScalar", []), - StdMethod(ObjPointer(ID3D10EffectVectorVariable), "AsVector", []), - StdMethod(ObjPointer(ID3D10EffectMatrixVariable), "AsMatrix", []), - StdMethod(ObjPointer(ID3D10EffectStringVariable), "AsString", []), - StdMethod(ObjPointer(ID3D10EffectShaderResourceVariable), "AsShaderResource", []), - StdMethod(ObjPointer(ID3D10EffectRenderTargetViewVariable), "AsRenderTargetView", []), - StdMethod(ObjPointer(ID3D10EffectDepthStencilViewVariable), "AsDepthStencilView", []), - StdMethod(ObjPointer(ID3D10EffectConstantBuffer), "AsConstantBuffer", []), - StdMethod(ObjPointer(ID3D10EffectShaderVariable), "AsShader", []), - StdMethod(ObjPointer(ID3D10EffectBlendVariable), "AsBlend", []), - StdMethod(ObjPointer(ID3D10EffectDepthStencilVariable), "AsDepthStencil", []), - StdMethod(ObjPointer(ID3D10EffectRasterizerVariable), "AsRasterizer", []), - StdMethod(ObjPointer(ID3D10EffectSamplerVariable), "AsSampler", []), - StdMethod(HRESULT, "SetRawValue", [(Blob(Void, "ByteCount"), "pData"), (UINT, "Offset"), (UINT, "ByteCount")]), - StdMethod(HRESULT, "GetRawValue", [Out(OpaqueBlob(Void, "ByteCount"), "pData"), (UINT, "Offset"), (UINT, "ByteCount")], sideeffects=False), -] - -ID3D10EffectScalarVariable.methods += [ - StdMethod(HRESULT, "SetFloat", [(Float, "Value")]), - StdMethod(HRESULT, "GetFloat", [Out(Pointer(Float), "pValue")]), - StdMethod(HRESULT, "SetFloatArray", [(Pointer(Float), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetFloatArray", [Out(Pointer(Float), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "SetInt", [(Int, "Value")]), - StdMethod(HRESULT, "GetInt", [Out(Pointer(Int), "pValue")]), - StdMethod(HRESULT, "SetIntArray", [(Pointer(Int), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetIntArray", [Out(Pointer(Int), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "SetBool", [(BOOL, "Value")]), - StdMethod(HRESULT, "GetBool", [Out(Pointer(BOOL), "pValue")]), - StdMethod(HRESULT, "SetBoolArray", [(Pointer(BOOL), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetBoolArray", [Out(Pointer(BOOL), "pData"), (UINT, "Offset"), (UINT, "Count")]), -] - -ID3D10EffectVectorVariable.methods += [ - StdMethod(HRESULT, "SetBoolVector", [(Pointer(BOOL), "pData")]), - StdMethod(HRESULT, "SetIntVector", [(Pointer(Int), "pData")]), - StdMethod(HRESULT, "SetFloatVector", [(Pointer(Float), "pData")]), - StdMethod(HRESULT, "GetBoolVector", [Out(Pointer(BOOL), "pData")]), - StdMethod(HRESULT, "GetIntVector", [Out(Pointer(Int), "pData")]), - StdMethod(HRESULT, "GetFloatVector", [Out(Pointer(Float), "pData")]), - StdMethod(HRESULT, "SetBoolVectorArray", [(Pointer(BOOL), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "SetIntVectorArray", [(Pointer(Int), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "SetFloatVectorArray", [(Pointer(Float), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetBoolVectorArray", [Out(Pointer(BOOL), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetIntVectorArray", [Out(Pointer(Int), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetFloatVectorArray", [Out(Pointer(Float), "pData"), (UINT, "Offset"), (UINT, "Count")]), -] - -ID3D10EffectMatrixVariable.methods += [ - StdMethod(HRESULT, "SetMatrix", [(Pointer(Float), "pData")]), - StdMethod(HRESULT, "GetMatrix", [Out(Pointer(Float), "pData")]), - StdMethod(HRESULT, "SetMatrixArray", [(Pointer(Float), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetMatrixArray", [Out(Pointer(Float), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "SetMatrixTranspose", [(Pointer(Float), "pData")]), - StdMethod(HRESULT, "GetMatrixTranspose", [Out(Pointer(Float), "pData")]), - StdMethod(HRESULT, "SetMatrixTransposeArray", [(Pointer(Float), "pData"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetMatrixTransposeArray", [Out(Pointer(Float), "pData"), (UINT, "Offset"), (UINT, "Count")]), -] - -ID3D10EffectStringVariable.methods += [ - StdMethod(HRESULT, "GetString", [Out(Pointer(LPCSTR), "ppString")]), - StdMethod(HRESULT, "GetStringArray", [Out(Pointer(LPCSTR), "ppStrings"), (UINT, "Offset"), (UINT, "Count")]), -] - -ID3D10EffectShaderResourceVariable.methods += [ - StdMethod(HRESULT, "SetResource", [(ObjPointer(ID3D10ShaderResourceView), "pResource")]), - StdMethod(HRESULT, "GetResource", [Out(Pointer(ObjPointer(ID3D10ShaderResourceView)), "ppResource")]), - StdMethod(HRESULT, "SetResourceArray", [(Pointer(ObjPointer(ID3D10ShaderResourceView)), "ppResources"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetResourceArray", [Out(Pointer(ObjPointer(ID3D10ShaderResourceView)), "ppResources"), (UINT, "Offset"), (UINT, "Count")]), -] - -ID3D10EffectRenderTargetViewVariable.methods += [ - StdMethod(HRESULT, "SetRenderTarget", [(ObjPointer(ID3D10RenderTargetView), "pResource")]), - StdMethod(HRESULT, "GetRenderTarget", [Out(Pointer(ObjPointer(ID3D10RenderTargetView)), "ppResource")]), - StdMethod(HRESULT, "SetRenderTargetArray", [(Pointer(ObjPointer(ID3D10RenderTargetView)), "ppResources"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetRenderTargetArray", [Out(Pointer(ObjPointer(ID3D10RenderTargetView)), "ppResources"), (UINT, "Offset"), (UINT, "Count")]), -] - -ID3D10EffectDepthStencilViewVariable.methods += [ - StdMethod(HRESULT, "SetDepthStencil", [(ObjPointer(ID3D10DepthStencilView), "pResource")]), - StdMethod(HRESULT, "GetDepthStencil", [Out(Pointer(ObjPointer(ID3D10DepthStencilView)), "ppResource")]), - StdMethod(HRESULT, "SetDepthStencilArray", [(Pointer(ObjPointer(ID3D10DepthStencilView)), "ppResources"), (UINT, "Offset"), (UINT, "Count")]), - StdMethod(HRESULT, "GetDepthStencilArray", [Out(Pointer(ObjPointer(ID3D10DepthStencilView)), "ppResources"), (UINT, "Offset"), (UINT, "Count")]), -] - -ID3D10EffectConstantBuffer.methods += [ - StdMethod(HRESULT, "SetConstantBuffer", [(ObjPointer(ID3D10Buffer), "pConstantBuffer")]), - StdMethod(HRESULT, "GetConstantBuffer", [Out(Pointer(ObjPointer(ID3D10Buffer)), "ppConstantBuffer")]), - StdMethod(HRESULT, "SetTextureBuffer", [(ObjPointer(ID3D10ShaderResourceView), "pTextureBuffer")]), - StdMethod(HRESULT, "GetTextureBuffer", [Out(Pointer(ObjPointer(ID3D10ShaderResourceView)), "ppTextureBuffer")]), -] - -D3D10_EFFECT_SHADER_DESC = Struct("D3D10_EFFECT_SHADER_DESC", [ - (Pointer(Const(BYTE)), "pInputSignature"), - (BOOL, "IsInline"), - (Pointer(Const(BYTE)), "pBytecode"), - (UINT, "BytecodeLength"), - (LPCSTR, "SODecl"), - (UINT, "NumInputSignatureEntries"), - (UINT, "NumOutputSignatureEntries"), -]) - -ID3D10EffectShaderVariable.methods += [ - StdMethod(HRESULT, "GetShaderDesc", [(UINT, "ShaderIndex"), Out(Pointer(D3D10_EFFECT_SHADER_DESC), "pDesc")]), - StdMethod(HRESULT, "GetVertexShader", [(UINT, "ShaderIndex"), Out(Pointer(ObjPointer(ID3D10VertexShader)), "ppVS")]), - StdMethod(HRESULT, "GetGeometryShader", [(UINT, "ShaderIndex"), Out(Pointer(ObjPointer(ID3D10GeometryShader)), "ppGS")]), - StdMethod(HRESULT, "GetPixelShader", [(UINT, "ShaderIndex"), Out(Pointer(ObjPointer(ID3D10PixelShader)), "ppPS")]), - StdMethod(HRESULT, "GetInputSignatureElementDesc", [(UINT, "ShaderIndex"), (UINT, "Element"), Out(Pointer(D3D10_SIGNATURE_PARAMETER_DESC), "pDesc")]), - StdMethod(HRESULT, "GetOutputSignatureElementDesc", [(UINT, "ShaderIndex"), (UINT, "Element"), Out(Pointer(D3D10_SIGNATURE_PARAMETER_DESC), "pDesc")]), -] - -ID3D10EffectBlendVariable.methods += [ - StdMethod(HRESULT, "GetBlendState", [(UINT, "Index"), Out(Pointer(ObjPointer(ID3D10BlendState)), "ppBlendState")]), - StdMethod(HRESULT, "GetBackingStore", [(UINT, "Index"), Out(Pointer(D3D10_BLEND_DESC), "pBlendDesc")]), -] - -ID3D10EffectDepthStencilVariable.methods += [ - StdMethod(HRESULT, "GetDepthStencilState", [(UINT, "Index"), Out(Pointer(ObjPointer(ID3D10DepthStencilState)), "ppDepthStencilState")]), - StdMethod(HRESULT, "GetBackingStore", [(UINT, "Index"), Out(Pointer(D3D10_DEPTH_STENCIL_DESC), "pDepthStencilDesc")]), -] - -ID3D10EffectRasterizerVariable.methods += [ - StdMethod(HRESULT, "GetRasterizerState", [(UINT, "Index"), Out(Pointer(ObjPointer(ID3D10RasterizerState)), "ppRasterizerState")]), - StdMethod(HRESULT, "GetBackingStore", [(UINT, "Index"), Out(Pointer(D3D10_RASTERIZER_DESC), "pRasterizerDesc")]), -] - -ID3D10EffectSamplerVariable.methods += [ - StdMethod(HRESULT, "GetSampler", [(UINT, "Index"), Out(Pointer(ObjPointer(ID3D10SamplerState)), "ppSampler")]), - StdMethod(HRESULT, "GetBackingStore", [(UINT, "Index"), Out(Pointer(D3D10_SAMPLER_DESC), "pSamplerDesc")]), -] - -D3D10_PASS_DESC = Struct("D3D10_PASS_DESC", [ - (LPCSTR, "Name"), - (UINT, "Annotations"), - (Pointer(BYTE), "pIAInputSignature"), - (SIZE_T, "IAInputSignatureSize"), - (UINT, "StencilRef"), - (UINT, "SampleMask"), - (Array(FLOAT, 4), "BlendFactor"), -]) - -D3D10_PASS_SHADER_DESC = Struct("D3D10_PASS_SHADER_DESC", [ - (ObjPointer(ID3D10EffectShaderVariable), "pShaderVariable"), - (UINT, "ShaderIndex"), -]) - -ID3D10EffectPass.methods += [ - StdMethod(BOOL, "IsValid", []), - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_PASS_DESC), "pDesc")]), - StdMethod(HRESULT, "GetVertexShaderDesc", [Out(Pointer(D3D10_PASS_SHADER_DESC), "pDesc")]), - StdMethod(HRESULT, "GetGeometryShaderDesc", [Out(Pointer(D3D10_PASS_SHADER_DESC), "pDesc")]), - StdMethod(HRESULT, "GetPixelShaderDesc", [Out(Pointer(D3D10_PASS_SHADER_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetAnnotationByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetAnnotationByName", [(LPCSTR, "Name")]), - StdMethod(HRESULT, "Apply", [(UINT, "Flags")]), - StdMethod(HRESULT, "ComputeStateBlockMask", [Out(Pointer(D3D10_STATE_BLOCK_MASK), "pStateBlockMask")]), -] - -D3D10_TECHNIQUE_DESC = Struct("D3D10_TECHNIQUE_DESC", [ - (LPCSTR, "Name"), - (UINT, "Passes"), - (UINT, "Annotations"), -]) - -ID3D10EffectTechnique.methods += [ - StdMethod(BOOL, "IsValid", []), - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_TECHNIQUE_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetAnnotationByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetAnnotationByName", [(LPCSTR, "Name")]), - StdMethod(ObjPointer(ID3D10EffectPass), "GetPassByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectPass), "GetPassByName", [(LPCSTR, "Name")]), - StdMethod(HRESULT, "ComputeStateBlockMask", [Out(Pointer(D3D10_STATE_BLOCK_MASK), "pStateBlockMask")]), -] - -D3D10_EFFECT_DESC = Struct("D3D10_EFFECT_DESC", [ - (BOOL, "IsChildEffect"), - (UINT, "ConstantBuffers"), - (UINT, "SharedConstantBuffers"), - (UINT, "GlobalVariables"), - (UINT, "SharedGlobalVariables"), - (UINT, "Techniques"), -]) - -ID3D10Effect.methods += [ - StdMethod(BOOL, "IsValid", []), - StdMethod(BOOL, "IsPool", []), - StdMethod(HRESULT, "GetDevice", [Out(Pointer(ObjPointer(ID3D10Device)), "ppDevice")]), - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_EFFECT_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10EffectConstantBuffer), "GetConstantBufferByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectConstantBuffer), "GetConstantBufferByName", [(LPCSTR, "Name")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetVariableByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetVariableByName", [(LPCSTR, "Name")]), - StdMethod(ObjPointer(ID3D10EffectVariable), "GetVariableBySemantic", [(LPCSTR, "Semantic")]), - StdMethod(ObjPointer(ID3D10EffectTechnique), "GetTechniqueByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10EffectTechnique), "GetTechniqueByName", [(LPCSTR, "Name")]), - StdMethod(HRESULT, "Optimize", []), - StdMethod(BOOL, "IsOptimized", []), -] - -ID3D10EffectPool.methods += [ - StdMethod(ObjPointer(ID3D10Effect), "AsEffect", []), -] - - -d3d10.addFunctions([ - StdFunction(HRESULT, "D3D10StateBlockMaskUnion", [(Pointer(D3D10_STATE_BLOCK_MASK), "pA"), (Pointer(D3D10_STATE_BLOCK_MASK), "pB"), Out(Pointer(D3D10_STATE_BLOCK_MASK), "pResult")]), - StdFunction(HRESULT, "D3D10StateBlockMaskIntersect", [(Pointer(D3D10_STATE_BLOCK_MASK), "pA"), (Pointer(D3D10_STATE_BLOCK_MASK), "pB"), Out(Pointer(D3D10_STATE_BLOCK_MASK), "pResult")]), - StdFunction(HRESULT, "D3D10StateBlockMaskDifference", [(Pointer(D3D10_STATE_BLOCK_MASK), "pA"), (Pointer(D3D10_STATE_BLOCK_MASK), "pB"), Out(Pointer(D3D10_STATE_BLOCK_MASK), "pResult")]), - StdFunction(HRESULT, "D3D10StateBlockMaskEnableCapture", [Out(Pointer(D3D10_STATE_BLOCK_MASK), "pMask"), (D3D10_DEVICE_STATE_TYPES, "StateType"), (UINT, "RangeStart"), (UINT, "RangeLength")]), - StdFunction(HRESULT, "D3D10StateBlockMaskDisableCapture", [Out(Pointer(D3D10_STATE_BLOCK_MASK), "pMask"), (D3D10_DEVICE_STATE_TYPES, "StateType"), (UINT, "RangeStart"), (UINT, "RangeLength")]), - StdFunction(HRESULT, "D3D10StateBlockMaskEnableAll", [Out(Pointer(D3D10_STATE_BLOCK_MASK), "pMask")]), - StdFunction(HRESULT, "D3D10StateBlockMaskDisableAll", [Out(Pointer(D3D10_STATE_BLOCK_MASK), "pMask")]), - StdFunction(BOOL, "D3D10StateBlockMaskGetSetting", [(Pointer(D3D10_STATE_BLOCK_MASK), "pMask"), (D3D10_DEVICE_STATE_TYPES, "StateType"), (UINT, "Entry")]), - StdFunction(HRESULT, "D3D10CreateStateBlock", [(ObjPointer(ID3D10Device), "pDevice"), (Pointer(D3D10_STATE_BLOCK_MASK), "pStateBlockMask"), Out(Pointer(ObjPointer(ID3D10StateBlock)), "ppStateBlock")]), - StdFunction(HRESULT, "D3D10CompileEffectFromMemory", [(Blob(Void, "DataLength"), "pData"), (SIZE_T, "DataLength"), (LPCSTR, "pSrcFileName"), (Pointer(Const(D3D10_SHADER_MACRO)), "pDefines"), (LPD3D10INCLUDE, "pInclude"), (UINT, "HLSLFlags"), (UINT, "FXFlags"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppCompiledEffect"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppErrors")]), - StdFunction(HRESULT, "D3D10CreateEffectFromMemory", [(Blob(Void, "DataLength"), "pData"), (SIZE_T, "DataLength"), (UINT, "FXFlags"), (ObjPointer(ID3D10Device), "pDevice"), (ObjPointer(ID3D10EffectPool), "pEffectPool"), Out(Pointer(ObjPointer(ID3D10Effect)), "ppEffect")]), - StdFunction(HRESULT, "D3D10CreateEffectPoolFromMemory", [(Blob(Void, "DataLength"), "pData"), (SIZE_T, "DataLength"), (UINT, "FXFlags"), (ObjPointer(ID3D10Device), "pDevice"), Out(Pointer(ObjPointer(ID3D10EffectPool)), "ppEffectPool")]), - StdFunction(HRESULT, "D3D10DisassembleEffect", [(ObjPointer(ID3D10Effect), "pEffect"), (BOOL, "EnableColorCode"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppDisassembly")]), -]) diff --git a/specs/d3d10misc.py b/specs/d3d10misc.py index 2a3c55e..08795b3 100644 --- a/specs/d3d10misc.py +++ b/specs/d3d10misc.py @@ -41,11 +41,6 @@ D3D10_DRIVER_TYPE = Enum("D3D10_DRIVER_TYPE", [ d3d10.addFunctions([ StdFunction(HRESULT, "D3D10CreateDevice", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (UINT, "SDKVersion"), Out(Pointer(ObjPointer(ID3D10Device)), "ppDevice")]), StdFunction(HRESULT, "D3D10CreateDeviceAndSwapChain", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (UINT, "SDKVersion"), (Pointer(DXGI_SWAP_CHAIN_DESC), "pSwapChainDesc"), Out(Pointer(ObjPointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(ObjPointer(ID3D10Device)), "ppDevice")]), - StdFunction(HRESULT, "D3D10CreateBlob", [(SIZE_T, "NumBytes"), Out(Pointer(LPD3D10BLOB), "ppBuffer")]), - - # Undocumented - StdFunction(DWORD, "D3D10GetVersion", [], internal=True), - StdFunction(DWORD, "D3D10RegisterLayers", [], internal=True), ]) d3d10.addInterfaces([ diff --git a/specs/d3d10shader.py b/specs/d3d10shader.py deleted file mode 100644 index 08de330..0000000 --- a/specs/d3d10shader.py +++ /dev/null @@ -1,175 +0,0 @@ -########################################################################## -# -# Copyright 2012 Jose Fonseca -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -from d3dcommon import * -from d3d10 import * - - -D3D10_SHADER = Flags(UINT, [ - "D3D10_SHADER_DEBUG", - "D3D10_SHADER_SKIP_VALIDATION", - "D3D10_SHADER_SKIP_OPTIMIZATION", - "D3D10_SHADER_PACK_MATRIX_ROW_MAJOR", - "D3D10_SHADER_PACK_MATRIX_COLUMN_MAJOR", - "D3D10_SHADER_PARTIAL_PRECISION", - "D3D10_SHADER_FORCE_VS_SOFTWARE_NO_OPT", - "D3D10_SHADER_FORCE_PS_SOFTWARE_NO_OPT", - "D3D10_SHADER_NO_PRESHADER", - "D3D10_SHADER_AVOID_FLOW_CONTROL", - "D3D10_SHADER_PREFER_FLOW_CONTROL", - "D3D10_SHADER_ENABLE_STRICTNESS", - "D3D10_SHADER_ENABLE_BACKWARDS_COMPATIBILITY", - "D3D10_SHADER_IEEE_STRICTNESS", - "D3D10_SHADER_WARNINGS_ARE_ERRORS", - "D3D10_SHADER_OPTIMIZATION_LEVEL0", - "D3D10_SHADER_OPTIMIZATION_LEVEL1", - "D3D10_SHADER_OPTIMIZATION_LEVEL2", - "D3D10_SHADER_OPTIMIZATION_LEVEL3", -]) - -D3D10_SHADER_DESC = Struct("D3D10_SHADER_DESC", [ - (UINT, "Version"), - (LPCSTR, "Creator"), - (UINT, "Flags"), - (UINT, "ConstantBuffers"), - (UINT, "BoundResources"), - (UINT, "InputParameters"), - (UINT, "OutputParameters"), - (UINT, "InstructionCount"), - (UINT, "TempRegisterCount"), - (UINT, "TempArrayCount"), - (UINT, "DefCount"), - (UINT, "DclCount"), - (UINT, "TextureNormalInstructions"), - (UINT, "TextureLoadInstructions"), - (UINT, "TextureCompInstructions"), - (UINT, "TextureBiasInstructions"), - (UINT, "TextureGradientInstructions"), - (UINT, "FloatInstructionCount"), - (UINT, "IntInstructionCount"), - (UINT, "UintInstructionCount"), - (UINT, "StaticFlowControlCount"), - (UINT, "DynamicFlowControlCount"), - (UINT, "MacroInstructionCount"), - (UINT, "ArrayInstructionCount"), - (UINT, "CutInstructionCount"), - (UINT, "EmitInstructionCount"), - (D3D10_PRIMITIVE_TOPOLOGY, "GSOutputTopology"), - (UINT, "GSMaxOutputVertexCount"), -]) - -D3D10_SHADER_BUFFER_DESC = Struct("D3D10_SHADER_BUFFER_DESC", [ - (LPCSTR, "Name"), - (D3D10_CBUFFER_TYPE, "Type"), - (UINT, "Variables"), - (UINT, "Size"), - (UINT, "uFlags"), -]) - -D3D10_SHADER_VARIABLE_DESC = Struct("D3D10_SHADER_VARIABLE_DESC", [ - (LPCSTR, "Name"), - (UINT, "StartOffset"), - (UINT, "Size"), - (UINT, "uFlags"), - (LPVOID, "DefaultValue"), -]) - -D3D10_SHADER_TYPE_DESC = Struct("D3D10_SHADER_TYPE_DESC", [ - (D3D10_SHADER_VARIABLE_CLASS, "Class"), - (D3D10_SHADER_VARIABLE_TYPE, "Type"), - (UINT, "Rows"), - (UINT, "Columns"), - (UINT, "Elements"), - (UINT, "Members"), - (UINT, "Offset"), -]) - -D3D10_SHADER_INPUT_BIND_DESC = Struct("D3D10_SHADER_INPUT_BIND_DESC", [ - (LPCSTR, "Name"), - (D3D10_SHADER_INPUT_TYPE, "Type"), - (UINT, "BindPoint"), - (UINT, "BindCount"), - (UINT, "uFlags"), - (D3D10_RESOURCE_RETURN_TYPE, "ReturnType"), - (D3D10_SRV_DIMENSION, "Dimension"), - (UINT, "NumSamples"), -]) - -D3D10_SIGNATURE_PARAMETER_DESC = Struct("D3D10_SIGNATURE_PARAMETER_DESC", [ - (LPCSTR, "SemanticName"), - (UINT, "SemanticIndex"), - (UINT, "Register"), - (D3D10_NAME, "SystemValueType"), - (D3D10_REGISTER_COMPONENT_TYPE, "ComponentType"), - (BYTE, "Mask"), - (BYTE, "ReadWriteMask"), -]) - -ID3D10ShaderReflectionType = Interface("ID3D10ShaderReflectionType") -ID3D10ShaderReflectionType.methods += [ - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_SHADER_TYPE_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10ShaderReflectionType), "GetMemberTypeByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10ShaderReflectionType), "GetMemberTypeByName", [(LPCSTR, "Name")]), - StdMethod(LPCSTR, "GetMemberTypeName", [(UINT, "Index")]), -] - -ID3D10ShaderReflectionVariable = Interface("ID3D10ShaderReflectionVariable") -ID3D10ShaderReflectionVariable.methods += [ - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_SHADER_VARIABLE_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10ShaderReflectionType), "GetType", []), -] - -ID3D10ShaderReflectionConstantBuffer = Interface("ID3D10ShaderReflectionConstantBuffer") -ID3D10ShaderReflectionConstantBuffer.methods += [ - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_SHADER_BUFFER_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10ShaderReflectionVariable), "GetVariableByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10ShaderReflectionVariable), "GetVariableByName", [(LPCSTR, "Name")]), -] - -ID3D10ShaderReflection = Interface("ID3D10ShaderReflection", IUnknown) -ID3D10ShaderReflection.methods += [ - StdMethod(HRESULT, "GetDesc", [Out(Pointer(D3D10_SHADER_DESC), "pDesc")]), - StdMethod(ObjPointer(ID3D10ShaderReflectionConstantBuffer), "GetConstantBufferByIndex", [(UINT, "Index")]), - StdMethod(ObjPointer(ID3D10ShaderReflectionConstantBuffer), "GetConstantBufferByName", [(LPCSTR, "Name")]), - StdMethod(HRESULT, "GetResourceBindingDesc", [(UINT, "ResourceIndex"), Out(Pointer(D3D10_SHADER_INPUT_BIND_DESC), "pDesc")]), - StdMethod(HRESULT, "GetInputParameterDesc", [(UINT, "ParameterIndex"), Out(Pointer(D3D10_SIGNATURE_PARAMETER_DESC), "pDesc")]), - StdMethod(HRESULT, "GetOutputParameterDesc", [(UINT, "ParameterIndex"), Out(Pointer(D3D10_SIGNATURE_PARAMETER_DESC), "pDesc")]), -] - - -d3d10.addFunctions([ - StdFunction(HRESULT, "D3D10CompileShader", [(LPCSTR, "pSrcData"), (SIZE_T, "SrcDataSize"), (LPCSTR, "pFileName"), (Pointer(Const(D3D10_SHADER_MACRO)), "pDefines"), (LPD3D10INCLUDE, "pInclude"), (LPCSTR, "pFunctionName"), (LPCSTR, "pProfile"), (UINT, "Flags"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppShader"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppErrorMsgs")]), - StdFunction(HRESULT, "D3D10DisassembleShader", [(Blob(Const(Void), "BytecodeLength"), "pShader"), (SIZE_T, "BytecodeLength"), (BOOL, "EnableColorCode"), (LPCSTR, "pComments"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppDisassembly")]), - StdFunction(LPCSTR, "D3D10GetPixelShaderProfile", [(ObjPointer(ID3D10Device), "pDevice")]), - StdFunction(LPCSTR, "D3D10GetVertexShaderProfile", [(ObjPointer(ID3D10Device), "pDevice")]), - StdFunction(LPCSTR, "D3D10GetGeometryShaderProfile", [(ObjPointer(ID3D10Device), "pDevice")]), - StdFunction(HRESULT, "D3D10ReflectShader", [(Blob(Const(Void), "BytecodeLength"), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), Out(Pointer(ObjPointer(ID3D10ShaderReflection)), "ppReflector")]), - StdFunction(HRESULT, "D3D10PreprocessShader", [(LPCSTR, "pSrcData"), (SIZE_T, "SrcDataSize"), (LPCSTR, "pFileName"), (Pointer(Const(D3D10_SHADER_MACRO)), "pDefines"), (LPD3D10INCLUDE, "pInclude"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppShaderText"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppErrorMsgs")]), - StdFunction(HRESULT, "D3D10GetInputSignatureBlob", [(Blob(Const(Void), "BytecodeLength"), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppSignatureBlob")]), - StdFunction(HRESULT, "D3D10GetOutputSignatureBlob", [(Blob(Const(Void), "BytecodeLength"), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppSignatureBlob")]), - StdFunction(HRESULT, "D3D10GetInputAndOutputSignatureBlob", [(Blob(Const(Void), "BytecodeLength"), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppSignatureBlob")]), - StdFunction(HRESULT, "D3D10GetShaderDebugInfo", [(Blob(Const(Void), "BytecodeLength"), "pShaderBytecode"), (SIZE_T, "BytecodeLength"), Out(Pointer(ObjPointer(ID3D10Blob)), "ppDebugInfo")]), -]) diff --git a/specs/d3d11.py b/specs/d3d11.py index f0e1e27..7d1e1d7 100644 --- a/specs/d3d11.py +++ b/specs/d3d11.py @@ -1117,44 +1117,44 @@ ID3D11DeviceContext.methods += [ StdMethod(Void, "CSSetShader", [(ObjPointer(ID3D11ComputeShader), "pComputeShader"), (Array(Const(ObjPointer(ID3D11ClassInstance)), "NumClassInstances"), "ppClassInstances"), (UINT, "NumClassInstances")]), StdMethod(Void, "CSSetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (Array(Const(ObjPointer(ID3D11SamplerState)), "NumSamplers"), "ppSamplers")]), StdMethod(Void, "CSSetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(Const(ObjPointer(ID3D11Buffer)), "NumBuffers"), "ppConstantBuffers")]), - StdMethod(Void, "VSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), - StdMethod(Void, "PSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), + StdMethod(Void, "VSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), + StdMethod(Void, "PSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), StdMethod(Void, "PSGetShader", [Out(Pointer(ObjPointer(ID3D11PixelShader)), "ppPixelShader"), Out(Array(ObjPointer(ID3D11ClassInstance), "*pNumClassInstances"), "ppClassInstances"), Out(Pointer(UINT), "pNumClassInstances")]), - StdMethod(Void, "PSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), + StdMethod(Void, "PSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), StdMethod(Void, "VSGetShader", [Out(Pointer(ObjPointer(ID3D11VertexShader)), "ppVertexShader"), Out(Array(ObjPointer(ID3D11ClassInstance), "*pNumClassInstances"), "ppClassInstances"), Out(Pointer(UINT), "pNumClassInstances")]), - StdMethod(Void, "PSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), + StdMethod(Void, "PSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), StdMethod(Void, "IAGetInputLayout", [Out(Pointer(ObjPointer(ID3D11InputLayout)), "ppInputLayout")]), - StdMethod(Void, "IAGetVertexBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppVertexBuffers"), Out(Array(UINT, "NumBuffers"), "pStrides"), Out(Array(UINT, "NumBuffers"), "pOffsets")]), + StdMethod(Void, "IAGetVertexBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppVertexBuffers"), Out(Array(UINT, "NumBuffers"), "pStrides"), Out(Array(UINT, "NumBuffers"), "pOffsets")]), StdMethod(Void, "IAGetIndexBuffer", [Out(Pointer(ObjPointer(ID3D11Buffer)), "pIndexBuffer"), Out(Pointer(DXGI_FORMAT), "Format"), Out(Pointer(UINT), "Offset")]), - StdMethod(Void, "GSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), + StdMethod(Void, "GSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), StdMethod(Void, "GSGetShader", [Out(Pointer(ObjPointer(ID3D11GeometryShader)), "ppGeometryShader"), Out(Array(ObjPointer(ID3D11ClassInstance), "*pNumClassInstances"), "ppClassInstances"), Out(Pointer(UINT), "pNumClassInstances")]), StdMethod(Void, "IAGetPrimitiveTopology", [Out(Pointer(D3D11_PRIMITIVE_TOPOLOGY), "pTopology")], sideeffects=False), - StdMethod(Void, "VSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), - StdMethod(Void, "VSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), + StdMethod(Void, "VSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), + StdMethod(Void, "VSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), StdMethod(Void, "GetPredication", [Out(Pointer(ObjPointer(ID3D11Predicate)), "ppPredicate"), Out(Pointer(BOOL), "pPredicateValue")]), - StdMethod(Void, "GSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), - StdMethod(Void, "GSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), - StdMethod(Void, "OMGetRenderTargets", [(UINT, "NumViews"), (Array(ObjPointer(ID3D11RenderTargetView), "NumViews"), "ppRenderTargetViews"), Out(Pointer(ObjPointer(ID3D11DepthStencilView)), "ppDepthStencilView")]), - StdMethod(Void, "OMGetRenderTargetsAndUnorderedAccessViews", [(UINT, "NumRTVs"), (Array(ObjPointer(ID3D11RenderTargetView), "NumRTVs"), "ppRenderTargetViews"), Out(Pointer(ObjPointer(ID3D11DepthStencilView)), "ppDepthStencilView"), (UINT, "UAVStartSlot"), (UINT, "NumUAVs"), (Array(ObjPointer(ID3D11UnorderedAccessView), "NumUAVs"), "ppUnorderedAccessViews")]), + StdMethod(Void, "GSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), + StdMethod(Void, "GSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), + StdMethod(Void, "OMGetRenderTargets", [(UINT, "NumViews"), Out(Array(ObjPointer(ID3D11RenderTargetView), "NumViews"), "ppRenderTargetViews"), Out(Pointer(ObjPointer(ID3D11DepthStencilView)), "ppDepthStencilView")]), + StdMethod(Void, "OMGetRenderTargetsAndUnorderedAccessViews", [(UINT, "NumRTVs"), Out(Array(ObjPointer(ID3D11RenderTargetView), "NumRTVs"), "ppRenderTargetViews"), Out(Pointer(ObjPointer(ID3D11DepthStencilView)), "ppDepthStencilView"), (UINT, "UAVStartSlot"), (UINT, "NumUAVs"), Out(Array(ObjPointer(ID3D11UnorderedAccessView), "NumUAVs"), "ppUnorderedAccessViews")]), StdMethod(Void, "OMGetBlendState", [Out(Pointer(ObjPointer(ID3D11BlendState)), "ppBlendState"), Out(Array(FLOAT, 4), "BlendFactor"), Out(Pointer(UINT), "pSampleMask")]), StdMethod(Void, "OMGetDepthStencilState", [Out(Pointer(ObjPointer(ID3D11DepthStencilState)), "ppDepthStencilState"), Out(Pointer(UINT), "pStencilRef")]), - StdMethod(Void, "SOGetTargets", [(UINT, "NumBuffers"), (Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppSOTargets")]), + StdMethod(Void, "SOGetTargets", [(UINT, "NumBuffers"), Out(Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppSOTargets")]), StdMethod(Void, "RSGetState", [Out(Pointer(ObjPointer(ID3D11RasterizerState)), "ppRasterizerState")]), StdMethod(Void, "RSGetViewports", [Out(Pointer(UINT), "pNumViewports"), Out(Array(D3D11_VIEWPORT, "*pNumViewports"), "pViewports")]), StdMethod(Void, "RSGetScissorRects", [Out(Pointer(UINT), "pNumRects"), Out(Array(D3D11_RECT, "*pNumRects"), "pRects")]), - StdMethod(Void, "HSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), + StdMethod(Void, "HSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), StdMethod(Void, "HSGetShader", [Out(Pointer(ObjPointer(ID3D11HullShader)), "ppHullShader"), Out(Array(ObjPointer(ID3D11ClassInstance), "*pNumClassInstances"), "ppClassInstances"), Out(Pointer(UINT), "pNumClassInstances")]), - StdMethod(Void, "HSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), - StdMethod(Void, "HSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), - StdMethod(Void, "DSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), + StdMethod(Void, "HSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), + StdMethod(Void, "HSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), + StdMethod(Void, "DSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), StdMethod(Void, "DSGetShader", [Out(Pointer(ObjPointer(ID3D11DomainShader)), "ppDomainShader"), Out(Array(ObjPointer(ID3D11ClassInstance), "*pNumClassInstances"), "ppClassInstances"), Out(Pointer(UINT), "pNumClassInstances")]), - StdMethod(Void, "DSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), - StdMethod(Void, "DSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), - StdMethod(Void, "CSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), (Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), - StdMethod(Void, "CSGetUnorderedAccessViews", [(UINT, "StartSlot"), (UINT, "NumUAVs"), (Array(ObjPointer(ID3D11UnorderedAccessView), "NumUAVs"), "ppUnorderedAccessViews")]), + StdMethod(Void, "DSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), + StdMethod(Void, "DSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), + StdMethod(Void, "CSGetShaderResources", [(UINT, "StartSlot"), (UINT, "NumViews"), Out(Array(ObjPointer(ID3D11ShaderResourceView), "NumViews"), "ppShaderResourceViews")]), + StdMethod(Void, "CSGetUnorderedAccessViews", [(UINT, "StartSlot"), (UINT, "NumUAVs"), Out(Array(ObjPointer(ID3D11UnorderedAccessView), "NumUAVs"), "ppUnorderedAccessViews")]), StdMethod(Void, "CSGetShader", [Out(Pointer(ObjPointer(ID3D11ComputeShader)), "ppComputeShader"), Out(Array(ObjPointer(ID3D11ClassInstance), "*pNumClassInstances"), "ppClassInstances"), Out(Pointer(UINT), "pNumClassInstances")]), - StdMethod(Void, "CSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), (Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), - StdMethod(Void, "CSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), (Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), + StdMethod(Void, "CSGetSamplers", [(UINT, "StartSlot"), (UINT, "NumSamplers"), Out(Array(ObjPointer(ID3D11SamplerState), "NumSamplers"), "ppSamplers")]), + StdMethod(Void, "CSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(Array(ObjPointer(ID3D11Buffer), "NumBuffers"), "ppConstantBuffers")]), StdMethod(Void, "ClearState", []), StdMethod(Void, "Flush", []), StdMethod(D3D11_DEVICE_CONTEXT_TYPE, "GetType", [], sideeffects=False), @@ -1218,12 +1218,6 @@ d3d11 = Module("d3d11") d3d11.addFunctions([ StdFunction(HRESULT, "D3D11CreateDevice", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D11_CREATE_DEVICE_FLAG, "Flags"), (Array(Const(D3D_FEATURE_LEVEL), "FeatureLevels"), "pFeatureLevels"), (UINT, "FeatureLevels"), (UINT, "SDKVersion"), Out(Pointer(ObjPointer(ID3D11Device)), "ppDevice"), Out(Pointer(D3D_FEATURE_LEVEL), "pFeatureLevel"), Out(Pointer(ObjPointer(ID3D11DeviceContext)), "ppImmediateContext")]), StdFunction(HRESULT, "D3D11CreateDeviceAndSwapChain", [(ObjPointer(IDXGIAdapter), "pAdapter"), (D3D_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D11_CREATE_DEVICE_FLAG, "Flags"), (Array(Const(D3D_FEATURE_LEVEL), "FeatureLevels"), "pFeatureLevels"), (UINT, "FeatureLevels"), (UINT, "SDKVersion"), (Pointer(Const(DXGI_SWAP_CHAIN_DESC)), "pSwapChainDesc"), Out(Pointer(ObjPointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(ObjPointer(ID3D11Device)), "ppDevice"), Out(Pointer(D3D_FEATURE_LEVEL), "pFeatureLevel"), Out(Pointer(ObjPointer(ID3D11DeviceContext)), "ppImmediateContext")]), - - # XXX: Undocumented functions, called by d3d11sdklayers.dll when D3D11_CREATE_DEVICE_DEBUG is set - StdFunction(HRESULT, "D3D11CoreRegisterLayers", [LPCVOID, DWORD], internal=True), - StdFunction(SIZE_T, "D3D11CoreGetLayeredDeviceSize", [LPCVOID, DWORD], internal=True), - StdFunction(HRESULT, "D3D11CoreCreateLayeredDevice", [LPCVOID, DWORD, LPCVOID, (REFIID, "riid"), Out(Pointer(ObjPointer(Void)), "ppvObj")], internal=True), - StdFunction(HRESULT, "D3D11CoreCreateDevice", [DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD], internal=True), ]) d3d11.addInterfaces([ diff --git a/specs/d3d11_1.py b/specs/d3d11_1.py index 32bba17..5681191 100644 --- a/specs/d3d11_1.py +++ b/specs/d3d11_1.py @@ -168,9 +168,9 @@ ID3D11Device1.methods += [ ] ID3DUserDefinedAnnotation.methods += [ - StdMethod(INT, "BeginEvent", [(LPCWSTR, "Name")]), - StdMethod(INT, "EndEvent", []), - StdMethod(Void, "SetMarker", [(LPCWSTR, "Name")]), + StdMethod(INT, "BeginEvent", [(LPCWSTR, "Name")], sideeffects=False), + StdMethod(INT, "EndEvent", [], sideeffects=False), + StdMethod(Void, "SetMarker", [(LPCWSTR, "Name")], sideeffects=False), StdMethod(BOOL, "GetStatus", [], sideeffects=False), ] diff --git a/specs/d3d8.py b/specs/d3d8.py index a6094c2..1166ea4 100644 --- a/specs/d3d8.py +++ b/specs/d3d8.py @@ -116,7 +116,7 @@ IDirect3D8.methods += [ StdMethod(HRESULT, "CheckDepthStencilMatch", [(D3DADAPTER, "Adapter"), (D3DDEVTYPE, "DeviceType"), (D3DFORMAT, "AdapterFormat"), (D3DFORMAT, "RenderTargetFormat"), (D3DFORMAT, "DepthStencilFormat")], sideeffects=False), StdMethod(HRESULT, "GetDeviceCaps", [(D3DADAPTER, "Adapter"), (D3DDEVTYPE, "DeviceType"), Out(Pointer(D3DCAPS8), "pCaps")], sideeffects=False), StdMethod(HMONITOR, "GetAdapterMonitor", [(D3DADAPTER, "Adapter")], sideeffects=False), - StdMethod(HRESULT, "CreateDevice", [(D3DADAPTER, "Adapter"), (D3DDEVTYPE, "DeviceType"), (HWND, "hFocusWindow"), (D3DCREATE, "BehaviorFlags"), Out(Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters"), Out(Pointer(PDIRECT3DDEVICE8), "ppReturnedDeviceInterface")]), + StdMethod(HRESULT, "CreateDevice", [(D3DADAPTER, "Adapter"), (D3DDEVTYPE, "DeviceType"), (HWND, "hFocusWindow"), (D3DCREATE, "BehaviorFlags"), InOut(Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters"), Out(Pointer(PDIRECT3DDEVICE8), "ppReturnedDeviceInterface")]), ] IDirect3DDevice8.methods += [ @@ -130,11 +130,11 @@ IDirect3DDevice8.methods += [ StdMethod(HRESULT, "SetCursorProperties", [(UINT, "XHotSpot"), (UINT, "YHotSpot"), (PDIRECT3DSURFACE8, "pCursorBitmap")]), # XXX: There are different signatures of # IDirect3DDevice8::SetCursorPosition depending on the DXSDK version - StdMethod(Void, "SetCursorPosition", [(UINT, "XScreenSpace"), (UINT, "YScreenSpace"), (D3DCURSOR, "Flags")]), + #StdMethod(Void, "SetCursorPosition", [(UINT, "XScreenSpace"), (UINT, "YScreenSpace"), (D3DCURSOR, "Flags")]), StdMethod(Void, "SetCursorPosition", [(Int, "X"), (Int, "Y"), (D3DCURSOR, "Flags")]), StdMethod(BOOL, "ShowCursor", [(BOOL, "bShow")]), - StdMethod(HRESULT, "CreateAdditionalSwapChain", [Out(Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters"), Out(Pointer(PDIRECT3DSWAPCHAIN8), "pSwapChain")]), - StdMethod(HRESULT, "Reset", [Out(Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters")]), + StdMethod(HRESULT, "CreateAdditionalSwapChain", [InOut(Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters"), Out(Pointer(PDIRECT3DSWAPCHAIN8), "pSwapChain")]), + StdMethod(HRESULT, "Reset", [InOut(Pointer(D3DPRESENT_PARAMETERS), "pPresentationParameters")]), StdMethod(HRESULT, "Present", [(ConstPointer(RECT), "pSourceRect"), (ConstPointer(RECT), "pDestRect"), (HWND, "hDestWindowOverride"), (ConstPointer(RGNDATA), "pDirtyRegion")]), StdMethod(HRESULT, "GetBackBuffer", [(UINT, "BackBuffer"), (D3DBACKBUFFER_TYPE, "Type"), Out(Pointer(PDIRECT3DSURFACE8), "ppBackBuffer")]), StdMethod(HRESULT, "GetRasterStatus", [Out(Pointer(D3DRASTER_STATUS), "pRasterStatus")], sideeffects=False), @@ -201,8 +201,8 @@ IDirect3DDevice8.methods += [ StdMethod(HRESULT, "DeleteVertexShader", [(DWORD, "Handle")]), StdMethod(HRESULT, "SetVertexShaderConstant", [(DWORD, "Register"), (Blob(Const(Void), "ConstantCount*4*sizeof(float)"), "pConstantData"), (DWORD, "ConstantCount")]), StdMethod(HRESULT, "GetVertexShaderConstant", [(DWORD, "Register"), Out(OpaqueBlob(Void, "ConstantCount*4*sizeof(float)"), "pConstantData"), (DWORD, "ConstantCount")], sideeffects=False), - StdMethod(HRESULT, "GetVertexShaderDeclaration", [(DWORD, "Handle"), Out(OpaqueBlob(Void, "*pSizeOfData"), "pData"), Out(Pointer(DWORD), "pSizeOfData")]), - StdMethod(HRESULT, "GetVertexShaderFunction", [(DWORD, "Handle"), Out(OpaqueBlob(Void, "*pSizeOfData"), "pData"), Out(Pointer(DWORD), "pSizeOfData")]), + StdMethod(HRESULT, "GetVertexShaderDeclaration", [(DWORD, "Handle"), Out(OpaqueBlob(Void, "*pSizeOfData"), "pData"), Out(Pointer(DWORD), "pSizeOfData")], sideeffects=False), + StdMethod(HRESULT, "GetVertexShaderFunction", [(DWORD, "Handle"), Out(OpaqueBlob(Void, "*pSizeOfData"), "pData"), Out(Pointer(DWORD), "pSizeOfData")], sideeffects=False), StdMethod(HRESULT, "SetStreamSource", [(UINT, "StreamNumber"), (PDIRECT3DVERTEXBUFFER8, "pStreamData"), (UINT, "Stride")]), StdMethod(HRESULT, "GetStreamSource", [(UINT, "StreamNumber"), Out(Pointer(PDIRECT3DVERTEXBUFFER8), "ppStreamData"), Out(Pointer(UINT), "pStride")]), StdMethod(HRESULT, "SetIndices", [(PDIRECT3DINDEXBUFFER8, "pIndexData"), (UINT, "BaseVertexIndex")]), diff --git a/specs/d3d8types.py b/specs/d3d8types.py index 7843d59..df90f71 100644 --- a/specs/d3d8types.py +++ b/specs/d3d8types.py @@ -238,9 +238,6 @@ D3DTRANSFORMSTATETYPE = Enum("D3DTRANSFORMSTATETYPE", [ "D3DTS_TEXTURE5", "D3DTS_TEXTURE6", "D3DTS_TEXTURE7", -]) - -D3DTS = Flags(DWORD, [ "D3DTS_WORLD", "D3DTS_WORLD1", "D3DTS_WORLD2", @@ -253,12 +250,6 @@ D3DMATERIALCOLORSOURCE = Enum("D3DMATERIALCOLORSOURCE", [ "D3DMCS_COLOR2", ]) -D3DWRAP = Flags(DWORD, [ - "D3DWRAP_U", - "D3DWRAP_V", - "D3DWRAP_W", -]) - D3DWRAPCOORD = Flags(DWORD, [ "D3DWRAPCOORD_0", "D3DWRAPCOORD_1", diff --git a/specs/d3d9types.py b/specs/d3d9types.py index 6c9a8ba..8979734 100644 --- a/specs/d3d9types.py +++ b/specs/d3d9types.py @@ -238,9 +238,6 @@ D3DTRANSFORMSTATETYPE = Enum("D3DTRANSFORMSTATETYPE", [ "D3DTS_TEXTURE5", "D3DTS_TEXTURE6", "D3DTS_TEXTURE7", -]) - -D3DTS = Flags(DWORD, [ "D3DTS_WORLD", "D3DTS_WORLD1", "D3DTS_WORLD2", diff --git a/specs/d3dtypes.py b/specs/d3dtypes.py index 0b6a8b2..1137143 100644 --- a/specs/d3dtypes.py +++ b/specs/d3dtypes.py @@ -28,24 +28,22 @@ from winapi import * D3DVALUE = Float -LPD3DVALUE = Pointer(Float) +LPD3DVALUE = Pointer(D3DVALUE) + D3DFIXED = LONG LPD3DVALIDATECALLBACK = Opaque("LPD3DVALIDATECALLBACK") LPD3DENUMTEXTUREFORMATSCALLBACK = Opaque("LPD3DENUMTEXTUREFORMATSCALLBACK") LPD3DENUMPIXELFORMATSCALLBACK = Opaque("LPD3DENUMPIXELFORMATSCALLBACK") -D3DCOLOR = DWORD -LPD3DCOLOR = Pointer(D3DCOLOR) - -D3DMATERIALHANDLE = DWORD -LPD3DMATERIALHANDLE = Pointer(D3DMATERIALHANDLE) - -D3DTEXTUREHANDLE = DWORD -LPD3DTEXTUREHANDLE = Pointer(D3DTEXTUREHANDLE) +D3DCOLOR = Alias("D3DCOLOR", DWORD) -D3DMATRIXHANDLE = DWORD -LPD3DMATRIXHANDLE = Pointer(D3DMATRIXHANDLE) +D3DVECTOR = Struct("D3DVECTOR", [ + (D3DVALUE, "x"), + (D3DVALUE, "y"), + (D3DVALUE, "z"), +]) +LPD3DVECTOR = Pointer(D3DVECTOR) D3DCOLORVALUE = Struct("D3DCOLORVALUE", [ (D3DVALUE, "r"), @@ -63,12 +61,14 @@ D3DRECT = Struct("D3DRECT", [ ]) LPD3DRECT = Pointer(D3DRECT) -D3DVECTOR = Struct("D3DVECTOR", [ - (D3DVALUE, "x"), - (D3DVALUE, "y"), - (D3DVALUE, "z"), -]) -LPD3DVECTOR = Pointer(D3DVECTOR) +D3DMATERIALHANDLE = DWORD +LPD3DMATERIALHANDLE = Pointer(D3DMATERIALHANDLE) + +D3DTEXTUREHANDLE = DWORD +LPD3DTEXTUREHANDLE = Pointer(D3DTEXTUREHANDLE) + +D3DMATRIXHANDLE = DWORD +LPD3DMATRIXHANDLE = Pointer(D3DMATRIXHANDLE) D3DHVERTEX = Struct("D3DHVERTEX", [ (DWORD, "dwFlags"), @@ -528,6 +528,19 @@ D3DLIGHTSTATETYPE = Enum("D3DLIGHTSTATETYPE", [ "D3DLIGHTSTATE_COLORVERTEX", ]) +D3DMATERIALCOLORSOURCE = Enum("D3DMATERIALCOLORSOURCE", [ + "D3DMCS_MATERIAL", + "D3DMCS_COLOR1", + "D3DMCS_COLOR2", +]) + +D3DWRAPCOORD = Flags(DWORD, [ + "D3DWRAPCOORD_0", + "D3DWRAPCOORD_1", + "D3DWRAPCOORD_2", + "D3DWRAPCOORD_3", +]) + D3DRENDERSTATETYPE = Enum("D3DRENDERSTATETYPE", [ "D3DRENDERSTATE_ANTIALIAS", "D3DRENDERSTATE_TEXTUREPERSPECTIVE", @@ -645,21 +658,6 @@ D3DRENDERSTATETYPE = Enum("D3DRENDERSTATETYPE", [ "D3DRENDERSTATE_STIPPLEPATTERN31", ]) -D3DMATERIALCOLORSOURCE = Enum("D3DMATERIALCOLORSOURCE", [ - "D3DMCS_MATERIAL", - "D3DMCS_COLOR1", - "D3DMCS_COLOR2", -]) - -D3DWRAP = Flags(DWORD, [ - "D3DWRAP_U", - "D3DWRAP_V", - "D3DWRAPCOORD_0", - "D3DWRAPCOORD_1", - "D3DWRAPCOORD_2", - "D3DWRAPCOORD_3", -]) - D3DSTATE = Struct("D3DSTATE", [ (D3DTRANSFORMSTATETYPE, "dtstTransformStateType"), (D3DLIGHTSTATETYPE, "dlstLightStateType"), @@ -757,15 +755,15 @@ D3DTEXTUREOP = Enum("D3DTEXTUREOP", [ "D3DTOP_DOTPRODUCT3", ]) -D3DTA = Flags(DWORD, [ - "D3DTA_SELECTMASK", +# XXX: Actually a mixture of enums and flags +D3DTA = FakeEnum(DWORD, [ "D3DTA_DIFFUSE", "D3DTA_CURRENT", "D3DTA_TEXTURE", "D3DTA_TFACTOR", "D3DTA_SPECULAR", - "D3DTA_COMPLEMENT", - "D3DTA_ALPHAREPLICATE", + #"D3DTA_COMPLEMENT", + #"D3DTA_ALPHAREPLICATE", ]) D3DTEXTUREMAGFILTER = Enum("D3DTEXTUREMAGFILTER", [ @@ -918,7 +916,6 @@ D3DPV = Flags(DWORD, [ D3DFVF = Flags(DWORD, [ "D3DFVF_RESERVED0", - "D3DFVF_POSITION_MASK", "D3DFVF_XYZ", "D3DFVF_XYZRHW", "D3DFVF_XYZB1", @@ -930,30 +927,32 @@ D3DFVF = Flags(DWORD, [ "D3DFVF_RESERVED1", "D3DFVF_DIFFUSE", "D3DFVF_SPECULAR", - "D3DFVF_TEXCOUNT_MASK", - "D3DFVF_TEXCOUNT_SHIFT", - "D3DFVF_TEX0", - "D3DFVF_TEX1", - "D3DFVF_TEX2", - "D3DFVF_TEX3", - "D3DFVF_TEX4", - "D3DFVF_TEX5", - "D3DFVF_TEX6", - "D3DFVF_TEX7", - "D3DFVF_TEX8", + #"D3DFVF_TEX0", + #"D3DFVF_TEX1", + #"D3DFVF_TEX2", + #"D3DFVF_TEX3", + #"D3DFVF_TEX4", + #"D3DFVF_TEX5", + #"D3DFVF_TEX6", + #"D3DFVF_TEX7", + #"D3DFVF_TEX8", "D3DFVF_RESERVED2", - "D3DFVF_RESERVED1", - "D3DFVF_VERTEX", - "D3DFVF_LVERTEX", - "D3DFVF_TLVERTEX", - "D3DFVF_TEXCOORDSIZE1(0)", - "D3DFVF_TEXCOORDSIZE1(1)", - "D3DFVF_TEXCOORDSIZE2(0)", - "D3DFVF_TEXCOORDSIZE2(1)", - "D3DFVF_TEXCOORDSIZE3(0)", - "D3DFVF_TEXCOORDSIZE3(1)", - "D3DFVF_TEXCOORDSIZE4(0)", - "D3DFVF_TEXCOORDSIZE4(1)", + #"D3DFVF_TEXCOORDSIZE1(0)", + #"D3DFVF_TEXCOORDSIZE2(0)", + #"D3DFVF_TEXCOORDSIZE3(0)", + #"D3DFVF_TEXCOORDSIZE4(0)", + #"D3DFVF_TEXCOORDSIZE1(1)", + #"D3DFVF_TEXCOORDSIZE2(1)", + #"D3DFVF_TEXCOORDSIZE3(1)", + #"D3DFVF_TEXCOORDSIZE4(1)", + #"D3DFVF_TEXCOORDSIZE1(2)", + #"D3DFVF_TEXCOORDSIZE2(2)", + #"D3DFVF_TEXCOORDSIZE3(2)", + #"D3DFVF_TEXCOORDSIZE4(2)", + #"D3DFVF_TEXCOORDSIZE1(3)", + #"D3DFVF_TEXCOORDSIZE2(3)", + #"D3DFVF_TEXCOORDSIZE3(3)", + #"D3DFVF_TEXCOORDSIZE4(3)", ]) D3DDP_PTRSTRIDE = Struct("D3DDP_PTRSTRIDE", [ diff --git a/specs/ddraw.py b/specs/ddraw.py index 7ca6783..1b22476 100644 --- a/specs/ddraw.py +++ b/specs/ddraw.py @@ -455,8 +455,10 @@ DDPIXELFORMAT = Struct("DDPIXELFORMAT", [ (DWORD, "dwUBitMask"), (DWORD, "dwZBitMask"), (DWORD, "dwBumpDvBitMask"), - (WORD, "MultiSampleCaps.wFlipMSTypes"), - (WORD, "MultiSampleCaps.wBltMSTypes"), + (Struct(None, [ + (WORD, "wFlipMSTypes"), + (WORD, "wBltMSTypes"), + ]), "MultiSampleCaps"), (DWORD, "dwBBitMask"), (DWORD, "dwVBitMask"), (DWORD, "dwStencilBitMask"), diff --git a/specs/stdapi.py b/specs/stdapi.py index 930bb82..b86668b 100644 --- a/specs/stdapi.py +++ b/specs/stdapi.py @@ -340,13 +340,7 @@ def InOut(type, name): class Function: - # 0-3 are reserved to memcpy, malloc, free, and realloc - __id = 4 - def __init__(self, type, name, args, call = '', fail = None, sideeffects=True, internal=False): - self.id = Function.__id - Function.__id += 1 - self.type = type self.name = name diff --git a/wrappers/.gitignore b/wrappers/.gitignore index e124b5d..dfd8c30 100644 --- a/wrappers/.gitignore +++ b/wrappers/.gitignore @@ -1,11 +1,10 @@ OpenGL cgltrace.cpp d2d1trace.cpp -d3d10_1trace.cpp -d3d10trace.cpp -d3d11trace.cpp d3d8trace.cpp d3d9trace.cpp +dxgitrace.cpp +dxgitrace.def ddrawtrace.cpp dlltrace.cpp egltrace.cpp diff --git a/wrappers/CMakeLists.txt b/wrappers/CMakeLists.txt index 2cdf458..6c33ead 100644 --- a/wrappers/CMakeLists.txt +++ b/wrappers/CMakeLists.txt @@ -29,7 +29,7 @@ if (WIN32) # ddraw.dll if (DirectX_D3D_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D_INCLUDE_DIR}) + include_directories (BEFORE SYSTEM ${DirectX_D3D_INCLUDE_DIR}) add_custom_command ( OUTPUT ddrawtrace.cpp COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ddrawtrace.py > ${CMAKE_CURRENT_BINARY_DIR}/ddrawtrace.cpp @@ -60,8 +60,8 @@ if (WIN32) endif () # d3d8.dll - if (DirectX_D3D8_INCLUDE_DIR AND DirectX_D3DX9_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D8_INCLUDE_DIR} ${DirectX_D3DX9_INCLUDE_DIR}) + if (DirectX_D3D8_INCLUDE_DIR AND DirectX_D3D9_INCLUDE_DIR) + include_directories (BEFORE SYSTEM ${DirectX_D3D9_INCLUDE_DIR} ${DirectX_D3D8_INCLUDE_DIR}) add_custom_command ( OUTPUT d3d8trace.cpp COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d8trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d8trace.cpp @@ -76,8 +76,13 @@ if (WIN32) ${CMAKE_SOURCE_DIR}/specs/winapi.py ${CMAKE_SOURCE_DIR}/specs/stdapi.py ) - add_library (d3d8trace MODULE d3d8.def d3d8trace.cpp d3d9shader.cpp) + add_library (d3d8trace MODULE + d3d8.def + d3d8trace.cpp + d3d9shader.cpp + ) target_link_libraries (d3d8trace + d3dhelpers common_trace common ${ZLIB_LIBRARIES} @@ -91,8 +96,8 @@ if (WIN32) endif () # d3d9.dll - if (DirectX_D3DX9_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3DX9_INCLUDE_DIR}) + if (DirectX_D3D9_INCLUDE_DIR) + include_directories (BEFORE SYSTEM ${DirectX_D3D9_INCLUDE_DIR}) add_custom_command ( OUTPUT d3d9trace.cpp COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d9trace.cpp @@ -108,8 +113,13 @@ if (WIN32) ${CMAKE_SOURCE_DIR}/specs/winapi.py ${CMAKE_SOURCE_DIR}/specs/stdapi.py ) - add_library (d3d9trace MODULE d3d9.def d3d9trace.cpp d3d9shader.cpp) + add_library (d3d9trace MODULE + d3d9.def + d3d9trace.cpp + d3d9shader.cpp + ) target_link_libraries (d3d9trace + d3dhelpers common_trace common ${ZLIB_LIBRARIES} @@ -122,23 +132,47 @@ if (WIN32) install (TARGETS d3d9trace LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) endif () - # d3d10.dll + # dxgi.dll, d3d10.dll, d3d10_1.dll, d3d11.dll + set (DXGI_MODULES) if (DirectX_D3D10_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D10_INCLUDE_DIR}) + set (DXGITRACE_DEF ${CMAKE_CURRENT_BINARY_DIR}/dxgitrace.def) + file (WRITE ${DXGITRACE_DEF} "EXPORTS\n") + file (APPEND ${DXGITRACE_DEF} "CreateDXGIFactory\n") + file (APPEND ${DXGITRACE_DEF} "CreateDXGIFactory1\n") + file (APPEND ${DXGITRACE_DEF} "D3D10CreateDevice\n") + file (APPEND ${DXGITRACE_DEF} "D3D10CreateDeviceAndSwapChain\n") + + include_directories (BEFORE SYSTEM ${DirectX_D3D10_INCLUDE_DIR}) + set (DXGI_MODULES d3d10) + if (DirectX_D3D10_1_INCLUDE_DIR) + include_directories (BEFORE SYSTEM ${DirectX_D3D10_1_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d10_1) + file (APPEND ${DXGITRACE_DEF} "D3D10CreateDevice1\n") + file (APPEND ${DXGITRACE_DEF} "D3D10CreateDeviceAndSwapChain1\n") + endif () + if (DirectX_D3D11_INCLUDE_DIR) + include_directories (BEFORE SYSTEM ${DirectX_D3D11_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d11) + if (DirectX_D3D11_1_INCLUDE_DIR) + include_directories (BEFORE SYSTEM ${DirectX_D3D11_1_INCLUDE_DIR}) + set (DXGI_MODULES ${DXGI_MODULES} d3d11_1) + endif () + file (APPEND ${DXGITRACE_DEF} "D3D11CreateDevice\n") + file (APPEND ${DXGITRACE_DEF} "D3D11CreateDeviceAndSwapChain\n") + endif () + add_custom_command ( - OUTPUT d3d10trace.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d10trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d10trace.cpp + OUTPUT dxgitrace.cpp + COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgitrace.py ${DXGI_MODULES} > ${CMAKE_CURRENT_BINARY_DIR}/dxgitrace.cpp DEPENDS - d3d10trace.py - d3dcommontrace.py + dxgitrace.py dlltrace.py trace.py ${CMAKE_SOURCE_DIR}/dispatch/dispatch.py + ${CMAKE_SOURCE_DIR}/specs/d3d10_1.py ${CMAKE_SOURCE_DIR}/specs/d3d10.py ${CMAKE_SOURCE_DIR}/specs/d3d10misc.py ${CMAKE_SOURCE_DIR}/specs/d3d10sdklayers.py - ${CMAKE_SOURCE_DIR}/specs/d3d10shader.py - ${CMAKE_SOURCE_DIR}/specs/d3d10effect.py ${CMAKE_SOURCE_DIR}/specs/d3dcommon.py ${CMAKE_SOURCE_DIR}/specs/dxgi.py ${CMAKE_SOURCE_DIR}/specs/dxgitype.py @@ -146,112 +180,84 @@ if (WIN32) ${CMAKE_SOURCE_DIR}/specs/winapi.py ${CMAKE_SOURCE_DIR}/specs/stdapi.py ) - add_library (d3d10trace MODULE - d3d10.def - d3d10trace.cpp + add_library (dxgitrace SHARED + ${DXGITRACE_DEF} + dxgitrace.cpp d3dcommonshader.cpp ) - target_link_libraries (d3d10trace + target_link_libraries (dxgitrace + d3dhelpers common_trace common ${ZLIB_LIBRARIES} ${SNAPPY_LIBRARIES} ) - set_target_properties (d3d10trace PROPERTIES - PREFIX "" - OUTPUT_NAME d3d10 - ) - install (TARGETS d3d10trace LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) - endif () - - # d3d10_1.dll - if (DirectX_D3D10_1_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D3D10_1_INCLUDE_DIR}) - add_custom_command ( - OUTPUT d3d10_1trace.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d10_1trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d10_1trace.cpp - DEPENDS - d3d10_1trace.py - d3dcommontrace.py - dlltrace.py - trace.py - ${CMAKE_SOURCE_DIR}/dispatch/dispatch.py - ${CMAKE_SOURCE_DIR}/specs/d3d10_1.py - ${CMAKE_SOURCE_DIR}/specs/d3d10.py - ${CMAKE_SOURCE_DIR}/specs/d3d10sdklayers.py - ${CMAKE_SOURCE_DIR}/specs/d3dcommon.py - ${CMAKE_SOURCE_DIR}/specs/dxgi.py - ${CMAKE_SOURCE_DIR}/specs/dxgitype.py - ${CMAKE_SOURCE_DIR}/specs/dxgiformat.py - ${CMAKE_SOURCE_DIR}/specs/winapi.py - ${CMAKE_SOURCE_DIR}/specs/stdapi.py + set_target_properties (dxgitrace + PROPERTIES PREFIX "" ) - add_library (d3d10_1trace MODULE - d3d10_1.def - d3d10_1trace.cpp - d3dcommonshader.cpp + install (TARGETS dxgitrace + RUNTIME DESTINATION ${WRAPPER_INSTALL_DIR} COMPONENT RUNTIME + LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR} COMPONENT RUNTIME ) - target_link_libraries (d3d10_1trace - common_trace - common - ${ZLIB_LIBRARIES} - ${SNAPPY_LIBRARIES} + + # dxgi.dll (empty stub for dxgitrace.dll) + add_library (dxgistubs MODULE + dxgi.def + dxgistubs.cpp + d3dkmtstubs.cpp ) - set_target_properties (d3d10_1trace + target_link_libraries (dxgistubs dxgitrace) + set_target_properties (dxgistubs PROPERTIES PREFIX "" - OUTPUT_NAME d3d10_1 + OUTPUT_NAME dxgi ) - install (TARGETS d3d10_1trace LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) - endif () - - # d3d11.dll - if (DirectX_D3D11_INCLUDE_DIR) - if (DirectX_D3D11_1_INCLUDE_DIR) - set (HAVE_D3D11_1 1) - else () - set (HAVE_D3D11_1 0) - endif () + install (TARGETS dxgistubs LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) - include_directories (SYSTEM ${DirectX_D3D11_INCLUDE_DIR}) - add_custom_command ( - OUTPUT d3d11trace.cpp - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d11trace.py ${HAVE_D3D11_1} > ${CMAKE_CURRENT_BINARY_DIR}/d3d11trace.cpp - DEPENDS - d3d11trace.py - d3dcommontrace.py - dlltrace.py - trace.py - ${CMAKE_SOURCE_DIR}/specs/d3d11_1.py - ${CMAKE_SOURCE_DIR}/specs/d3d11.py - ${CMAKE_SOURCE_DIR}/specs/d3d11sdklayers.py - ${CMAKE_SOURCE_DIR}/specs/d3dcommon.py - ${CMAKE_SOURCE_DIR}/specs/dxgi.py - ${CMAKE_SOURCE_DIR}/specs/dxgitype.py - ${CMAKE_SOURCE_DIR}/specs/dxgiformat.py - ${CMAKE_SOURCE_DIR}/specs/winapi.py - ${CMAKE_SOURCE_DIR}/specs/stdapi.py - ) - add_library (d3d11trace MODULE - d3d11.def - d3d11trace.cpp - d3dcommonshader.cpp - ) - target_link_libraries (d3d11trace - common_trace - common - ${ZLIB_LIBRARIES} - ${SNAPPY_LIBRARIES} + # d3d10.dll (empty stub for dxgitrace.dll) + add_library (d3d10stubs MODULE + d3d10.def + d3d10stubs.cpp ) - set_target_properties (d3d11trace + target_link_libraries (d3d10stubs dxgitrace) + set_target_properties (d3d10stubs PROPERTIES PREFIX "" - OUTPUT_NAME d3d11 + OUTPUT_NAME d3d10 ) - install (TARGETS d3d11trace LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) + install (TARGETS d3d10stubs LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) + + # d3d10_1.dll (empty stub for dxgitrace.dll) + if (DirectX_D3D10_1_INCLUDE_DIR) + add_library (d3d10_1stubs MODULE + d3d10_1.def + d3d10stubs.cpp + ) + target_link_libraries (d3d10_1stubs dxgitrace) + set_target_properties (d3d10_1stubs + PROPERTIES PREFIX "" + OUTPUT_NAME d3d10_1 + ) + install (TARGETS d3d10_1stubs LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) + endif () + + # d3d11.dll (empty stub for dxgitrace.dll) + if (DirectX_D3D11_INCLUDE_DIR) + add_library (d3d11stubs MODULE + d3d11.def + d3d11stubs.cpp + d3dkmtstubs.cpp + ) + target_link_libraries (d3d11stubs dxgitrace) + set_target_properties (d3d11stubs + PROPERTIES PREFIX "" + OUTPUT_NAME d3d11 + ) + install (TARGETS d3d11stubs LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR}) + endif () endif () # d2d1.dll, dwrite.dll if (DirectX_D2D1_INCLUDE_DIR) - include_directories (SYSTEM ${DirectX_D2D1_INCLUDE_DIR}) + include_directories (BEFORE SYSTEM ${DirectX_D2D1_INCLUDE_DIR}) add_custom_command ( OUTPUT d2d1trace.cpp diff --git a/wrappers/d3d10.def b/wrappers/d3d10.def index 95dc4ef..4cf0f7d 100644 --- a/wrappers/d3d10.def +++ b/wrappers/d3d10.def @@ -29,6 +29,3 @@ EXPORTS D3D10StateBlockMaskGetSetting D3D10StateBlockMaskIntersect D3D10StateBlockMaskUnion - - CreateDXGIFactory - CreateDXGIFactory1 diff --git a/wrappers/d3d10_1.def b/wrappers/d3d10_1.def index 730cb0e..836827a 100644 --- a/wrappers/d3d10_1.def +++ b/wrappers/d3d10_1.def @@ -1,9 +1,32 @@ LIBRARY "d3d10_1" EXPORTS + D3D10CompileEffectFromMemory + D3D10CompileShader + D3D10CreateBlob D3D10CreateDevice1 D3D10CreateDeviceAndSwapChain1 - D3D10CreateBlob - - CreateDXGIFactory - CreateDXGIFactory1 + D3D10CreateEffectFromMemory + D3D10CreateEffectPoolFromMemory + D3D10CreateStateBlock + D3D10DisassembleEffect + D3D10DisassembleShader + D3D10GetGeometryShaderProfile + D3D10GetInputAndOutputSignatureBlob + D3D10GetInputSignatureBlob + D3D10GetOutputSignatureBlob + D3D10GetPixelShaderProfile + D3D10GetShaderDebugInfo + D3D10GetVersion + D3D10GetVertexShaderProfile + D3D10PreprocessShader + D3D10ReflectShader + D3D10RegisterLayers + D3D10StateBlockMaskDifference + D3D10StateBlockMaskDisableAll + D3D10StateBlockMaskDisableCapture + D3D10StateBlockMaskEnableAll + D3D10StateBlockMaskEnableCapture + D3D10StateBlockMaskGetSetting + D3D10StateBlockMaskIntersect + D3D10StateBlockMaskUnion diff --git a/wrappers/d3d10_1trace.py b/wrappers/d3d10_1trace.py deleted file mode 100644 index 08aa239..0000000 --- a/wrappers/d3d10_1trace.py +++ /dev/null @@ -1,48 +0,0 @@ -########################################################################## -# -# Copyright 2008-2009 VMware, Inc. -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -from d3dcommontrace import D3DCommonTracer -from specs.stdapi import API -from specs.dxgi import dxgi -from specs.d3d10_1 import d3d10_1 - - -if __name__ == '__main__': - print '#define INITGUID' - print - print '#include "trace_writer_local.hpp"' - print '#include "os.hpp"' - print - print '#include "d3d10_1imports.hpp"' - print '#include "d3dcommonshader.hpp"' - print '#include "d3d10size.hpp"' - print - - api = API() - api.addModule(dxgi) - api.addModule(d3d10_1) - tracer = D3DCommonTracer() - tracer.traceApi(api) diff --git a/wrappers/d3d10stubs.cpp b/wrappers/d3d10stubs.cpp new file mode 100644 index 0000000..7c28d28 --- /dev/null +++ b/wrappers/d3d10stubs.cpp @@ -0,0 +1,522 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + *Stubs for internal D3D10 functions. + */ + + +#include "os.hpp" + +#include "d3d10imports.hpp" + + +static HMODULE g_hD3D10Module = NULL; + + +static PROC +_getD3D10ProcAddress(LPCSTR lpProcName) { + if (!g_hD3D10Module) { + char szDll[MAX_PATH] = {0}; + if (!GetSystemDirectoryA(szDll, MAX_PATH)) { + return NULL; + } + strcat(szDll, "\\\\d3d10.dll"); + g_hD3D10Module = LoadLibraryA(szDll); + if (!g_hD3D10Module) { + return NULL; + } + } + return GetProcAddress(g_hD3D10Module, lpProcName); +} + + +#ifndef NDEBUG +#define LOG() os::log("%s\n", __FUNCTION__) +#else +#define LOG() +#endif + + +typedef HRESULT (WINAPI *PFN_D3D10COMPILESHADER)(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, const char *pFunctionName, const char *pProfile, UINT Flags, ID3D10Blob **ppShader, ID3D10Blob **ppErrorMsgs); +static PFN_D3D10COMPILESHADER _D3D10CompileShader_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CompileShader(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, const char *pFunctionName, const char *pProfile, UINT Flags, ID3D10Blob **ppShader, ID3D10Blob **ppErrorMsgs) { + const char *_name = "D3D10CompileShader"; + LOG(); + if (!_D3D10CompileShader_ptr) { + _D3D10CompileShader_ptr = (PFN_D3D10COMPILESHADER)_getD3D10ProcAddress(_name); + if (!_D3D10CompileShader_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CompileShader_ptr(pSrcData, SrcDataSize, pFileName, pDefines, pInclude, pFunctionName, pProfile, Flags, ppShader, ppErrorMsgs); +} + +typedef HRESULT (WINAPI *PFN_D3D10DISASSEMBLESHADER)(const void *pShader, SIZE_T BytecodeLength, BOOL EnableColorCode, const char *pComments, ID3D10Blob **ppDisassembly); +static PFN_D3D10DISASSEMBLESHADER _D3D10DisassembleShader_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10DisassembleShader(const void *pShader, SIZE_T BytecodeLength, BOOL EnableColorCode, const char *pComments, ID3D10Blob **ppDisassembly) { + const char *_name = "D3D10DisassembleShader"; + LOG(); + if (!_D3D10DisassembleShader_ptr) { + _D3D10DisassembleShader_ptr = (PFN_D3D10DISASSEMBLESHADER)_getD3D10ProcAddress(_name); + if (!_D3D10DisassembleShader_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10DisassembleShader_ptr(pShader, BytecodeLength, EnableColorCode, pComments, ppDisassembly); +} + +typedef const char *(WINAPI *PFN_D3D10GETPIXELSHADERPROFILE)(ID3D10Device *pDevice); +static PFN_D3D10GETPIXELSHADERPROFILE _D3D10GetPixelShaderProfile_ptr = NULL; + +EXTERN_C const char *WINAPI +D3D10GetPixelShaderProfile(ID3D10Device *pDevice) { + const char *_name = "D3D10GetPixelShaderProfile"; + LOG(); + if (!_D3D10GetPixelShaderProfile_ptr) { + _D3D10GetPixelShaderProfile_ptr = (PFN_D3D10GETPIXELSHADERPROFILE)_getD3D10ProcAddress(_name); + if (!_D3D10GetPixelShaderProfile_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetPixelShaderProfile_ptr(pDevice); +} + +typedef const char *(WINAPI *PFN_D3D10GETVERTEXSHADERPROFILE)(ID3D10Device *pDevice); +static PFN_D3D10GETVERTEXSHADERPROFILE _D3D10GetVertexShaderProfile_ptr = NULL; + +EXTERN_C const char *WINAPI +D3D10GetVertexShaderProfile(ID3D10Device *pDevice) { + const char *_name = "D3D10GetVertexShaderProfile"; + LOG(); + if (!_D3D10GetVertexShaderProfile_ptr) { + _D3D10GetVertexShaderProfile_ptr = (PFN_D3D10GETVERTEXSHADERPROFILE)_getD3D10ProcAddress(_name); + if (!_D3D10GetVertexShaderProfile_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetVertexShaderProfile_ptr(pDevice); +} + +typedef const char *(WINAPI *PFN_D3D10GETGEOMETRYSHADERPROFILE)(ID3D10Device *pDevice); +static PFN_D3D10GETGEOMETRYSHADERPROFILE _D3D10GetGeometryShaderProfile_ptr = NULL; + +EXTERN_C const char *WINAPI +D3D10GetGeometryShaderProfile(ID3D10Device *pDevice) { + const char *_name = "D3D10GetGeometryShaderProfile"; + LOG(); + if (!_D3D10GetGeometryShaderProfile_ptr) { + _D3D10GetGeometryShaderProfile_ptr = (PFN_D3D10GETGEOMETRYSHADERPROFILE)_getD3D10ProcAddress(_name); + if (!_D3D10GetGeometryShaderProfile_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetGeometryShaderProfile_ptr(pDevice); +} + +typedef HRESULT (WINAPI *PFN_D3D10REFLECTSHADER)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector); +static PFN_D3D10REFLECTSHADER _D3D10ReflectShader_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10ReflectShader(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10ShaderReflection **ppReflector) { + const char *_name = "D3D10ReflectShader"; + LOG(); + if (!_D3D10ReflectShader_ptr) { + _D3D10ReflectShader_ptr = (PFN_D3D10REFLECTSHADER)_getD3D10ProcAddress(_name); + if (!_D3D10ReflectShader_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10ReflectShader_ptr(pShaderBytecode, BytecodeLength, ppReflector); +} + +typedef HRESULT (WINAPI *PFN_D3D10PREPROCESSSHADER)(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, ID3D10Blob **ppShaderText, ID3D10Blob **ppErrorMsgs); +static PFN_D3D10PREPROCESSSHADER _D3D10PreprocessShader_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10PreprocessShader(const char *pSrcData, SIZE_T SrcDataSize, const char *pFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, ID3D10Blob **ppShaderText, ID3D10Blob **ppErrorMsgs) { + const char *_name = "D3D10PreprocessShader"; + LOG(); + if (!_D3D10PreprocessShader_ptr) { + _D3D10PreprocessShader_ptr = (PFN_D3D10PREPROCESSSHADER)_getD3D10ProcAddress(_name); + if (!_D3D10PreprocessShader_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10PreprocessShader_ptr(pSrcData, SrcDataSize, pFileName, pDefines, pInclude, ppShaderText, ppErrorMsgs); +} + +typedef HRESULT (WINAPI *PFN_D3D10GETINPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob); +static PFN_D3D10GETINPUTSIGNATUREBLOB _D3D10GetInputSignatureBlob_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10GetInputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) { + const char *_name = "D3D10GetInputSignatureBlob"; + LOG(); + if (!_D3D10GetInputSignatureBlob_ptr) { + _D3D10GetInputSignatureBlob_ptr = (PFN_D3D10GETINPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name); + if (!_D3D10GetInputSignatureBlob_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetInputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob); +} + +typedef HRESULT (WINAPI *PFN_D3D10GETOUTPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob); +static PFN_D3D10GETOUTPUTSIGNATUREBLOB _D3D10GetOutputSignatureBlob_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10GetOutputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) { + const char *_name = "D3D10GetOutputSignatureBlob"; + LOG(); + if (!_D3D10GetOutputSignatureBlob_ptr) { + _D3D10GetOutputSignatureBlob_ptr = (PFN_D3D10GETOUTPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name); + if (!_D3D10GetOutputSignatureBlob_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetOutputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob); +} + +typedef HRESULT (WINAPI *PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob); +static PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB _D3D10GetInputAndOutputSignatureBlob_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10GetInputAndOutputSignatureBlob(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppSignatureBlob) { + const char *_name = "D3D10GetInputAndOutputSignatureBlob"; + LOG(); + if (!_D3D10GetInputAndOutputSignatureBlob_ptr) { + _D3D10GetInputAndOutputSignatureBlob_ptr = (PFN_D3D10GETINPUTANDOUTPUTSIGNATUREBLOB)_getD3D10ProcAddress(_name); + if (!_D3D10GetInputAndOutputSignatureBlob_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetInputAndOutputSignatureBlob_ptr(pShaderBytecode, BytecodeLength, ppSignatureBlob); +} + +typedef HRESULT (WINAPI *PFN_D3D10GETSHADERDEBUGINFO)(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppDebugInfo); +static PFN_D3D10GETSHADERDEBUGINFO _D3D10GetShaderDebugInfo_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10GetShaderDebugInfo(const void *pShaderBytecode, SIZE_T BytecodeLength, ID3D10Blob **ppDebugInfo) { + const char *_name = "D3D10GetShaderDebugInfo"; + LOG(); + if (!_D3D10GetShaderDebugInfo_ptr) { + _D3D10GetShaderDebugInfo_ptr = (PFN_D3D10GETSHADERDEBUGINFO)_getD3D10ProcAddress(_name); + if (!_D3D10GetShaderDebugInfo_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetShaderDebugInfo_ptr(pShaderBytecode, BytecodeLength, ppDebugInfo); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKUNION)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult); +static PFN_D3D10STATEBLOCKMASKUNION _D3D10StateBlockMaskUnion_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskUnion(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) { + const char *_name = "D3D10StateBlockMaskUnion"; + LOG(); + if (!_D3D10StateBlockMaskUnion_ptr) { + _D3D10StateBlockMaskUnion_ptr = (PFN_D3D10STATEBLOCKMASKUNION)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskUnion_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskUnion_ptr(pA, pB, pResult); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKINTERSECT)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult); +static PFN_D3D10STATEBLOCKMASKINTERSECT _D3D10StateBlockMaskIntersect_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskIntersect(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) { + const char *_name = "D3D10StateBlockMaskIntersect"; + LOG(); + if (!_D3D10StateBlockMaskIntersect_ptr) { + _D3D10StateBlockMaskIntersect_ptr = (PFN_D3D10STATEBLOCKMASKINTERSECT)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskIntersect_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskIntersect_ptr(pA, pB, pResult); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDIFFERENCE)(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult); +static PFN_D3D10STATEBLOCKMASKDIFFERENCE _D3D10StateBlockMaskDifference_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskDifference(D3D10_STATE_BLOCK_MASK *pA, D3D10_STATE_BLOCK_MASK *pB, D3D10_STATE_BLOCK_MASK *pResult) { + const char *_name = "D3D10StateBlockMaskDifference"; + LOG(); + if (!_D3D10StateBlockMaskDifference_ptr) { + _D3D10StateBlockMaskDifference_ptr = (PFN_D3D10STATEBLOCKMASKDIFFERENCE)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskDifference_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskDifference_ptr(pA, pB, pResult); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKENABLECAPTURE)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength); +static PFN_D3D10STATEBLOCKMASKENABLECAPTURE _D3D10StateBlockMaskEnableCapture_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskEnableCapture(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength) { + const char *_name = "D3D10StateBlockMaskEnableCapture"; + LOG(); + if (!_D3D10StateBlockMaskEnableCapture_ptr) { + _D3D10StateBlockMaskEnableCapture_ptr = (PFN_D3D10STATEBLOCKMASKENABLECAPTURE)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskEnableCapture_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskEnableCapture_ptr(pMask, StateType, RangeStart, RangeLength); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDISABLECAPTURE)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength); +static PFN_D3D10STATEBLOCKMASKDISABLECAPTURE _D3D10StateBlockMaskDisableCapture_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskDisableCapture(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT RangeStart, UINT RangeLength) { + const char *_name = "D3D10StateBlockMaskDisableCapture"; + LOG(); + if (!_D3D10StateBlockMaskDisableCapture_ptr) { + _D3D10StateBlockMaskDisableCapture_ptr = (PFN_D3D10STATEBLOCKMASKDISABLECAPTURE)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskDisableCapture_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskDisableCapture_ptr(pMask, StateType, RangeStart, RangeLength); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKENABLEALL)(D3D10_STATE_BLOCK_MASK *pMask); +static PFN_D3D10STATEBLOCKMASKENABLEALL _D3D10StateBlockMaskEnableAll_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskEnableAll(D3D10_STATE_BLOCK_MASK *pMask) { + const char *_name = "D3D10StateBlockMaskEnableAll"; + LOG(); + if (!_D3D10StateBlockMaskEnableAll_ptr) { + _D3D10StateBlockMaskEnableAll_ptr = (PFN_D3D10STATEBLOCKMASKENABLEALL)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskEnableAll_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskEnableAll_ptr(pMask); +} + +typedef HRESULT (WINAPI *PFN_D3D10STATEBLOCKMASKDISABLEALL)(D3D10_STATE_BLOCK_MASK *pMask); +static PFN_D3D10STATEBLOCKMASKDISABLEALL _D3D10StateBlockMaskDisableAll_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10StateBlockMaskDisableAll(D3D10_STATE_BLOCK_MASK *pMask) { + const char *_name = "D3D10StateBlockMaskDisableAll"; + LOG(); + if (!_D3D10StateBlockMaskDisableAll_ptr) { + _D3D10StateBlockMaskDisableAll_ptr = (PFN_D3D10STATEBLOCKMASKDISABLEALL)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskDisableAll_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskDisableAll_ptr(pMask); +} + +typedef BOOL (WINAPI *PFN_D3D10STATEBLOCKMASKGETSETTING)(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT Entry); +static PFN_D3D10STATEBLOCKMASKGETSETTING _D3D10StateBlockMaskGetSetting_ptr = NULL; + +EXTERN_C BOOL WINAPI +D3D10StateBlockMaskGetSetting(D3D10_STATE_BLOCK_MASK *pMask, D3D10_DEVICE_STATE_TYPES StateType, UINT Entry) { + const char *_name = "D3D10StateBlockMaskGetSetting"; + LOG(); + if (!_D3D10StateBlockMaskGetSetting_ptr) { + _D3D10StateBlockMaskGetSetting_ptr = (PFN_D3D10STATEBLOCKMASKGETSETTING)_getD3D10ProcAddress(_name); + if (!_D3D10StateBlockMaskGetSetting_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10StateBlockMaskGetSetting_ptr(pMask, StateType, Entry); +} + +typedef HRESULT (WINAPI *PFN_D3D10CREATESTATEBLOCK)(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask, ID3D10StateBlock **ppStateBlock); +static PFN_D3D10CREATESTATEBLOCK _D3D10CreateStateBlock_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CreateStateBlock(ID3D10Device *pDevice, D3D10_STATE_BLOCK_MASK *pStateBlockMask, ID3D10StateBlock **ppStateBlock) { + const char *_name = "D3D10CreateStateBlock"; + LOG(); + if (!_D3D10CreateStateBlock_ptr) { + _D3D10CreateStateBlock_ptr = (PFN_D3D10CREATESTATEBLOCK)_getD3D10ProcAddress(_name); + if (!_D3D10CreateStateBlock_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CreateStateBlock_ptr(pDevice, pStateBlockMask, ppStateBlock); +} + +typedef HRESULT (WINAPI *PFN_D3D10COMPILEEFFECTFROMMEMORY)(void *pData, SIZE_T DataLength, const char *pSrcFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, UINT HLSLFlags, UINT FXFlags, ID3D10Blob **ppCompiledEffect, ID3D10Blob **ppErrors); +static PFN_D3D10COMPILEEFFECTFROMMEMORY _D3D10CompileEffectFromMemory_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CompileEffectFromMemory(void *pData, SIZE_T DataLength, const char *pSrcFileName, const D3D10_SHADER_MACRO *pDefines, ID3D10Include *pInclude, UINT HLSLFlags, UINT FXFlags, ID3D10Blob **ppCompiledEffect, ID3D10Blob **ppErrors) { + const char *_name = "D3D10CompileEffectFromMemory"; + LOG(); + if (!_D3D10CompileEffectFromMemory_ptr) { + _D3D10CompileEffectFromMemory_ptr = (PFN_D3D10COMPILEEFFECTFROMMEMORY)_getD3D10ProcAddress(_name); + if (!_D3D10CompileEffectFromMemory_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CompileEffectFromMemory_ptr(pData, DataLength, pSrcFileName, pDefines, pInclude, HLSLFlags, FXFlags, ppCompiledEffect, ppErrors); +} + +typedef HRESULT (WINAPI *PFN_D3D10CREATEEFFECTFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool *pEffectPool, ID3D10Effect **ppEffect); +static PFN_D3D10CREATEEFFECTFROMMEMORY _D3D10CreateEffectFromMemory_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CreateEffectFromMemory(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool *pEffectPool, ID3D10Effect **ppEffect) { + const char *_name = "D3D10CreateEffectFromMemory"; + LOG(); + if (!_D3D10CreateEffectFromMemory_ptr) { + _D3D10CreateEffectFromMemory_ptr = (PFN_D3D10CREATEEFFECTFROMMEMORY)_getD3D10ProcAddress(_name); + if (!_D3D10CreateEffectFromMemory_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CreateEffectFromMemory_ptr(pData, DataLength, FXFlags, pDevice, pEffectPool, ppEffect); +} + +typedef HRESULT (WINAPI *PFN_D3D10CREATEEFFECTPOOLFROMMEMORY)(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool); +static PFN_D3D10CREATEEFFECTPOOLFROMMEMORY _D3D10CreateEffectPoolFromMemory_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CreateEffectPoolFromMemory(void *pData, SIZE_T DataLength, UINT FXFlags, ID3D10Device *pDevice, ID3D10EffectPool **ppEffectPool) { + const char *_name = "D3D10CreateEffectPoolFromMemory"; + LOG(); + if (!_D3D10CreateEffectPoolFromMemory_ptr) { + _D3D10CreateEffectPoolFromMemory_ptr = (PFN_D3D10CREATEEFFECTPOOLFROMMEMORY)_getD3D10ProcAddress(_name); + if (!_D3D10CreateEffectPoolFromMemory_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CreateEffectPoolFromMemory_ptr(pData, DataLength, FXFlags, pDevice, ppEffectPool); +} + +typedef HRESULT (WINAPI *PFN_D3D10DISASSEMBLEEFFECT)(ID3D10Effect *pEffect, BOOL EnableColorCode, ID3D10Blob **ppDisassembly); +static PFN_D3D10DISASSEMBLEEFFECT _D3D10DisassembleEffect_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10DisassembleEffect(ID3D10Effect *pEffect, BOOL EnableColorCode, ID3D10Blob **ppDisassembly) { + const char *_name = "D3D10DisassembleEffect"; + LOG(); + if (!_D3D10DisassembleEffect_ptr) { + _D3D10DisassembleEffect_ptr = (PFN_D3D10DISASSEMBLEEFFECT)_getD3D10ProcAddress(_name); + if (!_D3D10DisassembleEffect_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10DisassembleEffect_ptr(pEffect, EnableColorCode, ppDisassembly); +} + +typedef HRESULT (WINAPI *PFN_D3D10CREATEBLOB)(SIZE_T NumBytes, ID3D10Blob **ppBuffer); +static PFN_D3D10CREATEBLOB _D3D10CreateBlob_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D10CreateBlob(SIZE_T NumBytes, ID3D10Blob **ppBuffer) { + const char *_name = "D3D10CreateBlob"; + LOG(); + if (!_D3D10CreateBlob_ptr) { + _D3D10CreateBlob_ptr = (PFN_D3D10CREATEBLOB)_getD3D10ProcAddress(_name); + if (!_D3D10CreateBlob_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10CreateBlob_ptr(NumBytes, ppBuffer); +} + +typedef DWORD (WINAPI *PFN_D3D10GETVERSION)(void); +static PFN_D3D10GETVERSION _D3D10GetVersion_ptr = NULL; + +EXTERN_C DWORD WINAPI +D3D10GetVersion(void) { + const char *_name = "D3D10GetVersion"; + LOG(); + if (!_D3D10GetVersion_ptr) { + _D3D10GetVersion_ptr = (PFN_D3D10GETVERSION)_getD3D10ProcAddress(_name); + if (!_D3D10GetVersion_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10GetVersion_ptr(); +} + +typedef DWORD (WINAPI *PFN_D3D10REGISTERLAYERS)(void); +static PFN_D3D10REGISTERLAYERS _D3D10RegisterLayers_ptr = NULL; + +EXTERN_C DWORD WINAPI +D3D10RegisterLayers(void) { + const char *_name = "D3D10RegisterLayers"; + LOG(); + if (!_D3D10RegisterLayers_ptr) { + _D3D10RegisterLayers_ptr = (PFN_D3D10REGISTERLAYERS)_getD3D10ProcAddress(_name); + if (!_D3D10RegisterLayers_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D10RegisterLayers_ptr(); +} + diff --git a/wrappers/d3d10trace.py b/wrappers/d3d10trace.py deleted file mode 100644 index 1de1392..0000000 --- a/wrappers/d3d10trace.py +++ /dev/null @@ -1,48 +0,0 @@ -########################################################################## -# -# Copyright 2008-2009 VMware, Inc. -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -from d3dcommontrace import D3DCommonTracer -from specs.stdapi import API -from specs.dxgi import dxgi -from specs.d3d10misc import d3d10 - - -if __name__ == '__main__': - print '#define INITGUID' - print - print '#include "trace_writer_local.hpp"' - print '#include "os.hpp"' - print - print '#include "d3d10imports.hpp"' - print '#include "d3dcommonshader.hpp"' - print '#include "d3d10size.hpp"' - print - - api = API() - api.addModule(dxgi) - api.addModule(d3d10) - tracer = D3DCommonTracer() - tracer.traceApi(api) diff --git a/wrappers/d3d11.def b/wrappers/d3d11.def index a9d2d4b..af7ea8c 100644 --- a/wrappers/d3d11.def +++ b/wrappers/d3d11.def @@ -1,12 +1,44 @@ LIBRARY "d3d11" EXPORTS + D3DKMTDestroyAllocation + D3DKMTDestroyContext + D3DKMTDestroyDevice + D3DKMTDestroySynchronizationObject + D3DKMTQueryAdapterInfo + D3DKMTSetDisplayPrivateDriverFormat + D3DKMTSignalSynchronizationObject + D3DKMTUnlock + D3DKMTWaitForSynchronizationObject + OpenAdapter10 + OpenAdapter10_2 D3D11CoreCreateDevice D3D11CoreCreateLayeredDevice D3D11CoreGetLayeredDeviceSize D3D11CoreRegisterLayers D3D11CreateDevice D3D11CreateDeviceAndSwapChain - - CreateDXGIFactory - CreateDXGIFactory1 + D3DKMTCreateAllocation + D3DKMTCreateContext + D3DKMTCreateDevice + D3DKMTCreateSynchronizationObject + D3DKMTEscape + D3DKMTGetContextSchedulingPriority + D3DKMTGetDeviceState + D3DKMTGetDisplayModeList + D3DKMTGetMultisampleMethodList + D3DKMTGetRuntimeData + D3DKMTGetSharedPrimaryHandle + D3DKMTLock + D3DKMTOpenAdapterFromHdc + D3DKMTOpenResource + D3DKMTPresent + D3DKMTQueryAllocationResidency + D3DKMTQueryResourceInfo + D3DKMTRender + D3DKMTSetAllocationPriority + D3DKMTSetContextSchedulingPriority + D3DKMTSetDisplayMode + D3DKMTSetGammaRamp + D3DKMTSetVidPnSourceOwner + D3DKMTWaitForVerticalBlankEvent diff --git a/wrappers/d3d11stubs.cpp b/wrappers/d3d11stubs.cpp new file mode 100644 index 0000000..e5d9909 --- /dev/null +++ b/wrappers/d3d11stubs.cpp @@ -0,0 +1,121 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + *Stubs for internal D3D11 functions. + */ + + +#include "os.hpp" + +#include "d3d11imports.hpp" + + +static HMODULE g_hD3D11Module = NULL; + + +static PROC +_getD3D11ProcAddress(LPCSTR lpProcName) { + if (!g_hD3D11Module) { + char szDll[MAX_PATH] = {0}; + if (!GetSystemDirectoryA(szDll, MAX_PATH)) { + return NULL; + } + strcat(szDll, "\\\\d3d11.dll"); + g_hD3D11Module = LoadLibraryA(szDll); + if (!g_hD3D11Module) { + return NULL; + } + } + return GetProcAddress(g_hD3D11Module, lpProcName); +} + + +typedef HRESULT (WINAPI *PFN_D3D11COREREGISTERLAYERS)(const void *unknown0, DWORD unknown1); +static PFN_D3D11COREREGISTERLAYERS _D3D11CoreRegisterLayers_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D11CoreRegisterLayers(const void *unknown0, DWORD unknown1) { + const char *_name = "D3D11CoreRegisterLayers"; + if (!_D3D11CoreRegisterLayers_ptr) { + _D3D11CoreRegisterLayers_ptr = (PFN_D3D11COREREGISTERLAYERS)_getD3D11ProcAddress(_name); + if (!_D3D11CoreRegisterLayers_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D11CoreRegisterLayers_ptr(unknown0, unknown1); +} + +typedef SIZE_T (WINAPI *PFN_D3D11COREGETLAYEREDDEVICESIZE)(const void *unknown0, DWORD unknown1); +static PFN_D3D11COREGETLAYEREDDEVICESIZE _D3D11CoreGetLayeredDeviceSize_ptr = NULL; + +EXTERN_C SIZE_T WINAPI +D3D11CoreGetLayeredDeviceSize(const void *unknown0, DWORD unknown1) { + const char *_name = "D3D11CoreGetLayeredDeviceSize"; + if (!_D3D11CoreGetLayeredDeviceSize_ptr) { + _D3D11CoreGetLayeredDeviceSize_ptr = (PFN_D3D11COREGETLAYEREDDEVICESIZE)_getD3D11ProcAddress(_name); + if (!_D3D11CoreGetLayeredDeviceSize_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D11CoreGetLayeredDeviceSize_ptr(unknown0, unknown1); +} + +typedef HRESULT (WINAPI *PFN_D3D11CORECREATELAYEREDDEVICE)(const void *unknown0, DWORD unknown1, const void *unknown2, REFIID riid, void **ppvObj); +static PFN_D3D11CORECREATELAYEREDDEVICE _D3D11CoreCreateLayeredDevice_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D11CoreCreateLayeredDevice(const void *unknown0, DWORD unknown1, const void *unknown2, REFIID riid, void **ppvObj) { + const char *_name = "D3D11CoreCreateLayeredDevice"; + if (!_D3D11CoreCreateLayeredDevice_ptr) { + _D3D11CoreCreateLayeredDevice_ptr = (PFN_D3D11CORECREATELAYEREDDEVICE)_getD3D11ProcAddress(_name); + if (!_D3D11CoreCreateLayeredDevice_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D11CoreCreateLayeredDevice_ptr(unknown0, unknown1, unknown2, riid, ppvObj); +} + +typedef HRESULT (WINAPI *PFN_D3D11CORECREATEDEVICE)(DWORD unknown0, DWORD unknown1, DWORD unknown2, DWORD unknown3, DWORD unknown4, DWORD unknown5, DWORD unknown6, DWORD unknown7, DWORD unknown8); +static PFN_D3D11CORECREATEDEVICE _D3D11CoreCreateDevice_ptr = NULL; + +EXTERN_C HRESULT WINAPI +D3D11CoreCreateDevice(DWORD unknown0, DWORD unknown1, DWORD unknown2, DWORD unknown3, DWORD unknown4, DWORD unknown5, DWORD unknown6, DWORD unknown7, DWORD unknown8) { + const char *_name = "D3D11CoreCreateDevice"; + if (!_D3D11CoreCreateDevice_ptr) { + _D3D11CoreCreateDevice_ptr = (PFN_D3D11CORECREATEDEVICE)_getD3D11ProcAddress(_name); + if (!_D3D11CoreCreateDevice_ptr) { + os::log("error: unavailable function %s\n", _name); + os::abort(); + } + } + return _D3D11CoreCreateDevice_ptr(unknown0, unknown1, unknown2, unknown3, unknown4, unknown5, unknown6, unknown7, unknown8); +} + + diff --git a/wrappers/d3d11trace.py b/wrappers/d3d11trace.py deleted file mode 100644 index d43f147..0000000 --- a/wrappers/d3d11trace.py +++ /dev/null @@ -1,57 +0,0 @@ -########################################################################## -# -# Copyright 2008-2012 VMware, Inc. -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -import sys - -from d3dcommontrace import D3DCommonTracer -from specs.stdapi import API -from specs.dxgi import dxgi -from specs.d3d11 import d3d11 - - -if __name__ == '__main__': - print '#define INITGUID' - print - print '#include "trace_writer_local.hpp"' - print '#include "os.hpp"' - print - print '#include "d3d11imports.hpp"' - print - - if int(sys.argv[1]): - import specs.d3d11_1 - print '#include ' - print - - print '#include "d3dcommonshader.hpp"' - print '#include "d3d11size.hpp"' - print - - api = API() - api.addModule(dxgi) - api.addModule(d3d11) - tracer = D3DCommonTracer() - tracer.traceApi(api) diff --git a/wrappers/d3d9shader.cpp b/wrappers/d3d9shader.cpp index b2a39f6..6dbe06b 100644 --- a/wrappers/d3d9shader.cpp +++ b/wrappers/d3d9shader.cpp @@ -27,78 +27,28 @@ #include +#include "os.hpp" +#include "d3dshader.hpp" + #include "d3d9shader.hpp" #include "d3d9imports.hpp" #include "d3d9size.hpp" -typedef HRESULT -(WINAPI *PD3DXDISASSEMBLESHADER)( - CONST DWORD *pShader, - BOOL EnableColorCode, - LPCSTR pComments, - LPD3DXBUFFER *ppDisassembly -); - - void DumpShader(trace::Writer &writer, const DWORD *tokens) { - static BOOL firsttime = TRUE; - - /* - * TODO: Consider using d3dcompile_xx.dll per - * http://msdn.microsoft.com/en-us/library/windows/desktop/ee663275.aspx - */ - - static HMODULE hD3DXModule = NULL; - static PD3DXDISASSEMBLESHADER pfnD3DXDisassembleShader = NULL; - - if (firsttime) { - if (!hD3DXModule) { - unsigned release; - int version; - for (release = 0; release <= 1; ++release) { - /* Version 41 corresponds to Mar 2009 version of DirectX Runtime / SDK */ - for (version = 41; version >= 0; --version) { - char filename[256]; - _snprintf(filename, sizeof(filename), - "d3dx9%s%s%u.dll", release ? "" : "d", version ? "_" : "", version); - hD3DXModule = LoadLibraryA(filename); - if (hD3DXModule) - goto found; - } - } -found: - ; - } - - if (hD3DXModule) { - if (!pfnD3DXDisassembleShader) { - pfnD3DXDisassembleShader = (PD3DXDISASSEMBLESHADER)GetProcAddress(hD3DXModule, "D3DXDisassembleShader"); - } - } - - firsttime = FALSE; - } - - LPD3DXBUFFER pDisassembly = NULL; - HRESULT hr = E_FAIL; - - if (pfnD3DXDisassembleShader) { - hr = pfnD3DXDisassembleShader(tokens, FALSE, NULL, &pDisassembly); - } + IDisassemblyBuffer *pDisassembly = NULL; + HRESULT hr = DisassembleShader(tokens, &pDisassembly); if (SUCCEEDED(hr)) { writer.beginRepr(); - writer.writeString((const char *)pDisassembly->GetBufferPointer(), pDisassembly->GetBufferSize()); + writer.writeString((const char *)pDisassembly->GetBufferPointer(), + pDisassembly->GetBufferSize()); + pDisassembly->Release(); } writer.writeBlob(tokens, _shaderSize(tokens)); - if (pDisassembly) { - pDisassembly->Release(); - } - if (SUCCEEDED(hr)) { writer.endRepr(); } diff --git a/wrappers/d3dcommonshader.cpp b/wrappers/d3dcommonshader.cpp index 2ae804b..a66e017 100644 --- a/wrappers/d3dcommonshader.cpp +++ b/wrappers/d3dcommonshader.cpp @@ -27,106 +27,24 @@ #include +#include "d3dshader.hpp" #include "d3dcommonshader.hpp" -struct ID3D10Blob : public IUnknown { -public: - virtual LPVOID STDMETHODCALLTYPE GetBufferPointer( void) = 0; - virtual SIZE_T STDMETHODCALLTYPE GetBufferSize( void) = 0; -}; - -typedef ID3D10Blob ID3DBlob; -typedef ID3DBlob* LPD3DBLOB; - -#define D3D_DISASM_ENABLE_COLOR_CODE 0x00000001 -#define D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS 0x00000002 -#define D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING 0x00000004 -#define D3D_DISASM_ENABLE_INSTRUCTION_CYCLE 0x00000008 -#define D3D_DISASM_DISABLE_DEBUG_INFO 0x00000010 -#define D3D_DISASM_ENABLE_INSTRUCTION_OFFSET 0x00000020 -#define D3D_DISASM_INSTRUCTION_ONLY 0x00000040 - -typedef HRESULT -(WINAPI *PFND3DDISASSEMBLE)( - LPCVOID pSrcData, - SIZE_T SrcDataSize, - UINT Flags, - LPCSTR szComments, - ID3DBlob **ppDisassembly -); - -static PFND3DDISASSEMBLE pfnD3DDisassemble = NULL; - -typedef HRESULT -(WINAPI *PFND3D10DISASSEMBLESHADER)( - const void *pShader, - SIZE_T BytecodeLength, - BOOL EnableColorCode, - LPCSTR pComments, - ID3D10Blob **ppDisassembly -); - -static PFND3D10DISASSEMBLESHADER pfnD3D10DisassembleShader = NULL; - void DumpShader(trace::Writer &writer, const void *pShaderBytecode, SIZE_T BytecodeLength) { - static bool firsttime = true; - - if (firsttime) { - char szFilename[MAX_PATH]; - HMODULE hModule = NULL; - - int version; - for (version = 44; version >= 33; --version) { - _snprintf(szFilename, sizeof(szFilename), "d3dcompiler_%i.dll", version); - hModule = LoadLibraryA(szFilename); - if (hModule) { - pfnD3DDisassemble = (PFND3DDISASSEMBLE) - GetProcAddress(hModule, "D3DDisassemble"); - if (pfnD3DDisassemble) { - break; - } - } - } - - if (!pfnD3DDisassemble) { - /* - * Fallback to D3D10DisassembleShader, which should be always present. - */ - if (GetSystemDirectoryA(szFilename, MAX_PATH)) { - strcat(szFilename, "\\d3d10.dll"); - hModule = LoadLibraryA(szFilename); - if (hModule) { - pfnD3D10DisassembleShader = (PFND3D10DISASSEMBLESHADER) - GetProcAddress(hModule, "D3D10DisassembleShader"); - } - } - } - - firsttime = false; - } - - LPD3DBLOB pDisassembly = NULL; - HRESULT hr = E_FAIL; - - if (pfnD3DDisassemble) { - hr = pfnD3DDisassemble(pShaderBytecode, BytecodeLength, 0, NULL, &pDisassembly); - } else if (pfnD3D10DisassembleShader) { - hr = pfnD3D10DisassembleShader(pShaderBytecode, BytecodeLength, 0, NULL, &pDisassembly); - } + IDisassemblyBuffer *pDisassembly = NULL; + HRESULT hr = DisassembleShader(pShaderBytecode, BytecodeLength, &pDisassembly); if (SUCCEEDED(hr)) { writer.beginRepr(); - writer.writeString((const char *)pDisassembly->GetBufferPointer(), pDisassembly->GetBufferSize()); + writer.writeString((const char *)pDisassembly->GetBufferPointer(), + pDisassembly->GetBufferSize()); + pDisassembly->Release(); } writer.writeBlob(pShaderBytecode, BytecodeLength); - if (pDisassembly) { - pDisassembly->Release(); - } - if (SUCCEEDED(hr)) { writer.endRepr(); } diff --git a/wrappers/d3dcommontrace.py b/wrappers/d3dcommontrace.py deleted file mode 100644 index e0927cc..0000000 --- a/wrappers/d3dcommontrace.py +++ /dev/null @@ -1,70 +0,0 @@ -########################################################################## -# -# Copyright 2008-2009 VMware, Inc. -# All Rights Reserved. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. -# -##########################################################################/ - - -from dlltrace import DllTracer -from specs import stdapi - - -class D3DCommonTracer(DllTracer): - - def serializeArgValue(self, function, arg): - # Dump shaders as strings - if isinstance(arg.type, stdapi.Blob) and arg.name.startswith('pShaderBytecode'): - print ' DumpShader(trace::localWriter, %s, %s);' % (arg.name, arg.type.size) - return - - DllTracer.serializeArgValue(self, function, arg) - - def enumWrapperInterfaceVariables(self, interface): - variables = DllTracer.enumWrapperInterfaceVariables(self, interface) - - # Add additional members to track maps - if interface.getMethodByName('Map') is not None: - variables += [ - ('VOID *', '_pMappedData', '0'), - ('size_t', '_MappedSize', '0'), - ] - - return variables - - def implementWrapperInterfaceMethodBody(self, interface, base, method): - if method.name == 'Unmap': - print ' if (_MappedSize && _pMappedData) {' - self.emit_memcpy('_pMappedData', '_pMappedData', '_MappedSize') - print ' }' - - DllTracer.implementWrapperInterfaceMethodBody(self, interface, base, method) - - if method.name == 'Map': - # NOTE: recursive locks are explicitely forbidden - print ' if (SUCCEEDED(_result)) {' - print ' _getMapInfo(_this, %s, _pMappedData, _MappedSize);' % ', '.join(method.argNames()) - print ' } else {' - print ' _pMappedData = NULL;' - print ' _MappedSize = 0;' - print ' }' - - diff --git a/wrappers/d3dkmtstubs.cpp b/wrappers/d3dkmtstubs.cpp new file mode 100644 index 0000000..2d12587 --- /dev/null +++ b/wrappers/d3dkmtstubs.cpp @@ -0,0 +1,713 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + * Stubs for internal DXGI D3DKMT functions. + */ + + +#include +#include + + +#ifndef NTSTATUS +#define NTSTATUS LONG +#endif + +#ifndef STATUS_NOT_IMPLEMENTED +#define STATUS_NOT_IMPLEMENTED 0xC0000002 +#endif + +#define D3DKMT_CREATEALLOCATION void +#define D3DKMT_CREATEALLOCATION void +#define D3DKMT_QUERYRESOURCEINFO void +#define D3DKMT_OPENRESOURCE void +#define D3DKMT_OPENRESOURCE void +#define D3DKMT_DESTROYALLOCATION void +#define D3DKMT_SETALLOCATIONPRIORITY void +#define D3DKMT_QUERYALLOCATIONRESIDENCY void +#define D3DKMT_CREATEDEVICE void +#define D3DKMT_DESTROYDEVICE void +#define D3DKMT_CREATECONTEXT void +#define D3DKMT_DESTROYCONTEXT void +#define D3DKMT_CREATESYNCHRONIZATIONOBJECT void +#define D3DKMT_CREATESYNCHRONIZATIONOBJECT2 void +#define D3DKMT_OPENSYNCHRONIZATIONOBJECT void +#define D3DKMT_DESTROYSYNCHRONIZATIONOBJECT void +#define D3DKMT_WAITFORSYNCHRONIZATIONOBJECT void +#define D3DKMT_WAITFORSYNCHRONIZATIONOBJECT2 void +#define D3DKMT_SIGNALSYNCHRONIZATIONOBJECT void +#define D3DKMT_SIGNALSYNCHRONIZATIONOBJECT2 void +#define D3DKMT_LOCK void +#define D3DKMT_UNLOCK void +#define D3DKMT_GETDISPLAYMODELIST void +#define D3DKMT_SETDISPLAYMODE void +#define D3DKMT_GETMULTISAMPLEMETHODLIST void +#define D3DKMT_PRESENT void +#define D3DKMT_RENDER void +#define D3DKMT_GETRUNTIMEDATA void +#define D3DKMT_QUERYADAPTERINFO void +#define D3DKMT_OPENADAPTERFROMHDC void +#define D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME void +#define D3DKMT_OPENADAPTERFROMDEVICENAME void +#define D3DKMT_CLOSEADAPTER void +#define D3DKMT_GETSHAREDPRIMARYHANDLE void +#define D3DKMT_ESCAPE void +#define D3DKMT_SETVIDPNSOURCEOWNER void +#define D3DKMT_GETPRESENTHISTORY void +#define D3DKMT_HANDLE LONG +#define D3DKMT_CREATEOVERLAY void +#define D3DKMT_UPDATEOVERLAY void +#define D3DKMT_FLIPOVERLAY void +#define D3DKMT_DESTROYOVERLAY void +#define D3DKMT_WAITFORVERTICALBLANKEVENT void +#define D3DKMT_SETGAMMARAMP void +#define D3DKMT_GETDEVICESTATE void +#define D3DKMT_CREATEDCFROMMEMORY void +#define D3DKMT_DESTROYDCFROMMEMORY void +#define D3DKMT_SETCONTEXTSCHEDULINGPRIORITY void +#define D3DKMT_GETCONTEXTSCHEDULINGPRIORITY void +#define D3DKMT_SCHEDULINGPRIORITYCLASS INT +#define D3DKMT_GETSCANLINE void +#define D3DKMT_CHANGESURFACEPOINTER void +#define D3DKMT_SETQUEUEDLIMIT void +#define D3DKMT_POLLDISPLAYCHILDREN void +#define D3DKMT_INVALIDATEACTIVEVIDPN void +#define D3DKMT_CHECKOCCLUSION void +#define D3DKMT_WAITFORIDLE void +#define D3DKMT_CHECKMONITORPOWERSTATE void +#define D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP void +#define D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT void +#define D3DKMT_SHAREDPRIMARYLOCKNOTIFICATION void +#define D3DKMT_SHAREDPRIMARYUNLOCKNOTIFICATION void +#define D3DKMT_CREATEKEYEDMUTEX void +#define D3DKMT_OPENKEYEDMUTEX void +#define D3DKMT_DESTROYKEYEDMUTEX void +#define D3DKMT_ACQUIREKEYEDMUTEX void +#define D3DKMT_RELEASEKEYEDMUTEX void +#define D3DKMT_CONFIGURESHAREDRESOURCE void +#define D3DKMT_GETOVERLAYSTATE void +#define D3DKMT_CHECKSHAREDRESOURCEACCESS void + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateAllocation(D3DKMT_CREATEALLOCATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateAllocation2(D3DKMT_CREATEALLOCATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTQueryResourceInfo(D3DKMT_QUERYRESOURCEINFO *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenResource(D3DKMT_OPENRESOURCE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenResource2(D3DKMT_OPENRESOURCE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyAllocation(CONST D3DKMT_DESTROYALLOCATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetAllocationPriority(CONST D3DKMT_SETALLOCATIONPRIORITY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTQueryAllocationResidency(CONST D3DKMT_QUERYALLOCATIONRESIDENCY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateDevice(D3DKMT_CREATEDEVICE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyDevice(CONST D3DKMT_DESTROYDEVICE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateContext(D3DKMT_CREATECONTEXT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyContext(CONST D3DKMT_DESTROYCONTEXT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateSynchronizationObject(D3DKMT_CREATESYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateSynchronizationObject2(D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenSynchronizationObject(D3DKMT_OPENSYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroySynchronizationObject(CONST D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTWaitForSynchronizationObject(CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTWaitForSynchronizationObject2(CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECT2 *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSignalSynchronizationObject(CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSignalSynchronizationObject2(CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT2 *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTLock(D3DKMT_LOCK *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTUnlock(CONST D3DKMT_UNLOCK *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetDisplayModeList(D3DKMT_GETDISPLAYMODELIST *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetDisplayMode(CONST D3DKMT_SETDISPLAYMODE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetMultisampleMethodList(D3DKMT_GETMULTISAMPLEMETHODLIST *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTPresent(CONST D3DKMT_PRESENT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTRender(D3DKMT_RENDER *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetRuntimeData(CONST D3DKMT_GETRUNTIMEDATA *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTQueryAdapterInfo(CONST D3DKMT_QUERYADAPTERINFO *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenAdapterFromHdc(D3DKMT_OPENADAPTERFROMHDC *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenAdapterFromGdiDisplayName(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenAdapterFromDeviceName(D3DKMT_OPENADAPTERFROMDEVICENAME *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCloseAdapter(CONST D3DKMT_CLOSEADAPTER *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetSharedPrimaryHandle(D3DKMT_GETSHAREDPRIMARYHANDLE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTEscape(CONST D3DKMT_ESCAPE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetVidPnSourceOwner(CONST D3DKMT_SETVIDPNSOURCEOWNER *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetPresentHistory(D3DKMT_GETPRESENTHISTORY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetPresentQueueEvent(D3DKMT_HANDLE hAdapter, HANDLE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateOverlay(D3DKMT_CREATEOVERLAY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTUpdateOverlay(CONST D3DKMT_UPDATEOVERLAY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTFlipOverlay(CONST D3DKMT_FLIPOVERLAY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyOverlay(CONST D3DKMT_DESTROYOVERLAY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTWaitForVerticalBlankEvent(CONST D3DKMT_WAITFORVERTICALBLANKEVENT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetGammaRamp(CONST D3DKMT_SETGAMMARAMP *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetDeviceState(D3DKMT_GETDEVICESTATE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateDCFromMemory(D3DKMT_CREATEDCFROMMEMORY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyDCFromMemory(CONST D3DKMT_DESTROYDCFROMMEMORY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetContextSchedulingPriority(CONST D3DKMT_SETCONTEXTSCHEDULINGPRIORITY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetContextSchedulingPriority(D3DKMT_GETCONTEXTSCHEDULINGPRIORITY *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetProcessSchedulingPriorityClass(HANDLE hProcess, D3DKMT_SCHEDULINGPRIORITYCLASS Priority) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetProcessSchedulingPriorityClass(HANDLE hProcess, D3DKMT_SCHEDULINGPRIORITYCLASS *pPriority) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTReleaseProcessVidPnSourceOwners(HANDLE hProcess) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetScanLine(D3DKMT_GETSCANLINE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTChangeSurfacePointer(CONST D3DKMT_CHANGESURFACEPOINTER *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetQueuedLimit(CONST D3DKMT_SETQUEUEDLIMIT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTPollDisplayChildren(CONST D3DKMT_POLLDISPLAYCHILDREN *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTInvalidateActiveVidPn(CONST D3DKMT_INVALIDATEACTIVEVIDPN *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCheckOcclusion(CONST D3DKMT_CHECKOCCLUSION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTWaitForIdle(CONST D3DKMT_WAITFORIDLE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCheckMonitorPowerState(CONST D3DKMT_CHECKMONITORPOWERSTATE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C BOOLEAN APIENTRY +D3DKMTCheckExclusiveOwnership(VOID) +{ + assert(0); + return FALSE; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCheckVidPnExclusiveOwnership(CONST D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSetDisplayPrivateDriverFormat(CONST D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSharedPrimaryLockNotification(CONST D3DKMT_SHAREDPRIMARYLOCKNOTIFICATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTSharedPrimaryUnLockNotification(CONST D3DKMT_SHAREDPRIMARYUNLOCKNOTIFICATION *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCreateKeyedMutex(D3DKMT_CREATEKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTOpenKeyedMutex(D3DKMT_OPENKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTDestroyKeyedMutex(CONST D3DKMT_DESTROYKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTAcquireKeyedMutex(D3DKMT_ACQUIREKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTReleaseKeyedMutex(D3DKMT_RELEASEKEYEDMUTEX *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTConfigureSharedResource(CONST D3DKMT_CONFIGURESHAREDRESOURCE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTGetOverlayState(D3DKMT_GETOVERLAYSTATE *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +EXTERN_C NTSTATUS APIENTRY +D3DKMTCheckSharedResourceAccess(CONST D3DKMT_CHECKSHAREDRESOURCEACCESS *pData) +{ + assert(0); + return STATUS_NOT_IMPLEMENTED; +} + + +#define D3D10DDIARG_OPENADAPTER void + +EXTERN_C HRESULT APIENTRY +OpenAdapter10(D3D10DDIARG_OPENADAPTER *pData) { + assert(0); + return E_NOTIMPL; +} + +EXTERN_C HRESULT APIENTRY +OpenAdapter10_2(D3D10DDIARG_OPENADAPTER *pData) { + assert(0); + return E_NOTIMPL; +} + diff --git a/wrappers/dxgi.def b/wrappers/dxgi.def new file mode 100644 index 0000000..db1db15 --- /dev/null +++ b/wrappers/dxgi.def @@ -0,0 +1,47 @@ +LIBRARY "dxgi" + +EXPORTS + D3DKMTCloseAdapter + D3DKMTDestroyAllocation + D3DKMTDestroyContext + D3DKMTDestroyDevice + D3DKMTDestroySynchronizationObject + D3DKMTQueryAdapterInfo + D3DKMTSetDisplayPrivateDriverFormat + D3DKMTSignalSynchronizationObject + D3DKMTUnlock + D3DKMTWaitForSynchronizationObject + DXGIDumpJournal + OpenAdapter10 + OpenAdapter10_2 + CreateDXGIFactory1 + CreateDXGIFactory + D3DKMTCreateAllocation + D3DKMTCreateContext + D3DKMTCreateDevice + D3DKMTCreateSynchronizationObject + D3DKMTEscape + D3DKMTGetContextSchedulingPriority + D3DKMTGetDeviceState + D3DKMTGetDisplayModeList + D3DKMTGetMultisampleMethodList + D3DKMTGetRuntimeData + D3DKMTGetSharedPrimaryHandle + D3DKMTLock + D3DKMTOpenAdapterFromHdc + D3DKMTOpenResource + D3DKMTPresent + D3DKMTQueryAllocationResidency + D3DKMTQueryResourceInfo + D3DKMTRender + D3DKMTSetAllocationPriority + D3DKMTSetContextSchedulingPriority + D3DKMTSetDisplayMode + D3DKMTSetGammaRamp + D3DKMTSetVidPnSourceOwner + D3DKMTWaitForVerticalBlankEvent + DXGID3D10CreateDevice + DXGID3D10CreateLayeredDevice + DXGID3D10GetLayeredDeviceSize + DXGID3D10RegisterLayers + DXGIReportAdapterConfiguration diff --git a/wrappers/dxgistubs.cpp b/wrappers/dxgistubs.cpp new file mode 100644 index 0000000..a4ff930 --- /dev/null +++ b/wrappers/dxgistubs.cpp @@ -0,0 +1,114 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + * Stubs for internal DXGI functions. + */ + + +#include + +#include "d3d10imports.hpp" + +#include "os.hpp" + + +static HMODULE g_hDXGIModule = NULL; + + +static PROC +_getDXGIProcAddress(LPCSTR lpProcName) { + if (!g_hDXGIModule) { + char szDll[MAX_PATH] = {0}; + if (!GetSystemDirectoryA(szDll, MAX_PATH)) { + return NULL; + } + strcat(szDll, "\\\\dxgi.dll"); + g_hDXGIModule = LoadLibraryA(szDll); + if (!g_hDXGIModule) { + return NULL; + } + } + return GetProcAddress(g_hDXGIModule, lpProcName); +} + + +#define STUB(_Ret, _Name, _ArgsDecl, _Args) \ + EXTERN_C _Ret WINAPI \ + _Name _ArgsDecl { \ + typedef _Ret (WINAPI *_PFN) _ArgsDecl; \ + static _PFN _pfn = NULL; \ + if (!_pfn) { \ + static const char *_name = #_Name; \ + _pfn = (_PFN)_getDXGIProcAddress(_name); \ + if (!_pfn) { \ + os::log("error: unavailable function %s\n", _name); \ + os::abort(); \ + } \ + } \ + return _pfn _Args; \ + } + + +STUB(HRESULT, DXGID3D10CreateDevice, + (HMODULE hModule, IDXGIFactory *pFactory, IDXGIAdapter *pAdapter, UINT Flags, void *unknown, void *ppDevice), + (hModule, pFactory, pAdapter, Flags, unknown, ppDevice) +) + +struct UNKNOWN { + BYTE unknown[20]; +}; + +STUB(HRESULT, DXGID3D10CreateLayeredDevice, + (UNKNOWN Unknown), + (Unknown) +) + +STUB(SIZE_T, DXGID3D10GetLayeredDeviceSize, + (const void *pLayers, UINT NumLayers), + (pLayers, NumLayers) +) + +STUB(HRESULT, DXGID3D10RegisterLayers, + (const void *pLayers, UINT NumLayers), + (pLayers, NumLayers) +) + +EXTERN_C HRESULT WINAPI +DXGIDumpJournal() +{ + assert(0); + return E_NOTIMPL; +} + +EXTERN_C HRESULT WINAPI +DXGIReportAdapterConfiguration() +{ + assert(0); + return E_NOTIMPL; +} + + diff --git a/wrappers/dxgitrace.py b/wrappers/dxgitrace.py new file mode 100644 index 0000000..ef4a458 --- /dev/null +++ b/wrappers/dxgitrace.py @@ -0,0 +1,111 @@ +########################################################################## +# +# Copyright 2008-2009 VMware, Inc. +# All Rights Reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# +##########################################################################/ + + +import sys +from dlltrace import DllTracer +from specs import stdapi +from specs.stdapi import API +from specs.dxgi import dxgi +from specs.d3d10 import d3d10 +from specs.d3d10_1 import d3d10_1 +from specs.d3d11 import d3d11 + + +class D3DCommonTracer(DllTracer): + + def serializeArgValue(self, function, arg): + # Dump shaders as strings + if isinstance(arg.type, stdapi.Blob) and arg.name.startswith('pShaderBytecode'): + print ' DumpShader(trace::localWriter, %s, %s);' % (arg.name, arg.type.size) + return + + DllTracer.serializeArgValue(self, function, arg) + + def enumWrapperInterfaceVariables(self, interface): + variables = DllTracer.enumWrapperInterfaceVariables(self, interface) + + # Add additional members to track maps + if interface.getMethodByName('Map') is not None: + variables += [ + ('VOID *', '_pMappedData', '0'), + ('size_t', '_MappedSize', '0'), + ] + + return variables + + def implementWrapperInterfaceMethodBody(self, interface, base, method): + if method.name == 'Unmap': + print ' if (_MappedSize && _pMappedData) {' + self.emit_memcpy('_pMappedData', '_pMappedData', '_MappedSize') + print ' }' + + DllTracer.implementWrapperInterfaceMethodBody(self, interface, base, method) + + if method.name == 'Map': + # NOTE: recursive locks are explicitely forbidden + print ' if (SUCCEEDED(_result)) {' + print ' _getMapInfo(_this, %s, _pMappedData, _MappedSize);' % ', '.join(method.argNames()) + print ' } else {' + print ' _pMappedData = NULL;' + print ' _MappedSize = 0;' + print ' }' + + +if __name__ == '__main__': + print '#define INITGUID' + print + print '#include "trace_writer_local.hpp"' + print '#include "os.hpp"' + print + print '#include "d3dcommonshader.hpp"' + print + + moduleNames = sys.argv[1:] + + api = API() + + if moduleNames: + api.addModule(dxgi) + + if 'd3d10' in moduleNames: + if 'd3d10_1' in moduleNames: + print r'#include "d3d10_1imports.hpp"' + api.addModule(d3d10_1) + else: + print r'#include "d3d10imports.hpp"' + print r'#include "d3d10size.hpp"' + api.addModule(d3d10) + + if 'd3d11' in moduleNames: + print r'#include "d3d11imports.hpp"' + if 'd3d11_1' in moduleNames: + print '#include ' + import specs.d3d11_1 + print r'#include "d3d11size.hpp"' + api.addModule(d3d11) + + tracer = D3DCommonTracer() + tracer.traceApi(api) diff --git a/wrappers/trace.py b/wrappers/trace.py index 506570d..de02086 100644 --- a/wrappers/trace.py +++ b/wrappers/trace.py @@ -323,7 +323,7 @@ class ValueWrapper(stdapi.Traverser, stdapi.ExpanderMixin): def visitInterfacePointer(self, interface, instance): print " if (%s) {" % instance - print " %s = new %s(%s);" % (instance, getWrapperInterfaceName(interface), instance) + print " %s = %s::_Create(__FUNCTION__, %s);" % (instance, getWrapperInterfaceName(interface), instance) print " }" def visitPolymorphic(self, type, instance): @@ -382,6 +382,9 @@ class ValueUnwrapper(ValueWrapper): class Tracer: '''Base class to orchestrate the code generation of API tracing.''' + # 0-3 are reserved to memcpy, malloc, free, and realloc + __id = 4 + def __init__(self): self.api = None @@ -436,6 +439,7 @@ class Tracer: print print '#include "trace.hpp"' print + print 'static std::map g_WrappedObjects;' def footer(self, api): pass @@ -448,9 +452,14 @@ class Tracer: print 'static const char * _%s_args[%u] = {%s};' % (function.name, len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args])) else: print 'static const char ** _%s_args = NULL;' % (function.name,) - print 'static const trace::FunctionSig _%s_sig = {%u, "%s", %u, _%s_args};' % (function.name, function.id, function.name, len(function.args), function.name) + print 'static const trace::FunctionSig _%s_sig = {%u, "%s", %u, _%s_args};' % (function.name, self.getFunctionSigId(), function.name, len(function.args), function.name) print + def getFunctionSigId(self): + id = Tracer.__id + Tracer.__id += 1 + return id + def isFunctionPublic(self, function): return True @@ -497,9 +506,9 @@ class Tracer: print ' }' if function.type is not stdapi.Void: self.serializeRet(function, "_result") - print ' trace::localWriter.endLeave();' if function.type is not stdapi.Void: self.wrapRet(function, "_result") + print ' trace::localWriter.endLeave();' def invokeFunction(self, function, prefix='_', suffix=''): if function.type is stdapi.Void: @@ -585,9 +594,11 @@ class Tracer: def declareWrapperInterface(self, interface): print "class %s : public %s " % (getWrapperInterfaceName(interface), interface.name) print "{" - print "public:" + print "private:" print " %s(%s * pInstance);" % (getWrapperInterfaceName(interface), interface.name) print " virtual ~%s();" % getWrapperInterfaceName(interface) + print "public:" + print " static %s* _Create(const char *functionName, %s * pInstance);" % (getWrapperInterfaceName(interface), interface.name) print for method in interface.iterMethods(): print " " + method.prototype() + ";" @@ -595,6 +606,11 @@ class Tracer: #print "private:" for type, name, value in self.enumWrapperInterfaceVariables(interface): print ' %s %s;' % (type, name) + for i in range(64): + print r' virtual void _dummy%i(void) const {' % i + print r' os::log("error: %s: unexpected virtual method\n");' % interface.name + print r' os::abort();' + print r' }' print "};" print @@ -602,17 +618,45 @@ class Tracer: return [ ("DWORD", "m_dwMagic", "0xd8365d6c"), ("%s *" % interface.name, "m_pInstance", "pInstance"), + ("void *", "m_pVtbl", "*(void **)pInstance"), + ("UINT", "m_NumMethods", len(list(interface.iterBaseMethods()))), ] def implementWrapperInterface(self, interface): self.interface = interface + # Private constructor print '%s::%s(%s * pInstance) {' % (getWrapperInterfaceName(interface), getWrapperInterfaceName(interface), interface.name) for type, name, value in self.enumWrapperInterfaceVariables(interface): print ' %s = %s;' % (name, value) print '}' print + + # Public constructor + print '%s *%s::_Create(const char *functionName, %s * pInstance) {' % (getWrapperInterfaceName(interface), getWrapperInterfaceName(interface), interface.name) + print r' std::map::const_iterator it = g_WrappedObjects.find(pInstance);' + print r' if (it != g_WrappedObjects.end()) {' + print r' Wrap%s *pWrapper = (Wrap%s *)it->second;' % (interface.name, interface.name) + print r' assert(pWrapper);' + print r' assert(pWrapper->m_dwMagic == 0xd8365d6c);' + print r' assert(pWrapper->m_pInstance == pInstance);' + print r' if (pWrapper->m_pVtbl == *(void **)pInstance &&' + print r' pWrapper->m_NumMethods >= %s) {' % len(list(interface.iterBaseMethods())) + #print r' os::log("%s: fetched pvObj=%p pWrapper=%p pVtbl=%p\n", functionName, pInstance, pWrapper, pWrapper->m_pVtbl);' + print r' return pWrapper;' + print r' }' + print r' }' + print r' Wrap%s *pWrapper = new Wrap%s(pInstance);' % (interface.name, interface.name) + #print r' os::log("%%s: created %s pvObj=%%p pWrapper=%%p pVtbl=%%p\n", functionName, pInstance, pWrapper, pWrapper->m_pVtbl);' % interface.name + print r' g_WrappedObjects[pInstance] = pWrapper;' + print r' return pWrapper;' + print '}' + print + + # Destructor print '%s::~%s() {' % (getWrapperInterfaceName(interface), getWrapperInterfaceName(interface)) + #print r' os::log("%s::Release: deleted pvObj=%%p pWrapper=%%p pVtbl=%%p\n", m_pInstance, this, m_pVtbl);' % interface.name + print r' g_WrappedObjects.erase(m_pInstance);' print '}' print @@ -624,6 +668,10 @@ class Tracer: def implementWrapperInterfaceMethod(self, interface, base, method): print method.prototype(getWrapperInterfaceName(interface) + '::' + method.name) + ' {' + + if False: + print r' os::log("%%s(%%p -> %%p)\n", "%s", this, m_pInstance);' % (getWrapperInterfaceName(interface) + '::' + method.name) + if method.type is not stdapi.Void: print ' %s _result;' % method.type @@ -638,7 +686,7 @@ class Tracer: assert not method.internal print ' static const char * _args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args])) - print ' static const trace::FunctionSig _sig = {%u, "%s", %u, _args};' % (method.id, interface.name + '::' + method.name, len(method.args) + 1) + print ' static const trace::FunctionSig _sig = {%u, "%s", %u, _args};' % (self.getFunctionSigId(), interface.name + '::' + method.name, len(method.args) + 1) print ' %s *_this = static_cast<%s *>(m_pInstance);' % (base, base) @@ -665,14 +713,16 @@ class Tracer: if method.type is not stdapi.Void: self.serializeRet(method, '_result') - print ' trace::localWriter.endLeave();' if method.type is not stdapi.Void: self.wrapRet(method, '_result') if method.name == 'Release': assert method.type is not stdapi.Void - print ' if (!_result)' - print ' delete this;' + print r' if (!_result) {' + print r' delete this;' + print r' }' + + print ' trace::localWriter.endLeave();' def implementIidWrapper(self, api): print r'static void' @@ -691,7 +741,7 @@ class Tracer: else_ = '' for iface in api.getAllInterfaces(): print r' %sif (riid == IID_%s) {' % (else_, iface.name) - print r' *ppvObj = new Wrap%s((%s *) *ppvObj);' % (iface.name, iface.name) + print r' *ppvObj = Wrap%s::_Create(functionName, (%s *) *ppvObj);' % (iface.name, iface.name) print r' }' else_ = 'else ' print r' %s{' % else_