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 # Whether we need user arrays
105 print 'static inline bool __need_user_arrays(void)'
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;'
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;'
138 print ' return false;'
142 print 'static void __trace_user_arrays(GLuint maxindex);'
145 array_pointer_function_names = set((
153 "glSecondaryColorPointer",
155 #"glVertexPointerEXT",
156 #"glNormalPointerEXT",
157 #"glColorPointerEXT",
158 #"glIndexPointerEXT",
159 #"glTexCoordPointerEXT",
160 #"glEdgeFlagPointerEXT",
161 #"glFogCoordPointerEXT",
162 #"glSecondaryColorPointerEXT",
164 "glVertexAttribPointer",
165 "glVertexAttribPointerARB",
166 "glVertexAttribPointerNV",
167 "glVertexAttribLPointer",
168 "glVertexAttribLPointerEXT",
170 #"glMatrixIndexPointerARB",
173 draw_function_names = set((
176 'glDrawRangeElements',
179 interleaved_formats = [
192 'GL_T2F_C4F_N3F_V3F',
193 'GL_T4F_C4F_N3F_V4F',
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)
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);'
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)
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
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
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
247 # Emit a fake function
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();'
262 Tracer.trace_function_impl_body(self, function)
269 def gl_boolean(self, value):
270 return self.boolean_names[int(bool(value))]
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)
279 print ' Trace::LiteralOpaque((const void *)%s);' % (arg.name)
283 Tracer.dump_arg_instance(self, function, arg)
285 def state_tracker_impl(self, api):
286 # A simple state tracker to track the pointer values
289 print 'static void __trace_user_arrays(GLuint maxindex)'
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)
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) {'
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)
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)
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)
322 print ' Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
323 print ' Trace::EndArg();'
325 print ' Trace::EndEnter();'
326 print ' Trace::BeginLeave(__call);'
327 print ' Trace::EndLeave();'
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) {'
344 function = api.get_function_by_name('glVertexAttribPointer')
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)
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)
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)
364 print ' Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
365 print ' Trace::EndArg();'
367 print ' Trace::EndEnter();'
368 print ' Trace::BeginLeave(__call);'
369 print ' Trace::EndLeave();'