add_custom_command (
OUTPUT d3d10trace.cpp
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d10trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d10trace.cpp
- DEPENDS d3d10trace.py trace.py specs/d3d10misc.py specs/d3d10.py specs/dxgi.py specs/dxgitype.py specs/dxgiformat.py specs/winapi.py specs/stdapi.py
+ DEPENDS d3d10trace.py trace.py specs/d3d10misc.py specs/d3d10.py specs/d3d10sdklayers.py specs/dxgi.py specs/dxgitype.py specs/dxgiformat.py specs/winapi.py specs/stdapi.py
)
add_library (d3d10 MODULE specs/d3d10.def d3d10trace.cpp)
target_link_libraries (d3d10
install (TARGETS d3d10 LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR})
endif (DirectX_D3D10_INCLUDE_DIR)
+ # d3d10_1.dll
+ if (DirectX_D3D10_INCLUDE_DIR)
+ include_directories (SYSTEM ${DirectX_D3D10_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 trace.py specs/d3d10_1.py specs/d3d10.py specs/d3d10sdklayers.py specs/dxgi.py specs/dxgitype.py specs/dxgiformat.py specs/winapi.py specs/stdapi.py
+ )
+ add_library (d3d10_1 MODULE specs/d3d10_1.def d3d10_1trace.cpp)
+ target_link_libraries (d3d10_1
+ common
+ ${ZLIB_LIBRARIES}
+ ${SNAPPY_LIBRARIES}
+ )
+ set_target_properties (d3d10_1
+ PROPERTIES PREFIX ""
+ RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/wrappers
+ LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/wrappers
+ )
+ install (TARGETS d3d10_1 LIBRARY DESTINATION ${WRAPPER_INSTALL_DIR})
+ endif (DirectX_D3D10_INCLUDE_DIR)
+
# opengl32.dll
add_custom_command (
OUTPUT wgltrace.cpp
cli_diff_state.cpp
cli_diff_images.cpp
cli_dump.cpp
+ cli_dump_images.cpp
cli_pager.cpp
cli_pickle.cpp
cli_repack.cpp
extern const Command diff_state_command;
extern const Command diff_images_command;
extern const Command dump_command;
+extern const Command dump_images_command;
extern const Command pickle_command;
extern const Command repack_command;
extern const Command trace_command;
--- /dev/null
+/*********************************************************************
+ *
+ * Copyright 2011 Jose Fonseca
+ * Copyright 2012 Intel Corporation
+ * 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 <string.h>
+#include <limits.h> // for CHAR_MAX
+#include <getopt.h>
+#include <iostream>
+
+#include "cli.hpp"
+
+#include "os_string.hpp"
+#include "os_process.hpp"
+
+static const char *synopsis = "Dump frame images obtained from a trace.";
+
+static void
+usage(void)
+{
+ std::cout << "usage apitrace dump-images [OPTIONS] TRACE_FILE\n"
+ << synopsis << "\n"
+ "\n"
+ " -h, --help show this help message and exit\n"
+ " --calls=CALLSET dump images only for specified calls\n"
+ " (default value is \"*/frame\" which\n"
+ " which dumps an image for each frame)\n"
+ " -o, --output=PREFIX prefix to use in naming output files\n"
+ " (default is trace filename without extension)\n"
+ "\n";
+}
+
+enum {
+ CALLS_OPT = CHAR_MAX + 1,
+};
+
+const static char *
+shortOptions = "ho:";
+
+const static struct option
+longOptions[] = {
+ {"help", no_argument, 0, 'h'},
+ {"calls", required_argument, 0, CALLS_OPT},
+ {"output", required_argument, 0, 'o'},
+ {0, 0, 0, 0}
+};
+
+static int
+command(int argc, char *argv[])
+{
+ os::String prefix;
+ const char *calls, *filename, *output = NULL;
+
+ int opt;
+ while ((opt = getopt_long(argc, argv, shortOptions, longOptions, NULL)) != -1) {
+ switch (opt) {
+ case 'h':
+ usage();
+ return 0;
+ case CALLS_OPT:
+ calls = optarg;
+ break;
+ case 'o':
+ output = optarg;
+ break;
+ default:
+ std::cerr << "error: unexpected option `" << opt << "`\n";
+ usage();
+ return 1;
+ }
+ }
+
+ if (optind >= argc) {
+ std::cerr << "error: apitrace dump-images requires a trace file as an argument.\n";
+ usage();
+ return 1;
+ }
+
+ if (optind < argc - 1) {
+ std::cerr << "error: apitrace dump-images can accept only a single trace file argument.\n";
+ usage();
+ return 1;
+ }
+
+ filename = argv[optind];
+
+ if (output == NULL) {
+ prefix = filename;
+ prefix.trimDirectory();
+ prefix.trimExtension();
+ output = prefix.str();
+ }
+
+ /* FIXME: It would be cleaner to pull the replaying of the trace
+ * in-process here and generate the images directly. But that
+ * pulls in a non-trivial amount of the existing 'retrace' code,
+ * along with dependencies on GL, etc.
+ *
+ * It will definitely make sense to do that once all that code has
+ * already been pulled in for the "apitrace retrace" (or "apitrace
+ * replay") command. */
+ std::vector<const char *> command;
+ command.push_back("glretrace");
+ command.push_back("-s");
+ command.push_back(output);
+ command.push_back("-S");
+ if (calls)
+ command.push_back(calls);
+ else
+ command.push_back("*/frame");
+ command.push_back(filename);
+ command.push_back(NULL);
+
+ return os::execute((char * const *)&command[0]);
+}
+
+const Command dump_images_command = {
+ "dump-images",
+ synopsis,
+ usage,
+ command
+};
&diff_state_command,
&diff_images_command,
&dump_command,
+ &dump_images_command,
&pickle_command,
&repack_command,
&trace_command,
};
const static char *
-shortOptions = "ho";
+shortOptions = "ho:";
const static struct option
longOptions[] = {
return -1;
}
int status = -1;
+ int ret;
waitpid(pid, &status, 0);
- return status;
+ if (WIFEXITED(status)) {
+ ret = WEXITSTATUS(status);
+ } else if (WIFSIGNALED(status)) {
+ // match shell return code
+ ret = WTERMSIG(status) + 128;
+ } else {
+ ret = 128;
+ }
+ return ret;
}
}
#endif
process.trimDirectory();
- os::String prefix = os::getCurrentDir();
+#ifdef ANDROID
+ os::String prefix = "/data";
+#else
+ os::String prefix = os::getCurrentDir();
+#endif
prefix.join(process);
for (;;) {
--- /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 specs.d3d10_1 import d3d10_1
+from dlltrace import DllTracer
+
+
+if __name__ == '__main__':
+ print '#define INITGUID'
+ print
+ print '#include "trace_writer_local.hpp"'
+ print '#include "os.hpp"'
+ print
+ print '#include <windows.h>'
+ print '#include <tchar.h>'
+ print
+ print '#include "compat.h"'
+ print
+ print '#include <d3d10_1.h>'
+ print '#include <d3dx10.h>'
+ print
+ tracer = DllTracer('d3d10_1.dll')
+ tracer.trace_api(d3d10_1)
print '#include "compat.h"'
print
print '#include <d3d10.h>'
+ print '#include <d3dx10.h>'
print
tracer = DllTracer('d3d10.dll')
tracer.trace_api(d3d10)
* Android does not support LD_PRELOAD. It is assumed that applications
* are explicitely loading egltrace.so.
*/
- void *lib = NULL;
+
if (procName[0] == 'e' && procName[1] == 'g' && procName[2] == 'l') {
static void *libEGL = NULL;
if (!libEGL) {
libEGL = dlopen("libEGL.so", RTLD_LOCAL | RTLD_LAZY);
+ if (!libEGL) {
+ return NULL;
+ }
}
- lib = libEGL;
- } else if (procName[0] == 'g' && procName[1] == 'l') {
- /* TODO: Support libGLESv1_CM.so too somehow. */
+ return dlsym(libEGL, procName);
+ }
+
+ if (procName[0] == 'g' && procName[1] == 'l') {
+ /* TODO: Use GLESv1/GLESv2 on a per-context basis. */
+ static void *sym = NULL;
+
static void *libGLESv2 = NULL;
if (!libGLESv2) {
libGLESv2 = dlopen("libGLESv2.so", RTLD_LOCAL | RTLD_LAZY);
}
- lib = libGLESv2;
- }
- if (lib) {
- return dlsym(lib, procName);
+ if (libGLESv2) {
+ sym = dlsym(libGLESv2, procName);
+ }
+ if (sym) {
+ return sym;
+ }
+
+ static void *libGLESv1 = NULL;
+ if (!libGLESv1) {
+ libGLESv1 = dlopen("libGLESv1_CM.so", RTLD_LOCAL | RTLD_LAZY);
+ }
+ if (libGLESv1) {
+ sym = dlsym(libGLESv1, procName);
+ }
+ if (sym) {
+ return sym;
+ }
}
+
return NULL;
#else
return dlsym(RTLD_NEXT, procName);
print ' samples = max_samples;'
print ' }'
+ # These parameters are referred beyond the call life-time
+ # TODO: Replace ad-hoc solution for bindable parameters with general one
+ if function.name in ('glFeedbackBuffer', 'glSelectBuffer') and arg.output:
+ print ' _allocator.bind(%s);' % arg.name
+
+
if __name__ == '__main__':
print r'''
version[6] == ' ' &&
version[7] == 'E' &&
version[8] == 'S' &&
- version[9] == ' ') {
+ (version[9] == ' ' || version[9] == '-')) {
ES = true;
}
}
Context context;
dumpParameters(json, context);
- dumpShadersUniforms(json);
+ dumpShadersUniforms(json, context);
dumpTextures(json, context);
dumpFramebuffer(json, context);
json.beginObject();
GLint active_texture = GL_TEXTURE0;
glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
+
GLint max_texture_coords = 0;
glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);
GLint max_combined_texture_image_units = 0;
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_combined_texture_image_units);
GLint max_units = std::max(max_combined_texture_image_units, max_texture_coords);
+
+ /*
+ * At least the Android software GL implementation doesn't return the
+ * proper value for this, but rather returns 0. The GL(ES) specification
+ * mandates a minimum value of 2, so use this as a fall-back value.
+ */
+ max_units = std::min(max_units, 2);
+
for (GLint unit = 0; unit < max_units; ++unit) {
GLenum texture = GL_TEXTURE0 + unit;
glActiveTexture(texture);
void dumpParameters(JSONWriter &json, Context &context);
-void dumpShadersUniforms(JSONWriter &json);
+void dumpShadersUniforms(JSONWriter &json, Context &context);
void dumpTextures(JSONWriter &json, Context &context);
print ' glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);'
print ' GLint max_combined_texture_image_units = 0;'
print ' glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_combined_texture_image_units);'
- print ' GLint max_units = std::max(max_combined_texture_image_units, max_texture_coords);'
+ print ' GLint max_units = std::min(std::max(max_combined_texture_image_units, max_texture_coords), 2);'
print ' for (GLint unit = 0; unit < max_units; ++unit) {'
print ' char name[32];'
print ' snprintf(name, sizeof name, "GL_TEXTURE%i", unit);'
void
-dumpShadersUniforms(JSONWriter &json)
+dumpShadersUniforms(JSONWriter &json, Context &context)
{
GLint program = 0;
glGetIntegerv(GL_CURRENT_PROGRAM, &program);
- GLhandleARB programObj = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
+ GLhandleARB programObj = 0;
+ if (!context.ES && !program) {
+ programObj = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
+ }
json.beginMember("shaders");
json.beginObject();
tracedialog.cpp
traceloader.cpp
traceprocess.cpp
+ trimprocess.cpp
vertexdatainterpreter.cpp
)
#include "shaderssourcewidget.h"
#include "tracedialog.h"
#include "traceprocess.h"
+#include "trimprocess.h"
#include "thumbnail.h"
#include "ui_retracerdialog.h"
#include "vertexdatainterpreter.h"
m_ui.actionReplay->setEnabled(true);
m_ui.actionLookupState->setEnabled(true);
m_ui.actionShowThumbnails->setEnabled(true);
+ m_ui.actionTrim->setEnabled(true);
setWindowTitle(
tr("QApiTrace - %1").arg(info.fileName()));
}
}
}
+void MainWindow::trimEvent()
+{
+
+ int trimIndex;
+ if (m_trimEvent->type() == ApiTraceEvent::Call) {
+ ApiTraceCall *call = static_cast<ApiTraceCall*>(m_trimEvent);
+ trimIndex = call->index();
+ } else if (m_trimEvent->type() == ApiTraceEvent::Frame) {
+ ApiTraceFrame *frame = static_cast<ApiTraceFrame*>(m_trimEvent);
+ const QList<ApiTraceFrame*> frames = m_trace->frames();
+ trimIndex = frame->lastCallIndex();
+ }
+
+ m_trimProcess->setTracePath(m_trace->fileName());
+ m_trimProcess->setTrimIndex(trimIndex);
+
+ m_trimProcess->start();
+}
+
void MainWindow::lookupState()
{
if (!m_selectedEvent) {
replayTrace(false, true);
}
+void MainWindow::trim()
+{
+ if (!m_selectedEvent) {
+ QMessageBox::warning(
+ this, tr("Unknown Event"),
+ tr("To trim select a frame or an event in the event list."));
+ return;
+ }
+ m_trimEvent = m_selectedEvent;
+ trimEvent();
+}
+
MainWindow::~MainWindow()
{
delete m_trace;
m_searchWidget->hide();
m_traceProcess = new TraceProcess(this);
+ m_trimProcess = new TrimProcess(this);
}
void MainWindow::initConnections()
this, SLOT(replayStop()));
connect(m_ui.actionLookupState, SIGNAL(triggered()),
this, SLOT(lookupState()));
+ connect(m_ui.actionTrim, SIGNAL(triggered()),
+ this, SLOT(trim()));
connect(m_ui.actionShowThumbnails, SIGNAL(triggered()),
this, SLOT(showThumbnails()));
connect(m_ui.actionOptions, SIGNAL(triggered()),
connect(m_traceProcess, SIGNAL(error(const QString&)),
SLOT(traceError(const QString&)));
+ connect(m_trimProcess, SIGNAL(trimmedFile(const QString&)),
+ SLOT(createdTrim(const QString&)));
+ connect(m_trimProcess, SIGNAL(error(const QString&)),
+ SLOT(trimError(const QString&)));
+
connect(m_ui.errorsDock, SIGNAL(visibilityChanged(bool)),
m_ui.actionShowErrorsDock, SLOT(setChecked(bool)));
connect(m_ui.actionShowErrorsDock, SIGNAL(triggered(bool)),
msg);
}
+void MainWindow::createdTrim(const QString &path)
+{
+ qDebug()<<"Done trimming "<<path;
+
+ newTraceFile(path);
+}
+
+void MainWindow::trimError(const QString &msg)
+{
+ QMessageBox::warning(
+ this,
+ tr("Trim Error"),
+ msg);
+}
+
void MainWindow::slotSearch()
{
m_jumpWidget->hide();
class SearchWidget;
class ShadersSourceWidget;
class TraceProcess;
+class TrimProcess;
class VertexDataInterpreter;
class MainWindow : public QMainWindow
void finishedLoadingTrace();
void lookupState();
void showThumbnails();
+ void trim();
void showSettings();
void openHelp(const QUrl &url);
void showSurfacesMenu(const QPoint &pos);
void slotJumpTo(int callNum);
void createdTrace(const QString &path);
void traceError(const QString &msg);
+ void createdTrim(const QString &path);
+ void trimError(const QString &msg);
void slotSearch();
void slotSearchNext(const QString &str, Qt::CaseSensitivity sensitivity);
void slotSearchPrev(const QString &str, Qt::CaseSensitivity sensitivity);
void initConnections();
void newTraceFile(const QString &fileName);
void replayTrace(bool dumpState, bool dumpThumbnails);
+ void trimEvent();
void fillStateForFrame();
/* there's a difference between selected frame/call and
ApiTraceEvent *m_stateEvent;
+ ApiTraceEvent *m_trimEvent;
+
Retracer *m_retracer;
VertexDataInterpreter *m_vdataInterpreter;
TraceProcess *m_traceProcess;
+ TrimProcess *m_trimProcess;
+
ArgumentsEditor *m_argsEditor;
ApiTraceEvent *m_nonDefaultsLookupEvent;
/*
* Parse JSON from the output.
*
- * XXX: QJSON expects blocking IO.
- *
* XXX: QJSON's scanner is inneficient as it abuses single
* character QIODevice::peek (not cheap), instead of maintaining a
* lookahead character on its own.
bool ok = false;
QJson::Parser jsonParser;
+#if 0
parsedJson = jsonParser.parse(&io, &ok).toMap();
+#else
+ /*
+ * XXX: QJSON expects blocking IO, and it looks like
+ * BlockingIODevice does not work reliably in all cases.
+ */
+ process.waitForFinished(-1);
+ parsedJson = jsonParser.parse(&process, &ok).toMap();
+#endif
if (!ok) {
msg = QLatin1String("failed to parse JSON");
}
--- /dev/null
+#include "trimprocess.h"
+#include "apitrace.h"
+
+#include <QDebug>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+
+TrimProcess::TrimProcess(QObject *parent)
+ : QObject(parent)
+{
+ m_process = new QProcess(this);
+
+ connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)),
+ this, SLOT(trimFinished()));
+ connect(m_process, SIGNAL(error(QProcess::ProcessError)),
+ this, SLOT(trimError(QProcess::ProcessError)));
+
+#ifdef Q_OS_WIN
+ QString format = QLatin1String("%1;");
+#else
+ QString format = QLatin1String("%1:");
+#endif
+ QString buildPath = format.arg(APITRACE_BINARY_DIR);
+ QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+ env.insert("PATH", buildPath + env.value("PATH"));
+ qputenv("PATH", env.value("PATH").toLatin1());
+}
+
+TrimProcess::~TrimProcess()
+{
+}
+
+void TrimProcess::trimFinished()
+{
+ // consume verbose output spew
+ QByteArray outputStrings = m_process->readAllStandardOutput();
+ QByteArray errorStrings = m_process->readAllStandardError();
+#if 0
+ qDebug()<<"trim finished on " << m_trimPath;
+ qDebug()<<"\terr = "<<errorStrings;
+ qDebug()<<"\tout = "<<outputStrings;
+#endif
+ emit trimmedFile(m_trimPath);
+}
+
+void TrimProcess::trimError(QProcess::ProcessError err)
+{
+ // consume verbose output spew
+ QByteArray outputStrings = m_process->readAllStandardOutput();
+ QByteArray errorStrings = m_process->readAllStandardError();
+#if 1
+ qDebug()<<"trace error = "<<m_tracePath;
+ qDebug()<<"\terr = "<<errorStrings;
+ qDebug()<<"\tout = "<<outputStrings;
+#endif
+ emit error(errorStrings);
+}
+
+
+void TrimProcess::start()
+{
+ QStringList arguments;
+
+ QString outputFormat = QLatin1String("--output=%1");
+ QString outputArgument = outputFormat
+ .arg(m_trimPath);
+
+ QString callSetFormat = QLatin1String("--calls=0-%1");
+ QString callSetArgument = callSetFormat
+ .arg(m_trimIndex);
+
+ arguments << QLatin1String("trim");
+ arguments << outputArgument;
+ arguments << callSetArgument;
+ arguments << m_tracePath;
+
+ m_process->start(QLatin1String("apitrace"), arguments);
+}
+
+int TrimProcess::trimIndex()
+{
+ return m_trimIndex;
+}
+
+void TrimProcess::setTrimIndex(int trimIndex)
+{
+ m_trimIndex = trimIndex;
+
+ updateTrimPath();
+}
+
+void TrimProcess::setTracePath(const QString &str)
+{
+ m_tracePath = str;
+
+ updateTrimPath();
+}
+
+QString TrimProcess::tracePath() const
+{
+ return m_tracePath;
+}
+
+void TrimProcess::updateTrimPath()
+{
+
+ QFileInfo fi(m_tracePath);
+ QString baseName = fi.baseName();
+ QString path = fi.path();
+
+ QString format = QString::fromLatin1("%1/%2.%3.trim.trace");
+
+ m_trimPath = format
+ .arg(path)
+ .arg(baseName)
+ .arg(m_trimIndex);
+}
+
+#include "trimprocess.moc"
--- /dev/null
+#ifndef TRIMPROCESS_H
+#define TRIMPROCESS_H
+
+#include "apitrace.h"
+
+#include <QObject>
+#include <QProcess>
+
+class TrimProcess : public QObject
+{
+ Q_OBJECT
+public:
+ TrimProcess(QObject *parent=0);
+ ~TrimProcess();
+
+ void setTrimIndex(int trimIndex);
+ int trimIndex();
+
+ void setTracePath(const QString &str);
+ QString tracePath() const;
+
+private:
+ void updateTrimPath();
+
+public slots:
+ void start();
+
+signals:
+ void trimmedFile(const QString &trimPath);
+ void error(const QString &msg);
+
+private slots:
+ void trimFinished();
+ void trimError(QProcess::ProcessError err);
+
+private:
+ QStringList m_args;
+ QString m_tracePath;
+ QString m_trimPath;
+ ApiTraceEvent *m_trimEvent;
+ int m_trimIndex;
+ QProcess *m_process;
+};
+
+#endif
<addaction name="actionStop"/>
<addaction name="actionLookupState"/>
<addaction name="actionShowThumbnails"/>
+ <addaction name="actionTrim"/>
<addaction name="separator"/>
<addaction name="actionOptions"/>
</widget>
<string>Ctrl+T</string>
</property>
</action>
+ <action name="actionTrim">
+ <property name="enabled">
+ <bool>false</bool>
+ </property>
+ <property name="text">
+ <string>Tr&im</string>
+ </property>
+ <property name="shortcut">
+ <string>Ctrl+I</string>
+ </property>
+ </action>
<action name="actionOptions">
<property name="text">
<string>Options</string>
#ifndef _RETRACE_HPP_
#define _RETRACE_HPP_
+#include <assert.h>
#include <string.h>
+#include <stdint.h>
#include <list>
#include <map>
class ScopedAllocator
{
private:
- void *next;
+ uintptr_t next;
public:
ScopedAllocator() :
- next(NULL) {
+ next(0) {
}
inline void *
return NULL;
}
- void * * buf = static_cast<void **>(malloc(sizeof(void *) + size));
+ uintptr_t * buf = static_cast<uintptr_t *>(malloc(sizeof(uintptr_t) + size));
if (!buf) {
return NULL;
}
*buf = next;
- next = buf;
+ next = reinterpret_cast<uintptr_t>(buf);
+ assert((next & 1) == 0);
- return &buf[1];
+ return static_cast<void *>(&buf[1]);
}
template< class T >
return NULL;
}
+ /**
+ * Prevent this pointer from being automatically freed.
+ */
+ template< class T >
+ inline void
+ bind(T *ptr) {
+ if (ptr) {
+ reinterpret_cast<uintptr_t *>(ptr)[-1] |= 1;
+ }
+ }
+
inline
~ScopedAllocator() {
while (next) {
- void *temp = *static_cast<void **>(next);
- free(next);
+ uintptr_t temp = *reinterpret_cast<uintptr_t *>(next);
+
+ bool bind = temp & 1;
+ temp &= ~1;
+
+ if (!bind) {
+ free(reinterpret_cast<void *>(next));
+ }
+
next = temp;
}
}
print
def retraceFunctionBody(self, function):
- if not function.sideeffects:
- print ' (void)call;'
- return
+ assert function.sideeffects
self.deserializeArgs(function)
self.swizzleValues(function)
def retraceInterfaceMethodBody(self, interface, method):
- if not method.sideeffects:
- print ' (void)call;'
- return
+ assert method.sideeffects
self.deserializeThisPointer(interface)
functions = filter(self.filterFunction, api.functions)
for function in functions:
- self.retraceFunction(function)
+ if function.sideeffects:
+ self.retraceFunction(function)
interfaces = api.getAllInterfaces()
for interface in interfaces:
for method in interface.iterMethods():
- self.retraceInterfaceMethod(interface, method)
+ if method.sideeffects:
+ self.retraceInterfaceMethod(interface, method)
print 'const retrace::Entry %s[] = {' % self.table_name
for function in functions:
- print ' {"%s", &retrace_%s},' % (function.name, function.name)
+ if function.sideeffects:
+ print ' {"%s", &retrace_%s},' % (function.name, function.name)
+ else:
+ print ' {"%s", &retrace::ignore},' % (function.name,)
for interface in interfaces:
- for method in interface.iterMethods():
- print ' {"%s::%s", &retrace_%s__%s},' % (interface.name, method.name, interface.name, method.name)
+ for method in interface.iterMethods():
+ if method.sideeffects:
+ print ' {"%s::%s", &retrace_%s__%s},' % (interface.name, method.name, interface.name, method.name)
+ else:
+ print ' {"%s::%s", &retrace::ignore},' % (interface.name, method.name)
print ' {NULL, NULL}'
print '};'
print
name = os.path.basename(path)
name, ext1 = os.path.splitext(name)
name, ext2 = os.path.splitext(name)
- print name, ext1, ext2
return ext1 in ('.png', '.bmp') and ext2 not in ('.diff', '.thumb')
def find_images(prefix):
- prefix = os.path.abspath(prefix)
if os.path.isdir(prefix):
prefix_dir = prefix
else:
optparser = optparse.OptionParser(
usage="\n\t%prog [options] <ref_prefix> <src_prefix>")
+ optparser.add_option(
+ '-v', '--verbose',
+ action="store_true", dest="verbose", default=False,
+ help="verbose output")
optparser.add_option(
'-o', '--output', metavar='FILE',
type="string", dest="output", default='index.html',
'--overwrite',
action="store_true", dest="overwrite", default=False,
help="overwrite images")
+ optparser.add_option(
+ '--show-all',
+ action="store_true", dest="show_all", default=False,
+ help="show all images, including similar ones")
(options, args) = optparser.parse_args(sys.argv[1:])
html.write('<html>\n')
html.write(' <body>\n')
html.write(' <table border="1">\n')
- html.write(' <tr><th>%s</th><th>%s</th><th>Δ</th></tr>\n' % (ref_prefix, src_prefix))
+ html.write(' <tr><th>File</th><th>%s</th><th>%s</th><th>Δ</th></tr>\n' % (ref_prefix, src_prefix))
+ failures = 0
for image in images:
ref_image = ref_prefix + image
src_image = src_prefix + image
root, ext = os.path.splitext(src_image)
delta_image = "%s.diff.png" % (root, )
if os.path.exists(ref_image) and os.path.exists(src_image):
- if options.overwrite \
- or not os.path.exists(delta_image) \
- or (os.path.getmtime(delta_image) < os.path.getmtime(ref_image) \
- and os.path.getmtime(delta_image) < os.path.getmtime(src_image)):
-
- comparer = Comparer(ref_image, src_image, options.alpha)
- comparer.write_diff(delta_image, fuzz=options.fuzz)
-
+ if options.verbose:
+ sys.stdout.write('Comparing %s and %s ...' % (ref_image, src_image))
+ comparer = Comparer(ref_image, src_image, options.alpha)
+ match = comparer.ae(fuzz=options.fuzz) == 0
+ if match:
+ result = 'MATCH'
+ bgcolor = '#20ff20'
+ else:
+ result = 'MISMATCH'
+ failures += 1
+ bgcolor = '#ff2020'
+ if options.verbose:
+ sys.stdout.write(' %s\n' % (result,))
html.write(' <tr>\n')
- surface(html, ref_image)
- surface(html, src_image)
- surface(html, delta_image)
+ html.write(' <td bgcolor="%s"><a href="%s">%s<a/></td>\n' % (bgcolor, ref_image, image))
+ if not match or options.show_all:
+ if options.overwrite \
+ or not os.path.exists(delta_image) \
+ or (os.path.getmtime(delta_image) < os.path.getmtime(ref_image) \
+ and os.path.getmtime(delta_image) < os.path.getmtime(src_image)):
+ comparer.write_diff(delta_image, fuzz=options.fuzz)
+ surface(html, ref_image)
+ surface(html, src_image)
+ surface(html, delta_image)
html.write(' </tr>\n')
html.flush()
html.write(' </table>\n')
html.write(' </body>\n')
html.write('</html>\n')
+ if failures:
+ sys.exit(1)
if __name__ == '__main__':
main()
from dxgi import *
+HRESULT = FakeEnum(HRESULT, [
+ "D3D10_ERROR_FILE_NOT_FOUND",
+ "D3D10_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTS",
+ "D3DERR_INVALIDCALL",
+ "D3DERR_WASSTILLDRAWING",
+ "E_FAIL",
+ "E_INVALIDARG",
+ "E_OUTOFMEMORY",
+ "S_FALSE",
+ "S_OK",
+])
+
D3D10_BLEND = Enum("D3D10_BLEND", [
"D3D10_BLEND_ZERO",
"D3D10_BLEND_ONE",
"D3D10_USAGE_STAGING",
])
-D3D10_BIND_FLAG = Enum("D3D10_BIND_FLAG", [
+D3D10_BIND_FLAG = Flags(UINT, [
"D3D10_BIND_VERTEX_BUFFER",
"D3D10_BIND_INDEX_BUFFER",
"D3D10_BIND_CONSTANT_BUFFER",
"D3D10_BIND_DEPTH_STENCIL",
])
+D3D10_CPU_ACCESS_FLAG = Flags(UINT, [
+ "D3D10_CPU_ACCESS_WRITE",
+ "D3D10_CPU_ACCESS_READ",
+])
+
+D3D10_RESOURCE_MISC_FLAG = Flags(UINT, [
+ "D3D10_RESOURCE_MISC_GENERATE_MIPS",
+ "D3D10_RESOURCE_MISC_SHARED",
+ "D3D10_RESOURCE_MISC_TEXTURECUBE",
+ "D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX",
+ "D3D10_RESOURCE_MISC_GDI_COMPATIBLE",
+])
+
D3D10_BUFFER_DESC = Struct("D3D10_BUFFER_DESC", [
(UINT, "ByteWidth"),
(D3D10_USAGE, "Usage"),
- (UINT, "BindFlags"),
- (UINT, "CPUAccessFlags"),
- (UINT, "MiscFlags"),
+ (D3D10_BIND_FLAG, "BindFlags"),
+ (D3D10_CPU_ACCESS_FLAG, "CPUAccessFlags"),
+ (D3D10_RESOURCE_MISC_FLAG, "MiscFlags"),
])
D3D10_MAP = Enum("D3D10_MAP", [
(UINT, "ArraySize"),
(DXGI_FORMAT, "Format"),
(D3D10_USAGE, "Usage"),
- (UINT, "BindFlags"),
- (UINT, "CPUAccessFlags"),
- (UINT, "MiscFlags"),
+ (D3D10_BIND_FLAG, "BindFlags"),
+ (D3D10_CPU_ACCESS_FLAG, "CPUAccessFlags"),
+ (D3D10_RESOURCE_MISC_FLAG, "MiscFlags"),
])
D3D10_TEXTURE2D_DESC = Struct("D3D10_TEXTURE2D_DESC", [
(DXGI_FORMAT, "Format"),
(DXGI_SAMPLE_DESC, "SampleDesc"),
(D3D10_USAGE, "Usage"),
- (UINT, "BindFlags"),
- (UINT, "CPUAccessFlags"),
- (UINT, "MiscFlags"),
+ (D3D10_BIND_FLAG, "BindFlags"),
+ (D3D10_CPU_ACCESS_FLAG, "CPUAccessFlags"),
+ (D3D10_RESOURCE_MISC_FLAG, "MiscFlags"),
])
D3D10_TEXTURE3D_DESC = Struct("D3D10_TEXTURE3D_DESC", [
(UINT, "MipLevels"),
(DXGI_FORMAT, "Format"),
(D3D10_USAGE, "Usage"),
- (UINT, "BindFlags"),
- (UINT, "CPUAccessFlags"),
- (UINT, "MiscFlags"),
+ (D3D10_BIND_FLAG, "BindFlags"),
+ (D3D10_CPU_ACCESS_FLAG, "CPUAccessFlags"),
+ (D3D10_RESOURCE_MISC_FLAG, "MiscFlags"),
])
D3D10_DSV_DIMENSION = Enum("D3D10_DSV_DIMENSION", [
"D3D10_QUERY_SO_OVERFLOW_PREDICATE",
])
+D3D10_QUERY_MISC_FLAG = Flags(UINT, [
+ "D3D10_QUERY_MISC_PREDICATEHINT",
+])
+
D3D10_QUERY_DESC = Struct("D3D10_QUERY_DESC", [
(D3D10_QUERY, "Query"),
- (UINT, "MiscFlags"),
+ (D3D10_QUERY_MISC_FLAG, "MiscFlags"),
])
D3D10_PRIMITIVE_TOPOLOGY = Enum("D3D10_PRIMITIVE_TOPOLOGY", [
(UINT, "DepthPitch"),
])
-D3D10_CPU_ACCESS_FLAG = Enum("D3D10_CPU_ACCESS_FLAG", [
- "D3D10_CPU_ACCESS_WRITE",
- "D3D10_CPU_ACCESS_READ",
-])
-
-D3D10_RESOURCE_MISC_FLAG = Enum("D3D10_RESOURCE_MISC_FLAG", [
- "D3D10_RESOURCE_MISC_GENERATE_MIPS",
- "D3D10_RESOURCE_MISC_SHARED",
- "D3D10_RESOURCE_MISC_TEXTURECUBE",
- "D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX",
- "D3D10_RESOURCE_MISC_GDI_COMPATIBLE",
-])
-
-D3D10_MAP_FLAG = Enum("D3D10_MAP_FLAG", [
+D3D10_MAP_FLAG = Flags(UINT, [
"D3D10_MAP_FLAG_DO_NOT_WAIT",
])
-D3D10_CLEAR_FLAG = Enum("D3D10_CLEAR_FLAG", [
+D3D10_CLEAR_FLAG = Flags(UINT, [
"D3D10_CLEAR_DEPTH",
"D3D10_CLEAR_STENCIL",
])
-D3D10_COLOR_WRITE_ENABLE = Enum("D3D10_COLOR_WRITE_ENABLE", [
- "D3D10_COLOR_WRITE_ENABLE_RED",
- "D3D10_COLOR_WRITE_ENABLE_GREEN",
- "D3D10_COLOR_WRITE_ENABLE_BLUE",
- "D3D10_COLOR_WRITE_ENABLE_ALPHA",
+D3D10_COLOR_WRITE_ENABLE = Flags(UINT, [
"D3D10_COLOR_WRITE_ENABLE_ALL",
"D3D10_COLOR_WRITE_ENABLE_RED",
- "|",
"D3D10_COLOR_WRITE_ENABLE_GREEN",
- "|",
"D3D10_COLOR_WRITE_ENABLE_BLUE",
- "|",
"D3D10_COLOR_WRITE_ENABLE_ALPHA",
- ")",
])
D3D10_TEXTURECUBE_FACE = Enum("D3D10_TEXTURECUBE_FACE", [
"D3D10_TEXTURECUBE_FACE_NEGATIVE_Z",
])
-D3D10_ASYNC_GETDATA_FLAG = Enum("D3D10_ASYNC_GETDATA_FLAG", [
+D3D10_ASYNC_GETDATA_FLAG = Flags(UINT, [
"D3D10_ASYNC_GETDATA_DONOTFLUSH",
])
"D3D10_FILTER_TYPE_LINEAR",
])
-D3D10_QUERY_MISC_FLAG = Enum("D3D10_QUERY_MISC_FLAG", [
- "D3D10_QUERY_MISC_PREDICATEHINT",
-])
-
D3D10_QUERY_DATA_TIMESTAMP_DISJOINT = Struct("D3D10_QUERY_DATA_TIMESTAMP_DISJOINT", [
(UINT64, "Frequency"),
(BOOL, "Disjoint"),
(UINT64, "PrimitivesStorageNeeded"),
])
-D3D10_CREATE_DEVICE_FLAG = Enum("D3D10_CREATE_DEVICE_FLAG", [
+D3D10_CREATE_DEVICE_FLAG = Flags(UINT, [
"D3D10_CREATE_DEVICE_SINGLETHREADED",
"D3D10_CREATE_DEVICE_DEBUG",
"D3D10_CREATE_DEVICE_SWITCH_TO_REF",
"D3D10_CREATE_DEVICE_STRICT_VALIDATION",
])
+D3D10_RAISE_FLAG = Flags(UINT, [
+ "D3D10_RAISE_FLAG_DRIVER_INTERNAL_ERROR",
+])
+
ID3D10DeviceChild = Interface("ID3D10DeviceChild", IUnknown)
ID3D10Resource = Interface("ID3D10Resource", ID3D10DeviceChild)
ID3D10Buffer = Interface("ID3D10Buffer", ID3D10Resource)
]
ID3D10Buffer.methods += [
- Method(HRESULT, "Map", [(D3D10_MAP, "MapType"), (UINT, "MapFlags"), Out(Pointer(OpaquePointer(Void)), "ppData")]),
+ Method(HRESULT, "Map", [(D3D10_MAP, "MapType"), (D3D10_MAP_FLAG, "MapFlags"), Out(Pointer(OpaquePointer(Void)), "ppData")]),
Method(Void, "Unmap", []),
Method(Void, "GetDesc", [Out(Pointer(D3D10_BUFFER_DESC), "pDesc")]),
]
ID3D10Texture1D.methods += [
- Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (UINT, "MapFlags"), Out(Pointer(OpaquePointer(Void)), "ppData")]),
+ Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (D3D10_MAP_FLAG, "MapFlags"), Out(Pointer(OpaquePointer(Void)), "ppData")]),
Method(Void, "Unmap", [(UINT, "Subresource")]),
Method(Void, "GetDesc", [Out(Pointer(D3D10_TEXTURE1D_DESC), "pDesc")]),
]
ID3D10Texture2D.methods += [
- Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (UINT, "MapFlags"), Out(Pointer(D3D10_MAPPED_TEXTURE2D), "pMappedTex2D")]),
+ Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (D3D10_MAP_FLAG, "MapFlags"), Out(Pointer(D3D10_MAPPED_TEXTURE2D), "pMappedTex2D")]),
Method(Void, "Unmap", [(UINT, "Subresource")]),
Method(Void, "GetDesc", [Out(Pointer(D3D10_TEXTURE2D_DESC), "pDesc")]),
]
ID3D10Texture3D.methods += [
- Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (UINT, "MapFlags"), Out(Pointer(D3D10_MAPPED_TEXTURE3D), "pMappedTex3D")]),
+ Method(HRESULT, "Map", [(UINT, "Subresource"), (D3D10_MAP, "MapType"), (D3D10_MAP_FLAG, "MapFlags"), Out(Pointer(D3D10_MAPPED_TEXTURE3D), "pMappedTex3D")]),
Method(Void, "Unmap", [(UINT, "Subresource")]),
Method(Void, "GetDesc", [Out(Pointer(D3D10_TEXTURE3D_DESC), "pDesc")]),
]
ID3D10Asynchronous.methods += [
Method(Void, "Begin", []),
Method(Void, "End", []),
- Method(HRESULT, "GetData", [Out(Blob(Void, "DataSize"), "pData"), (UINT, "DataSize"), (UINT, "GetDataFlags")]),
+ Method(HRESULT, "GetData", [Out(Blob(Void, "DataSize"), "pData"), (UINT, "DataSize"), (D3D10_ASYNC_GETDATA_FLAG, "GetDataFlags")]),
Method(UINT, "GetDataSize", []),
]
Method(Void, "CopyResource", [(Pointer(ID3D10Resource), "pDstResource"), (Pointer(ID3D10Resource), "pSrcResource")]),
Method(Void, "UpdateSubresource", [(Pointer(ID3D10Resource), "pDstResource"), (UINT, "DstSubresource"), (Pointer(Const(D3D10_BOX)), "pDstBox"), (OpaquePointer(Const(Void)), "pSrcData"), (UINT, "SrcRowPitch"), (UINT, "SrcDepthPitch")]),
Method(Void, "ClearRenderTargetView", [(OpaquePointer(ID3D10RenderTargetView), "pRenderTargetView"), (Array(Const(FLOAT), 4), "ColorRGBA")]),
- Method(Void, "ClearDepthStencilView", [(Pointer(ID3D10DepthStencilView), "pDepthStencilView"), (UINT, "ClearFlags"), (FLOAT, "Depth"), (UINT8, "Stencil")]),
+ Method(Void, "ClearDepthStencilView", [(Pointer(ID3D10DepthStencilView), "pDepthStencilView"), (D3D10_CLEAR_FLAG, "ClearFlags"), (FLOAT, "Depth"), (UINT8, "Stencil")]),
Method(Void, "GenerateMips", [(OpaquePointer(ID3D10ShaderResourceView), "pShaderResourceView")]),
Method(Void, "ResolveSubresource", [(Pointer(ID3D10Resource), "pDstResource"), (UINT, "DstSubresource"), (Pointer(ID3D10Resource), "pSrcResource"), (UINT, "SrcSubresource"), (DXGI_FORMAT, "Format")]),
Method(Void, "VSGetConstantBuffers", [(UINT, "StartSlot"), (UINT, "NumBuffers"), Out(Array(OpaquePointer(ID3D10Buffer), "NumBuffers"), "ppConstantBuffers")]),
Method(Void, "RSGetViewports", [Out(Pointer(UINT), "NumViewports"), Out(Array(D3D10_VIEWPORT, "*NumViewports"), "pViewports")]),
Method(Void, "RSGetScissorRects", [Out(Pointer(UINT), "NumRects"), Out(Array(D3D10_RECT, "*NumRects"), "pRects")]),
Method(HRESULT, "GetDeviceRemovedReason", []),
- Method(HRESULT, "SetExceptionMode", [(UINT, "RaiseFlags")]),
- Method(UINT, "GetExceptionMode", []),
+ Method(HRESULT, "SetExceptionMode", [(D3D10_RAISE_FLAG, "RaiseFlags")]),
+ Method(D3D10_RAISE_FLAG, "GetExceptionMode", []),
Method(HRESULT, "GetPrivateData", [(REFGUID, "guid"), Out(Pointer(UINT), "pDataSize"), Out(OpaquePointer(Void), "pData")]),
Method(HRESULT, "SetPrivateData", [(REFGUID, "guid"), (UINT, "DataSize"), (OpaquePointer(Const(Void)), "pData")]),
Method(HRESULT, "SetPrivateDataInterface", [(REFGUID, "guid"), (OpaquePointer(Const(IUnknown)), "pData")]),
Method(HRESULT, "CheckMultisampleQualityLevels", [(DXGI_FORMAT, "Format"), (UINT, "SampleCount"), Out(Pointer(UINT), "pNumQualityLevels")]),
Method(Void, "CheckCounterInfo", [Out(Pointer(D3D10_COUNTER_INFO), "pCounterInfo")]),
Method(HRESULT, "CheckCounter", [(Pointer(Const(D3D10_COUNTER_DESC)), "pDesc"), Out(Pointer(D3D10_COUNTER_TYPE), "pType"), Out(Pointer(UINT), "pActiveCounters"), Out(LPSTR, "szName"), Out(Pointer(UINT), "pNameLength"), Out(LPSTR, "szUnits"), Out(Pointer(UINT), "pUnitsLength"), Out(LPSTR, "szDescription"), Out(Pointer(UINT), "pDescriptionLength")]),
- Method(UINT, "GetCreationFlags", []),
+ Method(D3D10_CREATE_DEVICE_FLAG, "GetCreationFlags", []),
Method(HRESULT, "OpenSharedResource", [(HANDLE, "hResource"), (REFIID, "ReturnedInterface"), Out(Pointer(OpaquePointer(Void)), "ppResource")]),
Method(Void, "SetTextFilterSize", [(UINT, "Width"), (UINT, "Height")]),
Method(Void, "GetTextFilterSize", [Out(Pointer(UINT), "pWidth"), Out(Pointer(UINT), "pHeight")]),
##########################################################################
#
-# Copyright 2008-2009 VMware, Inc.
+# Copyright 2008-2012 VMware, Inc.
# All Rights Reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
"""d3d10_1.h"""
from winapi import *
+from d3d10sdklayers import *
+from d3d10 import *
ID3D10Blob = Interface("ID3D10Blob", IUnknown)
LPD3D10BLOB = Pointer(ID3D10Blob)
"D3D10_FEATURE_LEVEL_9_3",
])
-# TODO
-IDXGIAdapter = Alias("IDXGIAdapter", Void)
-ID3D10Device1 = Alias("ID3D10Device1", Void)
-IDXGISwapChain = Alias("IDXGISwapChain", Void)
-DXGI_SWAP_CHAIN_DESC = Alias("DXGI_SWAP_CHAIN_DESC", Void)
+D3D10_RENDER_TARGET_BLEND_DESC1 = Struct("D3D10_RENDER_TARGET_BLEND_DESC1", [
+ (BOOL, "BlendEnable"),
+ (D3D10_BLEND, "SrcBlend"),
+ (D3D10_BLEND, "DestBlend"),
+ (D3D10_BLEND_OP, "BlendOp"),
+ (D3D10_BLEND, "SrcBlendAlpha"),
+ (D3D10_BLEND, "DestBlendAlpha"),
+ (D3D10_BLEND_OP, "BlendOpAlpha"),
+ (UINT8, "RenderTargetWriteMask"),
+])
+
+D3D10_BLEND_DESC1 = Struct("D3D10_BLEND_DESC1", [
+ (BOOL, "AlphaToCoverageEnable"),
+ (BOOL, "IndependentBlendEnable"),
+ (Array(D3D10_RENDER_TARGET_BLEND_DESC1, "D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT"), "RenderTarget"),
+])
+
+ID3D10BlendState1 = Interface("ID3D10BlendState1", ID3D10BlendState)
+ID3D10BlendState1.methods += [
+ Method(Void, "GetDesc1", [Out(Pointer(D3D10_BLEND_DESC1), "pDesc")]),
+]
+
+D3D10_TEXCUBE_ARRAY_SRV1 = Struct("D3D10_TEXCUBE_ARRAY_SRV1", [
+ (UINT, "MostDetailedMip"),
+ (UINT, "MipLevels"),
+ (UINT, "First2DArrayFace"),
+ (UINT, "NumCubes"),
+])
-d3d10_1 = Dll("d3d10")
-d3d10_1.functions += [
- StdFunction(HRESULT, "D3D10CreateDevice1", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (UINT, "Flags"), (D3D10_FEATURE_LEVEL1, "HardwareLevel"), (UINT, "SDKVersion"), (OutPointer(Pointer(ID3D10Device1)), "ppDevice")]),
- StdFunction(HRESULT, "D3D10CreateDeviceAndSwapChain1", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (UINT, "Flags"), (D3D10_FEATURE_LEVEL1, "HardwareLevel"), (UINT, "SDKVersion"), (Pointer(DXGI_SWAP_CHAIN_DESC), "pSwapChainDesc"), (OutPointer(Pointer(IDXGISwapChain)), "ppSwapChain"), (OutPointer(Pointer(ID3D10Device1)), "ppDevice")]),
- StdFunction(HRESULT, "D3D10CreateBlob", [(SIZE_T, "NumBytes"), (OutPointer(LPD3D10BLOB), "ppBuffer")]),
+D3D10_SRV_DIMENSION1 = Alias("D3D10_SRV_DIMENSION1", D3D10_SRV_DIMENSION)
+D3D10_SHADER_RESOURCE_VIEW_DESC1 = Struct("D3D10_SHADER_RESOURCE_VIEW_DESC1", [
+ (DXGI_FORMAT, "Format"),
+ (D3D10_SRV_DIMENSION1, "ViewDimension"),
+ (D3D10_BUFFER_SRV, "Buffer"),
+ (D3D10_TEX1D_SRV, "Texture1D"),
+ (D3D10_TEX1D_ARRAY_SRV, "Texture1DArray"),
+ (D3D10_TEX2D_SRV, "Texture2D"),
+ (D3D10_TEX2D_ARRAY_SRV, "Texture2DArray"),
+ (D3D10_TEX2DMS_SRV, "Texture2DMS"),
+ (D3D10_TEX2DMS_ARRAY_SRV, "Texture2DMSArray"),
+ (D3D10_TEX3D_SRV, "Texture3D"),
+ (D3D10_TEXCUBE_SRV, "TextureCube"),
+ (D3D10_TEXCUBE_ARRAY_SRV1, "TextureCubeArray"),
+])
+
+ID3D10ShaderResourceView1 = Interface("ID3D10ShaderResourceView1", ID3D10ShaderResourceView)
+ID3D10ShaderResourceView1.methods += [
+ Method(Void, "GetDesc1", [Out(Pointer(D3D10_SHADER_RESOURCE_VIEW_DESC1), "pDesc")]),
+]
+
+ID3D10Device1 = Interface("ID3D10Device1", ID3D10Device)
+ID3D10Device1.methods += [
+ Method(HRESULT, "CreateShaderResourceView1", [(Pointer(ID3D10Resource), "pResource"), Out(Pointer(Const(D3D10_SHADER_RESOURCE_VIEW_DESC1)), "pDesc"), Out(Pointer(Pointer(ID3D10ShaderResourceView1)), "ppSRView")]),
+ Method(HRESULT, "CreateBlendState1", [(Pointer(Const(D3D10_BLEND_DESC1)), "pBlendStateDesc"), Out(Pointer(Pointer(ID3D10BlendState1)), "ppBlendState")]),
+ Method(D3D10_FEATURE_LEVEL1, "GetFeatureLevel", []),
]
-if __name__ == '__main__':
- print '#include <windows.h>'
- print '#include <tchar.h>'
- print
- print '#include "compat.h"'
- print
- print '#include <d3d10_1.h>'
- print
- print '#include "trace_writer.hpp"'
- print
- wrap()
+d3d10_1 = API("d3d10_1")
+d3d10_1.addFunctions([
+ StdFunction(HRESULT, "D3D10CreateDevice1", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (D3D10_FEATURE_LEVEL1, "HardwareLevel"), (UINT, "SDKVersion"), Out(Pointer(Pointer(ID3D10Device1)), "ppDevice")]),
+ StdFunction(HRESULT, "D3D10CreateDeviceAndSwapChain1", [(Pointer(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(Pointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(Pointer(ID3D10Device1)), "ppDevice")]),
+ StdFunction(HRESULT, "D3D10CreateBlob", [(SIZE_T, "NumBytes"), Out(Pointer(LPD3D10BLOB), "ppBuffer")]),
+])
+
+d3d10_1.addInterfaces([
+ IDXGIDevice,
+ ID3D10Debug,
+ ID3D10SwitchToRef,
+ ID3D10InfoQueue,
+ ID3D10DeviceChild,
+ ID3D10Resource,
+ ID3D10Buffer,
+ ID3D10Texture1D,
+ ID3D10Texture2D,
+ ID3D10Texture3D,
+ ID3D10View,
+ ID3D10DepthStencilView,
+ ID3D10RenderTargetView,
+ ID3D10ShaderResourceView1,
+ ID3D10BlendState1,
+ ID3D10DepthStencilState,
+ ID3D10GeometryShader,
+ ID3D10InputLayout,
+ ID3D10PixelShader,
+ ID3D10RasterizerState,
+ ID3D10SamplerState,
+ ID3D10VertexShader,
+ ID3D10Asynchronous,
+ ID3D10Counter,
+ ID3D10Query,
+ ID3D10Predicate,
+ ID3D10Device,
+ ID3D10Multithread,
+])
"""d3d10misc.h"""
from winapi import *
+from d3d10sdklayers import *
from d3d10 import *
d3d10 = API("d3d10")
d3d10.addFunctions([
- StdFunction(HRESULT, "D3D10CreateDevice", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (UINT, "Flags"), (UINT, "SDKVersion"), Out(Pointer(Pointer(ID3D10Device)), "ppDevice")]),
- StdFunction(HRESULT, "D3D10CreateDeviceAndSwapChain", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (UINT, "Flags"), (UINT, "SDKVersion"), (Pointer(DXGI_SWAP_CHAIN_DESC), "pSwapChainDesc"), Out(Pointer(Pointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(Pointer(ID3D10Device)), "ppDevice")]),
+ StdFunction(HRESULT, "D3D10CreateDevice", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (UINT, "SDKVersion"), Out(Pointer(Pointer(ID3D10Device)), "ppDevice")]),
+ StdFunction(HRESULT, "D3D10CreateDeviceAndSwapChain", [(Pointer(IDXGIAdapter), "pAdapter"), (D3D10_DRIVER_TYPE, "DriverType"), (HMODULE, "Software"), (D3D10_CREATE_DEVICE_FLAG, "Flags"), (UINT, "SDKVersion"), (Pointer(DXGI_SWAP_CHAIN_DESC), "pSwapChainDesc"), Out(Pointer(Pointer(IDXGISwapChain)), "ppSwapChain"), Out(Pointer(Pointer(ID3D10Device)), "ppDevice")]),
StdFunction(HRESULT, "D3D10CreateBlob", [(SIZE_T, "NumBytes"), Out(Pointer(LPD3D10BLOB), "ppBuffer")]),
])
d3d10.addInterfaces([
+ IDXGIDevice,
+ ID3D10Debug,
+ ID3D10SwitchToRef,
+ ID3D10InfoQueue,
ID3D10DeviceChild,
ID3D10Resource,
ID3D10Buffer,
--- /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.
+#
+##########################################################################/
+
+from dxgi import *
+from d3d10 import HRESULT
+
+D3D10_DEBUG_FEATURE = Flags(UINT, [
+ "D3D10_DEBUG_FEATURE_FLUSH_PER_RENDER_OP",
+ "D3D10_DEBUG_FEATURE_FINISH_PER_RENDER_OP",
+ "D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OP",
+])
+
+ID3D10Debug = Interface("ID3D10Debug", IUnknown)
+ID3D10Debug.methods += [
+ Method(HRESULT, "SetFeatureMask", [(D3D10_DEBUG_FEATURE, "Mask")]),
+ Method(UINT, "GetFeatureMask", []),
+ Method(HRESULT, "SetPresentPerRenderOpDelay", [(UINT, "Milliseconds")]),
+ Method(UINT, "GetPresentPerRenderOpDelay", []),
+ Method(HRESULT, "SetSwapChain", [(Pointer(IDXGISwapChain), "pSwapChain")]),
+ Method(HRESULT, "GetSwapChain", [Out(Pointer(Pointer(IDXGISwapChain)), "ppSwapChain")]),
+ Method(HRESULT, "Validate", []),
+]
+
+ID3D10SwitchToRef = Interface("ID3D10SwitchToRef", IUnknown)
+ID3D10SwitchToRef.methods += [
+ Method(BOOL, "SetUseRef", [(BOOL, "UseRef")]),
+ Method(BOOL, "GetUseRef", []),
+]
+
+D3D10_MESSAGE_CATEGORY = Enum("D3D10_MESSAGE_CATEGORY", [
+ "D3D10_MESSAGE_CATEGORY_APPLICATION_DEFINED",
+ "D3D10_MESSAGE_CATEGORY_MISCELLANEOUS",
+ "D3D10_MESSAGE_CATEGORY_INITIALIZATION",
+ "D3D10_MESSAGE_CATEGORY_CLEANUP",
+ "D3D10_MESSAGE_CATEGORY_COMPILATION",
+ "D3D10_MESSAGE_CATEGORY_STATE_CREATION",
+ "D3D10_MESSAGE_CATEGORY_STATE_SETTING",
+ "D3D10_MESSAGE_CATEGORY_STATE_GETTING",
+ "D3D10_MESSAGE_CATEGORY_RESOURCE_MANIPULATION",
+ "D3D10_MESSAGE_CATEGORY_EXECUTION",
+])
+
+D3D10_MESSAGE_SEVERITY = Enum("D3D10_MESSAGE_SEVERITY", [
+ "D3D10_MESSAGE_SEVERITY_CORRUPTION",
+ "D3D10_MESSAGE_SEVERITY_ERROR",
+ "D3D10_MESSAGE_SEVERITY_WARNING",
+ "D3D10_MESSAGE_SEVERITY_INFO",
+])
+
+D3D10_MESSAGE_ID = Enum("D3D10_MESSAGE_ID", [
+ "D3D10_MESSAGE_ID_UNKNOWN",
+ "D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_OMSETRENDERTARGETS_HAZARD",
+ "D3D10_MESSAGE_ID_DEVICE_SOSETTARGETS_HAZARD",
+ "D3D10_MESSAGE_ID_STRING_FROM_APPLICATION",
+ "D3D10_MESSAGE_ID_CORRUPTED_THIS",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER1",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER2",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER3",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER4",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER5",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER6",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER7",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER8",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER9",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER10",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER11",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER12",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER13",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER14",
+ "D3D10_MESSAGE_ID_CORRUPTED_PARAMETER15",
+ "D3D10_MESSAGE_ID_CORRUPTED_MULTITHREADING",
+ "D3D10_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY",
+ "D3D10_MESSAGE_ID_IASETINPUTLAYOUT_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_IASETINDEXBUFFER_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_VSSETSHADER_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_VSSETSHADERRESOURCES_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_VSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_VSSETSAMPLERS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_GSSETSHADER_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_GSSETSHADERRESOURCES_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_GSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_GSSETSAMPLERS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_SOSETTARGETS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_PSSETSHADER_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_PSSETSHADERRESOURCES_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_PSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_PSSETSAMPLERS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_RSSETSTATE_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_OMSETBLENDSTATE_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_OMSETDEPTHSTENCILSTATE_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_OMSETRENDERTARGETS_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_SETPREDICATION_UNBINDDELETINGOBJECT",
+ "D3D10_MESSAGE_ID_GETPRIVATEDATA_MOREDATA",
+ "D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA",
+ "D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN",
+ "D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS",
+ "D3D10_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS",
+ "D3D10_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDSAMPLES",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDUSAGE",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDBINDFLAGS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDCPUACCESSFLAGS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDCPUACCESSFLAGS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDBINDFLAGS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDINITIALDATA",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDDIMENSIONS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDMIPLEVELS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDCONSTANTBUFFERBINDINGS",
+ "D3D10_MESSAGE_ID_CREATEBUFFER_LARGEALLOCATION",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_UNSUPPORTEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDSAMPLES",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDUSAGE",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDBINDFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDCPUACCESSFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDCPUACCESSFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDBINDFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDINITIALDATA",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDDIMENSIONS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDMIPLEVELS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATETEXTURE1D_LARGEALLOCATION",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_UNSUPPORTEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDSAMPLES",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDUSAGE",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDBINDFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDCPUACCESSFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDCPUACCESSFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDBINDFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDINITIALDATA",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDDIMENSIONS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDMIPLEVELS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATETEXTURE2D_LARGEALLOCATION",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_UNSUPPORTEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDSAMPLES",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDUSAGE",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDBINDFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDCPUACCESSFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDCPUACCESSFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDBINDFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDINITIALDATA",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDDIMENSIONS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDMIPLEVELS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATETEXTURE3D_LARGEALLOCATION",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_TOOMANYOBJECTS",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_TOOMANYOBJECTS",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_TOOMANYOBJECTS",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY",
+ "D3D10_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE",
+ "D3D10_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE",
+ "D3D10_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY",
+ "D3D10_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE",
+ "D3D10_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE",
+ "D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE",
+ "D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE",
+ "D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP",
+ "D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS",
+ "D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_TOOMANYOBJECTS",
+ "D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_TOOMANYOBJECTS",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_TOOMANYOBJECTS",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_TOOMANYOBJECTS",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC",
+ "D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDQUERY",
+ "D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDMISCFLAGS",
+ "D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_UNEXPECTEDMISCFLAG",
+ "D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_NULLDESC",
+ "D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED",
+ "D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED",
+ "D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_INVALIDBUFFER",
+ "D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_OFFSET_TOO_LARGE",
+ "D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_IASETINDEXBUFFER_INVALIDBUFFER",
+ "D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_FORMAT_INVALID",
+ "D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_TOO_LARGE",
+ "D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_UNALIGNED",
+ "D3D10_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_VIEWS_EMPTY",
+ "D3D10_MESSAGE_ID_VSSETCONSTANTBUFFERS_INVALIDBUFFER",
+ "D3D10_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_VSSETSAMPLERS_SAMPLERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_VIEWS_EMPTY",
+ "D3D10_MESSAGE_ID_GSSETCONSTANTBUFFERS_INVALIDBUFFER",
+ "D3D10_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_GSSETSAMPLERS_SAMPLERS_EMPTY",
+ "D3D10_MESSAGE_ID_SOSETTARGETS_INVALIDBUFFER",
+ "D3D10_MESSAGE_ID_DEVICE_SOSETTARGETS_OFFSET_UNALIGNED",
+ "D3D10_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_VIEWS_EMPTY",
+ "D3D10_MESSAGE_ID_PSSETCONSTANTBUFFERS_INVALIDBUFFER",
+ "D3D10_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_PSSETSAMPLERS_SAMPLERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT",
+ "D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR",
+ "D3D10_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH",
+ "D3D10_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH",
+ "D3D10_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID",
+ "D3D10_MESSAGE_ID_DEVICE_IAGETVERTEXBUFFERS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_VSGETSHADERRESOURCES_VIEWS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_VSGETCONSTANTBUFFERS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_VSGETSAMPLERS_SAMPLERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_GSGETSHADERRESOURCES_VIEWS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_GSGETCONSTANTBUFFERS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_GSGETSAMPLERS_SAMPLERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_SOGETTARGETS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_PSGETSHADERRESOURCES_VIEWS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_PSGETCONSTANTBUFFERS_BUFFERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_PSGETSAMPLERS_SAMPLERS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_RSGETVIEWPORTS_VIEWPORTS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_RSGETSCISSORRECTS_RECTS_EMPTY",
+ "D3D10_MESSAGE_ID_DEVICE_GENERATEMIPS_RESOURCE_INVALID",
+ "D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSUBRESOURCE",
+ "D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESUBRESOURCE",
+ "D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCEBOX",
+ "D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCE",
+ "D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSTATE",
+ "D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESTATE",
+ "D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE",
+ "D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE",
+ "D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE",
+ "D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE",
+ "D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX",
+ "D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE",
+ "D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID",
+ "D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID",
+ "D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID",
+ "D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID",
+ "D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID",
+ "D3D10_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE",
+ "D3D10_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS",
+ "D3D10_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED",
+ "D3D10_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN",
+ "D3D10_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED",
+ "D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE",
+ "D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE",
+ "D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS",
+ "D3D10_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED",
+ "D3D10_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN",
+ "D3D10_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE",
+ "D3D10_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED",
+ "D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE",
+ "D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE",
+ "D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS",
+ "D3D10_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED",
+ "D3D10_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN",
+ "D3D10_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE",
+ "D3D10_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED",
+ "D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE",
+ "D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE",
+ "D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS",
+ "D3D10_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED",
+ "D3D10_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN",
+ "D3D10_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE",
+ "D3D10_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED",
+ "D3D10_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED",
+ "D3D10_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED",
+ "D3D10_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS",
+ "D3D10_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN",
+ "D3D10_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE",
+ "D3D10_MESSAGE_ID_REF_THREADING_MODE",
+ "D3D10_MESSAGE_ID_REF_UMDRIVER_EXCEPTION",
+ "D3D10_MESSAGE_ID_REF_KMDRIVER_EXCEPTION",
+ "D3D10_MESSAGE_ID_REF_HARDWARE_EXCEPTION",
+ "D3D10_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE",
+ "D3D10_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER",
+ "D3D10_MESSAGE_ID_REF_OUT_OF_MEMORY",
+ "D3D10_MESSAGE_ID_REF_INFO",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW",
+ "D3D10_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW",
+ "D3D10_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW",
+ "D3D10_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW",
+ "D3D10_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW",
+ "D3D10_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET",
+ "D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND",
+ "D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX",
+ "D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE",
+ "D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK",
+ "D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE",
+ "D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_NOT_SET",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_INPUTLAYOUT_NOT_SET",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_NOT_SET",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_TOO_SMALL",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_SAMPLER_NOT_SET",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_SHADERRESOURCEVIEW_NOT_SET",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VIEW_DIMENSION_MISMATCH",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_TOO_SMALL",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_NOT_SET",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_FORMAT_INVALID",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_TOO_SMALL",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_GS_INPUT_PRIMITIVE_MISMATCH",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_RETURN_TYPE_MISMATCH",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_POSITION_NOT_PRESENT",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_NOT_SET",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_BOUND_RESOURCE_MAPPED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_INVALID_PRIMITIVETOPOLOGY",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_OFFSET_UNALIGNED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_STRIDE_UNALIGNED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_OFFSET_UNALIGNED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_SO_STRIDE_LARGER_THAN_BUFFER",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0",
+ "D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT",
+ "D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT",
+ "D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT",
+ "D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN",
+ "D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC",
+ "D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC",
+ "D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH",
+ "D3D10_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW",
+ "D3D10_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH",
+ "D3D10_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY",
+ "D3D10_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY",
+ "D3D10_MESSAGE_ID_CREATEQUERY_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATEPREDICATE_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATECOUNTER_OUTOFRANGE_COUNTER",
+ "D3D10_MESSAGE_ID_CREATECOUNTER_SIMULTANEOUS_ACTIVE_COUNTERS_EXHAUSTED",
+ "D3D10_MESSAGE_ID_CREATECOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER",
+ "D3D10_MESSAGE_ID_CREATECOUNTER_OUTOFMEMORY_RETURN",
+ "D3D10_MESSAGE_ID_CREATECOUNTER_NONEXCLUSIVE_RETURN",
+ "D3D10_MESSAGE_ID_CREATECOUNTER_NULLDESC",
+ "D3D10_MESSAGE_ID_CHECKCOUNTER_OUTOFRANGE_COUNTER",
+ "D3D10_MESSAGE_ID_CHECKCOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER",
+ "D3D10_MESSAGE_ID_SETPREDICATION_INVALID_PREDICATE_STATE",
+ "D3D10_MESSAGE_ID_QUERY_BEGIN_UNSUPPORTED",
+ "D3D10_MESSAGE_ID_PREDICATE_BEGIN_DURING_PREDICATION",
+ "D3D10_MESSAGE_ID_QUERY_BEGIN_DUPLICATE",
+ "D3D10_MESSAGE_ID_QUERY_BEGIN_ABANDONING_PREVIOUS_RESULTS",
+ "D3D10_MESSAGE_ID_PREDICATE_END_DURING_PREDICATION",
+ "D3D10_MESSAGE_ID_QUERY_END_ABANDONING_PREVIOUS_RESULTS",
+ "D3D10_MESSAGE_ID_QUERY_END_WITHOUT_BEGIN",
+ "D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_DATASIZE",
+ "D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_FLAGS",
+ "D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_CALL",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN",
+ "D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE",
+ "D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT",
+ "D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH",
+ "D3D10_MESSAGE_ID_D3D10_MESSAGES_END",
+ "D3D10_MESSAGE_ID_D3D10L9_MESSAGES_START",
+ "D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_STENCIL_NO_TWO_SIDED",
+ "D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_DepthBiasClamp_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NO_COMPARISON_SUPPORT",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_EXCESSIVE_ANISOTROPY",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_OUT_OF_RANGE",
+ "D3D10_MESSAGE_ID_VSSETSAMPLERS_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_VSSETSAMPLERS_TOO_MANY_SAMPLERS",
+ "D3D10_MESSAGE_ID_PSSETSAMPLERS_TOO_MANY_SAMPLERS",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NO_ARRAYS",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NO_VB_AND_IB_BIND",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NO_TEXTURE_1D",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_DIMENSION_OUT_OF_RANGE",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_SHADER_RESOURCE",
+ "D3D10_MESSAGE_ID_OMSETRENDERTARGETS_TOO_MANY_RENDER_TARGETS",
+ "D3D10_MESSAGE_ID_OMSETRENDERTARGETS_NO_DIFFERING_BIT_DEPTHS",
+ "D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_BAD_BUFFER_INDEX",
+ "D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_TOO_MANY_VIEWPORTS",
+ "D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_ADJACENCY_UNSUPPORTED",
+ "D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_TOO_MANY_SCISSORS",
+ "D3D10_MESSAGE_ID_COPYRESOURCE_ONLY_TEXTURE_2D_WITHIN_GPU_MEMORY",
+ "D3D10_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_3D_READBACK",
+ "D3D10_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_ONLY_READBACK",
+ "D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_UNSUPPORTED_FORMAT",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_ALPHA_TO_COVERAGE",
+ "D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_DepthClipEnable_MUST_BE_TRUE",
+ "D3D10_MESSAGE_ID_DRAWINDEXED_STARTINDEXLOCATION_MUST_BE_POSITIVE",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_MUST_USE_LOWEST_LOD",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_MINLOD_MUST_NOT_BE_FRACTIONAL",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_MAXLOD_MUST_BE_FLT_MAX",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_FIRSTARRAYSLICE_MUST_BE_ZERO",
+ "D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_CUBES_MUST_HAVE_6_SIDES",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_RENDER_TARGET",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NO_DWORD_INDEX_BUFFER",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_MSAA_PRECLUDES_SHADER_RESOURCE",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_PRESENTATION_PRECLUDES_SHADER_RESOURCE",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_BLEND_ENABLE",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_WRITE_MASKS",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NO_STREAM_OUT",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_ONLY_VB_IB_FOR_BUFFERS",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NO_AUTOGEN_FOR_VOLUMES",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_DXGI_FORMAT_R8G8B8A8_CANNOT_BE_SHARED",
+ "D3D10_MESSAGE_ID_VSSHADERRESOURCES_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_GEOMETRY_SHADER_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_STREAM_OUT_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_TEXT_FILTER_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_SEPARATE_ALPHA_BLEND",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_MRT_BLEND",
+ "D3D10_MESSAGE_ID_CREATEBLENDSTATE_OPERATION_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NO_MIRRORONCE",
+ "D3D10_MESSAGE_ID_DRAWINSTANCED_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_DRAWINDEXEDINSTANCED_NOT_SUPPORTED_BELOW_9_3",
+ "D3D10_MESSAGE_ID_DRAWINDEXED_POINTLIST_UNSUPPORTED",
+ "D3D10_MESSAGE_ID_SETBLENDSTATE_SAMPLE_MASK_CANNOT_BE_ZERO",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_DIMENSION_EXCEEDS_FEATURE_LEVEL_DEFINITION",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_ONLY_SINGLE_MIP_LEVEL_DEPTH_STENCIL_SUPPORTED",
+ "D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_NEGATIVESCISSOR",
+ "D3D10_MESSAGE_ID_SLOT_ZERO_MUST_BE_D3D10_INPUT_PER_VERTEX_DATA",
+ "D3D10_MESSAGE_ID_CREATERESOURCE_NON_POW_2_MIPMAP",
+ "D3D10_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_NOT_SUPPORTED",
+ "D3D10_MESSAGE_ID_OMSETRENDERTARGETS_NO_SRGB_MRT",
+ "D3D10_MESSAGE_ID_D3D10L9_MESSAGES_END",
+])
+
+D3D10_MESSAGE = Struct("D3D10_MESSAGE", [
+ (D3D10_MESSAGE_CATEGORY, "Category"),
+ (D3D10_MESSAGE_SEVERITY, "Severity"),
+ (D3D10_MESSAGE_ID, "ID"),
+ (Const(CString), "pDescription"),
+ (SIZE_T, "DescriptionByteLength"),
+])
+
+D3D10_INFO_QUEUE_FILTER_DESC = Struct("D3D10_INFO_QUEUE_FILTER_DESC", [
+ (UINT, "NumCategories"),
+ (Pointer(D3D10_MESSAGE_CATEGORY), "pCategoryList"),
+ (UINT, "NumSeverities"),
+ (Pointer(D3D10_MESSAGE_SEVERITY), "pSeverityList"),
+ (UINT, "NumIDs"),
+ (OpaquePointer(D3D10_MESSAGE_ID), "pIDList"), # TODO: Array
+])
+
+D3D10_INFO_QUEUE_FILTER = Struct("D3D10_INFO_QUEUE_FILTER", [
+ (D3D10_INFO_QUEUE_FILTER_DESC, "AllowList"),
+ (D3D10_INFO_QUEUE_FILTER_DESC, "DenyList"),
+])
+
+ID3D10InfoQueue = Interface("ID3D10InfoQueue", IUnknown)
+ID3D10InfoQueue.methods += [
+ Method(HRESULT, "SetMessageCountLimit", [(UINT64, "MessageCountLimit")]),
+ Method(Void, "ClearStoredMessages", []),
+ Method(HRESULT, "GetMessage", [(UINT64, "MessageIndex"), Out(Pointer(D3D10_MESSAGE), "pMessage"), Out(Pointer(SIZE_T), "pMessageByteLength")]),
+ Method(UINT64, "GetNumMessagesAllowedByStorageFilter", []),
+ Method(UINT64, "GetNumMessagesDeniedByStorageFilter", []),
+ Method(UINT64, "GetNumStoredMessages", []),
+ Method(UINT64, "GetNumStoredMessagesAllowedByRetrievalFilter", []),
+ Method(UINT64, "GetNumMessagesDiscardedByMessageCountLimit", []),
+ Method(UINT64, "GetMessageCountLimit", []),
+ Method(HRESULT, "AddStorageFilterEntries", [(Pointer(D3D10_INFO_QUEUE_FILTER), "pFilter")]),
+ Method(HRESULT, "GetStorageFilter", [Out(Pointer(D3D10_INFO_QUEUE_FILTER), "pFilter"), Out(Pointer(SIZE_T), "pFilterByteLength")]),
+ Method(Void, "ClearStorageFilter", []),
+ Method(HRESULT, "PushEmptyStorageFilter", []),
+ Method(HRESULT, "PushCopyOfStorageFilter", []),
+ Method(HRESULT, "PushStorageFilter", [(Pointer(D3D10_INFO_QUEUE_FILTER), "pFilter")]),
+ Method(Void, "PopStorageFilter", []),
+ Method(UINT, "GetStorageFilterStackSize", []),
+ Method(HRESULT, "AddRetrievalFilterEntries", [(Pointer(D3D10_INFO_QUEUE_FILTER), "pFilter")]),
+ Method(HRESULT, "GetRetrievalFilter", [Out(Pointer(D3D10_INFO_QUEUE_FILTER), "pFilter"), Out(Pointer(SIZE_T), "pFilterByteLength")]),
+ Method(Void, "ClearRetrievalFilter", []),
+ Method(HRESULT, "PushEmptyRetrievalFilter", []),
+ Method(HRESULT, "PushCopyOfRetrievalFilter", []),
+ Method(HRESULT, "PushRetrievalFilter", [(Pointer(D3D10_INFO_QUEUE_FILTER), "pFilter")]),
+ Method(Void, "PopRetrievalFilter", []),
+ Method(UINT, "GetRetrievalFilterStackSize", []),
+ Method(HRESULT, "AddMessage", [(D3D10_MESSAGE_CATEGORY, "Category"), (D3D10_MESSAGE_SEVERITY, "Severity"), (D3D10_MESSAGE_ID, "ID"), (LPCSTR, "pDescription")]),
+ Method(HRESULT, "AddApplicationMessage", [(D3D10_MESSAGE_SEVERITY, "Severity"), (LPCSTR, "pDescription")]),
+ Method(HRESULT, "SetBreakOnCategory", [(D3D10_MESSAGE_CATEGORY, "Category"), (BOOL, "bEnable")]),
+ Method(HRESULT, "SetBreakOnSeverity", [(D3D10_MESSAGE_SEVERITY, "Severity"), (BOOL, "bEnable")]),
+ Method(HRESULT, "SetBreakOnID", [(D3D10_MESSAGE_ID, "ID"), (BOOL, "bEnable")]),
+ Method(BOOL, "GetBreakOnCategory", [(D3D10_MESSAGE_CATEGORY, "Category")]),
+ Method(BOOL, "GetBreakOnSeverity", [(D3D10_MESSAGE_SEVERITY, "Severity")]),
+ Method(BOOL, "GetBreakOnID", [(D3D10_MESSAGE_ID, "ID")]),
+ Method(Void, "SetMuteDebugOutput", [(BOOL, "bMute")]),
+ Method(BOOL, "GetMuteDebugOutput", []),
+]
+
GlFunction(Void, "glTexSubImage4DSGIS", [(GLenum, "target"), (GLint, "level"), (GLint, "xoffset"), (GLint, "yoffset"), (GLint, "zoffset"), (GLint, "woffset"), (GLsizei, "width"), (GLsizei, "height"), (GLsizei, "depth"), (GLsizei, "size4d"), (GLenum, "format"), (GLenum, "type"), (OpaqueBlob(Const(GLvoid), "__glTexSubImage4DSGIS_size(format, type, width, height, depth, size4d)"), "pixels")]),
# GL_EXT_texture_object
- GlFunction(GLboolean, "glAreTexturesResidentEXT", [(GLsizei, "n"), (Array(Const(GLtexture), "n"), "textures"), Out(Array(GLboolean, "n"), "residences")]),
+ GlFunction(GLboolean, "glAreTexturesResidentEXT", [(GLsizei, "n"), (Array(Const(GLtexture), "n"), "textures"), Out(Array(GLboolean, "n"), "residences")], sideeffects=False),
GlFunction(Void, "glBindTextureEXT", [(GLenum, "target"), (GLtexture, "texture")]),
GlFunction(Void, "glDeleteTexturesEXT", [(GLsizei, "n"), (Array(Const(GLtexture), "n"), "textures")]),
GlFunction(Void, "glGenTexturesEXT", [(GLsizei, "n"), Out(Array(GLtexture, "n"), "textures")]),
GlFunction(Void, "glUnlockArraysEXT", []),
# GL_EXT_cull_vertex
- GlFunction(Void, "glCullParameterdvEXT", [(GLenum, "pname"), Out(Array(GLdouble, 4), "params")]),
- GlFunction(Void, "glCullParameterfvEXT", [(GLenum, "pname"), Out(Array(GLfloat, 4), "params")]),
+ GlFunction(Void, "glCullParameterdvEXT", [(GLenum, "pname"), (Array(GLdouble, 4), "params")]),
+ GlFunction(Void, "glCullParameterfvEXT", [(GLenum, "pname"), (Array(GLfloat, 4), "params")]),
# GL_SGIX_fragment_lighting
GlFunction(Void, "glFragmentColorMaterialSGIX", [(GLenum, "face"), (GLenum, "mode")]),
GlFunction(Void, "glGetCombinerStageParameterfvNV", [(GLenum, "stage"), (GLenum, "pname"), Out(Array(GLfloat, "__gl_param_size(pname)"), "params")], sideeffects=False),
# GL_NV_vertex_program
- GlFunction(GLboolean, "glAreProgramsResidentNV", [(GLsizei, "n"), (Array(Const(GLprogramARB), "n"), "ids"), Out(Array(GLboolean, "n"), "residences")]),
+ GlFunction(GLboolean, "glAreProgramsResidentNV", [(GLsizei, "n"), (Array(Const(GLprogramARB), "n"), "ids"), Out(Array(GLboolean, "n"), "residences")], sideeffects=False),
GlFunction(Void, "glBindProgramNV", [(GLenum, "target"), (GLprogramARB, "program")]),
GlFunction(Void, "glDeleteProgramsNV", [(GLsizei, "n"), (Array(Const(GLprogramARB), "n"), "programs")]),
GlFunction(Void, "glExecuteProgramNV", [(GLenum, "target"), (GLprogramARB, "id"), (Array(Const(GLfloat), 4), "params")]),
GlFunction(Void, "glDisableVertexArrayEXT", [(GLarray, "vaobj"), (GLenum, "array")]),
GlFunction(Void, "glEnableVertexArrayAttribEXT", [(GLarray, "vaobj"), (GLuint, "index")]),
GlFunction(Void, "glDisableVertexArrayAttribEXT", [(GLarray, "vaobj"), (GLuint, "index")]),
- GlFunction(Void, "glGetVertexArrayIntegervEXT", [(GLarray, "vaobj"), (GLenum, "pname"), Out(Pointer(GLint), "param")]),
- GlFunction(Void, "glGetVertexArrayPointervEXT", [(GLarray, "vaobj"), (GLenum, "pname"), Out(Pointer(GLpointer), "param")]),
- GlFunction(Void, "glGetVertexArrayIntegeri_vEXT", [(GLarray, "vaobj"), (GLuint, "index"), (GLenum, "pname"), Out(Pointer(GLint), "param")]),
- GlFunction(Void, "glGetVertexArrayPointeri_vEXT", [(GLarray, "vaobj"), (GLuint, "index"), (GLenum, "pname"), Out(Pointer(GLpointer), "param")]),
+ GlFunction(Void, "glGetVertexArrayIntegervEXT", [(GLarray, "vaobj"), (GLenum, "pname"), Out(Pointer(GLint), "param")], sideeffects=False),
+ GlFunction(Void, "glGetVertexArrayPointervEXT", [(GLarray, "vaobj"), (GLenum, "pname"), Out(Pointer(GLpointer), "param")], sideeffects=False),
+ GlFunction(Void, "glGetVertexArrayIntegeri_vEXT", [(GLarray, "vaobj"), (GLuint, "index"), (GLenum, "pname"), Out(Pointer(GLint), "param")], sideeffects=False),
+ GlFunction(Void, "glGetVertexArrayPointeri_vEXT", [(GLarray, "vaobj"), (GLuint, "index"), (GLenum, "pname"), Out(Pointer(GLpointer), "param")], sideeffects=False),
# GL_NV_explicit_multisample
GlFunction(Void, "glGetMultisamplefvNV", [(GLenum, "pname"), (GLuint, "index"), Out(Array(GLfloat, 2), "val")], sideeffects=False),
GlFunction(Void, "glGetPerfMonitorCounterStringAMD", [(GLuint, "group"), (GLuint, "counter"), (GLsizei, "bufSize"), Out(Pointer(GLsizei), "length"), Out(Array(GLchar, "bufSize"), "counterString")], sideeffects=False),
GlFunction(Void, "glGetPerfMonitorCounterInfoAMD", [(GLuint, "group"), (GLuint, "counter"), (GLenum, "pname"), Out(OpaqueBlob(GLvoid, "__glGetPerfMonitorCounterInfoAMD_size(pname)"), "data")], sideeffects=False),
GlFunction(Void, "glGenPerfMonitorsAMD", [(GLsizei, "n"), Out(Array(GLuint, "n"), "monitors")]),
- GlFunction(Void, "glDeletePerfMonitorsAMD", [(GLsizei, "n"), Out(Array(GLuint, "n"), "monitors")]),
- GlFunction(Void, "glSelectPerfMonitorCountersAMD", [(GLuint, "monitor"), (GLboolean, "enable"), (GLuint, "group"), (GLint, "numCounters"), Out(Array(GLuint, "numCounters"), "counterList")]),
+ GlFunction(Void, "glDeletePerfMonitorsAMD", [(GLsizei, "n"), (Array(GLuint, "n"), "monitors")]),
+ GlFunction(Void, "glSelectPerfMonitorCountersAMD", [(GLuint, "monitor"), (GLboolean, "enable"), (GLuint, "group"), (GLint, "numCounters"), (Array(GLuint, "numCounters"), "counterList")]),
GlFunction(Void, "glBeginPerfMonitorAMD", [(GLuint, "monitor")]),
GlFunction(Void, "glEndPerfMonitorAMD", [(GLuint, "monitor")]),
GlFunction(Void, "glGetPerfMonitorCounterDataAMD", [(GLuint, "monitor"), (GLenum, "pname"), (GLsizei, "dataSize"), Out(Array(GLuint, "dataSize"), "data"), Out(Pointer(GLint), "bytesWritten")], sideeffects=False),
self.parse_define()
elif self.match('enum'):
self.parse_enum()
- elif self.match('interface'):
- self.parse_interface()
+ elif self.match('class', 'interface'):
+ self.parse_interface(self.lookahead())
elif self.match('mask'):
self.parse_value('mask', 'Flags')
elif self.match('struct'):
print '])'
print
- def parse_interface(self):
- self.consume('interface')
+ def parse_interface(self, ref_token):
+ self.consume(ref_token)
name = self.consume()
if self.match(';'):
return
print '%s.methods += [' % (name,)
while self.lookahead() != '}':
- self.parse_prototype('Method')
- self.consume(';')
+ if self.lookahead() in ('public', 'private'):
+ self.consume()
+ self.consume(':')
+ else:
+ self.parse_prototype('Method')
+ self.consume(';')
self.consume('}')
print ']'
print
def parse_prototype(self, creator = 'Function'):
- if self.match('extern'):
+ if self.match('extern', 'virtual'):
self.consume()
ret = self.parse_type()
if self.match('__stdcall', 'WINAPI'):
self.consume()
- creator = 'StdFunction'
+ creator = 'Std' + creator
name = self.consume()
extra = ''
if self.lookahead() == 'const':
self.consume()
extra = ', const=True' + extra
+
+ if self.lookahead() == '=':
+ self.consume()
+ self.consume('0')
print ' %s(%s, "%s", [%s]%s),' % (creator, ret, name, ', '.join(args), extra)
type, name = self.parse_named_type()
arg = '(%s, "%s")' % (type, name)
- if 'out' in tags:
+ if 'out' in tags or 'inout' in tags:
arg = 'Out' + arg
if self.match('='):
tag = self.consume()
tags.append(tag)
self.consume(']')
+ if self.lookahead().startswith('__'):
+ # Parse __in, __out, etc tags
+ tag = self.consume()[2:]
+ if self.match('('):
+ self.consume()
+ while not self.match(')'):
+ self.consume()
+ self.consume(')')
+ tags.extend(tag.split('_'))
return tags
def parse_named_type(self):
while True:
if self.match('*'):
self.consume('*')
- type = 'OpaquePointer(%s)' % type
+ type = 'Pointer(%s)' % type
elif self.match('const'):
self.consume('const')
type = 'Const(%s)' % type
typedef struct egl_native_pixmap_t* EGLNativePixmapType;
typedef void* EGLNativeDisplayType;
+#elif defined(__APPLE__)
+
+typedef void *EGLNativeDisplayType;
+typedef void *EGLNativePixmapType;
+typedef void *EGLNativeWindowType;
+
#elif defined(__unix__)
/* X11 (tentative) */
index 6d34ab5..5f30ef1 100644
--- a/thirdparty/khronos/EGL/eglplatform.h
+++ b/thirdparty/khronos/EGL/eglplatform.h
-@@ -83,6 +83,16 @@ typedef int EGLNativeDisplayType;
+@@ -83,6 +83,22 @@ typedef int EGLNativeDisplayType;
typedef void *EGLNativeWindowType;
typedef void *EGLNativePixmapType;
+typedef struct ANativeWindow* EGLNativeWindowType;
+typedef struct egl_native_pixmap_t* EGLNativePixmapType;
+typedef void* EGLNativeDisplayType;
++
++#elif defined(__APPLE__)
++
++typedef void *EGLNativeDisplayType;
++typedef void *EGLNativePixmapType;
++typedef void *EGLNativeWindowType;
+
#elif defined(__unix__)
self.wrapArg(method, arg)
if riid is not None and isinstance(arg.type, Pointer):
if isinstance(arg.type.type, Opaque):
- self.wrapIid(riid, arg)
+ self.wrapIid(interface, method, riid, arg)
else:
assert isinstance(arg.type.type, Pointer)
assert isinstance(arg.type.type.type, Interface)
print ' if (!__result)'
print ' delete this;'
- def wrapIid(self, riid, out):
+ def wrapIid(self, interface, method, riid, out):
print ' if (%s && *%s) {' % (out.name, out.name)
print ' if (*%s == m_pInstance) {' % (out.name,)
print ' *%s = this;' % (out.name,)
print r' *%s = new Wrap%s((%s *) *%s);' % (out.name, iface.name, iface.name, out.name)
print r' }'
print r' else {'
- print r' os::log("apitrace: warning: %s: unknown REFIID {0x%08lX,0x%04X,0x%04X,{0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X}}\n",'
- print r' __FUNCTION__,'
+ print r' os::log("apitrace: warning: %s::%s: unknown IID {0x%08lX,0x%04X,0x%04X,{0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X}}\n",'
+ print r' "%s", "%s",' % (interface.name, method.name)
print r' %s.Data1, %s.Data2, %s.Data3,' % (riid.name, riid.name, riid.name)
print r' %s.Data4[0],' % (riid.name,)
print r' %s.Data4[1],' % (riid.name,)
projects / apitrace / commitdiff