)
if (ANDROID)
- target_link_libraries (common log)
+ target_link_libraries (common
+ log
+ )
endif ()
# Sub-directories
add_subdirectory (dispatch)
+add_subdirectory (helpers)
add_subdirectory (wrappers)
add_subdirectory (retrace)
# CLI
if (ENABLE_CLI)
- add_subdirectory(cli)
+ add_subdirectory (cli)
endif ()
##############################################################################
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);
const char *
readPNMHeader(const char *buffer, size_t size, unsigned *channels, unsigned *width, unsigned *height);
+
} /* 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;
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);
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;
}
}
-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 */
#ifndef vsnprintf
#define vsnprintf _vsnprintf
#endif
+#ifndef strcasecmp
+#define strcasecmp stricmp
+#endif
#endif /* !_WIN32 */
namespace os {
#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
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:
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);
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) {
#include "compat.h"
#include <d3d9.h>
-#include <d3dx9.h>
#ifndef D3DFMT_A2B10G10R10_XR_BIAS
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);
QSize size() const;
void setSize(const QSize &size);
- int numChannels() const;
- void setNumChannels(int numChannels);
-
int depth() const;
void setDepth(int depth);
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();
tex.setSize(size);
tex.setDepth(depth);
tex.setFormatName(formatName);
- tex.setNumChannels(numChannels);
tex.setLabel(itr.key());
tex.contentsFromBase64(dataArray);
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();
fbo.setSize(size);
fbo.setDepth(depth);
fbo.setFormatName(formatName);
- fbo.setNumChannels(numChannels);
fbo.setType(itr.key());
fbo.contentsFromBase64(dataArray);
m_framebuffers.append(fbo);
bool ApiTraceState::isEmpty() const
{
- return m_parameters.isEmpty();
+ return m_parameters.isEmpty() &&
+ m_shaderSources.isEmpty() &&
+ m_textures.isEmpty() &&
+ m_framebuffers.isEmpty();
}
const QList<ApiTexture> & ApiTraceState::textures() const
--- /dev/null
+##############################################################################
+# 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 ()
--- /dev/null
+/**************************************************************************
+ *
+ * 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 <stdio.h>
+
+#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<ID3DXBuffer **>(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<ID3DBlob **>(ppDisassembly));
+ } else if (pfnD3D10DisassembleShader) {
+ hr = pfnD3D10DisassembleShader(pShaderBytecode, BytecodeLength, 0, NULL,
+ reinterpret_cast<ID3D10Blob **>(ppDisassembly));
+ }
+
+ return hr;
+}
--- /dev/null
+/**************************************************************************
+ *
+ * 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 <windows.h>
+
+// 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_ */
+d3dretrace_d3d9.cpp
+d3dretrace_dxgi.cpp
glretrace_gl.cpp
glstate_params.cpp
${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}
${GETOPT_LIBRARIES}
)
-add_library (glretrace_common
+add_library (glretrace_common STATIC
glretrace_gl.cpp
glretrace_cgl.cpp
glretrace_glx.cpp
glstate_shaders.cpp
glws.cpp
)
-
add_dependencies (glretrace_common glproc)
+target_link_libraries (glretrace_common
+ retrace_common
+)
if (WIN32 OR APPLE OR X11_FOUND)
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
)
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
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
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
${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
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
)
target_link_libraries (d3dretrace
retrace_common
+ d3dhelpers
)
install (TARGETS d3dretrace RUNTIME DESTINATION bin)
#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<ID3D10DeviceChild>(json, "VS", pVertexShader);
+ pVertexShader->Release();
+ }
+
+ ID3D10GeometryShader *pGeometryShader = NULL;
+ pDevice->GSGetShader(&pGeometryShader);
+ if (pGeometryShader) {
+ dumpShader<ID3D10DeviceChild>(json, "GS", pGeometryShader);
+ pGeometryShader->Release();
+ }
+
+ ID3D10PixelShader *pPixelShader = NULL;
+ pDevice->PSGetShader(&pPixelShader);
+ if (pPixelShader) {
+ dumpShader<ID3D10DeviceChild>(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);
}
#include <algorithm>
#include "image.hpp"
+#include "json.hpp"
#include "d3d10imports.hpp"
+#include "d3dstate.hpp"
namespace d3dstate {
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;
}
}
-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;
const unsigned char *src;
unsigned char *dst;
- pDevice->OMGetRenderTargets(1, &pRenderTargetView, NULL);
if (!pRenderTargetView) {
- goto no_rendertarget;
+ return NULL;
}
pRenderTargetView->GetResource(&pResource);
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 */
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;
"""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<IDirect3DDevice9> d3d9Dumper;'''
- print
-
print '// Swizzling mapping for lock addresses'
print 'static std::map<void *, void *> _maps;'
print
- self.table_name = 'd3dretrace::d3d9_callbacks'
-
Retracer.retraceApi(self, api)
def invokeFunction(self, function):
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 <string.h>
-
-#include <iostream>
+def main():
+ print r'#include <string.h>'
+ print
+ print r'#include <iostream>'
+ 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<IDirect3DDevice9> d3d9Dumper;'''
+ print
+ elif moduleName == 'd3d8':
+ from specs.d3d8 import d3d8
+ print r'#include <windows.h>'
+ print r'#include <d3d8.h>'
+ print r'#include "d3d8size.hpp"'
+ api.addModule(d3d8)
+ print
+ #print '''static d3dretrace::D3DDumper<IDirect3DDevice8> d3d8Dumper;'''
+ print
+ else:
+ assert False
+
retracer = D3DRetracer()
+ retracer.table_name = 'd3dretrace::%s_callbacks' % moduleName
retracer.retraceApi(api)
+
+
+if __name__ == '__main__':
+ main()
#include <iostream>
#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) {
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() */);
free(pData);
}
}
+
+ pShader->Release();
}
static void
+++ /dev/null
-##########################################################################
-#
-# 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<void *, void *> _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 <string.h>'''
- print
- print r'#include <iostream>'
- 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<ID3D10Device> d3d10Dumper;'''
- print
-
- if 'd3d11' in moduleNames:
- print r'#include "d3d11imports.hpp"'
- if 'd3d11_1' in moduleNames:
- print '#include <d3d11_1.h>'
- import specs.d3d11_1
- print r'#include "d3d11size.hpp"'
- print r'#include "d3dstate.hpp"'
- api.addModule(d3d11)
-
- print
- print '''static d3dretrace::D3DDumper<ID3D11DeviceContext> d3d11Dumper;'''
- print
-
- retracer = D3DRetracer()
- retracer.retraceApi(api)
-
-
-if __name__ == '__main__':
- main()
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 >
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);
}
#include <iostream>
+#include <windows.h>
+
struct IDirect3DDevice9;
struct ID3D10Device;
struct ID3D11DeviceContext;
+class JSONWriter;
+
namespace image {
class Image;
}
namespace d3dstate {
+extern const GUID GUID_D3DSTATE;
+
+
image::Image *
getRenderTargetImage(IDirect3DDevice9 *pDevice);
image::Image *
getRenderTargetImage(ID3D10Device *pDevice);
+void
+dumpFramebuffer(JSONWriter &json, ID3D10Device *pDevice);
+
void
dumpDevice(std::ostream &os, ID3D10Device *pDevice);
--- /dev/null
+##########################################################################
+#
+# 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<void *, void *> _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 <string.h>'
+ print
+ print r'#include <iostream>'
+ 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<ID3D10Device> d3d10Dumper;'''
+ print
+
+ if 'd3d11' in moduleNames:
+ print r'#include "d3d11imports.hpp"'
+ if 'd3d11_1' in moduleNames:
+ print '#include <d3d11_1.h>'
+ import specs.d3d11_1
+ print r'#include "d3d11size.hpp"'
+ print r'#include "d3dstate.hpp"'
+ api.addModule(d3d11)
+
+ print
+ print '''static d3dretrace::D3DDumper<ID3D11DeviceContext> d3d11Dumper;'''
+ print
+
+ retracer = D3DRetracer()
+ retracer.retraceApi(api)
+
+
+if __name__ == '__main__':
+ main()
**************************************************************************/
+#include <assert.h>
#include <string.h>
#include <algorithm>
}
char label[512];
-
GLint active_texture = GL_TEXTURE0;
glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
snprintf(label, sizeof label, "%s, %s, level = %d",
json.beginMember(label);
- json.beginObject();
-
GLuint channels;
GLenum format;
if (!context.ES && isDepthFormat(desc.internalFormat)) {
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
}
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
}
#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 = "<<pngBufferSize << ", ratio = " << double(width * height * channels * sizeof *pixels)/pngBufferSize;
- json.writeBase64(pngBuffer, pngBufferSize);
- free(pngBuffer);
- json.endMember(); // __data__
-
- delete [] pixels;
- json.endObject();
+ json.writeImage(image, formatToString(internalFormat));
+
+ delete image;
}
pass
def dump(self):
+ print '#include <assert.h>'
print '#include <string.h>'
print
print '#include "json.hpp"'
**************************************************************************/
+#include <assert.h>
#include <string.h>
#include <algorithm>
--- /dev/null
+/**************************************************************************
+ *
+ * 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 <assert.h>
+#include <string.h>
+
+#include <sstream>
+
+#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();
+}
**************************************************************************/
/*
- * Trace writing functions.
+ * JSON writing functions.
*/
#ifndef _JSON_HPP_
#define _JSON_HPP_
-#include <assert.h>
#include <stddef.h>
#include <wchar.h>
#include <string>
+namespace image {
+ class Image;
+}
+
+
class JSONWriter
{
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<int>(n);
value = true;
space = ' ';
}
- inline void writeInt(unsigned char n) {
+ inline void
+ writeInt(unsigned char n) {
separator();
os << std::dec << static_cast<unsigned>(n);
value = true;
}
template<class T>
- inline void writeInt(T n) {
+ inline void
+ writeInt(T n) {
separator();
os << std::dec << n;
value = true;
space = ' ';
}
+
template<class T>
- inline void writeFloat(T n) {
+ void
+ writeFloat(T n) {
separator();
if (isnan(n)) {
// NaN is non-standard but widely supported
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<class T>
- 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_ */
uintptr_t next;
public:
+ inline
ScopedAllocator() :
next(0) {
}
return static_cast<void *>(&buf[1]);
}
- template< class T >
- inline T *
- alloc(size_t n = 1) {
- return static_cast<T *>(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<const trace::Array *>(value);
if (array) {
- return alloc<T>(array->size());
+ return alloc(array->size() * size);
}
const trace::Null *null = dynamic_cast<const trace::Null *>(value);
if (null) {
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;
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
bool debug = true;
bool dumpingState = false;
+Driver driver = DRIVER_DEFAULT;
+const char *driverModule = NULL;
+
bool doubleBuffer = true;
bool coreProfile = false;
image::Image *src = dumper->getSnapshot();
if (!src) {
+ std::cout << "Failed to get snapshot\n";
return;
}
" -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"
enum {
CORE_OPT = CHAR_MAX + 1,
DB_OPT,
+ DRIVER_OPT,
PCPU_OPT,
PGPU_OPT,
PPD_OPT,
{"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},
{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)
{
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;
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;
retrace::parser.close();
}
+
+ os::resetExceptionCallback();
// XXX: X often hangs on XCloseDisplay
//retrace::cleanUp();
unsigned long long address = value.toUIntPtr();
if (!address) {
- assert(!obj);
+ if (obj) {
+ warning(call) << "unexpected non-null object\n";
+ }
return;
}
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:
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:
'-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=[],
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')
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")]),
from d3d10sdklayers import *
import d3d10misc
-import d3d10shader
-import d3d10effect
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([
+++ /dev/null
-##########################################################################
-#
-# 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")]),
-])
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([
+++ /dev/null
-##########################################################################
-#
-# 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")]),
-])
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),
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([
]
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),
]
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 += [
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),
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")]),
"D3DTS_TEXTURE5",
"D3DTS_TEXTURE6",
"D3DTS_TEXTURE7",
-])
-
-D3DTS = Flags(DWORD, [
"D3DTS_WORLD",
"D3DTS_WORLD1",
"D3DTS_WORLD2",
"D3DMCS_COLOR2",
])
-D3DWRAP = Flags(DWORD, [
- "D3DWRAP_U",
- "D3DWRAP_V",
- "D3DWRAP_W",
-])
-
D3DWRAPCOORD = Flags(DWORD, [
"D3DWRAPCOORD_0",
"D3DWRAPCOORD_1",
"D3DTS_TEXTURE5",
"D3DTS_TEXTURE6",
"D3DTS_TEXTURE7",
-])
-
-D3DTS = Flags(DWORD, [
"D3DTS_WORLD",
"D3DTS_WORLD1",
"D3DTS_WORLD2",
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"),
])
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"),
"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",
"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"),
"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", [
D3DFVF = Flags(DWORD, [
"D3DFVF_RESERVED0",
- "D3DFVF_POSITION_MASK",
"D3DFVF_XYZ",
"D3DFVF_XYZRHW",
"D3DFVF_XYZB1",
"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", [
(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"),
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
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
# 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
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
${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}
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
${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}
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
${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
D3D10StateBlockMaskGetSetting
D3D10StateBlockMaskIntersect
D3D10StateBlockMaskUnion
-
- CreateDXGIFactory
- CreateDXGIFactory1
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
+++ /dev/null
-##########################################################################
-#
-# 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)
--- /dev/null
+/**************************************************************************
+ *
+ * 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();
+}
+
+++ /dev/null
-##########################################################################
-#
-# 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)
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
--- /dev/null
+/**************************************************************************
+ *
+ * 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);
+}
+
+
+++ /dev/null
-##########################################################################
-#
-# 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 <d3d11_1.h>'
- print
-
- print '#include "d3dcommonshader.hpp"'
- print '#include "d3d11size.hpp"'
- print
-
- api = API()
- api.addModule(dxgi)
- api.addModule(d3d11)
- tracer = D3DCommonTracer()
- tracer.traceApi(api)
#include <stdio.h>
+#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();
}
#include <stdio.h>
+#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();
}
+++ /dev/null
-##########################################################################
-#
-# 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 ' }'
-
-
--- /dev/null
+/**************************************************************************
+ *
+ * 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 <assert.h>
+#include <windows.h>
+
+
+#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;
+}
+
--- /dev/null
+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
--- /dev/null
+/**************************************************************************
+ *
+ * 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 <assert.h>
+
+#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;
+}
+
+
--- /dev/null
+##########################################################################
+#
+# 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 <d3d11_1.h>'
+ import specs.d3d11_1
+ print r'#include "d3d11size.hpp"'
+ api.addModule(d3d11)
+
+ tracer = D3DCommonTracer()
+ tracer.traceApi(api)
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):
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
print
print '#include "trace.hpp"'
print
+ print 'static std::map<void *, void *> g_WrappedObjects;'
def footer(self, api):
pass
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
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:
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() + ";"
#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
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<void *, void *>::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
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
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)
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'
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_
projects / apitrace / commitdiff