X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=gltrace.py;h=f935e29913b6b1b8a64ea516dfec267011cff96c;hb=851d0b0452234ace66a511327bd8e6f9d68fe9e9;hp=78cc14ce60d974fe964be2feca639ada4e01ca98;hpb=eced747755020ebce502ba33555acb88e382aed8;p=apitrace diff --git a/gltrace.py b/gltrace.py index 78cc14c..f935e29 100644 --- a/gltrace.py +++ b/gltrace.py @@ -37,9 +37,10 @@ from trace import Tracer, dump_instance 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) @@ -47,27 +48,37 @@ class TypeGetter(stdapi.Visitor): 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) @@ -76,7 +87,7 @@ class TypeGetter(stdapi.Visitor): 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): @@ -96,9 +107,40 @@ 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 '{' @@ -124,16 +166,48 @@ class GlTracer(Tracer): 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 ' }' @@ -164,7 +238,7 @@ class GlTracer(Tracer): print ' case GL_%s:' % target print ' return & __%s_mapping;' % target.lower() print ' default:' - print ' OS::DebugMessage("warning: unknown buffer target 0x%04X\\n", target);' + print ' OS::DebugMessage("apitrace: warning: unknown buffer target 0x%04X\\n", target);' print ' return NULL;' print ' }' print '}' @@ -211,7 +285,7 @@ class GlTracer(Tracer): print ' return num_compressed_texture_formats;' print ' }' print ' default:' - print r' OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);' + print r' OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);' print ' return 1;' print ' }' print '}' @@ -300,6 +374,10 @@ class GlTracer(Tracer): 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 @@ -334,13 +412,13 @@ class GlTracer(Tracer): # 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;' @@ -416,27 +494,53 @@ class GlTracer(Tracer): 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', @@ -447,6 +551,7 @@ class GlTracer(Tracer): 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);' @@ -475,27 +580,88 @@ class GlTracer(Tracer): def gl_boolean(self, value): return self.boolean_names[int(bool(value))] + # Names of the functions that unpack from a pixel buffer object. See the + # ARB_pixel_buffer_object specification. + unpack_function_names = set([ + 'glBitmap', + 'glColorSubTable', + 'glColorTable', + 'glCompressedTexImage1D', + 'glCompressedTexImage2D', + 'glCompressedTexImage3D', + 'glCompressedTexSubImage1D', + 'glCompressedTexSubImage2D', + 'glCompressedTexSubImage3D', + 'glConvolutionFilter1D', + 'glConvolutionFilter2D', + 'glDrawPixels', + 'glMultiTexImage1DEXT', + 'glMultiTexImage2DEXT', + 'glMultiTexImage3DEXT', + 'glMultiTexSubImage1DEXT', + 'glMultiTexSubImage2DEXT', + 'glMultiTexSubImage3DEXT', + 'glPixelMapfv', + 'glPixelMapuiv', + 'glPixelMapusv', + 'glPolygonStipple', + 'glSeparableFilter2D', + 'glTexImage1D', + 'glTexImage1DEXT', + 'glTexImage2D', + 'glTexImage2DEXT', + 'glTexImage3D', + 'glTexImage3DEXT', + 'glTexSubImage1D', + 'glTexSubImage1DEXT', + 'glTexSubImage2D', + 'glTexSubImage2DEXT', + 'glTexSubImage3D', + 'glTexSubImage3DEXT', + 'glTextureImage1DEXT', + 'glTextureImage2DEXT', + 'glTextureImage3DEXT', + 'glTextureSubImage1DEXT', + 'glTextureSubImage2DEXT', + 'glTextureSubImage3DEXT', + ]) + def dump_arg_instance(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): - Tracer.dump_arg_instance(self, function, arg) - 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((const void *)%s, 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((const void *)%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 ' }' return + # Recognize offsets instead of blobs when a PBO is bound + if function.name in self.unpack_function_names \ + and (isinstance(arg.type, stdapi.Blob) \ + or (isinstance(arg.type, stdapi.Const) \ + and isinstance(arg.type.type, stdapi.Blob))): + print ' {' + print ' GLint __unpack_buffer = 0;' + print ' __glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &__unpack_buffer);' + print ' if (__unpack_buffer) {' + print ' Trace::localWriter.writeOpaque(%s);' % arg.name + print ' } else {' + Tracer.dump_arg_instance(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') \ @@ -547,67 +713,97 @@ class GlTracer(Tracer): # 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) self.array_trace_epilog(api, uppercase_name) print - # Samething, but for glVertexAttribPointer - 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) {' - - function = api.get_function_by_name('glVertexAttribPointer') - - # 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) - print ' %s %s = 0;' % (arg_type, arg.name) - print ' __%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name) - - arg_names = ', '.join([arg.name for arg in function.args[1:-1]]) - 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,) - for arg in function.args: - assert not arg.output - print ' __writer.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 ' __writer.endEnter();' - print ' __writer.beginLeave(__call);' - print ' __writer.endLeave();' - print ' }' - print ' }' - print ' }' + # Samething, but for glVertexAttribPointer* + # + # Some variants of glVertexAttribPointer alias conventional and generic attributes: + # - glVertexAttribPointer: no + # - glVertexAttribPointerARB: implementation dependent + # - glVertexAttribPointerNV: yes + # + # This means that the implementations of these functions do not always + # alias, and they need to be considered independently. + # + 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 (__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;' + 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;' + 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:]: + 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) + + arg_names = ', '.join([arg.name for arg in function.args[1:-1]]) + print ' size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names) + + # Emit a fake function + print ' unsigned __call = Trace::localWriter.beginEnter(&__%s_sig);' % (function.name,) + for arg in function.args: + assert not arg.output + print ' Trace::localWriter.beginArg(%u);' % (arg.index,) + if arg.name != 'pointer': + dump_instance(arg.type, arg.name) + else: + print ' Trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name) + print ' Trace::localWriter.endArg();' + + print ' Trace::localWriter.endEnter();' + print ' Trace::localWriter.beginLeave(__call);' + print ' Trace::localWriter.endLeave();' + print ' }' + print ' }' + print ' }' + print ' }' + print print '}' print @@ -658,15 +854,15 @@ class GlTracer(Tracer): 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();'