class TypeGetter(stdapi.Visitor):
'''Determine which glGet*v function that matches the specified type.'''
- def __init__(self, prefix = 'glGet', long_suffix = True):
+ def __init__(self, prefix = 'glGet', long_suffix = True, ext_suffix = ''):
self.prefix = prefix
self.long_suffix = long_suffix
+ self.ext_suffix = ext_suffix
def visit_const(self, const):
return self.visit(const.type)
def visit_alias(self, alias):
if alias.expr == 'GLboolean':
if self.long_suffix:
- return self.prefix + 'Booleanv', alias.expr
+ suffix = 'Booleanv'
+ arg_type = alias.expr
else:
- return self.prefix + 'iv', 'GLint'
+ suffix = 'iv'
+ arg_type = 'GLint'
elif alias.expr == 'GLdouble':
if self.long_suffix:
- return self.prefix + 'Doublev', alias.expr
+ suffix = 'Doublev'
+ arg_type = alias.expr
else:
- return self.prefix + 'dv', alias.expr
+ suffix = 'dv'
+ arg_type = alias.expr
elif alias.expr == 'GLfloat':
if self.long_suffix:
- return self.prefix + 'Floatv', alias.expr
+ suffix = 'Floatv'
+ arg_type = alias.expr
else:
- return self.prefix + 'fv', alias.expr
+ suffix = 'fv'
+ arg_type = alias.expr
elif alias.expr in ('GLint', 'GLuint', 'GLsizei'):
if self.long_suffix:
- return self.prefix + 'Integerv', 'GLint'
+ suffix = 'Integerv'
+ arg_type = 'GLint'
else:
- return self.prefix + 'iv', 'GLint'
+ suffix = 'iv'
+ arg_type = 'GLint'
else:
print alias.expr
assert False
+ function_name = self.prefix + suffix + self.ext_suffix
+ return function_name, arg_type
def visit_enum(self, enum):
return self.visit(glapi.GLint)
return self.visit(glapi.GLint)
def visit_opaque(self, pointer):
- return self.prefix + 'Pointerv', 'GLvoid *'
+ return self.prefix + 'Pointerv' + self.ext_suffix, 'GLvoid *'
class GlTracer(Tracer):
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,'
+ print ' VERTEX_ATTRIB_ARB,'
+ print ' VERTEX_ATTRIB_NV,'
+ print '};'
+ print
+ print 'static vertex_attrib __get_vertex_attrib(void) {'
+ print ' if (__user_arrays_arb || __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 ' GLint __vertex_program_binding_nv = 0;'
+ print ' __glGetIntegerv(GL_VERTEX_PROGRAM_BINDING_NV, &__vertex_program_binding_nv);'
+ print ' if (__vertex_program_binding_nv) {'
+ print ' return VERTEX_ATTRIB_NV;'
+ print ' }'
+ print ' }'
+ print ' return VERTEX_ATTRIB_ARB;'
+ print ' }'
+ print ' }'
+ print ' return VERTEX_ATTRIB;'
+ print '}'
print
+
# Whether we need user arrays
print 'static inline bool __need_user_arrays(void)'
print '{'
self.array_epilog(api, uppercase_name)
print
+ print ' vertex_attrib __vertex_attrib = __get_vertex_attrib();'
+ print
print ' // glVertexAttribPointer'
- print ' GLint __max_vertex_attribs = 0;'
- print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
- print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
- print ' GLint __enabled = 0;'
- print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
- print ' if (__enabled) {'
- print ' GLint __binding = 0;'
- print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
- print ' if (!__binding) {'
+ print ' if (__vertex_attrib == VERTEX_ATTRIB) {'
+ print ' GLint __max_vertex_attribs = 0;'
+ print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
+ print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
+ print ' GLint __enabled = 0;'
+ print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
+ print ' if (__enabled) {'
+ print ' GLint __binding = 0;'
+ print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
+ print ' if (!__binding) {'
+ print ' return true;'
+ print ' }'
+ print ' }'
+ print ' }'
+ print ' }'
+ print
+ print ' // glVertexAttribPointerARB'
+ print ' if (__vertex_attrib == VERTEX_ATTRIB_ARB) {'
+ print ' GLint __max_vertex_attribs = 0;'
+ print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &__max_vertex_attribs);'
+ print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
+ print ' GLint __enabled = 0;'
+ print ' __glGetVertexAttribivARB(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, &__enabled);'
+ print ' if (__enabled) {'
+ print ' GLint __binding = 0;'
+ print ' __glGetVertexAttribivARB(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB, &__binding);'
+ print ' if (!__binding) {'
+ print ' return true;'
+ print ' }'
+ print ' }'
+ print ' }'
+ print ' }'
+ print
+ print ' // glVertexAttribPointerNV'
+ print ' if (__vertex_attrib == VERTEX_ATTRIB_NV) {'
+ print ' for (GLint index = 0; index < 16; ++index) {'
+ print ' GLint __enabled = 0;'
+ print ' __glGetIntegerv(GL_VERTEX_ATTRIB_ARRAY0_NV + index, &__enabled);'
+ print ' if (__enabled) {'
print ' return true;'
print ' }'
print ' }'
print ' __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
print ' if (!__array_buffer) {'
print ' __user_arrays = true;'
+ if function.name == "glVertexAttribPointerARB":
+ print ' __user_arrays_arb = true;'
+ if function.name == "glVertexAttribPointerNV":
+ print ' __user_arrays_nv = true;'
self.dispatch_function(function)
# And also break down glInterleavedArrays into the individual calls
# 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);'
+ print ' unsigned __call = Trace::localWriter.beginEnter(&__sig);'
+ print ' Trace::localWriter.beginArg(0);'
dump_instance(glapi.GLenum, enable_name)
- print ' __writer.endArg();'
- print ' __writer.endEnter();'
- print ' __writer.beginLeave(__call);'
- print ' __writer.endLeave();'
+ print ' Trace::localWriter.endArg();'
+ print ' Trace::localWriter.endEnter();'
+ print ' Trace::localWriter.beginLeave(__call);'
+ print ' Trace::localWriter.endLeave();'
print ' }'
print ' return;'
Tracer.trace_function_impl_body(self, function)
+ gremedy_functions = [
+ 'glStringMarkerGREMEDY',
+ 'glFrameTerminatorGREMEDY',
+ ]
+
def dispatch_function(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 self.gremedy_functions:
+ return
+
+ if function.name in ('glXGetProcAddress', 'glXGetProcAddressARB', 'wglGetProcAddress'):
+ if_ = 'if'
+ for gremedy_function in self.gremedy_functions:
+ print ' %s (strcmp("%s", (const char *)%s) == 0) {' % (if_, gremedy_function, function.args[0].name)
+ print ' __result = (%s)&%s;' % (function.type, gremedy_function)
+ print ' }'
+ if_ = 'else if'
+ print ' else {'
+ Tracer.dispatch_function(self, function)
+ print ' }'
+ return
+
+ # Override GL extensions
+ if function.name in ('glGetString', 'glGetIntegerv', 'glGetStringi'):
+ Tracer.dispatch_function(self, function, prefix = 'gltrace::__', suffix = '_override')
+ 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();'
+ print ' unsigned __call = Trace::localWriter.beginEnter(&__memcpy_sig);'
+ print ' Trace::localWriter.beginArg(0);'
+ print ' Trace::localWriter.writeOpaque(%s);' % dest
+ print ' Trace::localWriter.endArg();'
+ print ' Trace::localWriter.beginArg(1);'
+ print ' Trace::localWriter.writeBlob(%s, %s);' % (src, length)
+ print ' Trace::localWriter.endArg();'
+ print ' Trace::localWriter.beginArg(2);'
+ print ' Trace::localWriter.writeUInt(%s);' % length
+ print ' Trace::localWriter.endArg();'
+ print ' Trace::localWriter.endEnter();'
+ print ' Trace::localWriter.beginLeave(__call);'
+ print ' Trace::localWriter.endLeave();'
buffer_targets = [
'ARRAY_BUFFER',
def wrap_ret(self, function, instance):
Tracer.wrap_ret(self, function, instance)
+
if function.name in ('glMapBuffer', 'glMapBufferARB'):
print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
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)
print ' }'
print ' GLint __unpack_buffer = 0;'
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)
print ' }'
# 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)
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)
# This means that the implementations of these functions do not always
# alias, and they need to be considered independently.
#
- for suffix in ['', 'ARB']:
+ print ' vertex_attrib __vertex_attrib = __get_vertex_attrib();'
+ print
+ for suffix in ['', 'ARB', 'NV']:
+ if suffix:
+ SUFFIX = '_' + suffix
+ else:
+ SUFFIX = suffix
function_name = 'glVertexAttribPointer' + suffix
print ' // %s' % function_name
- print ' if (__glVertexAttribPointer%s_ptr &&' % suffix
- print ' (__glVertexAttribPointer%s_ptr != __glVertexAttribPointer_ptr)) {' % suffix
- print ' GLint __max_vertex_attribs = 0;'
- print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
+ print ' if (__vertex_attrib == VERTEX_ATTRIB%s) {' % SUFFIX
+ if suffix == 'NV':
+ print ' GLint __max_vertex_attribs = 16;'
+ else:
+ print ' GLint __max_vertex_attribs = 0;'
+ print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
print ' GLint __enabled = 0;'
- print ' __glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);' % suffix
+ if suffix == 'NV':
+ print ' __glGetIntegerv(GL_VERTEX_ATTRIB_ARRAY0_NV + index, &__enabled);'
+ else:
+ print ' __glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED%s, &__enabled);' % (suffix, SUFFIX)
print ' if (__enabled) {'
print ' GLint __binding = 0;'
- print ' __glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);' % suffix
+ if suffix != 'NV':
+ # It doesn't seem possible to use VBOs with NV_vertex_program.
+ 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:]:
- arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s' % (arg.name.upper(),)
- arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False).visit(arg.type)
+ if suffix == 'NV':
+ arg_get_enum = 'GL_ATTRIB_ARRAY_%s%s' % (arg.name.upper(), SUFFIX)
+ else:
+ arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s%s' % (arg.name.upper(), SUFFIX)
+ arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False, suffix).visit(arg.type)
print ' %s %s = 0;' % (arg_type, arg.name)
print ' __%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
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)
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 ' }'
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,)
+ print ' Trace::localWriter.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.endArg();'
+ print ' Trace::localWriter.endEnter();'
+ print ' Trace::localWriter.beginLeave(__fake_call);'
+ print ' Trace::localWriter.endLeave();'
projects / apitrace / blobdiff