]> git.cworth.org Git - apitrace/blob - wrappers/gltrace.py
cmake: Link ${LIBBACKTRACE_LIBRARIES} once.
[apitrace] / wrappers / 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 from trace import Tracer
31 from dispatch import function_pointer_type, function_pointer_value
32 import specs.stdapi as stdapi
33 import specs.glapi as glapi
34 import specs.glparams as glparams
35 from specs.glxapi import glxapi
36
37
38 class TypeGetter(stdapi.Visitor):
39     '''Determine which glGet*v function that matches the specified type.'''
40
41     def __init__(self, prefix = 'glGet', long_suffix = True, ext_suffix = ''):
42         self.prefix = prefix
43         self.long_suffix = long_suffix
44         self.ext_suffix = ext_suffix
45
46     def visitConst(self, const):
47         return self.visit(const.type)
48
49     def visitAlias(self, alias):
50         if alias.expr == 'GLboolean':
51             if self.long_suffix:
52                 suffix = 'Booleanv'
53                 arg_type = alias.expr
54             else:
55                 suffix = 'iv'
56                 arg_type = 'GLint'
57         elif alias.expr == 'GLdouble':
58             if self.long_suffix:
59                 suffix = 'Doublev'
60                 arg_type = alias.expr
61             else:
62                 suffix = 'dv'
63                 arg_type = alias.expr
64         elif alias.expr == 'GLfloat':
65             if self.long_suffix:
66                 suffix = 'Floatv'
67                 arg_type = alias.expr
68             else:
69                 suffix = 'fv'
70                 arg_type = alias.expr
71         elif alias.expr in ('GLint', 'GLuint', 'GLsizei'):
72             if self.long_suffix:
73                 suffix = 'Integerv'
74                 arg_type = 'GLint'
75             else:
76                 suffix = 'iv'
77                 arg_type = 'GLint'
78         else:
79             print alias.expr
80             assert False
81         function_name = self.prefix + suffix + self.ext_suffix
82         return function_name, arg_type
83     
84     def visitEnum(self, enum):
85         return self.visit(glapi.GLint)
86
87     def visitBitmask(self, bitmask):
88         return self.visit(glapi.GLint)
89
90     def visitOpaque(self, pointer):
91         return self.prefix + 'Pointerv' + self.ext_suffix, 'GLvoid *'
92
93
94 class GlTracer(Tracer):
95
96     arrays = [
97         ("Vertex", "VERTEX"),
98         ("Normal", "NORMAL"),
99         ("Color", "COLOR"),
100         ("Index", "INDEX"),
101         ("TexCoord", "TEXTURE_COORD"),
102         ("EdgeFlag", "EDGE_FLAG"),
103         ("FogCoord", "FOG_COORD"),
104         ("SecondaryColor", "SECONDARY_COLOR"),
105     ]
106     arrays.reverse()
107
108     # arrays available in PROFILE_ES1
109     arrays_es1 = ("Vertex", "Normal", "Color", "TexCoord")
110
111     def header(self, api):
112         Tracer.header(self, api)
113
114         print '#include "gltrace.hpp"'
115         print
116         
117         # Which glVertexAttrib* variant to use
118         print 'enum vertex_attrib {'
119         print '    VERTEX_ATTRIB,'
120         print '    VERTEX_ATTRIB_ARB,'
121         print '    VERTEX_ATTRIB_NV,'
122         print '};'
123         print
124         print 'static vertex_attrib _get_vertex_attrib(void) {'
125         print '    gltrace::Context *ctx = gltrace::getContext();'
126         print '    if (ctx->user_arrays_arb || ctx->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 (ctx->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;'
135         print '                }'
136         print '            }'
137         print '            return VERTEX_ATTRIB_ARB;'
138         print '        }'
139         print '    }'
140         print '    return VERTEX_ATTRIB;'
141         print '}'
142         print
143
144         self.defineShadowBufferHelper()
145
146         # Whether we need user arrays
147         print 'static inline bool _need_user_arrays(void)'
148         print '{'
149         print '    gltrace::Context *ctx = gltrace::getContext();'
150         print '    if (!ctx->user_arrays) {'
151         print '        return false;'
152         print '    }'
153         print
154
155         for camelcase_name, uppercase_name in self.arrays:
156             # in which profile is the array available?
157             profile_check = 'ctx->profile == gltrace::PROFILE_COMPAT'
158             if camelcase_name in self.arrays_es1:
159                 profile_check = '(' + profile_check + ' || ctx->profile == gltrace::PROFILE_ES1)';
160
161             function_name = 'gl%sPointer' % camelcase_name
162             enable_name = 'GL_%s_ARRAY' % uppercase_name
163             binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
164             print '    // %s' % function_name
165             print '  if (%s) {' % profile_check
166             self.array_prolog(api, uppercase_name)
167             print '    if (_glIsEnabled(%s)) {' % enable_name
168             print '        GLint _binding = 0;'
169             print '        _glGetIntegerv(%s, &_binding);' % binding_name
170             print '        if (!_binding) {'
171             self.array_cleanup(api, uppercase_name)
172             print '            return true;'
173             print '        }'
174             print '    }'
175             self.array_epilog(api, uppercase_name)
176             print '  }'
177             print
178
179         print '    // ES1 does not support generic vertex attributes'
180         print '    if (ctx->profile == gltrace::PROFILE_ES1)'
181         print '        return false;'
182         print
183         print '    vertex_attrib _vertex_attrib = _get_vertex_attrib();'
184         print
185         print '    // glVertexAttribPointer'
186         print '    if (_vertex_attrib == VERTEX_ATTRIB) {'
187         print '        GLint _max_vertex_attribs = 0;'
188         print '        _glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &_max_vertex_attribs);'
189         print '        for (GLint index = 0; index < _max_vertex_attribs; ++index) {'
190         print '            GLint _enabled = 0;'
191         print '            _glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &_enabled);'
192         print '            if (_enabled) {'
193         print '                GLint _binding = 0;'
194         print '                _glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &_binding);'
195         print '                if (!_binding) {'
196         print '                    return true;'
197         print '                }'
198         print '            }'
199         print '        }'
200         print '    }'
201         print
202         print '    // glVertexAttribPointerARB'
203         print '    if (_vertex_attrib == VERTEX_ATTRIB_ARB) {'
204         print '        GLint _max_vertex_attribs = 0;'
205         print '        _glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &_max_vertex_attribs);'
206         print '        for (GLint index = 0; index < _max_vertex_attribs; ++index) {'
207         print '            GLint _enabled = 0;'
208         print '            _glGetVertexAttribivARB(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, &_enabled);'
209         print '            if (_enabled) {'
210         print '                GLint _binding = 0;'
211         print '                _glGetVertexAttribivARB(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB, &_binding);'
212         print '                if (!_binding) {'
213         print '                    return true;'
214         print '                }'
215         print '            }'
216         print '        }'
217         print '    }'
218         print
219         print '    // glVertexAttribPointerNV'
220         print '    if (_vertex_attrib == VERTEX_ATTRIB_NV) {'
221         print '        for (GLint index = 0; index < 16; ++index) {'
222         print '            GLint _enabled = 0;'
223         print '            _glGetIntegerv(GL_VERTEX_ATTRIB_ARRAY0_NV + index, &_enabled);'
224         print '            if (_enabled) {'
225         print '                return true;'
226         print '            }'
227         print '        }'
228         print '    }'
229         print
230
231         print '    return false;'
232         print '}'
233         print
234
235         print 'static void _trace_user_arrays(GLuint count);'
236         print
237
238         # Buffer mappings
239         print '// whether glMapBufferRange(GL_MAP_WRITE_BIT) has ever been called'
240         print 'static bool _checkBufferMapRange = false;'
241         print
242         print '// whether glBufferParameteriAPPLE(GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE) has ever been called'
243         print 'static bool _checkBufferFlushingUnmapAPPLE = false;'
244         print
245         # Buffer mapping information, necessary for old Mesa 2.1 drivers which
246         # do not support glGetBufferParameteriv(GL_BUFFER_ACCESS_FLAGS/GL_BUFFER_MAP_LENGTH)
247         print 'struct buffer_mapping {'
248         print '    void *map;'
249         print '    GLint length;'
250         print '    bool write;'
251         print '    bool explicit_flush;'
252         print '};'
253         print
254         for target in self.buffer_targets:
255             print 'struct buffer_mapping _%s_mapping;' % target.lower();
256         print
257         print 'static inline struct buffer_mapping *'
258         print 'get_buffer_mapping(GLenum target) {'
259         print '    switch (target) {'
260         for target in self.buffer_targets:
261             print '    case GL_%s:' % target
262             print '        return & _%s_mapping;' % target.lower()
263         print '    default:'
264         print '        os::log("apitrace: warning: unknown buffer target 0x%04X\\n", target);'
265         print '        return NULL;'
266         print '    }'
267         print '}'
268         print
269
270         # Generate a helper function to determine whether a parameter name
271         # refers to a symbolic value or not
272         print 'static bool'
273         print 'is_symbolic_pname(GLenum pname) {'
274         print '    switch (pname) {'
275         for function, type, count, name in glparams.parameters:
276             if type is glapi.GLenum:
277                 print '    case %s:' % name
278         print '        return true;'
279         print '    default:'
280         print '        return false;'
281         print '    }'
282         print '}'
283         print
284         
285         # Generate a helper function to determine whether a parameter value is
286         # potentially symbolic or not; i.e., if the value can be represented in
287         # an enum or not
288         print 'template<class T>'
289         print 'static inline bool'
290         print 'is_symbolic_param(T param) {'
291         print '    return static_cast<T>(static_cast<GLenum>(param)) == param;'
292         print '}'
293         print
294
295         # Generate a helper function to know how many elements a parameter has
296         print 'static size_t'
297         print '_gl_param_size(GLenum pname) {'
298         print '    switch (pname) {'
299         for function, type, count, name in glparams.parameters:
300             if type is not None:
301                 print '    case %s: return %s;' % (name, count)
302         print '    default:'
303         print r'        os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);'
304         print '        return 1;'
305         print '    }'
306         print '}'
307         print
308
309         # states such as GL_UNPACK_ROW_LENGTH are not available in GLES
310         print 'static inline bool'
311         print 'can_unpack_subimage(void) {'
312         print '    gltrace::Context *ctx = gltrace::getContext();'
313         print '    return (ctx->profile == gltrace::PROFILE_COMPAT);'
314         print '}'
315         print
316
317     getProcAddressFunctionNames = []
318
319     def traceApi(self, api):
320         if self.getProcAddressFunctionNames:
321             # Generate a function to wrap proc addresses
322             getProcAddressFunction = api.getFunctionByName(self.getProcAddressFunctionNames[0])
323             argType = getProcAddressFunction.args[0].type
324             retType = getProcAddressFunction.type
325             
326             print 'static %s _wrapProcAddress(%s procName, %s procPtr);' % (retType, argType, retType)
327             print
328             
329             Tracer.traceApi(self, api)
330             
331             print 'static %s _wrapProcAddress(%s procName, %s procPtr) {' % (retType, argType, retType)
332             print '    if (!procPtr) {'
333             print '        return procPtr;'
334             print '    }'
335             for function in api.getAllFunctions():
336                 ptype = function_pointer_type(function)
337                 pvalue = function_pointer_value(function)
338                 print '    if (strcmp("%s", (const char *)procName) == 0) {' % function.name
339                 print '        %s = (%s)procPtr;' % (pvalue, ptype)
340                 print '        return (%s)&%s;' % (retType, function.name,)
341                 print '    }'
342             print '    os::log("apitrace: warning: unknown function \\"%s\\"\\n", (const char *)procName);'
343             print '    return procPtr;'
344             print '}'
345             print
346         else:
347             Tracer.traceApi(self, api)
348
349     def defineShadowBufferHelper(self):
350         print 'void _shadow_glGetBufferSubData(GLenum target, GLintptr offset,'
351         print '                                GLsizeiptr size, GLvoid *data)'
352         print '{'
353         print '    gltrace::Context *ctx = gltrace::getContext();'
354         print '    if (!ctx->needsShadowBuffers() || target != GL_ELEMENT_ARRAY_BUFFER) {'
355         print '        _glGetBufferSubData(target, offset, size, data);'
356         print '        return;'
357         print '    }'
358         print
359         print '    GLint buffer_binding = 0;'
360         print '    _glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &buffer_binding);'
361         print '    if (buffer_binding > 0) {'
362         print '        gltrace::Buffer & buf = ctx->buffers[buffer_binding];'
363         print '        buf.getSubData(offset, size, data);'
364         print '    }'
365         print '}'
366
367     def shadowBufferMethod(self, method):
368         # Emit code to fetch the shadow buffer, and invoke a method
369         print '    gltrace::Context *ctx = gltrace::getContext();'
370         print '    if (ctx->needsShadowBuffers() && target == GL_ELEMENT_ARRAY_BUFFER) {'
371         print '        GLint buffer_binding = 0;'
372         print '        _glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &buffer_binding);'
373         print '        if (buffer_binding > 0) {'
374         print '            gltrace::Buffer & buf = ctx->buffers[buffer_binding];'
375         print '            buf.' + method + ';'
376         print '        }'
377         print '    }'
378         print
379
380     def shadowBufferProlog(self, function):
381         if function.name == 'glBufferData':
382             self.shadowBufferMethod('bufferData(size, data)')
383
384         if function.name == 'glBufferSubData':
385             self.shadowBufferMethod('bufferSubData(offset, size, data)')
386
387         if function.name == 'glDeleteBuffers':
388             print '    gltrace::Context *ctx = gltrace::getContext();'
389             print '    if (ctx->needsShadowBuffers()) {'
390             print '        for (GLsizei i = 0; i < n; i++) {'
391             print '            ctx->buffers.erase(buffer[i]);'
392             print '        }'
393             print '    }'
394
395     array_pointer_function_names = set((
396         "glVertexPointer",
397         "glNormalPointer",
398         "glColorPointer",
399         "glIndexPointer",
400         "glTexCoordPointer",
401         "glEdgeFlagPointer",
402         "glFogCoordPointer",
403         "glSecondaryColorPointer",
404         
405         "glInterleavedArrays",
406
407         "glVertexPointerEXT",
408         "glNormalPointerEXT",
409         "glColorPointerEXT",
410         "glIndexPointerEXT",
411         "glTexCoordPointerEXT",
412         "glEdgeFlagPointerEXT",
413         "glFogCoordPointerEXT",
414         "glSecondaryColorPointerEXT",
415
416         "glVertexAttribPointer",
417         "glVertexAttribPointerARB",
418         "glVertexAttribPointerNV",
419         "glVertexAttribIPointer",
420         "glVertexAttribIPointerEXT",
421         "glVertexAttribLPointer",
422         "glVertexAttribLPointerEXT",
423         
424         #"glMatrixIndexPointerARB",
425     ))
426
427     draw_function_names = set((
428         'glDrawArrays',
429         'glDrawElements',
430         'glDrawRangeElements',
431         'glMultiDrawArrays',
432         'glMultiDrawElements',
433         'glDrawArraysInstanced',
434         "glDrawArraysInstancedBaseInstance",
435         'glDrawElementsInstanced',
436         'glDrawArraysInstancedARB',
437         'glDrawElementsInstancedARB',
438         'glDrawElementsBaseVertex',
439         'glDrawRangeElementsBaseVertex',
440         'glDrawElementsInstancedBaseVertex',
441         "glDrawElementsInstancedBaseInstance",
442         "glDrawElementsInstancedBaseVertexBaseInstance",
443         'glMultiDrawElementsBaseVertex',
444         'glDrawArraysIndirect',
445         'glDrawElementsIndirect',
446         'glMultiDrawArraysIndirect',
447         'glMultiDrawArraysIndirectAMD',
448         'glMultiDrawElementsIndirect',
449         'glMultiDrawElementsIndirectAMD',
450         'glDrawArraysEXT',
451         'glDrawRangeElementsEXT',
452         'glDrawRangeElementsEXT_size',
453         'glMultiDrawArraysEXT',
454         'glMultiDrawElementsEXT',
455         'glMultiModeDrawArraysIBM',
456         'glMultiModeDrawElementsIBM',
457         'glDrawArraysInstancedEXT',
458         'glDrawElementsInstancedEXT',
459     ))
460
461     interleaved_formats = [
462          'GL_V2F',
463          'GL_V3F',
464          'GL_C4UB_V2F',
465          'GL_C4UB_V3F',
466          'GL_C3F_V3F',
467          'GL_N3F_V3F',
468          'GL_C4F_N3F_V3F',
469          'GL_T2F_V3F',
470          'GL_T4F_V4F',
471          'GL_T2F_C4UB_V3F',
472          'GL_T2F_C3F_V3F',
473          'GL_T2F_N3F_V3F',
474          'GL_T2F_C4F_N3F_V3F',
475          'GL_T4F_C4F_N3F_V4F',
476     ]
477
478     def traceFunctionImplBody(self, function):
479         # Defer tracing of user array pointers...
480         if function.name in self.array_pointer_function_names:
481             print '    GLint _array_buffer = 0;'
482             print '    _glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &_array_buffer);'
483             print '    if (!_array_buffer) {'
484             print '        gltrace::Context *ctx = gltrace::getContext();'
485             print '        ctx->user_arrays = true;'
486             if function.name == "glVertexAttribPointerARB":
487                 print '        ctx->user_arrays_arb = true;'
488             if function.name == "glVertexAttribPointerNV":
489                 print '        ctx->user_arrays_nv = true;'
490             self.invokeFunction(function)
491
492             # And also break down glInterleavedArrays into the individual calls
493             if function.name == 'glInterleavedArrays':
494                 print
495
496                 # Initialize the enable flags
497                 for camelcase_name, uppercase_name in self.arrays:
498                     flag_name = '_' + uppercase_name.lower()
499                     print '        GLboolean %s = GL_FALSE;' % flag_name
500                 print
501
502                 # Switch for the interleaved formats
503                 print '        switch (format) {'
504                 for format in self.interleaved_formats:
505                     print '            case %s:' % format
506                     for camelcase_name, uppercase_name in self.arrays:
507                         flag_name = '_' + uppercase_name.lower()
508                         if format.find('_' + uppercase_name[0]) >= 0:
509                             print '                %s = GL_TRUE;' % flag_name
510                     print '                break;'
511                 print '            default:'
512                 print '               return;'
513                 print '        }'
514                 print
515
516                 # Emit fake glEnableClientState/glDisableClientState flags
517                 for camelcase_name, uppercase_name in self.arrays:
518                     flag_name = '_' + uppercase_name.lower()
519                     enable_name = 'GL_%s_ARRAY' % uppercase_name
520
521                     # Emit a fake function
522                     print '        {'
523                     print '            static const trace::FunctionSig &_sig = %s ? _glEnableClientState_sig : _glDisableClientState_sig;' % flag_name
524                     print '            unsigned _call = trace::localWriter.beginEnter(&_sig);'
525                     print '            trace::localWriter.beginArg(0);'
526                     self.serializeValue(glapi.GLenum, enable_name)
527                     print '            trace::localWriter.endArg();'
528                     print '            trace::localWriter.endEnter();'
529                     print '            trace::localWriter.beginLeave(_call);'
530                     print '            trace::localWriter.endLeave();'
531                     print '        }'
532
533             print '        return;'
534             print '    }'
535
536         # ... to the draw calls
537         if function.name in self.draw_function_names:
538             print '    if (_need_user_arrays()) {'
539             arg_names = ', '.join([arg.name for arg in function.args[1:]])
540             print '        GLuint _count = _%s_count(%s);' % (function.name, arg_names)
541             print '        _trace_user_arrays(_count);'
542             print '    }'
543         
544         # Emit a fake memcpy on buffer uploads
545         if function.name == 'glBufferParameteriAPPLE':
546             print '    if (pname == GL_BUFFER_FLUSHING_UNMAP_APPLE && param == GL_FALSE) {'
547             print '        _checkBufferFlushingUnmapAPPLE = true;'
548             print '    }'
549         if function.name in ('glUnmapBuffer', 'glUnmapBufferARB'):
550             if function.name.endswith('ARB'):
551                 suffix = 'ARB'
552             else:
553                 suffix = ''
554             print '    GLint access = 0;'
555             print '    _glGetBufferParameteriv%s(target, GL_BUFFER_ACCESS, &access);' % suffix
556             print '    if (access != GL_READ_ONLY) {'
557             print '        GLvoid *map = NULL;'
558             print '        _glGetBufferPointerv%s(target, GL_BUFFER_MAP_POINTER, &map);'  % suffix
559             print '        if (map) {'
560             print '            GLint length = -1;'
561             print '            bool flush = true;'
562             print '            if (_checkBufferMapRange) {'
563             print '                _glGetBufferParameteriv%s(target, GL_BUFFER_MAP_LENGTH, &length);' % suffix
564             print '                GLint access_flags = 0;'
565             print '                _glGetBufferParameteriv(target, GL_BUFFER_ACCESS_FLAGS, &access_flags);'
566             print '                flush = flush && !(access_flags & GL_MAP_FLUSH_EXPLICIT_BIT);'
567             print '                if (length == -1) {'
568             print '                    // Mesa drivers refuse GL_BUFFER_MAP_LENGTH without GL 3.0'
569             print '                    static bool warned = false;'
570             print '                    if (!warned) {'
571             print '                        os::log("apitrace: warning: glGetBufferParameteriv%s(GL_BUFFER_MAP_LENGTH) failed\\n");' % suffix
572             print '                        warned = true;'
573             print '                    }'
574             print '                    struct buffer_mapping *mapping = get_buffer_mapping(target);'
575             print '                    if (mapping) {'
576             print '                        length = mapping->length;'
577             print '                        flush = flush && !mapping->explicit_flush;'
578             print '                    } else {'
579             print '                        length = 0;'
580             print '                        flush = false;'
581             print '                    }'
582             print '                }'
583             print '            } else {'
584             print '                length = 0;'
585             print '                _glGetBufferParameteriv%s(target, GL_BUFFER_SIZE, &length);' % suffix
586             print '            }'
587             print '            if (_checkBufferFlushingUnmapAPPLE) {'
588             print '                GLint flushing_unmap = GL_TRUE;'
589             print '                _glGetBufferParameteriv%s(target, GL_BUFFER_FLUSHING_UNMAP_APPLE, &flushing_unmap);' % suffix
590             print '                flush = flush && flushing_unmap;'
591             print '            }'
592             print '            if (flush && length > 0) {'
593             self.emit_memcpy('map', 'map', 'length')
594             print '            }'
595             print '        }'
596             print '    }'
597         if function.name == 'glUnmapBufferOES':
598             print '    GLint access = 0;'
599             print '    _glGetBufferParameteriv(target, GL_BUFFER_ACCESS_OES, &access);'
600             print '    if (access == GL_WRITE_ONLY_OES) {'
601             print '        GLvoid *map = NULL;'
602             print '        _glGetBufferPointervOES(target, GL_BUFFER_MAP_POINTER_OES, &map);'
603             print '        GLint size = 0;'
604             print '        _glGetBufferParameteriv(target, GL_BUFFER_SIZE, &size);'
605             print '        if (map && size > 0) {'
606             self.emit_memcpy('map', 'map', 'size')
607             self.shadowBufferMethod('bufferSubData(0, size, map)')
608             print '        }'
609             print '    }'
610         if function.name == 'glUnmapNamedBufferEXT':
611             print '    GLint access_flags = 0;'
612             print '    _glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_ACCESS_FLAGS, &access_flags);'
613             print '    if ((access_flags & GL_MAP_WRITE_BIT) && !(access_flags & GL_MAP_FLUSH_EXPLICIT_BIT)) {'
614             print '        GLvoid *map = NULL;'
615             print '        _glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &map);'
616             print '        GLint length = 0;'
617             print '        _glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_MAP_LENGTH, &length);'
618             print '        if (map && length > 0) {'
619             self.emit_memcpy('map', 'map', 'length')
620             print '        }'
621             print '    }'
622         if function.name == 'glFlushMappedBufferRange':
623             print '    GLvoid *map = NULL;'
624             print '    _glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &map);'
625             print '    if (map && length > 0) {'
626             self.emit_memcpy('(char *)map + offset', '(const char *)map + offset', 'length')
627             print '    }'
628         if function.name == 'glFlushMappedBufferRangeAPPLE':
629             print '    GLvoid *map = NULL;'
630             print '    _glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &map);'
631             print '    if (map && size > 0) {'
632             self.emit_memcpy('(char *)map + offset', '(const char *)map + offset', 'size')
633             print '    }'
634         if function.name == 'glFlushMappedNamedBufferRangeEXT':
635             print '    GLvoid *map = NULL;'
636             print '    _glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &map);'
637             print '    if (map && length > 0) {'
638             self.emit_memcpy('(char *)map + offset', '(const char *)map + offset', 'length')
639             print '    }'
640
641         # Don't leave vertex attrib locations to chance.  Instead emit fake
642         # glBindAttribLocation calls to ensure that the same locations will be
643         # used when retracing.  Trying to remap locations after the fact would
644         # be an herculian task given that vertex attrib locations appear in
645         # many entry-points, including non-shader related ones.
646         if function.name == 'glLinkProgram':
647             Tracer.invokeFunction(self, function)
648             print '    GLint active_attributes = 0;'
649             print '    _glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active_attributes);'
650             print '    for (GLint attrib = 0; attrib < active_attributes; ++attrib) {'
651             print '        GLint size = 0;'
652             print '        GLenum type = 0;'
653             print '        GLchar name[256];'
654             # TODO: Use ACTIVE_ATTRIBUTE_MAX_LENGTH instead of 256
655             print '        _glGetActiveAttrib(program, attrib, sizeof name, NULL, &size, &type, name);'
656             print "        if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {"
657             print '            GLint location = _glGetAttribLocation(program, name);'
658             print '            if (location >= 0) {'
659             bind_function = glapi.glapi.getFunctionByName('glBindAttribLocation')
660             self.fake_call(bind_function, ['program', 'location', 'name'])
661             print '            }'
662             print '        }'
663             print '    }'
664         if function.name == 'glLinkProgramARB':
665             Tracer.invokeFunction(self, function)
666             print '    GLint active_attributes = 0;'
667             print '    _glGetObjectParameterivARB(programObj, GL_OBJECT_ACTIVE_ATTRIBUTES_ARB, &active_attributes);'
668             print '    for (GLint attrib = 0; attrib < active_attributes; ++attrib) {'
669             print '        GLint size = 0;'
670             print '        GLenum type = 0;'
671             print '        GLcharARB name[256];'
672             # TODO: Use ACTIVE_ATTRIBUTE_MAX_LENGTH instead of 256
673             print '        _glGetActiveAttribARB(programObj, attrib, sizeof name, NULL, &size, &type, name);'
674             print "        if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {"
675             print '            GLint location = _glGetAttribLocationARB(programObj, name);'
676             print '            if (location >= 0) {'
677             bind_function = glapi.glapi.getFunctionByName('glBindAttribLocationARB')
678             self.fake_call(bind_function, ['programObj', 'location', 'name'])
679             print '            }'
680             print '        }'
681             print '    }'
682
683         self.shadowBufferProlog(function)
684
685         Tracer.traceFunctionImplBody(self, function)
686
687     marker_functions = [
688         # GL_GREMEDY_string_marker
689         'glStringMarkerGREMEDY',
690         # GL_GREMEDY_frame_terminator
691         'glFrameTerminatorGREMEDY',
692         # GL_EXT_debug_marker
693         'glInsertEventMarkerEXT',
694         'glPushGroupMarkerEXT',
695         'glPopGroupMarkerEXT',
696     ]
697
698     def invokeFunction(self, function):
699         if function.name in ('glLinkProgram', 'glLinkProgramARB'):
700             # These functions have been dispatched already
701             return
702
703         Tracer.invokeFunction(self, function)
704
705     def doInvokeFunction(self, function):
706         # Same as invokeFunction() but called both when trace is enabled or disabled.
707         #
708         # Used to modify the behavior of GL entry-points.
709
710         # Override GL extensions
711         if function.name in ('glGetString', 'glGetIntegerv', 'glGetStringi'):
712             Tracer.doInvokeFunction(self, function, prefix = 'gltrace::_', suffix = '_override')
713             return
714
715         # We implement GL_EXT_debug_marker, GL_GREMEDY_*, etc., and not the
716         # driver
717         if function.name in self.marker_functions:
718             return
719
720         if function.name in self.getProcAddressFunctionNames:
721             else_ = ''
722             for marker_function in self.marker_functions:
723                 if self.api.getFunctionByName(marker_function):
724                     print '    %sif (strcmp("%s", (const char *)%s) == 0) {' % (else_, marker_function, function.args[0].name)
725                     print '        _result = (%s)&%s;' % (function.type, marker_function)
726                     print '    }'
727                 else_ = 'else '
728             print '    %s{' % else_
729             Tracer.doInvokeFunction(self, function)
730
731             # Replace function addresses with ours
732             # XXX: Doing this here instead of wrapRet means that the trace will
733             # contain the addresses of the wrapper functions, and not the real
734             # functions, but in practice this should make no difference.
735             if function.name in self.getProcAddressFunctionNames:
736                 print '    _result = _wrapProcAddress(%s, _result);' % (function.args[0].name,)
737
738             print '    }'
739             return
740
741         Tracer.doInvokeFunction(self, function)
742
743     buffer_targets = [
744         'ARRAY_BUFFER',
745         'ELEMENT_ARRAY_BUFFER',
746         'PIXEL_PACK_BUFFER',
747         'PIXEL_UNPACK_BUFFER',
748         'UNIFORM_BUFFER',
749         'TEXTURE_BUFFER',
750         'TRANSFORM_FEEDBACK_BUFFER',
751         'COPY_READ_BUFFER',
752         'COPY_WRITE_BUFFER',
753         'DRAW_INDIRECT_BUFFER',
754         'ATOMIC_COUNTER_BUFFER',
755     ]
756
757     def wrapRet(self, function, instance):
758         Tracer.wrapRet(self, function, instance)
759
760         # Keep track of buffer mappings
761         if function.name in ('glMapBuffer', 'glMapBufferARB'):
762             print '    struct buffer_mapping *mapping = get_buffer_mapping(target);'
763             print '    if (mapping) {'
764             print '        mapping->map = %s;' % (instance)
765             print '        mapping->length = 0;'
766             print '        _glGetBufferParameteriv(target, GL_BUFFER_SIZE, &mapping->length);'
767             print '        mapping->write = (access != GL_READ_ONLY);'
768             print '        mapping->explicit_flush = false;'
769             print '    }'
770         if function.name == 'glMapBufferRange':
771             print '    if (access & GL_MAP_WRITE_BIT) {'
772             print '        _checkBufferMapRange = true;'
773             print '    }'
774             print '    struct buffer_mapping *mapping = get_buffer_mapping(target);'
775             print '    if (mapping) {'
776             print '        mapping->map = %s;' % (instance)
777             print '        mapping->length = length;'
778             print '        mapping->write = access & GL_MAP_WRITE_BIT;'
779             print '        mapping->explicit_flush = access & GL_MAP_FLUSH_EXPLICIT_BIT;'
780             print '    }'
781
782     boolean_names = [
783         'GL_FALSE',
784         'GL_TRUE',
785     ]
786
787     def gl_boolean(self, value):
788         return self.boolean_names[int(bool(value))]
789
790     # Names of the functions that unpack from a pixel buffer object.  See the
791     # ARB_pixel_buffer_object specification.
792     unpack_function_names = set([
793         'glBitmap',
794         'glColorSubTable',
795         'glColorTable',
796         'glCompressedMultiTexImage1DEXT',
797         'glCompressedMultiTexImage2DEXT',
798         'glCompressedMultiTexImage3DEXT',
799         'glCompressedMultiTexSubImage1DEXT',
800         'glCompressedMultiTexSubImage2DEXT',
801         'glCompressedMultiTexSubImage3DEXT',
802         'glCompressedTexImage1D',
803         'glCompressedTexImage2D',
804         'glCompressedTexImage3D',
805         'glCompressedTexSubImage1D',
806         'glCompressedTexSubImage2D',
807         'glCompressedTexSubImage3D',
808         'glCompressedTextureImage1DEXT',
809         'glCompressedTextureImage2DEXT',
810         'glCompressedTextureImage3DEXT',
811         'glCompressedTextureSubImage1DEXT',
812         'glCompressedTextureSubImage2DEXT',
813         'glCompressedTextureSubImage3DEXT',
814         'glConvolutionFilter1D',
815         'glConvolutionFilter2D',
816         'glDrawPixels',
817         'glMultiTexImage1DEXT',
818         'glMultiTexImage2DEXT',
819         'glMultiTexImage3DEXT',
820         'glMultiTexSubImage1DEXT',
821         'glMultiTexSubImage2DEXT',
822         'glMultiTexSubImage3DEXT',
823         'glPixelMapfv',
824         'glPixelMapuiv',
825         'glPixelMapusv',
826         'glPolygonStipple',
827         'glSeparableFilter2D',
828         'glTexImage1D',
829         'glTexImage1DEXT',
830         'glTexImage2D',
831         'glTexImage2DEXT',
832         'glTexImage3D',
833         'glTexImage3DEXT',
834         'glTexSubImage1D',
835         'glTexSubImage1DEXT',
836         'glTexSubImage2D',
837         'glTexSubImage2DEXT',
838         'glTexSubImage3D',
839         'glTexSubImage3DEXT',
840         'glTextureImage1DEXT',
841         'glTextureImage2DEXT',
842         'glTextureImage3DEXT',
843         'glTextureSubImage1DEXT',
844         'glTextureSubImage2DEXT',
845         'glTextureSubImage3DEXT',
846     ])
847
848     def serializeArgValue(self, function, arg):
849         # Recognize offsets instead of blobs when a PBO is bound
850         if function.name in self.unpack_function_names \
851            and (isinstance(arg.type, stdapi.Blob) \
852                 or (isinstance(arg.type, stdapi.Const) \
853                     and isinstance(arg.type.type, stdapi.Blob))):
854             print '    {'
855             print '        gltrace::Context *ctx = gltrace::getContext();'
856             print '        GLint _unpack_buffer = 0;'
857             print '        if (ctx->profile == gltrace::PROFILE_COMPAT)'
858             print '            _glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &_unpack_buffer);'
859             print '        if (_unpack_buffer) {'
860             print '            trace::localWriter.writePointer((uintptr_t)%s);' % arg.name
861             print '        } else {'
862             Tracer.serializeArgValue(self, function, arg)
863             print '        }'
864             print '    }'
865             return
866
867         # Several GL state functions take GLenum symbolic names as
868         # integer/floats; so dump the symbolic name whenever possible
869         if function.name.startswith('gl') \
870            and arg.type in (glapi.GLint, glapi.GLfloat, glapi.GLdouble) \
871            and arg.name == 'param':
872             assert arg.index > 0
873             assert function.args[arg.index - 1].name == 'pname'
874             assert function.args[arg.index - 1].type == glapi.GLenum
875             print '    if (is_symbolic_pname(pname) && is_symbolic_param(%s)) {' % arg.name
876             self.serializeValue(glapi.GLenum, arg.name)
877             print '    } else {'
878             Tracer.serializeArgValue(self, function, arg)
879             print '    }'
880             return
881
882         Tracer.serializeArgValue(self, function, arg)
883
884     def footer(self, api):
885         Tracer.footer(self, api)
886
887         # A simple state tracker to track the pointer values
888         # update the state
889         print 'static void _trace_user_arrays(GLuint count)'
890         print '{'
891         print '    gltrace::Context *ctx = gltrace::getContext();'
892
893         for camelcase_name, uppercase_name in self.arrays:
894             # in which profile is the array available?
895             profile_check = 'ctx->profile == gltrace::PROFILE_COMPAT'
896             if camelcase_name in self.arrays_es1:
897                 profile_check = '(' + profile_check + ' || ctx->profile == gltrace::PROFILE_ES1)';
898
899             function_name = 'gl%sPointer' % camelcase_name
900             enable_name = 'GL_%s_ARRAY' % uppercase_name
901             binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
902             function = api.getFunctionByName(function_name)
903
904             print '    // %s' % function.prototype()
905             print '  if (%s) {' % profile_check
906             self.array_trace_prolog(api, uppercase_name)
907             self.array_prolog(api, uppercase_name)
908             print '    if (_glIsEnabled(%s)) {' % enable_name
909             print '        GLint _binding = 0;'
910             print '        _glGetIntegerv(%s, &_binding);' % binding_name
911             print '        if (!_binding) {'
912
913             # Get the arguments via glGet*
914             for arg in function.args:
915                 arg_get_enum = 'GL_%s_ARRAY_%s' % (uppercase_name, arg.name.upper())
916                 arg_get_function, arg_type = TypeGetter().visit(arg.type)
917                 print '            %s %s = 0;' % (arg_type, arg.name)
918                 print '            _%s(%s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
919             
920             arg_names = ', '.join([arg.name for arg in function.args[:-1]])
921             print '            size_t _size = _%s_size(%s, count);' % (function.name, arg_names)
922
923             # Emit a fake function
924             self.array_trace_intermezzo(api, uppercase_name)
925             print '            unsigned _call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)
926             for arg in function.args:
927                 assert not arg.output
928                 print '            trace::localWriter.beginArg(%u);' % (arg.index,)
929                 if arg.name != 'pointer':
930                     self.serializeValue(arg.type, arg.name)
931                 else:
932                     print '            trace::localWriter.writeBlob((const void *)%s, _size);' % (arg.name)
933                 print '            trace::localWriter.endArg();'
934             
935             print '            trace::localWriter.endEnter();'
936             print '            trace::localWriter.beginLeave(_call);'
937             print '            trace::localWriter.endLeave();'
938             print '        }'
939             print '    }'
940             self.array_epilog(api, uppercase_name)
941             self.array_trace_epilog(api, uppercase_name)
942             print '  }'
943             print
944
945         # Samething, but for glVertexAttribPointer*
946         #
947         # Some variants of glVertexAttribPointer alias conventional and generic attributes:
948         # - glVertexAttribPointer: no
949         # - glVertexAttribPointerARB: implementation dependent
950         # - glVertexAttribPointerNV: yes
951         #
952         # This means that the implementations of these functions do not always
953         # alias, and they need to be considered independently.
954         #
955         print '    // ES1 does not support generic vertex attributes'
956         print '    if (ctx->profile == gltrace::PROFILE_ES1)'
957         print '        return;'
958         print
959         print '    vertex_attrib _vertex_attrib = _get_vertex_attrib();'
960         print
961         for suffix in ['', 'ARB', 'NV']:
962             if suffix:
963                 SUFFIX = '_' + suffix
964             else:
965                 SUFFIX = suffix
966             function_name = 'glVertexAttribPointer' + suffix
967             function = api.getFunctionByName(function_name)
968
969             print '    // %s' % function.prototype()
970             print '    if (_vertex_attrib == VERTEX_ATTRIB%s) {' % SUFFIX
971             if suffix == 'NV':
972                 print '        GLint _max_vertex_attribs = 16;'
973             else:
974                 print '        GLint _max_vertex_attribs = 0;'
975                 print '        _glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &_max_vertex_attribs);'
976             print '        for (GLint index = 0; index < _max_vertex_attribs; ++index) {'
977             print '            GLint _enabled = 0;'
978             if suffix == 'NV':
979                 print '            _glGetIntegerv(GL_VERTEX_ATTRIB_ARRAY0_NV + index, &_enabled);'
980             else:
981                 print '            _glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED%s, &_enabled);' % (suffix, SUFFIX)
982             print '            if (_enabled) {'
983             print '                GLint _binding = 0;'
984             if suffix != 'NV':
985                 # It doesn't seem possible to use VBOs with NV_vertex_program.
986                 print '                _glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING%s, &_binding);' % (suffix, SUFFIX)
987             print '                if (!_binding) {'
988
989             # Get the arguments via glGet*
990             for arg in function.args[1:]:
991                 if suffix == 'NV':
992                     arg_get_enum = 'GL_ATTRIB_ARRAY_%s%s' % (arg.name.upper(), SUFFIX)
993                 else:
994                     arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s%s' % (arg.name.upper(), SUFFIX)
995                 arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False, suffix).visit(arg.type)
996                 print '                    %s %s = 0;' % (arg_type, arg.name)
997                 print '                    _%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
998             
999             arg_names = ', '.join([arg.name for arg in function.args[1:-1]])
1000             print '                    size_t _size = _%s_size(%s, count);' % (function.name, arg_names)
1001
1002             # Emit a fake function
1003             print '                    unsigned _call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)
1004             for arg in function.args:
1005                 assert not arg.output
1006                 print '                    trace::localWriter.beginArg(%u);' % (arg.index,)
1007                 if arg.name != 'pointer':
1008                     self.serializeValue(arg.type, arg.name)
1009                 else:
1010                     print '                    trace::localWriter.writeBlob((const void *)%s, _size);' % (arg.name)
1011                 print '                    trace::localWriter.endArg();'
1012             
1013             print '                    trace::localWriter.endEnter();'
1014             print '                    trace::localWriter.beginLeave(_call);'
1015             print '                    trace::localWriter.endLeave();'
1016             print '                }'
1017             print '            }'
1018             print '        }'
1019             print '    }'
1020             print
1021
1022         print '}'
1023         print
1024
1025     #
1026     # Hooks for glTexCoordPointer, which is identical to the other array
1027     # pointers except the fact that it is indexed by glClientActiveTexture.
1028     #
1029
1030     def array_prolog(self, api, uppercase_name):
1031         if uppercase_name == 'TEXTURE_COORD':
1032             print '    GLint client_active_texture = 0;'
1033             print '    _glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &client_active_texture);'
1034             print '    GLint max_texture_coords = 0;'
1035             print '    if (ctx->profile == gltrace::PROFILE_COMPAT)'
1036             print '        _glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);'
1037             print '    else'
1038             print '        _glGetIntegerv(GL_MAX_TEXTURE_UNITS, &max_texture_coords);'
1039             print '    for (GLint unit = 0; unit < max_texture_coords; ++unit) {'
1040             print '        GLint texture = GL_TEXTURE0 + unit;'
1041             print '        _glClientActiveTexture(texture);'
1042
1043     def array_trace_prolog(self, api, uppercase_name):
1044         if uppercase_name == 'TEXTURE_COORD':
1045             print '    bool client_active_texture_dirty = false;'
1046
1047     def array_epilog(self, api, uppercase_name):
1048         if uppercase_name == 'TEXTURE_COORD':
1049             print '    }'
1050         self.array_cleanup(api, uppercase_name)
1051
1052     def array_cleanup(self, api, uppercase_name):
1053         if uppercase_name == 'TEXTURE_COORD':
1054             print '    _glClientActiveTexture(client_active_texture);'
1055         
1056     def array_trace_intermezzo(self, api, uppercase_name):
1057         if uppercase_name == 'TEXTURE_COORD':
1058             print '    if (texture != client_active_texture || client_active_texture_dirty) {'
1059             print '        client_active_texture_dirty = true;'
1060             self.fake_glClientActiveTexture_call(api, "texture");
1061             print '    }'
1062
1063     def array_trace_epilog(self, api, uppercase_name):
1064         if uppercase_name == 'TEXTURE_COORD':
1065             print '    if (client_active_texture_dirty) {'
1066             self.fake_glClientActiveTexture_call(api, "client_active_texture");
1067             print '    }'
1068
1069     def fake_glClientActiveTexture_call(self, api, texture):
1070         function = api.getFunctionByName('glClientActiveTexture')
1071         self.fake_call(function, [texture])
1072
1073     def emitFakeTexture2D(self):
1074         function = glapi.glapi.getFunctionByName('glTexImage2D')
1075         instances = function.argNames()
1076         print '        unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)
1077         for arg in function.args:
1078             assert not arg.output
1079             self.serializeArg(function, arg)
1080         print '        trace::localWriter.endEnter();'
1081         print '        trace::localWriter.beginLeave(_fake_call);'
1082         print '        trace::localWriter.endLeave();'
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093