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."""
33 from glxapi import glxapi
34 from trace import Tracer, dump_instance
37 class TypeGetter(stdapi.Visitor):
38 '''Determine which glGet*v function that matches the specified type.'''
40 def __init__(self, prefix = 'glGet', long_suffix = True, ext_suffix = ''):
42 self.long_suffix = long_suffix
43 self.ext_suffix = ext_suffix
45 def visit_const(self, const):
46 return self.visit(const.type)
48 def visit_alias(self, alias):
49 if alias.expr == 'GLboolean':
56 elif alias.expr == 'GLdouble':
63 elif alias.expr == 'GLfloat':
70 elif alias.expr in ('GLint', 'GLuint', 'GLsizei'):
80 function_name = self.prefix + suffix + self.ext_suffix
81 return function_name, arg_type
83 def visit_enum(self, enum):
84 return self.visit(glapi.GLint)
86 def visit_bitmask(self, bitmask):
87 return self.visit(glapi.GLint)
89 def visit_opaque(self, pointer):
90 return self.prefix + 'Pointerv' + self.ext_suffix, 'GLvoid *'
93 class GlTracer(Tracer):
100 ("TexCoord", "TEXTURE_COORD"),
101 ("EdgeFlag", "EDGE_FLAG"),
102 ("FogCoord", "FOG_COORD"),
103 ("SecondaryColor", "SECONDARY_COLOR"),
107 def header(self, api):
108 Tracer.header(self, api)
110 print '#include "gltrace.hpp"'
112 print '// Whether user arrays were used'
113 print 'static bool __user_arrays = false;'
114 print 'static bool __user_arrays_arb = false;'
115 print 'static bool __user_arrays_nv = false;'
118 # Which glVertexAttrib* variant to use
119 print 'enum vertex_attrib {'
120 print ' VERTEX_ATTRIB,'
121 print ' VERTEX_ATTRIB_ARB,'
122 print ' VERTEX_ATTRIB_NV,'
125 print 'static vertex_attrib __get_vertex_attrib(void) {'
126 print ' if (__user_arrays_arb || __user_arrays_nv) {'
127 print ' GLboolean __vertex_program = GL_FALSE;'
128 print ' __glGetBooleanv(GL_VERTEX_PROGRAM_ARB, &__vertex_program);'
129 print ' if (__vertex_program) {'
130 print ' if (__user_arrays_nv) {'
131 print ' GLint __vertex_program_binding_nv = 0;'
132 print ' __glGetIntegerv(GL_VERTEX_PROGRAM_BINDING_NV, &__vertex_program_binding_nv);'
133 print ' if (__vertex_program_binding_nv) {'
134 print ' return VERTEX_ATTRIB_NV;'
137 print ' return VERTEX_ATTRIB_ARB;'
140 print ' return VERTEX_ATTRIB;'
144 # Whether we need user arrays
145 print 'static inline bool __need_user_arrays(void)'
147 print ' if (!__user_arrays) {'
148 print ' return false;'
152 for camelcase_name, uppercase_name in self.arrays:
153 function_name = 'gl%sPointer' % camelcase_name
154 enable_name = 'GL_%s_ARRAY' % uppercase_name
155 binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
156 print ' // %s' % function_name
157 self.array_prolog(api, uppercase_name)
158 print ' if (__glIsEnabled(%s)) {' % enable_name
159 print ' GLint __binding = 0;'
160 print ' __glGetIntegerv(%s, &__binding);' % binding_name
161 print ' if (!__binding) {'
162 self.array_cleanup(api, uppercase_name)
163 print ' return true;'
166 self.array_epilog(api, uppercase_name)
169 print ' vertex_attrib __vertex_attrib = __get_vertex_attrib();'
171 print ' // glVertexAttribPointer'
172 print ' if (__vertex_attrib == VERTEX_ATTRIB) {'
173 print ' GLint __max_vertex_attribs = 0;'
174 print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
175 print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
176 print ' GLint __enabled = 0;'
177 print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
178 print ' if (__enabled) {'
179 print ' GLint __binding = 0;'
180 print ' __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
181 print ' if (!__binding) {'
182 print ' return true;'
188 print ' // glVertexAttribPointerARB'
189 print ' if (__vertex_attrib == VERTEX_ATTRIB_ARB) {'
190 print ' GLint __max_vertex_attribs = 0;'
191 print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &__max_vertex_attribs);'
192 print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
193 print ' GLint __enabled = 0;'
194 print ' __glGetVertexAttribivARB(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, &__enabled);'
195 print ' if (__enabled) {'
196 print ' GLint __binding = 0;'
197 print ' __glGetVertexAttribivARB(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB, &__binding);'
198 print ' if (!__binding) {'
199 print ' return true;'
205 print ' // glVertexAttribPointerNV'
206 print ' if (__vertex_attrib == VERTEX_ATTRIB_NV) {'
207 print ' for (GLint index = 0; index < 16; ++index) {'
208 print ' GLint __enabled = 0;'
209 print ' __glGetIntegerv(GL_VERTEX_ATTRIB_ARRAY0_NV + index, &__enabled);'
210 print ' if (__enabled) {'
211 print ' return true;'
217 print ' return false;'
221 print 'static void __trace_user_arrays(GLuint maxindex);'
224 print 'struct buffer_mapping {'
226 print ' GLint length;'
228 print ' bool explicit_flush;'
231 for target in self.buffer_targets:
232 print 'struct buffer_mapping __%s_mapping;' % target.lower();
234 print 'static inline struct buffer_mapping *'
235 print 'get_buffer_mapping(GLenum target) {'
236 print ' switch(target) {'
237 for target in self.buffer_targets:
238 print ' case GL_%s:' % target
239 print ' return & __%s_mapping;' % target.lower()
241 print ' OS::DebugMessage("apitrace: warning: unknown buffer target 0x%04X\\n", target);'
242 print ' return NULL;'
247 # Generate memcpy's signature
248 self.trace_function_decl(glapi.memcpy)
250 # Generate a helper function to determine whether a parameter name
251 # refers to a symbolic value or not
253 print 'is_symbolic_pname(GLenum pname) {'
254 print ' switch(pname) {'
255 for function, type, count, name in glparams.parameters:
256 if type is glapi.GLenum:
257 print ' case %s:' % name
258 print ' return true;'
260 print ' return false;'
265 # Generate a helper function to determine whether a parameter value is
266 # potentially symbolic or not; i.e., if the value can be represented in
268 print 'template<class T>'
269 print 'static inline bool'
270 print 'is_symbolic_param(T param) {'
271 print ' return static_cast<T>(static_cast<GLenum>(param)) == param;'
275 # Generate a helper function to know how many elements a parameter has
276 print 'static size_t'
277 print '__gl_param_size(GLenum pname) {'
278 print ' switch(pname) {'
279 for function, type, count, name in glparams.parameters:
281 print ' case %s: return %u;' % (name, count)
282 print ' case GL_COMPRESSED_TEXTURE_FORMATS: {'
283 print ' GLint num_compressed_texture_formats = 0;'
284 print ' __glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &num_compressed_texture_formats);'
285 print ' return num_compressed_texture_formats;'
288 print r' OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);'
294 array_pointer_function_names = set((
302 "glSecondaryColorPointer",
304 "glInterleavedArrays",
306 "glVertexPointerEXT",
307 "glNormalPointerEXT",
310 "glTexCoordPointerEXT",
311 "glEdgeFlagPointerEXT",
312 "glFogCoordPointerEXT",
313 "glSecondaryColorPointerEXT",
315 "glVertexAttribPointer",
316 "glVertexAttribPointerARB",
317 "glVertexAttribPointerNV",
318 "glVertexAttribIPointer",
319 "glVertexAttribIPointerEXT",
320 "glVertexAttribLPointer",
321 "glVertexAttribLPointerEXT",
323 #"glMatrixIndexPointerARB",
326 draw_function_names = set((
329 'glDrawRangeElements',
331 'glMultiDrawElements',
332 'glDrawArraysInstanced',
333 'glDrawElementsInstanced',
334 'glDrawArraysInstancedARB',
335 'glDrawElementsInstancedARB',
336 'glDrawElementsBaseVertex',
337 'glDrawRangeElementsBaseVertex',
338 'glDrawElementsInstancedBaseVertex',
339 'glMultiDrawElementsBaseVertex',
340 'glDrawArraysIndirect',
341 'glDrawElementsIndirect',
343 'glDrawRangeElementsEXT',
344 'glDrawRangeElementsEXT_size',
345 'glMultiDrawArraysEXT',
346 'glMultiDrawElementsEXT',
347 'glMultiModeDrawArraysIBM',
348 'glMultiModeDrawElementsIBM',
349 'glDrawArraysInstancedEXT',
350 'glDrawElementsInstancedEXT',
353 interleaved_formats = [
366 'GL_T2F_C4F_N3F_V3F',
367 'GL_T4F_C4F_N3F_V4F',
370 def trace_function_impl_body(self, function):
371 # Defer tracing of user array pointers...
372 if function.name in self.array_pointer_function_names:
373 print ' GLint __array_buffer = 0;'
374 print ' __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
375 print ' if (!__array_buffer) {'
376 print ' __user_arrays = true;'
377 if function.name == "glVertexAttribPointerARB":
378 print ' __user_arrays_arb = true;'
379 if function.name == "glVertexAttribPointerNV":
380 print ' __user_arrays_nv = true;'
381 self.dispatch_function(function)
383 # And also break down glInterleavedArrays into the individual calls
384 if function.name == 'glInterleavedArrays':
387 # Initialize the enable flags
388 for camelcase_name, uppercase_name in self.arrays:
389 flag_name = '__' + uppercase_name.lower()
390 print ' GLboolean %s = GL_FALSE;' % flag_name
393 # Switch for the interleaved formats
394 print ' switch (format) {'
395 for format in self.interleaved_formats:
396 print ' case %s:' % format
397 for camelcase_name, uppercase_name in self.arrays:
398 flag_name = '__' + uppercase_name.lower()
399 if format.find('_' + uppercase_name[0]) >= 0:
400 print ' %s = GL_TRUE;' % flag_name
407 # Emit fake glEnableClientState/glDisableClientState flags
408 for camelcase_name, uppercase_name in self.arrays:
409 flag_name = '__' + uppercase_name.lower()
410 enable_name = 'GL_%s_ARRAY' % uppercase_name
412 # Emit a fake function
414 print ' static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
415 print ' unsigned __call = Trace::localWriter.beginEnter(&__sig);'
416 print ' Trace::localWriter.beginArg(0);'
417 dump_instance(glapi.GLenum, enable_name)
418 print ' Trace::localWriter.endArg();'
419 print ' Trace::localWriter.endEnter();'
420 print ' Trace::localWriter.beginLeave(__call);'
421 print ' Trace::localWriter.endLeave();'
427 # ... to the draw calls
428 if function.name in self.draw_function_names:
429 print ' if (__need_user_arrays()) {'
430 arg_names = ', '.join([arg.name for arg in function.args[1:]])
431 print ' GLuint maxindex = __%s_maxindex(%s);' % (function.name, arg_names)
432 print ' __trace_user_arrays(maxindex);'
435 # Emit a fake memcpy on buffer uploads
436 if function.name in ('glUnmapBuffer', 'glUnmapBufferARB', ):
437 print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
438 print ' if (mapping && mapping->write && !mapping->explicit_flush) {'
439 self.emit_memcpy('mapping->map', 'mapping->map', 'mapping->length')
441 if function.name in ('glFlushMappedBufferRange', 'glFlushMappedBufferRangeAPPLE'):
442 # TODO: avoid copying [0, offset] bytes
443 print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
444 print ' if (mapping) {'
445 if function.name.endswith('APPLE'):
446 print ' GLsizeiptr length = size;'
447 print ' mapping->explicit_flush = true;'
448 print ' //assert(offset + length <= mapping->length);'
449 self.emit_memcpy('mapping->map', 'mapping->map', 'offset + length')
451 # FIXME: glFlushMappedNamedBufferRangeEXT
453 # Don't leave vertex attrib locations to chance. Instead emit fake
454 # glBindAttribLocation calls to ensure that the same locations will be
455 # used when retracing. Trying to remap locations after the fact would
456 # be an herculian task given that vertex attrib locations appear in
457 # many entry-points, including non-shader related ones.
458 if function.name == 'glLinkProgram':
459 Tracer.dispatch_function(self, function)
460 print ' GLint active_attributes = 0;'
461 print ' __glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active_attributes);'
462 print ' for (GLuint attrib = 0; attrib < active_attributes; ++attrib) {'
463 print ' GLint size = 0;'
464 print ' GLenum type = 0;'
465 print ' GLchar name[256];'
466 # TODO: Use ACTIVE_ATTRIBUTE_MAX_LENGTH instead of 256
467 print ' __glGetActiveAttrib(program, attrib, sizeof name, NULL, &size, &type, name);'
468 print " if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {"
469 print ' GLint location = __glGetAttribLocation(program, name);'
470 print ' if (location >= 0) {'
471 bind_function = glapi.glapi.get_function_by_name('glBindAttribLocation')
472 self.fake_call(bind_function, ['program', 'location', 'name'])
476 if function.name == 'glLinkProgramARB':
477 Tracer.dispatch_function(self, function)
478 print ' GLint active_attributes = 0;'
479 print ' __glGetObjectParameterivARB(programObj, GL_OBJECT_ACTIVE_ATTRIBUTES_ARB, &active_attributes);'
480 print ' for (GLuint attrib = 0; attrib < active_attributes; ++attrib) {'
481 print ' GLint size = 0;'
482 print ' GLenum type = 0;'
483 print ' GLcharARB name[256];'
484 # TODO: Use ACTIVE_ATTRIBUTE_MAX_LENGTH instead of 256
485 print ' __glGetActiveAttribARB(programObj, attrib, sizeof name, NULL, &size, &type, name);'
486 print " if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {"
487 print ' GLint location = __glGetAttribLocationARB(programObj, name);'
488 print ' if (location >= 0) {'
489 bind_function = glapi.glapi.get_function_by_name('glBindAttribLocationARB')
490 self.fake_call(bind_function, ['programObj', 'location', 'name'])
495 Tracer.trace_function_impl_body(self, function)
497 gremedy_functions = [
498 'glStringMarkerGREMEDY',
499 'glFrameTerminatorGREMEDY',
502 def dispatch_function(self, function):
503 if function.name in ('glLinkProgram', 'glLinkProgramARB'):
504 # These functions have been dispatched already
507 # We implement the GREMEDY extensions, not the driver
508 if function.name in self.gremedy_functions:
511 if function.name in ('glXGetProcAddress', 'glXGetProcAddressARB', 'wglGetProcAddress'):
513 for gremedy_function in self.gremedy_functions:
514 print ' %s (strcmp("%s", (const char *)%s) == 0) {' % (if_, gremedy_function, function.args[0].name)
515 print ' __result = (%s)&%s;' % (function.type, gremedy_function)
519 Tracer.dispatch_function(self, function)
523 # Override GL extensions
524 if function.name in ('glGetString', 'glGetIntegerv', 'glGetStringi'):
525 Tracer.dispatch_function(self, function, prefix = 'gltrace::__', suffix = '_override')
528 Tracer.dispatch_function(self, function)
530 def emit_memcpy(self, dest, src, length):
531 print ' unsigned __call = Trace::localWriter.beginEnter(&__memcpy_sig);'
532 print ' Trace::localWriter.beginArg(0);'
533 print ' Trace::localWriter.writeOpaque(%s);' % dest
534 print ' Trace::localWriter.endArg();'
535 print ' Trace::localWriter.beginArg(1);'
536 print ' Trace::localWriter.writeBlob(%s, %s);' % (src, length)
537 print ' Trace::localWriter.endArg();'
538 print ' Trace::localWriter.beginArg(2);'
539 print ' Trace::localWriter.writeUInt(%s);' % length
540 print ' Trace::localWriter.endArg();'
541 print ' Trace::localWriter.endEnter();'
542 print ' Trace::localWriter.beginLeave(__call);'
543 print ' Trace::localWriter.endLeave();'
547 'ELEMENT_ARRAY_BUFFER',
549 'PIXEL_UNPACK_BUFFER',
552 def wrap_ret(self, function, instance):
553 Tracer.wrap_ret(self, function, instance)
556 if function.name in ('glMapBuffer', 'glMapBufferARB'):
557 print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
558 print ' if (mapping) {'
559 print ' mapping->map = %s;' % (instance)
560 print ' mapping->length = 0;'
561 print ' __glGetBufferParameteriv(target, GL_BUFFER_SIZE, &mapping->length);'
562 print ' mapping->write = (access != GL_READ_ONLY);'
563 print ' mapping->explicit_flush = false;'
566 if function.name == 'glMapBufferRange':
567 print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
568 print ' if (mapping) {'
569 print ' mapping->map = %s;' % (instance)
570 print ' mapping->length = length;'
571 print ' mapping->write = access & GL_MAP_WRITE_BIT;'
572 print ' mapping->explicit_flush = access & GL_MAP_FLUSH_EXPLICIT_BIT;'
580 def gl_boolean(self, value):
581 return self.boolean_names[int(bool(value))]
583 # Names of the functions that unpack from a pixel buffer object. See the
584 # ARB_pixel_buffer_object specification.
585 unpack_function_names = set([
589 'glCompressedTexImage1D',
590 'glCompressedTexImage2D',
591 'glCompressedTexImage3D',
592 'glCompressedTexSubImage1D',
593 'glCompressedTexSubImage2D',
594 'glCompressedTexSubImage3D',
595 'glConvolutionFilter1D',
596 'glConvolutionFilter2D',
598 'glMultiTexImage1DEXT',
599 'glMultiTexImage2DEXT',
600 'glMultiTexImage3DEXT',
601 'glMultiTexSubImage1DEXT',
602 'glMultiTexSubImage2DEXT',
603 'glMultiTexSubImage3DEXT',
608 'glSeparableFilter2D',
616 'glTexSubImage1DEXT',
618 'glTexSubImage2DEXT',
620 'glTexSubImage3DEXT',
621 'glTextureImage1DEXT',
622 'glTextureImage2DEXT',
623 'glTextureImage3DEXT',
624 'glTextureSubImage1DEXT',
625 'glTextureSubImage2DEXT',
626 'glTextureSubImage3DEXT',
629 def dump_arg_instance(self, function, arg):
630 if function.name in self.draw_function_names and arg.name == 'indices':
631 print ' GLint __element_array_buffer = 0;'
632 print ' __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
633 print ' if (!__element_array_buffer) {'
634 if isinstance(arg.type, stdapi.Array):
635 print ' Trace::localWriter.beginArray(%s);' % arg.type.length
636 print ' for(GLsizei i = 0; i < %s; ++i) {' % arg.type.length
637 print ' Trace::localWriter.beginElement();'
638 print ' Trace::localWriter.writeBlob(%s[i], count[i]*__gl_type_size(type));' % (arg.name)
639 print ' Trace::localWriter.endElement();'
641 print ' Trace::localWriter.endArray();'
643 print ' Trace::localWriter.writeBlob(%s, count*__gl_type_size(type));' % (arg.name)
645 Tracer.dump_arg_instance(self, function, arg)
649 # Recognize offsets instead of blobs when a PBO is bound
650 if function.name in self.unpack_function_names \
651 and (isinstance(arg.type, stdapi.Blob) \
652 or (isinstance(arg.type, stdapi.Const) \
653 and isinstance(arg.type.type, stdapi.Blob))):
655 print ' GLint __unpack_buffer = 0;'
656 print ' __glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &__unpack_buffer);'
657 print ' if (__unpack_buffer) {'
658 print ' Trace::localWriter.writeOpaque(%s);' % arg.name
660 Tracer.dump_arg_instance(self, function, arg)
665 # Several GL state functions take GLenum symbolic names as
666 # integer/floats; so dump the symbolic name whenever possible
667 if function.name.startswith('gl') \
668 and arg.type in (glapi.GLint, glapi.GLfloat) \
669 and arg.name == 'param':
671 assert function.args[arg.index - 1].name == 'pname'
672 assert function.args[arg.index - 1].type == glapi.GLenum
673 print ' if (is_symbolic_pname(pname) && is_symbolic_param(%s)) {' % arg.name
674 dump_instance(glapi.GLenum, arg.name)
676 Tracer.dump_arg_instance(self, function, arg)
680 Tracer.dump_arg_instance(self, function, arg)
682 def footer(self, api):
683 Tracer.footer(self, api)
685 # A simple state tracker to track the pointer values
687 print 'static void __trace_user_arrays(GLuint maxindex)'
690 for camelcase_name, uppercase_name in self.arrays:
691 function_name = 'gl%sPointer' % camelcase_name
692 enable_name = 'GL_%s_ARRAY' % uppercase_name
693 binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
694 function = api.get_function_by_name(function_name)
696 print ' // %s' % function.name
697 self.array_trace_prolog(api, uppercase_name)
698 self.array_prolog(api, uppercase_name)
699 print ' if (__glIsEnabled(%s)) {' % enable_name
700 print ' GLint __binding = 0;'
701 print ' __glGetIntegerv(%s, &__binding);' % binding_name
702 print ' if (!__binding) {'
704 # Get the arguments via glGet*
705 for arg in function.args:
706 arg_get_enum = 'GL_%s_ARRAY_%s' % (uppercase_name, arg.name.upper())
707 arg_get_function, arg_type = TypeGetter().visit(arg.type)
708 print ' %s %s = 0;' % (arg_type, arg.name)
709 print ' __%s(%s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
711 arg_names = ', '.join([arg.name for arg in function.args[:-1]])
712 print ' size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
714 # Emit a fake function
715 self.array_trace_intermezzo(api, uppercase_name)
716 print ' unsigned __call = Trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
717 for arg in function.args:
718 assert not arg.output
719 print ' Trace::localWriter.beginArg(%u);' % (arg.index,)
720 if arg.name != 'pointer':
721 dump_instance(arg.type, arg.name)
723 print ' Trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name)
724 print ' Trace::localWriter.endArg();'
726 print ' Trace::localWriter.endEnter();'
727 print ' Trace::localWriter.beginLeave(__call);'
728 print ' Trace::localWriter.endLeave();'
731 self.array_epilog(api, uppercase_name)
732 self.array_trace_epilog(api, uppercase_name)
735 # Samething, but for glVertexAttribPointer*
737 # Some variants of glVertexAttribPointer alias conventional and generic attributes:
738 # - glVertexAttribPointer: no
739 # - glVertexAttribPointerARB: implementation dependent
740 # - glVertexAttribPointerNV: yes
742 # This means that the implementations of these functions do not always
743 # alias, and they need to be considered independently.
745 print ' vertex_attrib __vertex_attrib = __get_vertex_attrib();'
747 for suffix in ['', 'ARB', 'NV']:
749 SUFFIX = '_' + suffix
752 function_name = 'glVertexAttribPointer' + suffix
753 print ' // %s' % function_name
754 print ' if (__vertex_attrib == VERTEX_ATTRIB%s) {' % SUFFIX
756 print ' GLint __max_vertex_attribs = 16;'
758 print ' GLint __max_vertex_attribs = 0;'
759 print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
760 print ' for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
761 print ' GLint __enabled = 0;'
763 print ' __glGetIntegerv(GL_VERTEX_ATTRIB_ARRAY0_NV + index, &__enabled);'
765 print ' __glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED%s, &__enabled);' % (suffix, SUFFIX)
766 print ' if (__enabled) {'
767 print ' GLint __binding = 0;'
769 # It doesn't seem possible to use VBOs with NV_vertex_program.
770 print ' __glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING%s, &__binding);' % (suffix, SUFFIX)
771 print ' if (!__binding) {'
773 function = api.get_function_by_name(function_name)
775 # Get the arguments via glGet*
776 for arg in function.args[1:]:
778 arg_get_enum = 'GL_ATTRIB_ARRAY_%s%s' % (arg.name.upper(), SUFFIX)
780 arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s%s' % (arg.name.upper(), SUFFIX)
781 arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False, suffix).visit(arg.type)
782 print ' %s %s = 0;' % (arg_type, arg.name)
783 print ' __%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
785 arg_names = ', '.join([arg.name for arg in function.args[1:-1]])
786 print ' size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
788 # Emit a fake function
789 print ' unsigned __call = Trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
790 for arg in function.args:
791 assert not arg.output
792 print ' Trace::localWriter.beginArg(%u);' % (arg.index,)
793 if arg.name != 'pointer':
794 dump_instance(arg.type, arg.name)
796 print ' Trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name)
797 print ' Trace::localWriter.endArg();'
799 print ' Trace::localWriter.endEnter();'
800 print ' Trace::localWriter.beginLeave(__call);'
801 print ' Trace::localWriter.endLeave();'
812 # Hooks for glTexCoordPointer, which is identical to the other array
813 # pointers except the fact that it is indexed by glClientActiveTexture.
816 def array_prolog(self, api, uppercase_name):
817 if uppercase_name == 'TEXTURE_COORD':
818 print ' GLint client_active_texture = 0;'
819 print ' __glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &client_active_texture);'
820 print ' GLint max_texture_coords = 0;'
821 print ' __glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);'
822 print ' for (GLint unit = 0; unit < max_texture_coords; ++unit) {'
823 print ' GLenum texture = GL_TEXTURE0 + unit;'
824 print ' __glClientActiveTexture(texture);'
826 def array_trace_prolog(self, api, uppercase_name):
827 if uppercase_name == 'TEXTURE_COORD':
828 print ' bool client_active_texture_dirty = false;'
830 def array_epilog(self, api, uppercase_name):
831 if uppercase_name == 'TEXTURE_COORD':
833 self.array_cleanup(api, uppercase_name)
835 def array_cleanup(self, api, uppercase_name):
836 if uppercase_name == 'TEXTURE_COORD':
837 print ' __glClientActiveTexture(client_active_texture);'
839 def array_trace_intermezzo(self, api, uppercase_name):
840 if uppercase_name == 'TEXTURE_COORD':
841 print ' if (texture != client_active_texture || client_active_texture_dirty) {'
842 print ' client_active_texture_dirty = true;'
843 self.fake_glClientActiveTexture_call(api, "texture");
846 def array_trace_epilog(self, api, uppercase_name):
847 if uppercase_name == 'TEXTURE_COORD':
848 print ' if (client_active_texture_dirty) {'
849 self.fake_glClientActiveTexture_call(api, "client_active_texture");
852 def fake_glClientActiveTexture_call(self, api, texture):
853 function = api.get_function_by_name('glClientActiveTexture')
854 self.fake_call(function, [texture])
856 def fake_call(self, function, args):
857 print ' unsigned __fake_call = Trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
858 for arg, instance in zip(function.args, args):
859 assert not arg.output
860 print ' Trace::localWriter.beginArg(%u);' % (arg.index,)
861 dump_instance(arg.type, instance)
862 print ' Trace::localWriter.endArg();'
863 print ' Trace::localWriter.endEnter();'
864 print ' Trace::localWriter.beginLeave(__fake_call);'
865 print ' Trace::localWriter.endLeave();'