1 ##########################################################################
3 # Copyright 2008-2010 VMware, Inc.
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:
13 # The above copyright notice and this permission notice shall be included in
14 # all copies or substantial portions of the Software.
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
24 ##########################################################################/
27 """GL tracing generator."""
32 from glxapi import glxapi
33 from trace import Tracer, dump_instance
36 class TypeGetter(stdapi.Visitor):
37 '''Determine which glGet*v function that matches the specified type.'''
39 def __init__(self, prefix = 'glGet', long_suffix = True):
41 self.long_suffix = long_suffix
43 def visit_const(self, const):
44 return self.visit(const.type)
46 def visit_alias(self, alias):
47 if alias.expr == 'GLboolean':
49 return self.prefix + 'Booleanv', alias.expr
51 return self.prefix + 'iv', 'GLint'
52 elif alias.expr == 'GLdouble':
54 return self.prefix + 'Doublev', alias.expr
56 return self.prefix + 'dv', alias.expr
57 elif alias.expr == 'GLfloat':
59 return self.prefix + 'Floatv', alias.expr
61 return self.prefix + 'fv', alias.expr
62 elif alias.expr in ('GLint', 'GLuint', 'GLsizei'):
64 return self.prefix + 'Integerv', 'GLint'
66 return self.prefix + 'iv', 'GLint'
71 def visit_enum(self, enum):
72 return self.visit(glapi.GLint)
74 def visit_bitmask(self, bitmask):
75 return self.visit(glapi.GLint)
77 def visit_opaque(self, pointer):
78 return self.prefix + 'Pointerv', 'GLvoid *'
81 class GlTracer(Tracer):
83 def header(self, api):
84 Tracer.header(self, api)
85 self.state_tracker_decl(api)
87 def footer(self, api):
88 Tracer.footer(self, api)
89 self.state_tracker_impl(api)
96 ("TexCoord", "TEXTURE_COORD"),
97 ("EdgeFlag", "EDGE_FLAG"),
98 ("FogCoord", "FOG_COORD"),
99 ("SecondaryColor", "SECONDARY_COLOR"),
103 def state_tracker_decl(self, api):
104 print '// Whether user arrays were used'
105 print 'static bool __user_arrays = false;'
107 # Whether we need user arrays
108 print 'static inline bool __need_user_arrays(void)'
110 print ' if (!__user_arrays) {'
111 print ' return false;'
115 for camelcase_name, uppercase_name in self.arrays:
116 function_name = 'gl%sPointer' % camelcase_name
117 enable_name = 'GL_%s_ARRAY' % uppercase_name
118 binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
119 print ' // %s' % function_name
120 self.array_prolog(api, uppercase_name)
121 print ' if (__glIsEnabled(%s)) {' % enable_name
122 print ' GLint __binding = 0;'
123 print ' __glGetIntegerv(%s, &__binding);' % binding_name
124 print ' if (!__binding) {'
125 self.array_cleanup(api, uppercase_name)
126 print ' return true;'
129 self.array_epilog(api, uppercase_name)
132 print ' // glVertexAttribPointer'
133 print ' GLint __max_vertex_attribs = 0;'
134 print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
135 print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
136 print ' GLint __enabled = 0;'
137 print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
138 print ' if (__enabled) {'
139 print ' GLint __binding = 0;'
140 print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
141 print ' if (!__binding) {'
142 print ' return true;'
148 print ' return false;'
152 print 'static void __trace_user_arrays(GLuint maxindex);'
155 print 'struct buffer_mapping {'
157 print ' GLint length;'
161 for target in self.buffer_targets:
162 print 'struct buffer_mapping __%s_mapping;' % target.lower();
164 print 'static inline struct buffer_mapping *'
165 print 'get_buffer_mapping(GLenum target) {'
166 print ' switch(target) {'
167 for target in self.buffer_targets:
168 print ' case GL_%s:' % target
169 print ' return & __%s_mapping;' % target.lower()
171 print ' OS::DebugMessage("warning: unknown buffer target 0x%04X\\n", target);'
172 print ' return NULL;'
177 # Generate memcpy's signature
178 self.trace_function_decl(glapi.memcpy)
180 array_pointer_function_names = set((
188 "glSecondaryColorPointer",
190 #"glVertexPointerEXT",
191 #"glNormalPointerEXT",
192 #"glColorPointerEXT",
193 #"glIndexPointerEXT",
194 #"glTexCoordPointerEXT",
195 #"glEdgeFlagPointerEXT",
196 #"glFogCoordPointerEXT",
197 #"glSecondaryColorPointerEXT",
199 "glVertexAttribPointer",
200 "glVertexAttribPointerARB",
201 "glVertexAttribPointerNV",
202 "glVertexAttribLPointer",
203 "glVertexAttribLPointerEXT",
205 #"glMatrixIndexPointerARB",
208 draw_function_names = set((
211 'glDrawRangeElements',
214 interleaved_formats = [
227 'GL_T2F_C4F_N3F_V3F',
228 'GL_T4F_C4F_N3F_V4F',
231 def trace_function_impl_body(self, function):
232 # Defer tracing of user array pointers...
233 if function.name in self.array_pointer_function_names:
234 print ' GLint __array_buffer = 0;'
235 print ' __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
236 print ' if (!__array_buffer) {'
237 print ' __user_arrays = true;'
238 self.dispatch_function(function)
242 # ... to the draw calls
243 if function.name in self.draw_function_names:
244 print ' if (__need_user_arrays()) {'
245 arg_names = ', '.join([arg.name for arg in function.args[1:]])
246 print ' GLuint maxindex = __%s_maxindex(%s);' % (function.name, arg_names)
247 print ' __trace_user_arrays(maxindex);'
250 # And also break down glInterleavedArrays into the individual calls
251 if function.name == 'glInterleavedArrays':
252 print ' GLint __array_buffer = 0;'
253 print ' __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
254 print ' if (!__array_buffer) {'
255 print ' __user_arrays = true;'
256 self.dispatch_function(function)
259 # Initialize the enable flags
260 for camelcase_name, uppercase_name in self.arrays:
261 flag_name = '__' + uppercase_name.lower()
262 print ' GLboolean %s = GL_FALSE;' % flag_name
265 # Swicth for the interleaved formats
266 print ' switch (format) {'
267 for format in self.interleaved_formats:
268 print ' case %s:' % format
269 for camelcase_name, uppercase_name in self.arrays:
270 flag_name = '__' + uppercase_name.lower()
271 if format.find('_' + uppercase_name[0]) >= 0:
272 print ' %s = GL_TRUE;' % flag_name
279 # Emit fake glEnableClientState/glDisableClientState flags
280 for camelcase_name, uppercase_name in self.arrays:
281 flag_name = '__' + uppercase_name.lower()
282 enable_name = 'GL_%s_ARRAY' % uppercase_name
284 # Emit a fake function
286 print ' static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
287 print ' unsigned __call = Trace::BeginEnter(__sig);'
288 print ' Trace::BeginArg(0);'
289 dump_instance(glapi.GLenum, enable_name)
290 print ' Trace::EndArg();'
291 print ' Trace::EndEnter();'
292 print ' Trace::BeginLeave(__call);'
293 print ' Trace::EndLeave();'
299 # Emit a fake memcpy on
300 if function.name in ('glUnmapBuffer', 'glUnmapBufferARB'):
301 print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
302 print ' if (mapping && mapping->write) {'
303 print ' unsigned __call = Trace::BeginEnter(__memcpy_sig);'
304 print ' Trace::BeginArg(0);'
305 print ' Trace::LiteralOpaque(mapping->map);'
306 print ' Trace::EndArg();'
307 print ' Trace::BeginArg(1);'
308 print ' Trace::LiteralBlob(mapping->map, mapping->length);'
309 print ' Trace::EndArg();'
310 print ' Trace::BeginArg(2);'
311 print ' Trace::LiteralUInt(mapping->length);'
312 print ' Trace::EndArg();'
313 print ' Trace::EndEnter();'
314 print ' Trace::BeginLeave(__call);'
315 print ' Trace::EndLeave();'
318 Tracer.trace_function_impl_body(self, function)
322 'ELEMENT_ARRAY_BUFFER',
324 'PIXEL_UNPACK_BUFFER',
327 def wrap_ret(self, function, instance):
328 Tracer.wrap_ret(self, function, instance)
330 if function.name in ('glMapBuffer', 'glMapBufferARB'):
331 print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
332 print ' if (mapping) {'
333 print ' mapping->map = %s;' % (instance)
334 print ' mapping->length = 0;'
335 print ' __glGetBufferParameteriv(target, GL_BUFFER_SIZE, &mapping->length);'
336 print ' mapping->write = (access != GL_READ_ONLY);'
339 if function.name == 'glMapBufferRange':
340 print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
341 print ' if (mapping) {'
342 print ' mapping->map = %s;' % (instance)
343 print ' mapping->length = length;'
344 print ' mapping->write = access & GL_MAP_WRITE_BIT;'
352 def gl_boolean(self, value):
353 return self.boolean_names[int(bool(value))]
355 def dump_arg_instance(self, function, arg):
356 if function.name in self.draw_function_names and arg.name == 'indices':
357 print ' GLint __element_array_buffer = 0;'
358 print ' __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
359 print ' if (!__element_array_buffer) {'
360 print ' Trace::LiteralBlob((const void *)%s, count*__gl_type_size(type));' % (arg.name)
362 print ' Trace::LiteralOpaque((const void *)%s);' % (arg.name)
366 Tracer.dump_arg_instance(self, function, arg)
368 def state_tracker_impl(self, api):
369 # A simple state tracker to track the pointer values
372 print 'static void __trace_user_arrays(GLuint maxindex)'
375 for camelcase_name, uppercase_name in self.arrays:
376 function_name = 'gl%sPointer' % camelcase_name
377 enable_name = 'GL_%s_ARRAY' % uppercase_name
378 binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
379 function = api.get_function_by_name(function_name)
381 print ' // %s' % function.name
382 self.array_trace_prolog(api, uppercase_name)
383 self.array_prolog(api, uppercase_name)
384 print ' if (__glIsEnabled(%s)) {' % enable_name
385 print ' GLint __binding = 0;'
386 print ' __glGetIntegerv(%s, &__binding);' % binding_name
387 print ' if (!__binding) {'
389 # Get the arguments via glGet*
390 for arg in function.args:
391 arg_get_enum = 'GL_%s_ARRAY_%s' % (uppercase_name, arg.name.upper())
392 arg_get_function, arg_type = TypeGetter().visit(arg.type)
393 print ' %s %s = 0;' % (arg_type, arg.name)
394 print ' __%s(%s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
396 arg_names = ', '.join([arg.name for arg in function.args[:-1]])
397 print ' size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
399 # Emit a fake function
400 self.array_trace_intermezzo(api, uppercase_name)
401 print ' unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
402 for arg in function.args:
403 assert not arg.output
404 print ' Trace::BeginArg(%u);' % (arg.index,)
405 if arg.name != 'pointer':
406 dump_instance(arg.type, arg.name)
408 print ' Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
409 print ' Trace::EndArg();'
411 print ' Trace::EndEnter();'
412 print ' Trace::BeginLeave(__call);'
413 print ' Trace::EndLeave();'
416 self.array_epilog(api, uppercase_name)
417 self.array_trace_epilog(api, uppercase_name)
420 # Samething, but for glVertexAttribPointer
421 print ' // glVertexAttribPointer'
422 print ' GLint __max_vertex_attribs = 0;'
423 print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
424 print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
425 print ' GLint __enabled = 0;'
426 print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
427 print ' if (__enabled) {'
428 print ' GLint __binding = 0;'
429 print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
430 print ' if (!__binding) {'
432 function = api.get_function_by_name('glVertexAttribPointer')
434 # Get the arguments via glGet*
435 for arg in function.args[1:]:
436 arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s' % (arg.name.upper(),)
437 arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False).visit(arg.type)
438 print ' %s %s = 0;' % (arg_type, arg.name)
439 print ' __%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
441 arg_names = ', '.join([arg.name for arg in function.args[1:-1]])
442 print ' size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
444 # Emit a fake function
445 print ' unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
446 for arg in function.args:
447 assert not arg.output
448 print ' Trace::BeginArg(%u);' % (arg.index,)
449 if arg.name != 'pointer':
450 dump_instance(arg.type, arg.name)
452 print ' Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
453 print ' Trace::EndArg();'
455 print ' Trace::EndEnter();'
456 print ' Trace::BeginLeave(__call);'
457 print ' Trace::EndLeave();'
467 # Hooks for glTexCoordPointer, which is identical to the other array
468 # pointers except the fact that it is indexed by glClientActiveTexture.
471 def array_prolog(self, api, uppercase_name):
472 if uppercase_name == 'TEXTURE_COORD':
473 print ' GLint client_active_texture = 0;'
474 print ' __glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &client_active_texture);'
475 print ' GLint max_texture_coords = 0;'
476 print ' __glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);'
477 print ' for (GLint unit = 0; unit < max_texture_coords; ++unit) {'
478 print ' GLenum texture = GL_TEXTURE0 + unit;'
479 print ' __glClientActiveTexture(texture);'
481 def array_trace_prolog(self, api, uppercase_name):
482 if uppercase_name == 'TEXTURE_COORD':
483 print ' bool client_active_texture_dirty = false;'
485 def array_epilog(self, api, uppercase_name):
486 if uppercase_name == 'TEXTURE_COORD':
488 self.array_cleanup(api, uppercase_name)
490 def array_cleanup(self, api, uppercase_name):
491 if uppercase_name == 'TEXTURE_COORD':
492 print ' __glClientActiveTexture(client_active_texture);'
494 def array_trace_intermezzo(self, api, uppercase_name):
495 if uppercase_name == 'TEXTURE_COORD':
496 print ' if (texture != client_active_texture || client_active_texture_dirty) {'
497 print ' client_active_texture_dirty = true;'
498 self.fake_glClientActiveTexture_call(api, "texture");
501 def array_trace_epilog(self, api, uppercase_name):
502 if uppercase_name == 'TEXTURE_COORD':
503 print ' if (client_active_texture_dirty) {'
504 self.fake_glClientActiveTexture_call(api, "client_active_texture");
507 def fake_glClientActiveTexture_call(self, api, texture):
508 function = api.get_function_by_name('glClientActiveTexture')
509 self.fake_call(function, [texture])
511 def fake_call(self, function, args):
512 print ' unsigned __fake_call = Trace::BeginEnter(__%s_sig);' % (function.name,)
513 for arg, instance in zip(function.args, args):
514 assert not arg.output
515 print ' Trace::BeginArg(%u);' % (arg.index,)
516 dump_instance(arg.type, instance)
517 print ' Trace::EndArg();'
518 print ' Trace::EndEnter();'
519 print ' Trace::BeginLeave(__fake_call);'
520 print ' Trace::EndLeave();'