git.cworth.org Git - apitrace/blob - gltrace.py

   1 ##########################################################################
   2 #
   3 # Copyright 2008-2010 VMware, Inc.
   4 # All Rights Reserved.
   5 #
   6 # Permission is hereby granted, free of charge, to any person obtaining a copy
   7 # of this software and associated documentation files (the "Software"), to deal
   8 # in the Software without restriction, including without limitation the rights
   9 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 # copies of the Software, and to permit persons to whom the Software is
  11 # furnished to do so, subject to the following conditions:
  12 #
  13 # The above copyright notice and this permission notice shall be included in
  14 # all copies or substantial portions of the Software.
  15 #
  16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22 # THE SOFTWARE.
  23 #
  24 ##########################################################################/
  25
  26
  27 """GL tracing generator."""
  28
  29
  30 import stdapi
  31 import glapi
  32 from glxapi import glxapi
  33 from trace import Tracer, dump_instance
  34
  35
  36 class TypeGetter(stdapi.Visitor):
  37     '''Determine which glGet*v function that matches the specified type.'''
  38
  39     def __init__(self, prefix = 'glGet', long_suffix = True):
  40         self.prefix = prefix
  41         self.long_suffix = long_suffix
  42
  43     def visit_const(self, const):
  44         return self.visit(const.type)
  45
  46     def visit_alias(self, alias):
  47         if alias.expr == 'GLboolean':
  48             if self.long_suffix:
  49                 return self.prefix + 'Booleanv', alias.expr
  50             else:
  51                 return self.prefix + 'iv', 'GLint'
  52         elif alias.expr == 'GLdouble':
  53             if self.long_suffix:
  54                 return self.prefix + 'Doublev', alias.expr
  55             else:
  56                 return self.prefix + 'dv', alias.expr
  57         elif alias.expr == 'GLfloat':
  58             if self.long_suffix:
  59                 return self.prefix + 'Floatv', alias.expr
  60             else:
  61                 return self.prefix + 'fv', alias.expr
  62         elif alias.expr in ('GLint', 'GLuint', 'GLsizei'):
  63             if self.long_suffix:
  64                 return self.prefix + 'Integerv', 'GLint'
  65             else:
  66                 return self.prefix + 'iv', 'GLint'
  67         else:
  68             print alias.expr
  69             assert False
  70
  71     def visit_enum(self, enum):
  72         return self.visit(glapi.GLint)
  73
  74     def visit_bitmask(self, bitmask):
  75         return self.visit(glapi.GLint)
  76
  77     def visit_opaque(self, pointer):
  78         return self.prefix + 'Pointerv', 'GLvoid *'
  79
  80
  81 class GlTracer(Tracer):
  82
  83     def header(self, api):
  84         Tracer.header(self, api)
  85         self.state_tracker_decl(api)
  86
  87     def footer(self, api):
  88         Tracer.footer(self, api)
  89         self.state_tracker_impl(api)
  90
  91     arrays = [
  92         ("Vertex", "VERTEX"),
  93         ("Normal", "NORMAL"),
  94         ("Color", "COLOR"),
  95         ("Index", "INDEX"),
  96         ("TexCoord", "TEXTURE_COORD"),
  97         ("EdgeFlag", "EDGE_FLAG"),
  98         ("FogCoord", "FOG_COORD"),
  99         ("SecondaryColor", "SECONDARY_COLOR"),
 100     ]
 101     arrays.reverse()
 102
 103     def state_tracker_decl(self, api):
 104         # Whether we need user arrays
 105         print 'static inline bool __need_user_arrays(void)'
 106         print '{'
 107
 108         for camelcase_name, uppercase_name in self.arrays:
 109             function_name = 'gl%sPointer' % camelcase_name
 110             enable_name = 'GL_%s_ARRAY' % uppercase_name
 111             binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
 112             print '    // %s' % function_name
 113             print '    if (__glIsEnabled(%s)) {' % enable_name
 114             print '        GLint __binding = 0;'
 115             print '        __glGetIntegerv(%s, &__binding);' % binding_name
 116             print '        if (!__binding) {'
 117             print '            return true;'
 118             print '        }'
 119             print '    }'
 120             print
 121
 122         print '    // glVertexAttribPointer'
 123         print '    GLint __max_vertex_attribs;'
 124         print '    __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
 125         print '    for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
 126         print '        GLint __enabled = 0;'
 127         print '        __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
 128         print '        if (__enabled) {'
 129         print '            GLint __binding = 0;'
 130         print '            __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
 131         print '            if (!__binding) {'
 132         print '                return true;'
 133         print '            }'
 134         print '        }'
 135         print '    }'
 136         print
 137
 138         print '    return false;'
 139         print '}'
 140         print
 141
 142         print 'static void __trace_user_arrays(GLuint maxindex);'
 143         print
 144
 145     array_pointer_function_names = set((
 146         "glVertexPointer",
 147         "glNormalPointer",
 148         "glColorPointer",
 149         "glIndexPointer",
 150         "glTexCoordPointer",
 151         "glEdgeFlagPointer",
 152         "glFogCoordPointer",
 153         "glSecondaryColorPointer",
 154
 155         #"glVertexPointerEXT",
 156         #"glNormalPointerEXT",
 157         #"glColorPointerEXT",
 158         #"glIndexPointerEXT",
 159         #"glTexCoordPointerEXT",
 160         #"glEdgeFlagPointerEXT",
 161         #"glFogCoordPointerEXT",
 162         #"glSecondaryColorPointerEXT",
 163
 164         "glVertexAttribPointer",
 165         "glVertexAttribPointerARB",
 166         "glVertexAttribPointerNV",
 167         "glVertexAttribLPointer",
 168         "glVertexAttribLPointerEXT",
 169
 170         #"glMatrixIndexPointerARB",
 171     ))
 172
 173     draw_function_names = set((
 174         'glDrawArrays',
 175         'glDrawElements',
 176         'glDrawRangeElements',
 177     ))
 178
 179     interleaved_formats = [
 180          'GL_V2F',
 181          'GL_V3F',
 182          'GL_C4UB_V2F',
 183          'GL_C4UB_V3F',
 184          'GL_C3F_V3F',
 185          'GL_N3F_V3F',
 186          'GL_C4F_N3F_V3F',
 187          'GL_T2F_V3F',
 188          'GL_T4F_V4F',
 189          'GL_T2F_C4UB_V3F',
 190          'GL_T2F_C3F_V3F',
 191          'GL_T2F_N3F_V3F',
 192          'GL_T2F_C4F_N3F_V3F',
 193          'GL_T4F_C4F_N3F_V4F',
 194     ]
 195
 196     def trace_function_impl_body(self, function):
 197         # Defer tracing of user array pointers...
 198         if function.name in self.array_pointer_function_names:
 199             print '    GLint __array_buffer = 0;'
 200             print '    __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
 201             print '    if (!__array_buffer) {'
 202             self.dispatch_function(function)
 203             print '        return;'
 204             print '    }'
 205
 206         # ... to the draw calls
 207         if function.name in self.draw_function_names:
 208             print '    if (__need_user_arrays()) {'
 209             arg_names = ', '.join([arg.name for arg in function.args[1:]])
 210             print '        GLuint maxindex = __%s_maxindex(%s);' % (function.name, arg_names)
 211             print '        __trace_user_arrays(maxindex);'
 212             print '    }'
 213
 214         # And also break down glInterleavedArrays into the individual calls
 215         if function.name == 'glInterleavedArrays':
 216             print '    GLint __array_buffer = 0;'
 217             print '    __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
 218             print '    if (!__array_buffer) {'
 219             self.dispatch_function(function)
 220             print
 221
 222             # Initialize the enable flags
 223             for camelcase_name, uppercase_name in self.arrays:
 224                 flag_name = '__' + uppercase_name.lower()
 225                 print '        GLboolean %s = GL_FALSE;' % flag_name
 226             print
 227
 228             # Swicth for the interleaved formats
 229             print '        switch (format) {'
 230             for format in self.interleaved_formats:
 231                 print '            case %s:' % format
 232                 for camelcase_name, uppercase_name in self.arrays:
 233                     flag_name = '__' + uppercase_name.lower()
 234                     if format.find('_' + uppercase_name[0]) >= 0:
 235                         print '                %s = GL_TRUE;' % flag_name
 236                 print '                break;'
 237             print '            default:'
 238             print '               return;'
 239             print '        }'
 240             print
 241
 242             # Emit fake glEnableClientState/glDisableClientState flags
 243             for camelcase_name, uppercase_name in self.arrays:
 244                 flag_name = '__' + uppercase_name.lower()
 245                 enable_name = 'GL_%s_ARRAY' % uppercase_name
 246
 247                 # Emit a fake function
 248                 print '        {'
 249                 print '            static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
 250                 print '            unsigned __call = Trace::BeginEnter(__sig);'
 251                 print '            Trace::BeginArg(0);'
 252                 dump_instance(glapi.GLenum, enable_name)
 253                 print '            Trace::EndArg();'
 254                 print '            Trace::EndEnter();'
 255                 print '            Trace::BeginLeave(__call);'
 256                 print '            Trace::EndLeave();'
 257                 print '        }'
 258
 259             print '        return;'
 260             print '    }'
 261
 262         Tracer.trace_function_impl_body(self, function)
 263
 264     boolean_names = [
 265         'GL_FALSE',
 266         'GL_TRUE',
 267     ]
 268
 269     def gl_boolean(self, value):
 270         return self.boolean_names[int(bool(value))]
 271
 272     def dump_arg_instance(self, function, arg):
 273         if function.name in self.draw_function_names and arg.name == 'indices':
 274             print '    GLint __element_array_buffer = 0;'
 275             print '    __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
 276             print '    if (!__element_array_buffer) {'
 277             print '        Trace::LiteralBlob((const void *)%s, count*__gl_type_size(type));' % (arg.name)
 278             print '    } else {'
 279             print '        Trace::LiteralOpaque((const void *)%s);' % (arg.name)
 280             print '    }'
 281             return
 282
 283         Tracer.dump_arg_instance(self, function, arg)
 284
 285     def state_tracker_impl(self, api):
 286         # A simple state tracker to track the pointer values
 287
 288         # update the state
 289         print 'static void __trace_user_arrays(GLuint maxindex)'
 290         print '{'
 291
 292         for camelcase_name, uppercase_name in self.arrays:
 293             function_name = 'gl%sPointer' % camelcase_name
 294             enable_name = 'GL_%s_ARRAY' % uppercase_name
 295             binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
 296             function = api.get_function_by_name(function_name)
 297
 298             print '    // %s' % function.name
 299             print '    if (__glIsEnabled(%s)) {;' % enable_name
 300             print '        GLint __binding = 0;'
 301             print '        __glGetIntegerv(%s, &__binding);' % binding_name
 302             print '        if (!__binding) {'
 303
 304             # Get the arguments via glGet*
 305             for arg in function.args:
 306                 arg_get_enum = 'GL_%s_ARRAY_%s' % (uppercase_name, arg.name.upper())
 307                 arg_get_function, arg_type = TypeGetter().visit(arg.type)
 308                 print '            %s %s = 0;' % (arg_type, arg.name)
 309                 print '            __%s(%s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
 310
 311             arg_names = ', '.join([arg.name for arg in function.args[:-1]])
 312             print '            size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
 313
 314             # Emit a fake function
 315             print '            unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 316             for arg in function.args:
 317                 assert not arg.output
 318                 print '            Trace::BeginArg(%u);' % (arg.index,)
 319                 if arg.name != 'pointer':
 320                     dump_instance(arg.type, arg.name)
 321                 else:
 322                     print '            Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
 323                 print '            Trace::EndArg();'
 324
 325             print '            Trace::EndEnter();'
 326             print '            Trace::BeginLeave(__call);'
 327             print '            Trace::EndLeave();'
 328             print '        }'
 329             print '    }'
 330             print
 331
 332         # Samething, but for glVertexAttribPointer
 333         print '    // glVertexAttribPointer'
 334         print '    GLint __max_vertex_attribs;'
 335         print '    __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
 336         print '    for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
 337         print '        GLint __enabled = 0;'
 338         print '        __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
 339         print '        if (__enabled) {'
 340         print '            GLint __binding = 0;'
 341         print '            __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
 342         print '            if (!__binding) {'
 343
 344         function = api.get_function_by_name('glVertexAttribPointer')
 345
 346         # Get the arguments via glGet*
 347         for arg in function.args[1:]:
 348             arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s' % (arg.name.upper(),)
 349             arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False).visit(arg.type)
 350             print '                %s %s = 0;' % (arg_type, arg.name)
 351             print '                __%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
 352
 353         arg_names = ', '.join([arg.name for arg in function.args[1:-1]])
 354         print '                size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
 355
 356         # Emit a fake function
 357         print '                unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 358         for arg in function.args:
 359             assert not arg.output
 360             print '                Trace::BeginArg(%u);' % (arg.index,)
 361             if arg.name != 'pointer':
 362                 dump_instance(arg.type, arg.name)
 363             else:
 364                 print '                Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
 365             print '                Trace::EndArg();'
 366
 367         print '                Trace::EndEnter();'
 368         print '                Trace::BeginLeave(__call);'
 369         print '                Trace::EndLeave();'
 370         print '            }'
 371         print '        }'
 372         print '    }'
 373         print
 374
 375         print '}'
 376         print
 377
 378
 379
 380
 381
 382
 383