if (WIN32)
# http://msdn.microsoft.com/en-us/library/aa383745.aspx
- add_definitions (-D_WIN32_WINNT=0x0501 -DWINVER=0x0501)
+ add_definitions (-D_WIN32_WINNT=0x0601 -DWINVER=0x0601)
else (WIN32)
CHECK_CXX_COMPILER_FLAG("-fvisibility=hidden" CXX_COMPILER_FLAG_VISIBILITY)
if (CXX_COMPILER_FLAG_VISIBILITY)
#include <iostream>
+#ifdef _WIN32
+#include <windows.h>
+
+#ifndef COMMON_LVB_LEADING_BYTE
+#define COMMON_LVB_LEADING_BYTE 0x0100
+#endif
+
+#ifndef COMMON_LVB_TRAILING_BYTE
+#define COMMON_LVB_TRAILING_BYTE 0x0200
+#endif
+
+#ifndef COMMON_LVB_GRID_HORIZONTAL
+#define COMMON_LVB_GRID_HORIZONTAL 0x0400
+#endif
+
+#ifndef COMMON_LVB_GRID_LVERTICAL
+#define COMMON_LVB_GRID_LVERTICAL 0x0800
+#endif
+
+#ifndef COMMON_LVB_GRID_RVERTICAL
+#define COMMON_LVB_GRID_RVERTICAL 0x1000
+#endif
+
+#ifndef COMMON_LVB_REVERSE_VIDEO
+#define COMMON_LVB_REVERSE_VIDEO 0x4000
+#endif
+
+#ifndef COMMON_LVB_UNDERSCORE
+#define COMMON_LVB_UNDERSCORE 0x8000
+#endif
+
+#endif /* _WIN32 */
+
namespace formatter {
#ifdef _WIN32
-#include <windows.h>
-
-
-#ifndef COMMON_LVB_LEADING_BYTE
-#define COMMON_LVB_LEADING_BYTE 0x0100
-#endif
-
-#ifndef COMMON_LVB_TRAILING_BYTE
-#define COMMON_LVB_TRAILING_BYTE 0x0200
-#endif
-
-#ifndef COMMON_LVB_GRID_HORIZONTAL
-#define COMMON_LVB_GRID_HORIZONTAL 0x0400
-#endif
-
-#ifndef COMMON_LVB_GRID_LVERTICAL
-#define COMMON_LVB_GRID_LVERTICAL 0x0800
-#endif
-
-#ifndef COMMON_LVB_GRID_RVERTICAL
-#define COMMON_LVB_GRID_RVERTICAL 0x1000
-#endif
-
-#ifndef COMMON_LVB_REVERSE_VIDEO
-#define COMMON_LVB_REVERSE_VIDEO 0x4000
-#endif
-
-#ifndef COMMON_LVB_UNDERSCORE
-#define COMMON_LVB_UNDERSCORE 0x8000
-#endif
-
-
class WindowsAttribute : public Attribute {
protected:
WORD wAttributes;
}
};
-#endif
+
+#endif /* _WIN32 */
inline Formatter *defaultFormatter(bool color = true) {
#endif
+#ifndef D3DUSAGE_TEXTAPI
+#define D3DUSAGE_TEXTAPI 0x10000000L
+#endif
+
+#ifndef D3DUSAGE_RESTRICTED_CONTENT
+#define D3DUSAGE_RESTRICTED_CONTENT 0x00000800L
+#endif
+
+#ifndef D3DUSAGE_RESTRICT_SHARED_RESOURCE
+#define D3DUSAGE_RESTRICT_SHARED_RESOURCE 0x00002000L
+#endif
+
+#ifndef D3DUSAGE_RESTRICT_SHARED_RESOURCE_DRIVER
+#define D3DUSAGE_RESTRICT_SHARED_RESOURCE_DRIVER 0x00001000L
+#endif
+
+
#endif /* _D3D9IMPORTS_HPP_ */
--- /dev/null
+/*********************************************************************
+ *
+ * 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.
+ *
+ *********************************************************************/
+
+/*
+ * Auxiliary functions to compute the size of array/blob arguments.
+ */
+
+#include <string.h>
+
+#include "os_thread.hpp"
+#include "glimports.hpp"
+#include "glproc.hpp"
+#include "glsize.hpp"
+#include "eglsize.hpp"
+#include "assert.h"
+
+
+static int
+bisect_val(int min, int max, bool is_valid_val(int val))
+{
+ bool valid;
+
+ while (1) {
+ int try_val = min + (max - min + 1) / 2;
+
+ valid = is_valid_val(try_val);
+ if (min == max)
+ break;
+
+ if (valid)
+ min = try_val;
+ else
+ max = try_val - 1;
+ }
+
+ return valid ? min : -1;
+}
+
+static bool
+is_valid_width(int val)
+{
+ _glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, val, 1);
+ return _glGetError() == GL_NO_ERROR;
+}
+
+static bool
+is_valid_height(int val)
+{
+ _glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, val);
+ return _glGetError() == GL_NO_ERROR;
+}
+
+static int
+detect_size(int *width_ret, int *height_ret)
+{
+ GLint max_tex_size;
+ int width;
+ int height;
+
+ max_tex_size = 0;
+ _glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size);
+
+ width = bisect_val(1, max_tex_size, is_valid_width);
+ if (width < 0)
+ return -1;
+
+ height = bisect_val(1, max_tex_size, is_valid_height);
+ if (height < 0)
+ return -1;
+
+ *width_ret = width;
+ *height_ret = height;
+
+ return 0;
+}
+
+/* XXX */
+static inline bool
+can_unpack_subimage(void) {
+ return false;
+}
+
+static void
+_eglCreateImageKHR_get_image_size(EGLImageKHR image, image_info *info)
+{
+ GLuint fbo = 0;
+ GLuint orig_fbo = 0;
+ GLuint texture = 0;
+ GLuint orig_texture;
+ GLenum status;
+
+ _glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint *)&orig_fbo);
+ _glGenFramebuffers(1, &fbo);
+ _glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+
+ _glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint *)&orig_texture);
+ _glGenTextures(1, &texture);
+ _glBindTexture(GL_TEXTURE_2D, texture);
+
+ _glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
+
+ info->width = 0;
+ info->height = 0;
+
+ _glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+ GL_TEXTURE_2D, texture, 0);
+ status = _glCheckFramebufferStatus(GL_FRAMEBUFFER);
+ if (status == GL_FRAMEBUFFER_COMPLETE) {
+ if (detect_size(&info->width, &info->height) != 0)
+ os::log("%s: can't detect image size\n", __func__);
+ } else {
+ os::log("%s: error: %x\n", __func__, status);
+ }
+
+ /* Don't leak errors to the traced application. */
+ (void)_glGetError();
+
+ _glBindTexture(GL_TEXTURE_2D, orig_texture);
+ _glDeleteTextures(1, &texture);
+
+ _glBindFramebuffer(GL_FRAMEBUFFER, orig_fbo);
+ _glDeleteFramebuffers(1, &fbo);
+}
+
+static void
+get_texture_2d_image(image_info *info)
+{
+ GLuint fbo = 0;
+ GLint prev_fbo = 0;
+ GLint texture;
+ GLenum status;
+
+ _glGetIntegerv(GL_TEXTURE_BINDING_2D, &texture);
+ if (!texture)
+ return;
+
+ _glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prev_fbo);
+ _glGenFramebuffers(1, &fbo);
+ _glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+
+ _glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+ texture, 0);
+ status = _glCheckFramebufferStatus(GL_FRAMEBUFFER);
+ if (status != GL_FRAMEBUFFER_COMPLETE)
+ os::log("%s: error: %d\n", __func__, status);
+ _glReadPixels(0, 0, info->width, info->height, info->format, info->type, info->pixels);
+ /* Don't leak errors to the traced application. */
+ (void)_glGetError();
+
+ _glBindFramebuffer(GL_FRAMEBUFFER, prev_fbo);
+ _glDeleteFramebuffers(1, &fbo);
+}
+
+struct image_info *
+_EGLImageKHR_get_image_info(GLenum target, EGLImageKHR image)
+{
+ GLuint tex;
+ GLuint bound_tex;
+ struct image_info *info;
+
+ info = new image_info;
+
+ memset(info, 0, sizeof *info);
+
+ info->internalformat = GL_RGBA;
+ info->format = GL_RGBA;
+ info->type = GL_UNSIGNED_BYTE;
+
+ _eglCreateImageKHR_get_image_size(image, info);
+
+ _glGenTextures(1, &tex);
+ _glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint *)&bound_tex);
+ _glBindTexture(GL_TEXTURE_2D, tex);
+ _glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
+
+ info->size = _glTexImage2D_size(info->format, info->type, info->width, info->height);
+ info->pixels = malloc(info->size);
+
+ get_texture_2d_image(info);
+ _glBindTexture(GL_TEXTURE_2D, bound_tex);
+ _glDeleteBuffers(1, &tex);
+
+ return info;
+}
+
+void
+_EGLImageKHR_free_image_info(struct image_info *info)
+{
+ free(info->pixels);
+ delete info;
+}
+
+
--- /dev/null
+
+/*********************************************************************
+ *
+ * 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.
+ *
+ *********************************************************************/
+
+/*
+ * Auxiliary functions to compute the size of array/blob arguments.
+ */
+#ifndef _EGLSIZE_HPP_
+#define _EGLSIZE_HPP_
+
+
+#include "glimports.hpp"
+
+
+struct image_info
+{
+ GLint internalformat;
+ GLsizei width;
+ GLsizei height;
+ GLenum format;
+ GLenum type;
+ GLsizei size;
+ GLvoid * pixels;
+};
+
+struct image_info *
+_EGLImageKHR_get_image_info(GLenum target, EGLImageKHR image);
+
+void
+_EGLImageKHR_free_image_info(struct image_info *info);
+
+
+#endif
#include <string.h>
+#include <algorithm>
+
#include "os.hpp"
#include "glimports.hpp"
HWND
createWindow(int width, int height);
+void
+resizeWindow(HWND hWnd, int width, int height);
+
+bool
+processEvents(void);
+
} /* namespace d3dretrace */
if 'hFocusWindow' in method.argNames():
print r' hFocusWindow = hWnd;'
+ if method.name in ('Reset', 'ResetEx'):
+ print r' if (pPresentationParameters->Windowed) {'
+ print r' d3dretrace::resizeWindow(pPresentationParameters->hDeviceWindow, pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight);'
+ print r' }'
+
# notify frame has been completed
if method.name == 'Present':
print r' retrace::frameComplete(call);'
Retracer.invokeInterfaceMethod(self, interface, method)
+ # process events after presents
+ if method.name == 'Present':
+ print r' d3dretrace::processEvents();'
+
# check errors
if str(method.type) == 'HRESULT':
print r' if (FAILED(_result)) {'
{
MINMAXINFO *pMMI;
switch (uMsg) {
+ case WM_KEYDOWN:
+ switch (wParam) {
+ case VK_ESCAPE:
+ PostMessage(hWnd, WM_CLOSE, 0, 0);
+ break;
+ }
+ break;
case WM_GETMINMAXINFO:
// Allow to create a window bigger than the desktop
pMMI = (MINMAXINFO *)lParam;
pMMI->ptMaxTrackSize.x = 60000;
pMMI->ptMaxTrackSize.y = 60000;
break;
+ case WM_CLOSE:
+ exit(0);
+ break;
default:
break;
}
}
+void
+resizeWindow(HWND hWnd, int width, int height) {
+ RECT rClient;
+ GetClientRect(hWnd, &rClient);
+ if (width == rClient.right - rClient.left &&
+ height == rClient.bottom - rClient.top) {
+ return;
+ }
+
+ RECT rWindow;
+ GetWindowRect(hWnd, &rWindow);
+ width += (rWindow.right - rWindow.left) - rClient.right;
+ height += (rWindow.bottom - rWindow.top) - rClient.bottom;
+ SetWindowPos(hWnd, NULL, rWindow.left, rWindow.top, width, height, SWP_NOMOVE);
+}
+bool
+processEvents(void) {
+ MSG uMsg;
+ while (PeekMessage(&uMsg, NULL, 0, 0, PM_REMOVE)) {
+ if (uMsg.message == WM_QUIT) {
+ return false;
+ }
+
+ if (!TranslateAccelerator(uMsg.hwnd, NULL, &uMsg)) {
+ TranslateMessage(&uMsg);
+ DispatchMessage(&uMsg);
+ }
+ }
+ return true;
+}
+
} /* namespace d3dretrace */
#include "retrace.hpp"
#include "glretrace.hpp"
#include "os.hpp"
+#include "eglsize.hpp"
#ifndef EGL_OPENGL_ES_API
#define EGL_OPENGL_ES_API 0x30A0
{"eglSwapBuffers", &retrace_eglSwapBuffers},
//{"eglCopyBuffers", &retrace::ignore},
{"eglGetProcAddress", &retrace::ignore},
+ {"eglCreateImageKHR", &retrace::ignore},
+ {"eglDestroyImageKHR", &retrace::ignore},
+ {"glEGLImageTargetTexture2DOES", &retrace::ignore},
{NULL, NULL},
};
{
GLint channels = _gl_format_channels(format);
+ if (internalFormat == GL_NONE) {
+ internalFormat = format;
+ }
+
Context context;
json.beginObject();
eglWaitNative(EGL_CORE_NATIVE_ENGINE);
}
+ void
+ recreate(void) {
+ EGLContext currentContext = eglGetCurrentContext();
+ EGLSurface currentDrawSurface = eglGetCurrentSurface(EGL_DRAW);
+ EGLSurface currentReadSurface = eglGetCurrentSurface(EGL_DRAW);
+ bool rebindDrawSurface = currentDrawSurface == surface;
+ bool rebindReadSurface = currentReadSurface == surface;
+
+ if (rebindDrawSurface || rebindReadSurface) {
+ eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ }
+
+ eglDestroySurface(eglDisplay, surface);
+
+ EGLConfig config = static_cast<const EglVisual *>(visual)->config;
+ surface = eglCreateWindowSurface(eglDisplay, config, (EGLNativeWindowType)window, NULL);
+
+ if (rebindDrawSurface || rebindReadSurface) {
+ eglMakeCurrent(eglDisplay, surface, surface, currentContext);
+ }
+ }
+
void
resize(int w, int h) {
if (w == width && h == height) {
waitForEvent(ConfigureNotify);
eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+
+ /*
+ * Some implementations won't update the backbuffer unless we recreate
+ * the EGL surface.
+ */
+
+ int eglWidth;
+ int eglHeight;
+
+ eglQuerySurface(eglDisplay, surface, EGL_WIDTH, &eglWidth);
+ eglQuerySurface(eglDisplay, surface, EGL_HEIGHT, &eglHeight);
+
+ if (eglWidth != width || eglHeight != height) {
+ recreate();
+
+ eglQuerySurface(eglDisplay, surface, EGL_WIDTH, &eglWidth);
+ eglQuerySurface(eglDisplay, surface, EGL_HEIGHT, &eglHeight);
+ }
+
+ assert(eglWidth == width);
+ assert(eglHeight == height);
}
void show(void) {
#include <stddef.h>
#include <wchar.h>
+#ifdef _MSC_VER
+# include <float.h>
+# define isfinite _finite
+#else
+# include <math.h> // isfinite
+#endif
+
#include <iomanip>
#include <limits>
#include <ostream>
template<class T>
inline void writeNumber(T n) {
- if (n != n) {
- // NaN
+ if (!isfinite(n)) {
+ // NaN/Inf
writeNull();
} else {
separator();
"D3DUSAGE_RTPATCHES",
"D3DUSAGE_NPATCHES",
"D3DUSAGE_TEXTAPI",
+ "D3DUSAGE_RESTRICTED_CONTENT",
+ "D3DUSAGE_RESTRICT_SHARED_RESOURCE",
+ "D3DUSAGE_RESTRICT_SHARED_RESOURCE_DRIVER",
])
D3DCUBEMAP_FACES = Enum("D3DCUBEMAP_FACES", [
WORD = Alias("WORD", UInt16)
DWORD = Alias("DWORD", UInt32)
+UCHAR = Alias("UCHAR", UChar)
WCHAR = Alias("WCHAR", Short)
BOOL = Enum("BOOL", [
egltrace.cpp
glcaps.cpp
gltrace_state.cpp
+ ${CMAKE_SOURCE_DIR}/helpers/eglsize.cpp
)
add_dependencies (egltrace glproc)
print ' gltrace::releaseContext((uintptr_t)ctx);'
print ' }'
+ if function.name == 'glEGLImageTargetTexture2DOES':
+ print ' image_info *info = _EGLImageKHR_get_image_info(target, image);'
+ print ' if (info) {'
+ print ' GLint level = 0;'
+ print ' GLint internalformat = info->internalformat;'
+ print ' GLsizei width = info->width;'
+ print ' GLsizei height = info->height;'
+ print ' GLint border = 0;'
+ print ' GLenum format = info->format;'
+ print ' GLenum type = info->type;'
+ print ' const GLvoid * pixels = info->pixels;'
+ self.emitFakeTexture2D()
+ print ' _EGLImageKHR_free_image_info(info);'
+ print ' }'
+
+ def emitFakeTexture2D(self):
+ function = glapi.getFunctionByName('glTexImage2D')
+ instances = function.argNames()
+ print ' unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)
+ for arg in function.args:
+ assert not arg.output
+ self.serializeArg(function, arg)
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(_fake_call);'
+ print ' trace::localWriter.endLeave();'
+
+
+
if __name__ == '__main__':
print '#include <stdlib.h>'
print '#include <string.h>'
print
print '#include "glproc.hpp"'
print '#include "glsize.hpp"'
+ print '#include "eglsize.hpp"'
print
api = API()
function = api.getFunctionByName('glClientActiveTexture')
self.fake_call(function, [texture])
- def fake_call(self, function, args):
- print ' unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)
- for arg, instance in zip(function.args, args):
- assert not arg.output
- print ' trace::localWriter.beginArg(%u);' % (arg.index,)
- self.serializeValue(arg.type, instance)
- print ' trace::localWriter.endArg();'
- print ' trace::localWriter.endEnter();'
- print ' trace::localWriter.beginLeave(_fake_call);'
- print ' trace::localWriter.endLeave();'
"glXGetProcAddressARB",
]
+ createContextFunctionNames = [
+ 'glXCreateContext',
+ 'glXCreateContextAttribsARB',
+ 'glXCreateContextWithConfigSGIX',
+ 'glXCreateNewContext',
+ ]
+
+ destroyContextFunctionNames = [
+ 'glXDestroyContext',
+ ]
+
+ makeCurrentFunctionNames = [
+ 'glXMakeCurrent',
+ 'glXMakeContextCurrent',
+ 'glXMakeCurrentReadSGI',
+ ]
+
def traceFunctionImplBody(self, function):
- if function.name == 'glXDestroyContext':
+ if function.name in self.destroyContextFunctionNames:
print ' gltrace::releaseContext((uintptr_t)ctx);'
GlTracer.traceFunctionImplBody(self, function)
- if function.name == 'glXCreateContext':
+ if function.name in self.createContextFunctionNames:
print ' if (_result != NULL)'
print ' gltrace::createContext((uintptr_t)_result);'
- if function.name == 'glXMakeCurrent':
+ if function.name in self.makeCurrentFunctionNames:
print ' if (_result) {'
print ' if (ctx != NULL)'
print ' gltrace::setContext((uintptr_t)ctx);'
print ' trace::localWriter.endEnter();'
print ' trace::localWriter.beginLeave(_call);'
print ' trace::localWriter.endLeave();'
+
+ def fake_call(self, function, args):
+ print ' unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)
+ for arg, instance in zip(function.args, args):
+ assert not arg.output
+ print ' trace::localWriter.beginArg(%u);' % (arg.index,)
+ self.serializeValue(arg.type, instance)
+ print ' trace::localWriter.endArg();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(_fake_call);'
+ print ' trace::localWriter.endLeave();'
"wglGetProcAddress",
]
+ createContextFunctionNames = [
+ 'wglCreateContext',
+ 'wglCreateContextAttribsARB',
+ 'wglCreateLayerContext',
+ ]
+
+ destroyContextFunctionNames = [
+ 'wglDeleteContext',
+ ]
+
+ makeCurrentFunctionNames = [
+ 'wglMakeCurrent',
+ 'wglMakeContextCurrentARB',
+ 'wglMakeContextCurrentEXT',
+ ]
+
def traceFunctionImplBody(self, function):
- if function.name == 'wglDeleteContext':
+ if function.name in self.destroyContextFunctionNames:
# Unlike other GL APIs like EGL or GLX, WGL will make the context
# inactive if it's currently the active context.
print ' if (_wglGetCurrentContext() == hglrc) {'
GlTracer.traceFunctionImplBody(self, function)
- if function.name == 'wglCreateContext':
+ if function.name in self.createContextFunctionNames:
print ' if (_result)'
print ' gltrace::createContext((uintptr_t)_result);'
- if function.name == 'wglMakeCurrent':
+ if function.name in self.makeCurrentFunctionNames:
print ' if (_result) {'
print ' if (hglrc != NULL)'
print ' gltrace::setContext((uintptr_t)hglrc);'
projects / apitrace / commitdiff