"""GL tracing generator."""
-import stdapi
-import glapi
-import glparams
-from glxapi import glxapi
-from trace import Tracer, dump_instance
+import specs.stdapi as stdapi
+import specs.glapi as glapi
+import specs.glparams as glparams
+from specs.glxapi import glxapi
+from trace import Tracer
class TypeGetter(stdapi.Visitor):
self.long_suffix = long_suffix
self.ext_suffix = ext_suffix
- def visit_const(self, const):
+ def visitConst(self, const):
return self.visit(const.type)
- def visit_alias(self, alias):
+ def visitAlias(self, alias):
if alias.expr == 'GLboolean':
if self.long_suffix:
suffix = 'Booleanv'
function_name = self.prefix + suffix + self.ext_suffix
return function_name, arg_type
- def visit_enum(self, enum):
+ def visitEnum(self, enum):
return self.visit(glapi.GLint)
- def visit_bitmask(self, bitmask):
+ def visitBitmask(self, bitmask):
return self.visit(glapi.GLint)
- def visit_opaque(self, pointer):
+ def visitOpaque(self, pointer):
return self.prefix + 'Pointerv' + self.ext_suffix, 'GLvoid *'
]
arrays.reverse()
+ # arrays available in PROFILE_ES1
+ arrays_es1 = ("Vertex", "Normal", "Color", "TexCoord")
+
def header(self, api):
Tracer.header(self, api)
print '#include "gltrace.hpp"'
print
- print '// Whether user arrays were used'
- print 'static bool __user_arrays = false;'
- print 'static bool __user_arrays_arb = false;'
- print 'static bool __user_arrays_nv = false;'
- print
# Which glVertexAttrib* variant to use
print 'enum vertex_attrib {'
print ' VERTEX_ATTRIB_NV,'
print '};'
print
+ print 'gltrace::Context *'
+ print 'gltrace::getContext(void)'
+ print '{'
+ print ' // TODO return the context set by other APIs (GLX, EGL, and etc.)'
+ print ' static gltrace::Context __ctx = { gltrace::PROFILE_COMPAT, false, false, false };'
+ print ' return &__ctx;'
+ print '}'
+ print
print 'static vertex_attrib __get_vertex_attrib(void) {'
- print ' if (__user_arrays_arb || __user_arrays_nv) {'
+ print ' gltrace::Context *ctx = gltrace::getContext();'
+ print ' if (ctx->user_arrays_arb || ctx->user_arrays_nv) {'
print ' GLboolean __vertex_program = GL_FALSE;'
print ' __glGetBooleanv(GL_VERTEX_PROGRAM_ARB, &__vertex_program);'
print ' if (__vertex_program) {'
- print ' if (__user_arrays_nv) {'
+ print ' if (ctx->user_arrays_nv) {'
print ' GLint __vertex_program_binding_nv = 0;'
print ' __glGetIntegerv(GL_VERTEX_PROGRAM_BINDING_NV, &__vertex_program_binding_nv);'
print ' if (__vertex_program_binding_nv) {'
# Whether we need user arrays
print 'static inline bool __need_user_arrays(void)'
print '{'
- print ' if (!__user_arrays) {'
+ print ' gltrace::Context *ctx = gltrace::getContext();'
+ print ' if (!ctx->user_arrays) {'
print ' return false;'
print ' }'
print
for camelcase_name, uppercase_name in self.arrays:
+ # in which profile is the array available?
+ profile_check = 'ctx->profile == gltrace::PROFILE_COMPAT'
+ if camelcase_name in self.arrays_es1:
+ profile_check = '(' + profile_check + ' || ctx->profile == gltrace::PROFILE_ES1)';
+
function_name = 'gl%sPointer' % camelcase_name
enable_name = 'GL_%s_ARRAY' % uppercase_name
binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
print ' // %s' % function_name
+ print ' if (%s) {' % profile_check
self.array_prolog(api, uppercase_name)
print ' if (__glIsEnabled(%s)) {' % enable_name
print ' GLint __binding = 0;'
print ' }'
print ' }'
self.array_epilog(api, uppercase_name)
+ print ' }'
print
+ print ' // ES1 does not support generic vertex attributes'
+ print ' if (ctx->profile == gltrace::PROFILE_ES1)'
+ print ' return false;'
+ print
print ' vertex_attrib __vertex_attrib = __get_vertex_attrib();'
print
print ' // glVertexAttribPointer'
print
print 'static inline struct buffer_mapping *'
print 'get_buffer_mapping(GLenum target) {'
- print ' switch(target) {'
+ print ' switch (target) {'
for target in self.buffer_targets:
print ' case GL_%s:' % target
print ' return & __%s_mapping;' % target.lower()
print ' default:'
- print ' OS::DebugMessage("apitrace: warning: unknown buffer target 0x%04X\\n", target);'
+ print ' os::log("apitrace: warning: unknown buffer target 0x%04X\\n", target);'
print ' return NULL;'
print ' }'
print '}'
print
- # Generate memcpy's signature
- self.trace_function_decl(glapi.memcpy)
-
# Generate a helper function to determine whether a parameter name
# refers to a symbolic value or not
print 'static bool'
print 'is_symbolic_pname(GLenum pname) {'
- print ' switch(pname) {'
+ print ' switch (pname) {'
for function, type, count, name in glparams.parameters:
if type is glapi.GLenum:
print ' case %s:' % name
# Generate a helper function to know how many elements a parameter has
print 'static size_t'
print '__gl_param_size(GLenum pname) {'
- print ' switch(pname) {'
+ print ' switch (pname) {'
for function, type, count, name in glparams.parameters:
if type is not None:
print ' case %s: return %u;' % (name, count)
print ' return num_compressed_texture_formats;'
print ' }'
print ' default:'
- print r' OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);'
+ print r' os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);'
print ' return 1;'
print ' }'
print '}'
print
+ # states such as GL_UNPACK_ROW_LENGTH are not available in GLES
+ print 'static inline bool'
+ print 'can_unpack_subimage(void) {'
+ print ' gltrace::Context *ctx = gltrace::getContext();'
+ print ' return (ctx->profile == gltrace::PROFILE_COMPAT);'
+ print '}'
+ print
+
array_pointer_function_names = set((
"glVertexPointer",
"glNormalPointer",
'glMultiDrawArrays',
'glMultiDrawElements',
'glDrawArraysInstanced',
+ "glDrawArraysInstancedBaseInstance",
'glDrawElementsInstanced',
'glDrawArraysInstancedARB',
'glDrawElementsInstancedARB',
'glDrawElementsBaseVertex',
'glDrawRangeElementsBaseVertex',
'glDrawElementsInstancedBaseVertex',
+ "glDrawElementsInstancedBaseInstance",
+ "glDrawElementsInstancedBaseVertexBaseInstance",
'glMultiDrawElementsBaseVertex',
'glDrawArraysIndirect',
'glDrawElementsIndirect',
'GL_T4F_C4F_N3F_V4F',
]
- def trace_function_impl_body(self, function):
+ def traceFunctionImplBody(self, function):
# Defer tracing of user array pointers...
if function.name in self.array_pointer_function_names:
print ' GLint __array_buffer = 0;'
print ' __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
print ' if (!__array_buffer) {'
- print ' __user_arrays = true;'
+ print ' gltrace::Context *ctx = gltrace::getContext();'
+ print ' ctx->user_arrays = true;'
if function.name == "glVertexAttribPointerARB":
- print ' __user_arrays_arb = true;'
+ print ' ctx->user_arrays_arb = true;'
if function.name == "glVertexAttribPointerNV":
- print ' __user_arrays_nv = true;'
- self.dispatch_function(function)
+ print ' ctx->user_arrays_nv = true;'
+ self.invokeFunction(function)
# And also break down glInterleavedArrays into the individual calls
if function.name == 'glInterleavedArrays':
# Emit a fake function
print ' {'
- print ' static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
- print ' unsigned __call = __writer.beginEnter(&__sig);'
- print ' __writer.beginArg(0);'
- dump_instance(glapi.GLenum, enable_name)
- print ' __writer.endArg();'
- print ' __writer.endEnter();'
- print ' __writer.beginLeave(__call);'
- print ' __writer.endLeave();'
+ print ' static const trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
+ print ' unsigned __call = trace::localWriter.beginEnter(&__sig);'
+ print ' trace::localWriter.beginArg(0);'
+ self.serializeValue(glapi.GLenum, enable_name)
+ print ' trace::localWriter.endArg();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.endLeave();'
print ' }'
print ' return;'
print ' }'
# Emit a fake memcpy on buffer uploads
- if function.name in ('glUnmapBuffer', 'glUnmapBufferARB', ):
+ if function.name in ('glUnmapBuffer', 'glUnmapBufferARB', 'glUnmapBufferOES'):
print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
print ' if (mapping && mapping->write && !mapping->explicit_flush) {'
self.emit_memcpy('mapping->map', 'mapping->map', 'mapping->length')
print ' }'
+ if function.name == 'glUnmapNamedBufferEXT':
+ print ' GLint access = 0;'
+ print ' glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_ACCESS, &access);'
+ print ' if ((access & GL_MAP_WRITE_BIT) & !(access & GL_MAP_FLUSH_EXPLICIT_BIT)) {'
+ print ' GLvoid *map = NULL;'
+ print ' glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &map);'
+ print ' GLint length = 0;'
+ print ' glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_MAP_LENGTH, &length);'
+ self.emit_memcpy('map', 'map', 'length')
+ print ' }'
if function.name in ('glFlushMappedBufferRange', 'glFlushMappedBufferRangeAPPLE'):
- # TODO: avoid copying [0, offset] bytes
print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
print ' if (mapping) {'
if function.name.endswith('APPLE'):
print ' GLsizeiptr length = size;'
print ' mapping->explicit_flush = true;'
print ' //assert(offset + length <= mapping->length);'
- self.emit_memcpy('mapping->map', 'mapping->map', 'offset + length')
+ self.emit_memcpy('(char *)mapping->map + offset', '(const char *)mapping->map + offset', 'length')
+ print ' }'
+ if function.name == 'glFlushMappedNamedBufferRangeEXT':
+ print ' GLvoid *map = NULL;'
+ print ' glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &map);'
+ print ' if (map) {'
+ self.emit_memcpy('(char *)map + offset', '(const char *)map + offset', 'length')
print ' }'
- # FIXME: glFlushMappedNamedBufferRangeEXT
# Don't leave vertex attrib locations to chance. Instead emit fake
# glBindAttribLocation calls to ensure that the same locations will be
# be an herculian task given that vertex attrib locations appear in
# many entry-points, including non-shader related ones.
if function.name == 'glLinkProgram':
- Tracer.dispatch_function(self, function)
+ Tracer.invokeFunction(self, function)
print ' GLint active_attributes = 0;'
print ' __glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active_attributes);'
- print ' for (GLuint attrib = 0; attrib < active_attributes; ++attrib) {'
+ print ' for (GLint attrib = 0; attrib < active_attributes; ++attrib) {'
print ' GLint size = 0;'
print ' GLenum type = 0;'
print ' GLchar name[256];'
print ' }'
print ' }'
if function.name == 'glLinkProgramARB':
- Tracer.dispatch_function(self, function)
+ Tracer.invokeFunction(self, function)
print ' GLint active_attributes = 0;'
print ' __glGetObjectParameterivARB(programObj, GL_OBJECT_ACTIVE_ATTRIBUTES_ARB, &active_attributes);'
- print ' for (GLuint attrib = 0; attrib < active_attributes; ++attrib) {'
+ print ' for (GLint attrib = 0; attrib < active_attributes; ++attrib) {'
print ' GLint size = 0;'
print ' GLenum type = 0;'
print ' GLcharARB name[256];'
print ' }'
print ' }'
- Tracer.trace_function_impl_body(self, function)
+ Tracer.traceFunctionImplBody(self, function)
+
+ marker_functions = [
+ # GL_GREMEDY_string_marker
+ 'glStringMarkerGREMEDY',
+ # GL_GREMEDY_frame_terminator
+ 'glFrameTerminatorGREMEDY',
+ # GL_EXT_debug_marker
+ 'glInsertEventMarkerEXT',
+ 'glPushGroupMarkerEXT',
+ 'glPopGroupMarkerEXT',
+ ]
- def dispatch_function(self, function):
+ def invokeFunction(self, function):
if function.name in ('glLinkProgram', 'glLinkProgramARB'):
# These functions have been dispatched already
return
- # We implement the GREMEDY extensions, not the driver
- if function.name in ('glStringMarkerGREMEDY', 'glFrameTerminatorGREMEDY'):
+ # We implement GL_EXT_debug_marker, GL_GREMEDY_*, etc., and not the
+ # driver
+ if function.name in self.marker_functions:
return
- Tracer.dispatch_function(self, function)
-
- def emit_memcpy(self, dest, src, length):
- print ' unsigned __call = __writer.beginEnter(&__memcpy_sig);'
- print ' __writer.beginArg(0);'
- print ' __writer.writeOpaque(%s);' % dest
- print ' __writer.endArg();'
- print ' __writer.beginArg(1);'
- print ' __writer.writeBlob(%s, %s);' % (src, length)
- print ' __writer.endArg();'
- print ' __writer.beginArg(2);'
- print ' __writer.writeUInt(%s);' % length
- print ' __writer.endArg();'
- print ' __writer.endEnter();'
- print ' __writer.beginLeave(__call);'
- print ' __writer.endLeave();'
-
+ if function.name in ('glXGetProcAddress', 'glXGetProcAddressARB', 'wglGetProcAddress'):
+ else_ = ''
+ for marker_function in self.marker_functions:
+ if self.api.get_function_by_name(marker_function):
+ print ' %sif (strcmp("%s", (const char *)%s) == 0) {' % (else_, marker_function, function.args[0].name)
+ print ' __result = (%s)&%s;' % (function.type, marker_function)
+ print ' }'
+ else_ = 'else '
+ print ' %s{' % else_
+ Tracer.invokeFunction(self, function)
+ print ' }'
+ return
+
+ # Override GL extensions
+ if function.name in ('glGetString', 'glGetIntegerv', 'glGetStringi'):
+ Tracer.invokeFunction(self, function, prefix = 'gltrace::__', suffix = '_override')
+ return
+
+ Tracer.invokeFunction(self, function)
+
buffer_targets = [
'ARRAY_BUFFER',
'ELEMENT_ARRAY_BUFFER',
'PIXEL_PACK_BUFFER',
'PIXEL_UNPACK_BUFFER',
+ 'UNIFORM_BUFFER',
+ 'TEXTURE_BUFFER',
+ 'TRANSFORM_FEEDBACK_BUFFER',
+ 'COPY_READ_BUFFER',
+ 'COPY_WRITE_BUFFER',
+ 'DRAW_INDIRECT_BUFFER',
+ 'ATOMIC_COUNTER_BUFFER',
]
- def wrap_ret(self, function, instance):
- Tracer.wrap_ret(self, function, instance)
-
- if function.name == 'glGetString':
- print ' if (__result) {'
- print ' switch (name) {'
- print ' case GL_EXTENSIONS:'
- print ' __result = gltrace::translateExtensionsString(__result);'
- print ' break;'
- print ' default:'
- print ' break;'
- print ' }'
- print ' }'
+ def wrapRet(self, function, instance):
+ Tracer.wrapRet(self, function, instance)
+
- if function.name in ('glMapBuffer', 'glMapBufferARB'):
+ if function.name in ('glMapBuffer', 'glMapBufferARB', 'glMapBufferOES'):
print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
print ' if (mapping) {'
print ' mapping->map = %s;' % (instance)
'glTextureSubImage3DEXT',
])
- def dump_arg_instance(self, function, arg):
+ def serializeArgValue(self, function, arg):
if function.name in self.draw_function_names and arg.name == 'indices':
print ' GLint __element_array_buffer = 0;'
print ' __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
print ' if (!__element_array_buffer) {'
if isinstance(arg.type, stdapi.Array):
- print ' __writer.beginArray(%s);' % arg.type.length
+ print ' trace::localWriter.beginArray(%s);' % arg.type.length
print ' for(GLsizei i = 0; i < %s; ++i) {' % arg.type.length
- print ' __writer.beginElement();'
- print ' __writer.writeBlob(%s[i], count[i]*__gl_type_size(type));' % (arg.name)
- print ' __writer.endElement();'
+ print ' trace::localWriter.beginElement();'
+ print ' trace::localWriter.writeBlob(%s[i], count[i]*__gl_type_size(type));' % (arg.name)
+ print ' trace::localWriter.endElement();'
print ' }'
- print ' __writer.endArray();'
+ print ' trace::localWriter.endArray();'
else:
- print ' __writer.writeBlob(%s, count*__gl_type_size(type));' % (arg.name)
+ print ' trace::localWriter.writeBlob(%s, count*__gl_type_size(type));' % (arg.name)
print ' } else {'
- Tracer.dump_arg_instance(self, function, arg)
+ Tracer.serializeArgValue(self, function, arg)
print ' }'
return
or (isinstance(arg.type, stdapi.Const) \
and isinstance(arg.type.type, stdapi.Blob))):
print ' {'
+ print ' gltrace::Context *ctx = gltrace::getContext();'
print ' GLint __unpack_buffer = 0;'
- print ' __glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &__unpack_buffer);'
+ print ' if (ctx->profile == gltrace::PROFILE_COMPAT)'
+ print ' __glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &__unpack_buffer);'
print ' if (__unpack_buffer) {'
- print ' __writer.writeOpaque(%s);' % arg.name
+ print ' trace::localWriter.writeOpaque(%s);' % arg.name
print ' } else {'
- Tracer.dump_arg_instance(self, function, arg)
+ Tracer.serializeArgValue(self, function, arg)
print ' }'
print ' }'
return
# Several GL state functions take GLenum symbolic names as
# integer/floats; so dump the symbolic name whenever possible
if function.name.startswith('gl') \
- and arg.type in (glapi.GLint, glapi.GLfloat) \
+ and arg.type in (glapi.GLint, glapi.GLfloat, glapi.GLdouble) \
and arg.name == 'param':
assert arg.index > 0
assert function.args[arg.index - 1].name == 'pname'
assert function.args[arg.index - 1].type == glapi.GLenum
print ' if (is_symbolic_pname(pname) && is_symbolic_param(%s)) {' % arg.name
- dump_instance(glapi.GLenum, arg.name)
+ self.serializeValue(glapi.GLenum, arg.name)
print ' } else {'
- Tracer.dump_arg_instance(self, function, arg)
+ Tracer.serializeArgValue(self, function, arg)
print ' }'
return
- Tracer.dump_arg_instance(self, function, arg)
+ Tracer.serializeArgValue(self, function, arg)
def footer(self, api):
Tracer.footer(self, api)
# update the state
print 'static void __trace_user_arrays(GLuint maxindex)'
print '{'
+ print ' gltrace::Context *ctx = gltrace::getContext();'
for camelcase_name, uppercase_name in self.arrays:
+ # in which profile is the array available?
+ profile_check = 'ctx->profile == gltrace::PROFILE_COMPAT'
+ if camelcase_name in self.arrays_es1:
+ profile_check = '(' + profile_check + ' || ctx->profile == gltrace::PROFILE_ES1)';
+
function_name = 'gl%sPointer' % camelcase_name
enable_name = 'GL_%s_ARRAY' % uppercase_name
binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
function = api.get_function_by_name(function_name)
- print ' // %s' % function.name
+ print ' // %s' % function.prototype()
+ print ' if (%s) {' % profile_check
self.array_trace_prolog(api, uppercase_name)
self.array_prolog(api, uppercase_name)
print ' if (__glIsEnabled(%s)) {' % enable_name
# Emit a fake function
self.array_trace_intermezzo(api, uppercase_name)
- print ' unsigned __call = __writer.beginEnter(&__%s_sig);' % (function.name,)
+ print ' unsigned __call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
for arg in function.args:
assert not arg.output
- print ' __writer.beginArg(%u);' % (arg.index,)
+ print ' trace::localWriter.beginArg(%u);' % (arg.index,)
if arg.name != 'pointer':
- dump_instance(arg.type, arg.name)
+ self.serializeValue(arg.type, arg.name)
else:
- print ' __writer.writeBlob((const void *)%s, __size);' % (arg.name)
- print ' __writer.endArg();'
+ print ' trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name)
+ print ' trace::localWriter.endArg();'
- print ' __writer.endEnter();'
- print ' __writer.beginLeave(__call);'
- print ' __writer.endLeave();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.endLeave();'
print ' }'
print ' }'
self.array_epilog(api, uppercase_name)
self.array_trace_epilog(api, uppercase_name)
+ print ' }'
print
# Samething, but for glVertexAttribPointer*
# This means that the implementations of these functions do not always
# alias, and they need to be considered independently.
#
+ print ' // ES1 does not support generic vertex attributes'
+ print ' if (ctx->profile == gltrace::PROFILE_ES1)'
+ print ' return;'
+ print
print ' vertex_attrib __vertex_attrib = __get_vertex_attrib();'
print
for suffix in ['', 'ARB', 'NV']:
else:
SUFFIX = suffix
function_name = 'glVertexAttribPointer' + suffix
- print ' // %s' % function_name
+ function = api.get_function_by_name(function_name)
+
+ print ' // %s' % function.prototype()
print ' if (__vertex_attrib == VERTEX_ATTRIB%s) {' % SUFFIX
if suffix == 'NV':
print ' GLint __max_vertex_attribs = 16;'
print ' __glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING%s, &__binding);' % (suffix, SUFFIX)
print ' if (!__binding) {'
- function = api.get_function_by_name(function_name)
-
# Get the arguments via glGet*
for arg in function.args[1:]:
if suffix == 'NV':
print ' size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
# Emit a fake function
- print ' unsigned __call = __writer.beginEnter(&__%s_sig);' % (function.name,)
+ print ' unsigned __call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
for arg in function.args:
assert not arg.output
- print ' __writer.beginArg(%u);' % (arg.index,)
+ print ' trace::localWriter.beginArg(%u);' % (arg.index,)
if arg.name != 'pointer':
- dump_instance(arg.type, arg.name)
+ self.serializeValue(arg.type, arg.name)
else:
- print ' __writer.writeBlob((const void *)%s, __size);' % (arg.name)
- print ' __writer.endArg();'
+ print ' trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name)
+ print ' trace::localWriter.endArg();'
- print ' __writer.endEnter();'
- print ' __writer.beginLeave(__call);'
- print ' __writer.endLeave();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.endLeave();'
print ' }'
print ' }'
print ' }'
print ' GLint client_active_texture = 0;'
print ' __glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &client_active_texture);'
print ' GLint max_texture_coords = 0;'
- print ' __glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);'
+ print ' if (ctx->profile == gltrace::PROFILE_COMPAT)'
+ print ' __glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);'
+ print ' else'
+ print ' __glGetIntegerv(GL_MAX_TEXTURE_UNITS, &max_texture_coords);'
print ' for (GLint unit = 0; unit < max_texture_coords; ++unit) {'
- print ' GLenum texture = GL_TEXTURE0 + unit;'
+ print ' GLint texture = GL_TEXTURE0 + unit;'
print ' __glClientActiveTexture(texture);'
def array_trace_prolog(self, api, uppercase_name):
self.fake_call(function, [texture])
def fake_call(self, function, args):
- print ' unsigned __fake_call = __writer.beginEnter(&__%s_sig);' % (function.name,)
+ print ' unsigned __fake_call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
for arg, instance in zip(function.args, args):
assert not arg.output
- print ' __writer.beginArg(%u);' % (arg.index,)
- dump_instance(arg.type, instance)
- print ' __writer.endArg();'
- print ' __writer.endEnter();'
- print ' __writer.beginLeave(__fake_call);'
- print ' __writer.endLeave();'
+ 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();'
projects / apitrace / blobdiff