# This may work in other than FirefoxOS environments, but has not been tested.
#
+NDK := prebuilt/ndk/android-ndk-r7
+
ifeq ($(shell which cmake),)
$(shell echo "CMake not found, will not compile apitrace" >&2)
else # cmake
-$(shell echo "CMake found, will compile apitrace" >&2)
+ifeq ($(wildcard $(NDK)),)
+$(shell echo "CMake present but NDK not found at $(abspath $(NDK)), will not compile apitrace" >&2)
+else # NDK
+$(shell echo "CMake and NDK ($(abspath $(NDK))) found, will compile apitrace" >&2)
LOCAL_PATH := $(call my-dir)
cd $(MY_APITRACE_ROOT) && \
cmake \
-DCMAKE_TOOLCHAIN_FILE=cmake/toolchain/android.toolchain.cmake \
- -DANDROID_NDK=../../prebuilt/ndk/android-ndk-r7 \
+ -DANDROID_NDK=../../$(NDK) \
-DANDROID_NDK_LAYOUT=LINARO \
-DANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.4.x \
-DANDROID_API_LEVEL=9 \
$(hide) mkdir -p $(dir $@)
$(hide) cp $(MY_APITRACE_BUILD_ROOT_TARGET)/apitrace$(TARGET_EXECUTABLE_SUFFIX) $@
+endif # NDK
endif # cmake
------------
Please rebuild apitrace with debugging information, by passing
-`-DCMAKE_BUILD_TYPE=Debug` to cmake.
+`-DCMAKE_BUILD_TYPE=Debug` to cmake, or editing its value in `CMakeCache.txt`
+and rebuilding.
To obtain a stack back-trace, run the application with gdb from a terminal:
...
(gdb) bt
+On Linux, to trace an application inside gdb the `LD_PRELOAD` environment
+variable should be set from within gdb like:
+
+ gdb --ex 'set exec-wrapper env LD_PRELOAD=/path/to/glxtrace.so' --args application arg1 ...
See also more detailed and Distro specific instructions:
See the `ld.so` man page for more information about `LD_PRELOAD` and
`LD_LIBRARY_PATH` environment flags.
-To trace the application inside gdb, invoke gdb as:
-
- gdb --ex 'set exec-wrapper env LD_PRELOAD=/path/to/glxtrace.so' --args /path/to/application
-
### Android ###
To trace standalone native OpenGL ES applications, use
cli_pickle.cpp
cli_repack.cpp
cli_retrace.cpp
+ cli_sed.cpp
cli_trace.cpp
cli_trim.cpp
cli_resources.cpp
extern const Command pickle_command;
extern const Command repack_command;
extern const Command retrace_command;
+extern const Command sed_command;
extern const Command trace_command;
extern const Command trim_command;
&dump_command,
&dump_images_command,
&pickle_command,
+ &sed_command,
&repack_command,
&retrace_command,
&trace_command,
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2013 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 <limits.h> // for CHAR_MAX
+#include <getopt.h>
+
+#include "cli.hpp"
+
+#include "os_string.hpp"
+
+#include "trace_parser.hpp"
+#include "trace_writer.hpp"
+
+
+static const char *synopsis = "Stream editing of a trace.";
+
+
+static void
+usage(void)
+{
+ std::cout
+ << "usage: apitrace sed [OPTIONS] TRACE_FILE...\n"
+ << synopsis << "\n"
+ "\n"
+ " -h, --help Show detailed help for sed options and exit\n"
+ " -e s/SEARCH/REPLACE/ Search and replace a symbol.\n"
+ " XXX: Only works for enums.\n"
+ " -o, --output=TRACE_FILE Output trace file\n"
+ ;
+}
+
+
+const static char *
+shortOptions = "ho:e:";
+
+const static struct option
+longOptions[] = {
+ {"help", no_argument, 0, 'h'},
+ {"output", required_argument, 0, 'o'},
+ {0, 0, 0, 0}
+};
+
+using namespace trace;
+
+
+/**
+ * A visitor that replaces symbol constants.
+ */
+class Replacer : public Visitor
+{
+protected:
+ std::string searchName;
+ std::string replaceName;
+
+public:
+ Replacer(const std::string & _searchName, const std::string & _replaceName) :
+ searchName(_searchName),
+ replaceName(_replaceName)
+ {
+ }
+
+ ~Replacer() {
+ }
+
+ void visit(Null *) {
+ }
+
+ void visit(Bool *node) {
+ }
+
+ void visit(SInt *node) {
+ }
+
+ void visit(UInt *node) {
+ }
+
+ void visit(Float *node) {
+ }
+
+ void visit(Double *node) {
+ }
+
+ void visit(String *node) {
+ }
+
+ void visit(Enum *node) {
+ const EnumValue *it = node->lookup();
+ if (it) {
+ if (searchName.compare(it->name) == 0) {
+ const EnumSig *sig = node->sig;
+ for (unsigned i = 0; i < sig->num_values; ++i) {
+ if (replaceName.compare(sig->values[i].name) == 0) {
+ node->value = sig->values[i].value;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ void visit(Bitmask *bitmask) {
+ }
+
+ void visit(Struct *s) {
+ for (unsigned i = 0; i < s->members.size(); ++i) {
+ Value *memberValue = s->members[i];
+ _visit(memberValue);
+ }
+ }
+
+ void visit(Array *array) {
+ for (std::vector<Value *>::iterator it = array->values.begin(); it != array->values.end(); ++it) {
+ _visit(*it);
+ }
+ }
+
+ void visit(Blob *blob) {
+ }
+
+ void visit(Pointer *p) {
+ }
+
+ void visit(Repr *r) {
+ _visit(r->humanValue);
+ }
+
+ void visit(Call *call) {
+ for (unsigned i = 0; i < call->args.size(); ++i) {
+ if (call->args[i].value) {
+ _visit(call->args[i].value);
+ }
+ }
+
+ if (call->ret) {
+ _visit(call->ret);
+ }
+ }
+};
+
+
+typedef std::list<Replacer> Replacements;
+
+
+static int
+sed_trace(Replacements &replacements, const char *inFileName, std::string &outFileName)
+{
+ trace::Parser p;
+
+ if (!p.open(inFileName)) {
+ std::cerr << "error: failed to open " << inFileName << "\n";
+ return 1;
+ }
+
+ /* Prepare outFileName file and writer for outFileName. */
+ if (outFileName.empty()) {
+ os::String base(inFileName);
+ base.trimExtension();
+
+ outFileName = std::string(base.str()) + std::string("-sed.trace");
+ }
+
+ trace::Writer writer;
+ if (!writer.open(outFileName.c_str())) {
+ std::cerr << "error: failed to create " << outFileName << "\n";
+ return 1;
+ }
+
+ trace::Call *call;
+ while ((call = p.parse_call())) {
+
+ for (Replacements::iterator it = replacements.begin(); it != replacements.end(); ++it) {
+ it->visit(call);
+ }
+
+ writer.writeCall(call);
+
+ delete call;
+ }
+
+ std::cerr << "Trimmed trace is available as " << outFileName << "\n";
+
+ return 0;
+}
+
+
+/**
+ * Parse a string in the format "s/SEARCH/REPLACE/".
+ */
+static bool
+parseSubstOpt(Replacements &replacements, const char *opt)
+{
+ if (*opt++ != 's') {
+ return false;
+ }
+
+ if (*opt++ != '/') {
+ return false;
+ }
+
+ // Parse the search pattern
+ const char *search_begin = opt;
+ while (*opt != '/') {
+ if (*opt == 0) {
+ return false;
+ }
+ ++opt;
+ }
+ const char *search_end = opt++;
+
+ // Parse the replace pattern
+ const char *replace_begin = opt;
+ while (*opt != '/') {
+ if (*opt == 0) {
+ return false;
+ }
+ ++opt;
+ }
+ const char *replace_end = opt++;
+
+ if (*opt != 0) {
+ return false;
+ }
+
+ std::string search(search_begin, search_end);
+ std::string replace(replace_begin, replace_end);
+
+ replacements.push_back(Replacer(search, replace));
+
+ return true;
+}
+
+
+static int
+command(int argc, char *argv[])
+{
+ Replacements replacements;
+ std::string outFileName;
+
+ int opt;
+ while ((opt = getopt_long(argc, argv, shortOptions, longOptions, NULL)) != -1) {
+ switch (opt) {
+ case 'h':
+ usage();
+ return 0;
+ case 'o':
+ outFileName = optarg;
+ break;
+ case 'e':
+ if (!parseSubstOpt(replacements, optarg)) {
+ std::cerr << "error: invalid replacement patter `" << optarg << "`\n";
+ }
+ break;
+ default:
+ std::cerr << "error: unexpected option `" << opt << "`\n";
+ usage();
+ return 1;
+ }
+ }
+
+ if (optind >= argc) {
+ std::cerr << "error: apitrace sed requires a trace file as an argument.\n";
+ usage();
+ return 1;
+ }
+
+ if (argc > optind + 1) {
+ std::cerr << "error: extraneous arguments:";
+ for (int i = optind + 1; i < argc; i++) {
+ std::cerr << " " << argv[i];
+ }
+ std::cerr << "\n";
+ usage();
+ return 1;
+ }
+
+ return sed_trace(replacements, argv[optind], outFileName);
+}
+
+
+const Command sed_command = {
+ "sed",
+ synopsis,
+ usage,
+ command
+};
trace::Writer writer;
if (!writer.open(options->output.c_str())) {
- std::cerr << "error: failed to create " << filename << "\n";
+ std::cerr << "error: failed to create " << options->output << "\n";
return 1;
}
TraceAnalyzer::recordTextureSideEffects(trace::Call *call, const char *name)
{
if (strcmp(name, "glGenTextures") == 0) {
- const trace::Array *textures = dynamic_cast<const trace::Array *>(&call->arg(1));
+ const trace::Array *textures = call->arg(1).toArray();
size_t i;
GLuint texture;
} /* namespace trace */
-#ifdef ANDROID
+#if defined(ANDROID)
#include <dlfcn.h>
#include "os.hpp"
}
/* end ANDROID */
-#elif defined __linux__
+#elif defined(__ELF__)
#include <stdint.h>
#include <dlfcn.h>
#include <vector>
#include <cxxabi.h>
-#include "backtrace.h"
+#include <backtrace.h>
namespace trace {
if (!memberName || !*memberName) {
// Anonymous structure
- Struct *memberStruct = dynamic_cast<Struct *>(memberValue);
+ Struct *memberStruct = memberValue->toStruct();
assert(memberStruct);
if (memberStruct) {
sep = visitMembers(memberStruct, sep);
bool ZLibFile::rawWrite(const void *buffer, size_t length)
{
- return gzwrite(m_gzFile, buffer, length) != -1;
+ return gzwrite(m_gzFile, buffer, unsigned(length)) != -1;
}
size_t ZLibFile::rawRead(void *buffer, size_t length)
{
- int ret = gzread(m_gzFile, buffer, length);
+ int ret = gzread(m_gzFile, buffer, unsigned(length));
return ret < 0 ? 0 : ret;
}
int ZLibFile::rawPercentRead()
{
gz_state *state = (gz_state *)m_gzFile;
- return 100 * (lseek(state->fd, 0, SEEK_CUR) / m_endOffset);
+ return int(100 * (lseek(state->fd, 0, SEEK_CUR) / m_endOffset));
}
unsigned Loader::numberOfFrames() const
{
- return m_frameBookmarks.size();
+ return unsigned(m_frameBookmarks.size());
}
unsigned Loader::numberOfCallsInFrame(unsigned frameIdx) const
static Null null;
const Value & Value::operator[](size_t index) const {
- const Array *array = dynamic_cast<const Array *>(this);
+ const Array *array = toArray();
if (array) {
if (index < array->values.size()) {
return *array->values[index];
class Visitor;
+class Null;
+class Struct;
+class Array;
class Value
virtual unsigned long long toUIntPtr(void) const;
virtual const char *toString(void) const;
+ virtual const Null *toNull(void) const { return NULL; }
+ virtual Null *toNull(void) { return NULL; }
+
+ virtual const Array *toArray(void) const { return NULL; }
+ virtual Array *toArray(void) { return NULL; }
+
+ virtual const Struct *toStruct(void) const { return NULL; }
+ virtual Struct *toStruct(void) { return NULL; }
+
const Value & operator[](size_t index) const;
};
unsigned long long toUIntPtr(void) const;
const char *toString(void) const;
void visit(Visitor &visitor);
+
+ const Null *toNull(void) const { return this; }
+ Null *toNull(void) { return this; }
};
bool toBool(void) const;
void visit(Visitor &visitor);
+ const Struct *toStruct(void) const { return this; }
+ Struct *toStruct(void) { return this; }
+
const StructSig *sig;
std::vector<Value *> members;
};
bool toBool(void) const;
void visit(Visitor &visitor);
+ const Array *toArray(void) const { return this; }
+ Array *toArray(void) { return this; }
+
std::vector<Value *> values;
inline size_t
version = read_uint();
if (version > TRACE_VERSION) {
std::cerr << "error: unsupported trace format version " << version << "\n";
+ delete file;
+ file = NULL;
return false;
}
api = API_UNKNOWN;
}
} else if (type.compare("frame_end") == 0) {
Profile::Frame frame;
- frame.no = profile->frames.size();
+ frame.no = unsigned(profile->frames.size());
if (frame.no == 0) {
frame.gpuStart = 0;
#elif defined(__APPLE__)
#include <OpenGL/OpenGL.h>
+
+#include <AvailabilityMacros.h>
+
+#ifndef MAC_OS_X_VERSION_10_6
+#define MAC_OS_X_VERSION_10_6 1060
+#endif
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_6
#include <OpenGL/CGLIOSurface.h>
#include <OpenGL/CGLDevice.h>
+#else
+#define kCGLPFAAcceleratedCompute 97
+#define kCGLRPAcceleratedCompute 130
+typedef void *CGLShareGroupObj;
+typedef struct __IOSurface *IOSurfaceRef;
+#endif
#ifndef CGL_VERSION_1_3
#define kCGLPFAOpenGLProfile 99
case QVariant::ULongLong:
case QMetaType::Float:
case QVariant::Double:
+ case QVariant::String:
return true;
default:
return false;
new QStandardItemEditorCreator<FloatEditorCreator>();
QItemEditorCreatorBase *doubleEditorCreator =
new QStandardItemEditorCreator<DoubleEditorCreator>();
+ QItemEditorCreatorBase *stringEditorCreator =
+ new QStandardItemEditorCreator<StringEditorCreator>();
QItemEditorCreatorBase *invalidEditorCreator =
new QStandardItemEditorCreator<InvalidEditorCreator>();
factory->registerEditor(QVariant::Pixmap, pixmapEditorCreator);
factory->registerEditor(typeFloat, floatEditorCreator);
factory->registerEditor(QVariant::Double, doubleEditorCreator);
+ factory->registerEditor(QVariant::String, stringEditorCreator);
factory->registerEditor(QVariant::Invalid, invalidEditorCreator);
QItemEditorFactory::setDefaultFactory(factory);
#include <QItemEditorFactory>
#include <QStandardItemModel>
#include <QSpinBox>
+#include <QTextEdit>
#include <limits.h>
#include <float.h>
};
};
+class StringEditorCreator : public QTextEdit
+{
+ Q_OBJECT
+ Q_PROPERTY(QString plainText READ toPlainText WRITE setPlainText USER true)
+public:
+ StringEditorCreator(QWidget *widget = 0) : QTextEdit(widget)
+ {
+ };
+};
+
class InvalidEditorCreator : public QLabel
{
Q_OBJECT
dlgUi.errorCheckCB->setChecked(
!m_retracer->isBenchmarking());
+ dlgUi.singlethreadCB->setChecked(
+ m_retracer->isSinglethread());
+
if (dlg.exec() == QDialog::Accepted) {
m_retracer->setDoubleBuffered(
dlgUi.doubleBufferingCB->isChecked());
m_retracer->setBenchmarking(
!dlgUi.errorCheckCB->isChecked());
+ m_retracer->setSinglethread(
+ dlgUi.singlethreadCB->isChecked());
+
m_retracer->setProfiling(false, false, false);
replayTrace(false, false);
: QThread(parent),
m_benchmarking(false),
m_doubleBuffered(true),
+ m_singlethread(false),
m_captureState(false),
m_captureCall(0),
m_profileGpu(false),
m_doubleBuffered = db;
}
+bool Retracer::isSinglethread() const
+{
+ return m_singlethread;
+}
+
+void Retracer::setSinglethread(bool singlethread)
+{
+ m_singlethread = singlethread;
+}
+
bool Retracer::isProfilingGpu() const
{
return m_profileGpu;
return;
}
+ if (m_singlethread) {
+ arguments << QLatin1String("--singlethread");
+ }
+
if (m_captureState) {
arguments << QLatin1String("-D");
arguments << QString::number(m_captureCall);
bool isDoubleBuffered() const;
void setDoubleBuffered(bool db);
+ bool isSinglethread() const;
+ void setSinglethread(bool singlethread);
+
bool isProfilingGpu() const;
bool isProfilingCpu() const;
bool isProfilingPixels() const;
trace::API m_api;
bool m_benchmarking;
bool m_doubleBuffered;
+ bool m_singlethread;
bool m_captureState;
bool m_captureThumbnails;
qlonglong m_captureCall;
<x>0</x>
<y>0</y>
<width>286</width>
- <height>94</height>
+ <height>125</height>
</rect>
</property>
<property name="windowTitle">
</item>
</layout>
</item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_3">
+ <item>
+ <spacer name="horizontalSpacer_5">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QCheckBox" name="singlethreadCB">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="text">
+ <string>Singlethread</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_6">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </item>
<item>
<widget class="QDialogButtonBox" name="buttonBox">
<property name="orientation">
break;
case D3D10_SRV_DIMENSION_TEXTURE2D:
MipSlice = Desc.Texture2D.MostDetailedMip;
- MipSlice = 0;
break;
case D3D10_SRV_DIMENSION_TEXTURE2DARRAY:
MipSlice = Desc.Texture2DArray.MostDetailedMip;
break;
case D3D10_DSV_DIMENSION_TEXTURE2D:
MipSlice = Desc.Texture2D.MipSlice;
- MipSlice = 0;
break;
case D3D10_DSV_DIMENSION_TEXTURE2DARRAY:
MipSlice = Desc.Texture2DArray.MipSlice;
break;
case D3D11_SRV_DIMENSION_TEXTURE2D:
MipSlice = Desc.Texture2D.MostDetailedMip;
- MipSlice = 0;
break;
case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
MipSlice = Desc.Texture2DArray.MostDetailedMip;
break;
case D3D11_DSV_DIMENSION_TEXTURE2D:
MipSlice = Desc.Texture2D.MipSlice;
- MipSlice = 0;
break;
case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
MipSlice = Desc.Texture2DArray.MipSlice;
#include <assert.h>
+#include <iostream>
+
#include "image.hpp"
#include "dxgistate.hpp"
DirectX::ScratchImage ScratchImage;
ScratchImage.Initialize2D(DstFormat, Width, Height, 1, 1);
- hr = DirectX::Convert(SrcImage, DstFormat, DirectX::TEX_FILTER_DEFAULT, 0.0f, ScratchImage);
+ if (DirectX::IsCompressed(SrcFormat)) {
+ hr = DirectX::Decompress(SrcImage, DstFormat, ScratchImage);
+ } else {
+ hr = DirectX::Convert(SrcImage, DstFormat, DirectX::TEX_FILTER_DEFAULT, 0.0f, ScratchImage);
+ }
+
if (SUCCEEDED(hr)) {
hr = CopyRectangle(*ScratchImage.GetImage(0, 0, 0), rect, DstImage, DirectX::TEX_FILTER_DEFAULT, 0, 0);
}
image->start(), image->stride(),
Width, Height);
if (FAILED(hr)) {
+ std::cerr << "warning: failed to convert from format " << SrcFormat << " to format " << DstFormat << "\n";
delete image;
image = NULL;
}
static void retrace_CGLChoosePixelFormat(trace::Call &call) {
int profile = kCGLOGLPVersion_Legacy;
- const trace::Array * attribs = dynamic_cast<const trace::Array *>(&call.arg(0));
+ const trace::Array * attribs = call.arg(0).toArray();
if (attribs) {
size_t i = 0;
while (i < attribs->values.size()) {
unsigned long long share = call.arg(1).toUIntPtr();
Context *sharedContext = getContext(share);
- const trace::Array *ctx_ptr = dynamic_cast<const trace::Array *>(&call.arg(2));
+ const trace::Array *ctx_ptr = call.arg(2).toArray();
unsigned long long ctx = ctx_ptr->values[0]->toUIntPtr();
Context *context = glretrace::createContext(sharedContext);
unsigned long long orig_context = call.ret->toUIntPtr();
unsigned long long orig_config = call.arg(1).toUIntPtr();
Context *share_context = getContext(call.arg(2).toUIntPtr());
- trace::Array *attrib_array = dynamic_cast<trace::Array *>(&call.arg(3));
+ trace::Array *attrib_array = call.arg(3).toArray();
glws::Profile profile;
switch (current_api) {
}
static void retrace_glXCreatePbuffer(trace::Call &call) {
- const trace::Value *attrib_list = dynamic_cast<const trace::Array *>(&call.arg(2));
+ const trace::Value *attrib_list = call.arg(2).toArray();
int width = glretrace::parseAttrib(attrib_list, GLX_PBUFFER_WIDTH, 0);
int height = glretrace::parseAttrib(attrib_list, GLX_PBUFFER_HEIGHT, 0);
int
parseAttrib(const trace::Value *attribs, int param, int default_ = 0) {
- const trace::Array *attribs_ = dynamic_cast<const trace::Array *>(attribs);
+ const trace::Array *attribs_ = attribs ? attribs->toArray() : NULL;
if (attribs_) {
for (size_t i = 0; i + 1 < attribs_->values.size(); i += 2) {
}
-static inline GLboolean
-isDepthFormat(GLenum internalFormat)
+struct InternalFormatDesc
{
- switch (internalFormat) {
- case GL_DEPTH_COMPONENT:
- case GL_DEPTH_COMPONENT16:
- case GL_DEPTH_COMPONENT24:
- case GL_DEPTH_COMPONENT32:
- case GL_DEPTH_COMPONENT32F:
- case GL_DEPTH_COMPONENT32F_NV:
- case GL_DEPTH_STENCIL:
- case GL_DEPTH24_STENCIL8:
- case GL_DEPTH32F_STENCIL8:
- case GL_DEPTH32F_STENCIL8_NV:
- return GL_TRUE;
- }
- return GL_FALSE;
+ GLenum internalFormat;
+ GLenum format;
+};
+
+
+static const InternalFormatDesc
+internalFormatDescs[] = {
+
+ {1, GL_RED},
+ {2, GL_RG},
+ {3, GL_RGB},
+ {4, GL_RGBA},
+
+ {GL_RED, GL_RED},
+ {GL_GREEN, GL_GREEN},
+ {GL_BLUE, GL_BLUE},
+ {GL_ALPHA, GL_ALPHA},
+ {GL_RG, GL_RG},
+ {GL_RGB, GL_RGB},
+ {GL_BGR, GL_RGB},
+ {GL_RGBA, GL_RGBA},
+ {GL_BGRA, GL_RGBA},
+ {GL_LUMINANCE, GL_LUMINANCE},
+ {GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA},
+ {GL_INTENSITY, GL_INTENSITY},
+
+ {GL_RG8, GL_RG},
+ {GL_RG16, GL_RG},
+ {GL_RGB8, GL_RGB},
+ {GL_RGB16, GL_RGB},
+ {GL_RGBA8, GL_RGBA},
+ {GL_RGBA16, GL_RGBA},
+ {GL_RGB10_A2, GL_RGBA},
+ {GL_LUMINANCE8, GL_LUMINANCE},
+ {GL_LUMINANCE16, GL_LUMINANCE},
+ {GL_ALPHA8, GL_ALPHA},
+ {GL_ALPHA16, GL_ALPHA},
+ {GL_LUMINANCE8_ALPHA8, GL_LUMINANCE_ALPHA},
+ {GL_LUMINANCE16_ALPHA16, GL_LUMINANCE_ALPHA},
+ {GL_INTENSITY8, GL_INTENSITY},
+ {GL_INTENSITY16, GL_INTENSITY},
+
+ {GL_RED_INTEGER, GL_RED_INTEGER},
+ {GL_GREEN_INTEGER, GL_GREEN_INTEGER},
+ {GL_BLUE_INTEGER, GL_BLUE_INTEGER},
+ {GL_ALPHA_INTEGER, GL_ALPHA_INTEGER},
+ {GL_RG_INTEGER, GL_RG_INTEGER},
+ {GL_RGB_INTEGER, GL_RGB_INTEGER},
+ {GL_BGR_INTEGER, GL_RGB_INTEGER},
+ {GL_RGBA_INTEGER, GL_RGBA_INTEGER},
+ {GL_BGRA_INTEGER, GL_RGBA_INTEGER},
+ {GL_LUMINANCE_INTEGER_EXT, GL_LUMINANCE_INTEGER_EXT},
+ {GL_LUMINANCE_ALPHA_INTEGER_EXT, GL_LUMINANCE_ALPHA_INTEGER_EXT},
+
+ {GL_R8I, GL_RED_INTEGER},
+ {GL_R8UI, GL_RED_INTEGER},
+ {GL_R16I, GL_RED_INTEGER},
+ {GL_R16UI, GL_RED_INTEGER},
+ {GL_R32I, GL_RED_INTEGER},
+ {GL_R32UI, GL_RED_INTEGER},
+ {GL_RG8I, GL_RG_INTEGER},
+ {GL_RG8UI, GL_RG_INTEGER},
+ {GL_RG16I, GL_RG_INTEGER},
+ {GL_RG16UI, GL_RG_INTEGER},
+ {GL_RG32I, GL_RG_INTEGER},
+ {GL_RG32UI, GL_RG_INTEGER},
+ {GL_RGB8I, GL_RGB_INTEGER},
+ {GL_RGB8UI, GL_RGB_INTEGER},
+ {GL_RGB16I, GL_RGB_INTEGER},
+ {GL_RGB16UI, GL_RGB_INTEGER},
+ {GL_RGB32I, GL_RGB_INTEGER},
+ {GL_RGB32UI, GL_RGB_INTEGER},
+ {GL_RGBA8I, GL_RGBA_INTEGER},
+ {GL_RGBA8UI, GL_RGBA_INTEGER},
+ {GL_RGBA16I, GL_RGBA_INTEGER},
+ {GL_RGBA16UI, GL_RGBA_INTEGER},
+ {GL_RGBA32I, GL_RGBA_INTEGER},
+ {GL_RGBA32UI, GL_RGBA_INTEGER},
+ {GL_RGB10_A2UI, GL_RGBA_INTEGER},
+ {GL_LUMINANCE8I_EXT, GL_LUMINANCE_INTEGER_EXT},
+ {GL_LUMINANCE8UI_EXT, GL_LUMINANCE_INTEGER_EXT},
+ {GL_LUMINANCE16I_EXT, GL_LUMINANCE_INTEGER_EXT},
+ {GL_LUMINANCE16UI_EXT, GL_LUMINANCE_INTEGER_EXT},
+ {GL_LUMINANCE32I_EXT, GL_LUMINANCE_INTEGER_EXT},
+ {GL_LUMINANCE32UI_EXT, GL_LUMINANCE_INTEGER_EXT},
+ {GL_ALPHA8I_EXT, GL_ALPHA_INTEGER_EXT},
+ {GL_ALPHA8UI_EXT, GL_ALPHA_INTEGER_EXT},
+ {GL_ALPHA16I_EXT, GL_ALPHA_INTEGER_EXT},
+ {GL_ALPHA16UI_EXT, GL_ALPHA_INTEGER_EXT},
+ {GL_ALPHA32I_EXT, GL_ALPHA_INTEGER_EXT},
+ {GL_ALPHA32UI_EXT, GL_ALPHA_INTEGER_EXT},
+ {GL_LUMINANCE_ALPHA8I_EXT, GL_LUMINANCE_ALPHA_INTEGER_EXT},
+ {GL_LUMINANCE_ALPHA8UI_EXT, GL_LUMINANCE_ALPHA_INTEGER_EXT},
+ {GL_LUMINANCE_ALPHA16I_EXT, GL_LUMINANCE_ALPHA_INTEGER_EXT},
+ {GL_LUMINANCE_ALPHA16UI_EXT, GL_LUMINANCE_ALPHA_INTEGER_EXT},
+ {GL_LUMINANCE_ALPHA32I_EXT, GL_LUMINANCE_ALPHA_INTEGER_EXT},
+ {GL_LUMINANCE_ALPHA32UI_EXT, GL_LUMINANCE_ALPHA_INTEGER_EXT},
+ {GL_INTENSITY8I_EXT, GL_RED_INTEGER},
+ {GL_INTENSITY8UI_EXT, GL_RED_INTEGER},
+ {GL_INTENSITY16I_EXT, GL_RED_INTEGER},
+ {GL_INTENSITY16UI_EXT, GL_RED_INTEGER},
+ {GL_INTENSITY32I_EXT, GL_RED_INTEGER},
+ {GL_INTENSITY32UI_EXT, GL_RED_INTEGER},
+
+ {GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT},
+ {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT},
+ {GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT},
+ {GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT},
+ {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT},
+ {GL_DEPTH_COMPONENT32F_NV, GL_DEPTH_COMPONENT},
+ {GL_DEPTH_STENCIL, GL_DEPTH_COMPONENT},
+ {GL_DEPTH24_STENCIL8, GL_DEPTH_COMPONENT},
+ {GL_DEPTH32F_STENCIL8, GL_DEPTH_COMPONENT},
+ {GL_DEPTH32F_STENCIL8_NV, GL_DEPTH_COMPONENT},
+};
+
+
+static GLenum
+getFormat(GLenum internalFormat)
+{
+ for (unsigned i = 0; i < sizeof internalFormatDescs / sizeof internalFormatDescs[0]; ++i) {
+ if (internalFormatDescs[i].internalFormat == internalFormat) {
+ return internalFormatDescs[i].format;
+ }
+ }
+ return GL_RGBA;
}
json.beginMember(label);
- GLuint channels;
- GLenum format;
- if (!context.ES && isDepthFormat(desc.internalFormat)) {
- format = GL_DEPTH_COMPONENT;
- channels = 1;
- } else {
- format = GL_RGBA;
- channels = 4;
+ GLenum format = getFormat(desc.internalFormat);;
+ if (context.ES && format == GL_DEPTH_COMPONENT) {
+ format = GL_RED;
}
+ GLuint channels = _gl_format_channels(format);;
image::Image *image = new image::Image(desc.width, desc.height*desc.depth, channels, true);
*/
inline void *
alloc(const trace::Value *value, size_t size) {
- const trace::Array *array = dynamic_cast<const trace::Array *>(value);
+ const trace::Array *array = value->toArray();
if (array) {
return ::ScopedAllocator::alloc(array->size() * size);
}
- const trace::Null *null = dynamic_cast<const trace::Null *>(value);
+ const trace::Null *null = value->toNull();
if (null) {
return NULL;
}
self.seq += 1
print ' if (%s) {' % (lvalue,)
- print ' const trace::Array *%s = dynamic_cast<const trace::Array *>(&%s);' % (tmp, rvalue)
+ print ' const trace::Array *%s = (%s).toArray();' % (tmp, rvalue)
length = '%s->values.size()' % (tmp,)
index = '_j' + array.tag
print ' for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length)
self.seq += 1
print ' if (%s) {' % (lvalue,)
- print ' const trace::Array *%s = dynamic_cast<const trace::Array *>(&%s);' % (tmp, rvalue)
+ print ' const trace::Array *%s = (%s).toArray();' % (tmp, rvalue)
try:
self.visit(pointer.type, '%s[0]' % (lvalue,), '*%s->values[0]' % (tmp,))
finally:
tmp = '_s_' + struct.tag + '_' + str(self.seq)
self.seq += 1
- print ' const trace::Struct *%s = dynamic_cast<const trace::Struct *>(&%s);' % (tmp, rvalue)
+ print ' const trace::Struct *%s = (%s).toStruct();' % (tmp, rvalue)
print ' assert(%s);' % (tmp)
for i in range(len(struct.members)):
member = struct.members[i]
pass
def visitArray(self, array, lvalue, rvalue):
- print ' const trace::Array *_a%s = dynamic_cast<const trace::Array *>(&%s);' % (array.tag, rvalue)
+ print ' const trace::Array *_a%s = (%s).toArray();' % (array.tag, rvalue)
print ' if (_a%s) {' % (array.tag)
length = '_a%s->values.size()' % array.tag
index = '_j' + array.tag
print ' }'
def visitPointer(self, pointer, lvalue, rvalue):
- print ' const trace::Array *_a%s = dynamic_cast<const trace::Array *>(&%s);' % (pointer.tag, rvalue)
+ print ' const trace::Array *_a%s = (%s).toArray();' % (pointer.tag, rvalue)
print ' if (_a%s) {' % (pointer.tag)
try:
self.visit(pointer.type, '%s[0]' % (lvalue,), '*_a%s->values[0]' % (pointer.tag,))
tmp = '_s_' + struct.tag + '_' + str(self.seq)
self.seq += 1
- print ' const trace::Struct *%s = dynamic_cast<const trace::Struct *>(&%s);' % (tmp, rvalue)
+ print ' const trace::Struct *%s = (%s).toStruct();' % (tmp, rvalue)
print ' assert(%s);' % (tmp,)
print ' (void)%s;' % (tmp,)
for i in range(len(struct.members)):
GLXPbuffer = Alias("GLXPbuffer", UInt32)
GLXPbufferSGIX = Alias("GLXPbufferSGIX", UInt32)
GLXVideoSourceSGIX = Alias("GLXVideoSourceSGIX", UInt32)
+GLXVideoDeviceNV = Alias("GLXVideoDeviceNV", UInt32)
+GLXVideoCaptureDeviceNV = Alias("GLXVideoCaptureDeviceNV", UInt32)
XVisualInfo = Struct("XVisualInfo", [
(Visual, "visual"),
Function(Void, "glXReleaseTexImageEXT", [(Display, "display"), (GLXDrawable, "drawable"), (GLXEnum, "buffer")]),
# GLX_NV_present_video
- #Function(OpaquePointer(UInt), "glXEnumerateVideoDevicesNV", [(Display, "dpy"), (Int, "screen"), (OpaquePointer(Int), "nelements")]),
- #Function(Int, "glXBindVideoDeviceNV", [(Display, "dpy"), (UInt, "video_slot"), (UInt, "video_device"), (UnusedAttribs, "attrib_list")]),
+ Function(Array(UInt, "(nelements ? *nelements : 0)"), "glXEnumerateVideoDevicesNV", [(Display, "dpy"), (Int, "screen"), Out(Pointer(Int), "nelements")]),
+ Function(Int, "glXBindVideoDeviceNV", [(Display, "dpy"), (UInt, "video_slot"), (UInt, "video_device"), (UnusedAttribs, "attrib_list")]),
# GLX_NV_video_output
- #Function(Int, "glXGetVideoDeviceNV", [(Display, "dpy"), (Int, "screen"), (Int, "numVideoDevices"), (OpaquePointer(GLXVideoDeviceNV), "pVideoDevice")]),
- #Function(Int, "glXReleaseVideoDeviceNV", [(Display, "dpy"), (Int, "screen"), (GLXVideoDeviceNV, "VideoDevice")]),
- #Function(Int, "glXBindVideoImageNV", [(Display, "dpy"), (GLXVideoDeviceNV, "VideoDevice"), (GLXPbuffer, "pbuf"), (Int, "iVideoBuffer")]),
- #Function(Int, "glXReleaseVideoImageNV", [(Display, "dpy"), (GLXPbuffer, "pbuf")]),
- #Function(Int, "glXSendPbufferToVideoNV", [(Display, "dpy"), (GLXPbuffer, "pbuf"), (Int, "iBufferType"), (OpaquePointer(ULong), "pulCounterPbuffer"), (GLboolean, "bBlock")]),
- #Function(Int, "glXGetVideoInfoNV", [(Display, "dpy"), (Int, "screen"), (GLXVideoDeviceNV, "VideoDevice"), (OpaquePointer(ULong), "pulCounterOutputPbuffer"), (OpaquePointer(ULong), "pulCounterOutputVideo")]),
+ Function(Int, "glXGetVideoDeviceNV", [(Display, "dpy"), (Int, "screen"), (Int, "numVideoDevices"), Out(Array(GLXVideoDeviceNV, "numVideoDevices"), "pVideoDevice")]),
+ Function(Int, "glXReleaseVideoDeviceNV", [(Display, "dpy"), (Int, "screen"), (GLXVideoDeviceNV, "VideoDevice")]),
+ Function(Int, "glXBindVideoImageNV", [(Display, "dpy"), (GLXVideoDeviceNV, "VideoDevice"), (GLXPbuffer, "pbuf"), (Int, "iVideoBuffer")]),
+ Function(Int, "glXReleaseVideoImageNV", [(Display, "dpy"), (GLXPbuffer, "pbuf")]),
+ Function(Int, "glXSendPbufferToVideoNV", [(Display, "dpy"), (GLXPbuffer, "pbuf"), (Int, "iBufferType"), Out(Pointer(ULong), "pulCounterPbuffer"), (GLboolean, "bBlock")]),
+ Function(Int, "glXGetVideoInfoNV", [(Display, "dpy"), (Int, "screen"), (GLXVideoDeviceNV, "VideoDevice"), Out(Pointer(ULong), "pulCounterOutputPbuffer"), Out(Pointer(ULong), "pulCounterOutputVideo")], sideeffects=False),
# GLX_NV_swap_group
Function(Bool, "glXJoinSwapGroupNV", [(Display, "dpy"), (GLXDrawable, "drawable"), (GLuint, "group")]),
Function(Bool, "glXResetFrameCountNV", [(Display, "dpy"), (Int, "screen")]),
# GLX_NV_video_capture
- #Function(Int, "glXBindVideoCaptureDeviceNV", [(Display, "dpy"), (UInt, "video_capture_slot"), (GLXVideoCaptureDeviceNV, "device")]),
- #Function(OpaquePointer(GLXVideoCaptureDeviceNV), "glXEnumerateVideoCaptureDevicesNV", [(Display, "dpy"), (Int, "screen"), (OpaquePointer(Int), "nelements")]),
- #Function(Void, "glXLockVideoCaptureDeviceNV", [(Display, "dpy"), (GLXVideoCaptureDeviceNV, "device")]),
- #Function(Int, "glXQueryVideoCaptureDeviceNV", [(Display, "dpy"), (GLXVideoCaptureDeviceNV, "device"), (Int, "attribute"), (OpaquePointer(Int), "value")]),
- #Function(Void, "glXReleaseVideoCaptureDeviceNV", [(Display, "dpy"), (GLXVideoCaptureDeviceNV, "device")]),
+ Function(Int, "glXBindVideoCaptureDeviceNV", [(Display, "dpy"), (UInt, "video_capture_slot"), (GLXVideoCaptureDeviceNV, "device")]),
+ Function(Array(GLXVideoCaptureDeviceNV, "(nelements ? *nelements : 0)"), "glXEnumerateVideoCaptureDevicesNV", [(Display, "dpy"), (Int, "screen"), Out(Pointer(Int), "nelements")]),
+ Function(Void, "glXLockVideoCaptureDeviceNV", [(Display, "dpy"), (GLXVideoCaptureDeviceNV, "device")]),
+ Function(Int, "glXQueryVideoCaptureDeviceNV", [(Display, "dpy"), (GLXVideoCaptureDeviceNV, "device"), (Int, "attribute"), Out(Pointer(Int), "value")], sideeffects=False),
+ Function(Void, "glXReleaseVideoCaptureDeviceNV", [(Display, "dpy"), (GLXVideoCaptureDeviceNV, "device")]),
# GLX_EXT_swap_control
Function(Void, "glXSwapIntervalEXT", [(Display, "dpy"), (GLXDrawable, "drawable"), (Int, "interval")]),
])
HPBUFFERARB = Alias("HPBUFFERARB", HANDLE)
+HPBUFFEREXT = Alias("HPBUFFEREXT", HANDLE)
+HPVIDEODEV = Alias("HPVIDEODEV", HANDLE)
+HVIDEOOUTPUTDEVICENV = Alias("HVIDEOOUTPUTDEVICENV", HANDLE)
+HVIDEOINPUTDEVICENV = Alias("HVIDEOINPUTDEVICENV", HANDLE)
+HGPUNV = Alias("HGPUNV", HANDLE)
+
+GPU_DEVICE = Struct("GPU_DEVICE", [
+ (DWORD, "cb"),
+ (CString, "DeviceName"),
+ (CString, "DeviceString"),
+ (DWORD, "Flags"),
+ (RECT, "rcVirtualScreen"),
+])
wglapi.addFunctions([
# WGL_ARB_create_context
StdFunction(HGLRC, "wglCreateContextAttribsARB", [(HDC, "hDC"), (HGLRC, "hShareContext"), (WGLContextAttribs, "attribList")]),
+ # WGL_EXT_display_color_table
+ StdFunction(GLboolean, "wglCreateDisplayColorTableEXT", [(GLushort, "id")]),
+ StdFunction(GLboolean, "wglLoadDisplayColorTableEXT", [(Array(Const(GLushort), "length"), "table"), (GLuint, "length")]),
+ StdFunction(GLboolean, "wglBindDisplayColorTableEXT", [(GLushort, "id")]),
+ StdFunction(VOID, "wglDestroyDisplayColorTableEXT", [(GLushort, "id")]),
+
# WGL_EXT_extensions_string
StdFunction(ConstCString, "wglGetExtensionsStringEXT", [], sideeffects=False),
StdFunction(BOOL, "wglMakeContextCurrentEXT", [(HDC, "hDrawDC"), (HDC, "hReadDC"), (HGLRC, "hglrc")]),
StdFunction(HDC, "wglGetCurrentReadDCEXT", [], sideeffects=False),
+ # WGL_EXT_pbuffer
+ StdFunction(HPBUFFEREXT, "wglCreatePbufferEXT", [(HDC, "hDC"), (Int, "iPixelFormat"), (Int, "iWidth"), (Int, "iHeight"), (WGLCreatePbufferARBAttribs, "piAttribList")]),
+ StdFunction(HDC, "wglGetPbufferDCEXT", [(HPBUFFEREXT, "hPbuffer")], sideeffects=False),
+ StdFunction(Int, "wglReleasePbufferDCEXT", [(HPBUFFEREXT, "hPbuffer"), (HDC, "hDC")]),
+ StdFunction(BOOL, "wglDestroyPbufferEXT", [(HPBUFFEREXT, "hPbuffer")]),
+ StdFunction(BOOL, "wglQueryPbufferEXT", [(HPBUFFEREXT, "hPbuffer"), (WGLenum, "iAttribute"), Out(Pointer(Int), "piValue")], sideeffects=False),
+
# WGL_EXT_pixel_format
StdFunction(BOOL, "wglGetPixelFormatAttribivEXT", [(HDC, "hdc"), (Int, "iPixelFormat"), (Int, "iLayerPlane"), (UINT, "nAttributes"), (Array(WGLenum, "nAttributes"), "piAttributes"), Out(Array(Int, "nAttributes"), "piValues")], sideeffects=False),
StdFunction(BOOL, "wglGetPixelFormatAttribfvEXT", [(HDC, "hdc"), (Int, "iPixelFormat"), (Int, "iLayerPlane"), (UINT, "nAttributes"), (Array(WGLenum, "nAttributes"), "piAttributes"), Out(Array(FLOAT, "nAttributes"), "pfValues")], sideeffects=False),
StdFunction(OpaquePointer(Void), "wglAllocateMemoryNV", [(GLsizei, "size"), (GLfloat, "readfreq"), (GLfloat, "writefreq"), (GLfloat, "priority")]),
StdFunction(Void, "wglFreeMemoryNV", [(OpaquePointer(Void), "pointer")]),
+ # WGL_OML_sync_control
+ StdFunction(BOOL, "wglGetSyncValuesOML", [(HDC, "hdc"), Out(Pointer(INT64), "ust"), Out(Pointer(INT64), "msc"), Out(Pointer(INT64), "sbc")], sideeffects=False),
+ StdFunction(BOOL, "wglGetMscRateOML", [(HDC, "hdc"), Out(Pointer(INT32), "numerator"), Out(Pointer(INT32), "denominator")], sideeffects=False),
+ StdFunction(INT64, "wglSwapBuffersMscOML", [(HDC, "hdc"), (INT64, "target_msc"), (INT64, "divisor"), (INT64, "remainder")]),
+ StdFunction(INT64, "wglSwapLayerBuffersMscOML", [(HDC, "hdc"), (Int, "fuPlanes"), (INT64, "target_msc"), (INT64, "divisor"), (INT64, "remainder")]),
+ StdFunction(BOOL, "wglWaitForMscOML", [(HDC, "hdc"), (INT64, "target_msc"), (INT64, "divisor"), (INT64, "remainder"), Out(Pointer(INT64), "ust"), Out(Pointer(INT64), "msc"), Out(Pointer(INT64), "sbc")]),
+ StdFunction(BOOL, "wglWaitForSbcOML", [(HDC, "hdc"), (INT64, "target_sbc"), Out(Pointer(INT64), "ust"), Out(Pointer(INT64), "msc"), Out(Pointer(INT64), "sbc")]),
+
+ # WGL_I3D_digital_video_control
+ StdFunction(BOOL, "wglGetDigitalVideoParametersI3D", [(HDC, "hDC"), (Int, "iAttribute"), Out(OpaqueArray(Int, "_wglGetDigitalVideoParametersI3D_size(iAttribute)"), "piValue")], sideeffects=False),
+ StdFunction(BOOL, "wglSetDigitalVideoParametersI3D", [(HDC, "hDC"), (Int, "iAttribute"), (OpaqueArray(Const(Int), "_wglSetDigitalVideoParametersI3D_size(iAttribute)"), "piValue")]),
+
+ # WGL_I3D_gamma
+ StdFunction(BOOL, "wglGetGammaTableParametersI3D", [(HDC, "hDC"), (Int, "iAttribute"), Out(OpaqueArray(Int, "_wglGetGammaTableParametersI3D_size(iAttribute)"), "piValue")], sideeffects=False),
+ StdFunction(BOOL, "wglSetGammaTableParametersI3D", [(HDC, "hDC"), (Int, "iAttribute"), (OpaqueArray(Const(Int), "_wglSetGammaTableParametersI3D_size(iAttribute)"), "piValue")]),
+ StdFunction(BOOL, "wglGetGammaTableI3D", [(HDC, "hDC"), (Int, "iEntries"), Out(Array(USHORT, "iEntries"), "puRed"), Out(Array(USHORT, "iEntries"), "puGreen"), Out(Array(USHORT, "iEntries"), "puBlue")], sideeffects=False),
+ StdFunction(BOOL, "wglSetGammaTableI3D", [(HDC, "hDC"), (Int, "iEntries"), (Array(Const(USHORT), "iEntries"), "puRed"), (Array(Const(USHORT), "iEntries"), "puGreen"), (Array(Const(USHORT), "iEntries"), "puBlue")]),
+
+ # WGL_I3D_genlock
+ StdFunction(BOOL, "wglEnableGenlockI3D", [(HDC, "hDC")]),
+ StdFunction(BOOL, "wglDisableGenlockI3D", [(HDC, "hDC")]),
+ StdFunction(BOOL, "wglIsEnabledGenlockI3D", [(HDC, "hDC"), Out(Pointer(BOOL), "pFlag")], sideeffects=False),
+ StdFunction(BOOL, "wglGenlockSourceI3D", [(HDC, "hDC"), (UINT, "uSource")]),
+ StdFunction(BOOL, "wglGetGenlockSourceI3D", [(HDC, "hDC"), Out(Pointer(UINT), "uSource")], sideeffects=False),
+ StdFunction(BOOL, "wglGenlockSourceEdgeI3D", [(HDC, "hDC"), (UINT, "uEdge")]),
+ StdFunction(BOOL, "wglGetGenlockSourceEdgeI3D", [(HDC, "hDC"), Out(Pointer(UINT), "uEdge")], sideeffects=False),
+ StdFunction(BOOL, "wglGenlockSampleRateI3D", [(HDC, "hDC"), (UINT, "uRate")]),
+ StdFunction(BOOL, "wglGetGenlockSampleRateI3D", [(HDC, "hDC"), Out(Pointer(UINT), "uRate")], sideeffects=False),
+ StdFunction(BOOL, "wglGenlockSourceDelayI3D", [(HDC, "hDC"), (UINT, "uDelay")]),
+ StdFunction(BOOL, "wglGetGenlockSourceDelayI3D", [(HDC, "hDC"), Out(Pointer(UINT), "uDelay")], sideeffects=False),
+ StdFunction(BOOL, "wglQueryGenlockMaxSourceDelayI3D", [(HDC, "hDC"), Out(Pointer(UINT), "uMaxLineDelay"), Out(Pointer(UINT), "uMaxPixelDelay")]),
+
+ # WGL_I3D_image_buffer
+ StdFunction(LPVOID, "wglCreateImageBufferI3D", [(HDC, "hDC"), (DWORD, "dwSize"), (UINT, "uFlags")]),
+ StdFunction(BOOL, "wglDestroyImageBufferI3D", [(HDC, "hDC"), (LPVOID, "pAddress")]),
+ StdFunction(BOOL, "wglAssociateImageBufferEventsI3D", [(HDC, "hDC"), (Array(Const(HANDLE), "count"), "pEvent"), (Array(Const(LPVOID), "count"), "pAddress"), (Array(Const(DWORD), "count"), "pSize"), (UINT, "count")]),
+ StdFunction(BOOL, "wglReleaseImageBufferEventsI3D", [(HDC, "hDC"), (Array(Const(LPVOID), "count"), "pAddress"), (UINT, "count")]),
+
+ # WGL_I3D_swap_frame_lock
+ StdFunction(BOOL, "wglEnableFrameLockI3D", []),
+ StdFunction(BOOL, "wglDisableFrameLockI3D", []),
+ StdFunction(BOOL, "wglIsEnabledFrameLockI3D", [Out(Pointer(BOOL), "pFlag")], sideeffects=False),
+ StdFunction(BOOL, "wglQueryFrameLockMasterI3D", [Out(Pointer(BOOL), "pFlag")]),
+
+ # WGL_I3D_swap_frame_usage
+ StdFunction(BOOL, "wglGetFrameUsageI3D", [Out(Pointer(Float), "pUsage")], sideeffects=False),
+ StdFunction(BOOL, "wglBeginFrameTrackingI3D", []),
+ StdFunction(BOOL, "wglEndFrameTrackingI3D", []),
+ StdFunction(BOOL, "wglQueryFrameTrackingI3D", [Out(Pointer(DWORD), "pFrameCount"), Out(Pointer(DWORD), "pMissedFrames"), Out(Pointer(Float), "pLastMissedUsage")]),
+
+ # WGL_3DL_stereo_control
+ StdFunction(BOOL, "wglSetStereoEmitterState3DL", [(HDC, "hDC"), (UINT, "uState")]),
+
+ # WGL_NV_present_video
+ StdFunction(Int, "wglEnumerateVideoDevicesNV", [(HDC, "hDC"), Out(OpaquePointer(HVIDEOOUTPUTDEVICENV), "phDeviceList")]),
+ StdFunction(BOOL, "wglBindVideoDeviceNV", [(HDC, "hDC"), (UInt, "uVideoSlot"), (HVIDEOOUTPUTDEVICENV, "hVideoDevice"), (OpaqueArray(Const(Int), "_wglBindVideoDeviceNV_size()"), "piAttribList")]),
+ StdFunction(BOOL, "wglQueryCurrentContextNV", [(Int, "iAttribute"), Out(OpaqueArray(Int, "_wglQueryCurrentContextNV_size()"), "piValue")]),
+
+ # WGL_NV_video_output
+ StdFunction(BOOL, "wglGetVideoDeviceNV", [(HDC, "hDC"), (Int, "numDevices"), Out(Pointer(HPVIDEODEV), "hVideoDevice")], sideeffects=False),
+ StdFunction(BOOL, "wglReleaseVideoDeviceNV", [(HPVIDEODEV, "hVideoDevice")]),
+ StdFunction(BOOL, "wglBindVideoImageNV", [(HPVIDEODEV, "hVideoDevice"), (HPBUFFERARB, "hPbuffer"), (Int, "iVideoBuffer")]),
+ StdFunction(BOOL, "wglReleaseVideoImageNV", [(HPBUFFERARB, "hPbuffer"), (Int, "iVideoBuffer")]),
+ StdFunction(BOOL, "wglSendPbufferToVideoNV", [(HPBUFFERARB, "hPbuffer"), (Int, "iBufferType"), Out(Pointer(ULong), "pulCounterPbuffer"), (BOOL, "bBlock")]),
+ StdFunction(BOOL, "wglGetVideoInfoNV", [(HPVIDEODEV, "hpVideoDevice"), Out(Pointer(ULong), "pulCounterOutputPbuffer"), Out(Pointer(ULong), "pulCounterOutputVideo")], sideeffects=False),
+
+ # WGL_NV_swap_group
+ StdFunction(BOOL, "wglJoinSwapGroupNV", [(HDC, "hDC"), (GLuint, "group")]),
+ StdFunction(BOOL, "wglBindSwapBarrierNV", [(GLuint, "group"), (GLuint, "barrier")]),
+ StdFunction(BOOL, "wglQuerySwapGroupNV", [(HDC, "hDC"), Out(Pointer(GLuint), "group"), Out(Pointer(GLuint), "barrier")]),
+ StdFunction(BOOL, "wglQueryMaxSwapGroupsNV", [(HDC, "hDC"), Out(Pointer(GLuint), "maxGroups"), Out(Pointer(GLuint), "maxBarriers")]),
+ StdFunction(BOOL, "wglQueryFrameCountNV", [(HDC, "hDC"), Out(Pointer(GLuint), "count")]),
+ StdFunction(BOOL, "wglResetFrameCountNV", [(HDC, "hDC")]),
+
+ # WGL_NV_gpu_affinity
+ StdFunction(BOOL, "wglEnumGpusNV", [(UINT, "iGpuIndex"), Out(Pointer(HGPUNV), "phGpu")]),
+ StdFunction(BOOL, "wglEnumGpuDevicesNV", [(HGPUNV, "hGpu"), (UINT, "iDeviceIndex"), Out(Pointer(GPU_DEVICE), "lpGpuDevice")]),
+ StdFunction(HDC, "wglCreateAffinityDCNV", [(OpaqueArray(Const(HGPUNV), "_wglCreateAffinityDCNV_size()"), "phGpuList")]),
+ StdFunction(BOOL, "wglEnumGpusFromAffinityDCNV", [(HDC, "hAffinityDC"), (UINT, "iGpuIndex"), Out(Pointer(HGPUNV), "hGpu")]),
+ StdFunction(BOOL, "wglDeleteDCNV", [(HDC, "hdc")]),
+
+ # WGL_AMD_gpu_association
+ StdFunction(UINT, "wglGetGPUIDsAMD", [(UINT, "maxCount"), Out(Array(UINT, "maxCount"), "ids")], sideeffects=False),
+ StdFunction(INT, "wglGetGPUInfoAMD", [(UINT, "id"), (Int, "property"), (GLenum, "dataType"), (UINT, "size"), Out(OpaqueBlob(Void, "_wglGetGPUInfoAMD_size(dataType,size)"), "data")], sideeffects=False),
+ StdFunction(UINT, "wglGetContextGPUIDAMD", [(HGLRC, "hglrc")], sideeffects=False),
+ StdFunction(HGLRC, "wglCreateAssociatedContextAMD", [(UINT, "id")]),
+ StdFunction(HGLRC, "wglCreateAssociatedContextAttribsAMD", [(UINT, "id"), (HGLRC, "hShareContext"), (OpaqueArray(Const(Int), "_wglCreateAssociatedContextAttribsAMD_size()"), "attribList")]),
+ StdFunction(BOOL, "wglDeleteAssociatedContextAMD", [(HGLRC, "hglrc")]),
+ StdFunction(BOOL, "wglMakeAssociatedContextCurrentAMD", [(HGLRC, "hglrc")]),
+ StdFunction(HGLRC, "wglGetCurrentAssociatedContextAMD", [], sideeffects=False),
+ StdFunction(VOID, "wglBlitContextFramebufferAMD", [(HGLRC, "dstCtx"), (GLint, "srcX0"), (GLint, "srcY0"), (GLint, "srcX1"), (GLint, "srcY1"), (GLint, "dstX0"), (GLint, "dstY0"), (GLint, "dstX1"), (GLint, "dstY1"), (GLbitfield, "mask"), (GLenum, "filter")]),
+
+ # WGL_NV_video_capture
+ StdFunction(BOOL, "wglBindVideoCaptureDeviceNV", [(UINT, "uVideoSlot"), (HVIDEOINPUTDEVICENV, "hDevice")]),
+ StdFunction(UINT, "wglEnumerateVideoCaptureDevicesNV", [(HDC, "hDc"), Out(Pointer(HVIDEOINPUTDEVICENV), "phDeviceList")]),
+ StdFunction(BOOL, "wglLockVideoCaptureDeviceNV", [(HDC, "hDc"), (HVIDEOINPUTDEVICENV, "hDevice")]),
+ StdFunction(BOOL, "wglQueryVideoCaptureDeviceNV", [(HDC, "hDc"), (HVIDEOINPUTDEVICENV, "hDevice"), (Int, "iAttribute"), Out(Pointer(Int), "piValue")]),
+ StdFunction(BOOL, "wglReleaseVideoCaptureDeviceNV", [(HDC, "hDc"), (HVIDEOINPUTDEVICENV, "hDevice")]),
+
+ # WGL_NV_copy_image
+ StdFunction(BOOL, "wglCopyImageSubDataNV", [(HGLRC, "hSrcRC"), (GLuint, "srcName"), (GLenum, "srcTarget"), (GLint, "srcLevel"), (GLint, "srcX"), (GLint, "srcY"), (GLint, "srcZ"), (HGLRC, "hDstRC"), (GLuint, "dstName"), (GLenum, "dstTarget"), (GLint, "dstLevel"), (GLint, "dstX"), (GLint, "dstY"), (GLint, "dstZ"), (GLsizei, "width"), (GLsizei, "height"), (GLsizei, "depth")]),
+
+ # WGL_NV_DX_interop
+ StdFunction(BOOL, "wglDXSetResourceShareHandleNV", [(OpaquePointer(Void), "dxObject"), (HANDLE, "shareHandle")]),
+ StdFunction(HANDLE, "wglDXOpenDeviceNV", [(OpaquePointer(Void), "dxDevice")]),
+ StdFunction(BOOL, "wglDXCloseDeviceNV", [(HANDLE, "hDevice")]),
+ StdFunction(HANDLE, "wglDXRegisterObjectNV", [(HANDLE, "hDevice"), (OpaquePointer(Void), "dxObject"), (GLuint, "name"), (GLenum, "type"), (GLenum, "access")]),
+ StdFunction(BOOL, "wglDXUnregisterObjectNV", [(HANDLE, "hDevice"), (HANDLE, "hObject")]),
+ StdFunction(BOOL, "wglDXObjectAccessNV", [(HANDLE, "hObject"), (GLenum, "access")]),
+ StdFunction(BOOL, "wglDXLockObjectsNV", [(HANDLE, "hDevice"), (GLint, "count"), Out(Array(HANDLE, "count"), "hObjects")]),
+ StdFunction(BOOL, "wglDXUnlockObjectsNV", [(HANDLE, "hDevice"), (GLint, "count"), Out(Array(HANDLE, "count"), "hObjects")]),
+
# must be last
StdFunction(PROC, "wglGetProcAddress", [(LPCSTR, "lpszProc")]),
])
bool _LoadScanline( XMVECTOR* pDestination, size_t count,
LPCVOID pSource, size_t size, DXGI_FORMAT format )
{
+#if !defined(_XM_NO_INTRINSICS_)
assert( pDestination && count > 0 && (((uintptr_t)pDestination & 0xF) == 0) );
+#endif
assert( pSource && size > 0 );
assert( IsValid(format) && !IsVideo(format) && !IsTypeless(format) && !IsCompressed(format) );
const XMVECTOR* pSource, size_t count )
{
assert( pDestination && size > 0 );
+#if !defined(_XM_NO_INTRINSICS_)
assert( pSource && count > 0 && (((uintptr_t)pSource & 0xF) == 0) );
+#endif
assert( IsValid(format) && !IsVideo(format) && !IsTypeless(format) && !IsCompressed(format) );
const XMVECTOR* __restrict sPtr = pSource;
void _ConvertScanline( XMVECTOR* pBuffer, size_t count, DXGI_FORMAT outFormat, DXGI_FORMAT inFormat, DWORD flags )
{
+#if !defined(_XM_NO_INTRINSICS_)
assert( pBuffer && count > 0 && (((uintptr_t)pBuffer & 0xF) == 0) );
+#endif
assert( IsValid(outFormat) && !IsVideo(outFormat) && !IsTypeless(outFormat) );
assert( IsValid(inFormat) && !IsVideo(inFormat) && !IsTypeless(inFormat) );
projects / apitrace / commitdiff