gltrace_api.cpp revision 93a826f78f6313db791e6fc880439189897651b3 
1/*
2 * Copyright 2011, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 * THIS FILE WAS GENERATED BY A SCRIPT. DO NOT EDIT.
17 */
18
19#include <cutils/log.h>
20#include <GLES2/gl2.h>
21
22#include "gltrace.pb.h"
23#include "gltrace_context.h"
24#include "gltrace_fixup.h"
25#include "gltrace_transport.h"
26
27namespace android {
28namespace gltrace {
29
30
31// Definitions for GL2 APIs
32
33void GLTrace_glActiveTexture(GLenum texture) {
34    GLMessage glmsg;
35    GLTraceContext *glContext = getGLTraceContext();
36
37    glmsg.set_function(GLMessage::glActiveTexture);
38
39    // copy argument texture
40    GLMessage_DataType *arg_texture = glmsg.add_args();
41    arg_texture->set_isarray(false);
42    arg_texture->set_type(GLMessage::DataType::ENUM);
43    arg_texture->add_intvalue((int)texture);
44
45    // call function
46    glContext->hooks->gl.glActiveTexture(texture);
47
48    fixupGLMessage(glContext, &glmsg);
49    glContext->traceGLMessage(&glmsg);
50}
51
52void GLTrace_glAttachShader(GLuint program, GLuint shader) {
53    GLMessage glmsg;
54    GLTraceContext *glContext = getGLTraceContext();
55
56    glmsg.set_function(GLMessage::glAttachShader);
57
58    // copy argument program
59    GLMessage_DataType *arg_program = glmsg.add_args();
60    arg_program->set_isarray(false);
61    arg_program->set_type(GLMessage::DataType::INT);
62    arg_program->add_intvalue(program);
63
64    // copy argument shader
65    GLMessage_DataType *arg_shader = glmsg.add_args();
66    arg_shader->set_isarray(false);
67    arg_shader->set_type(GLMessage::DataType::INT);
68    arg_shader->add_intvalue(shader);
69
70    // call function
71    glContext->hooks->gl.glAttachShader(program, shader);
72
73    fixupGLMessage(glContext, &glmsg);
74    glContext->traceGLMessage(&glmsg);
75}
76
77void GLTrace_glBindAttribLocation(GLuint program, GLuint index, const GLchar* name) {
78    GLMessage glmsg;
79    GLTraceContext *glContext = getGLTraceContext();
80
81    glmsg.set_function(GLMessage::glBindAttribLocation);
82
83    // copy argument program
84    GLMessage_DataType *arg_program = glmsg.add_args();
85    arg_program->set_isarray(false);
86    arg_program->set_type(GLMessage::DataType::INT);
87    arg_program->add_intvalue(program);
88
89    // copy argument index
90    GLMessage_DataType *arg_index = glmsg.add_args();
91    arg_index->set_isarray(false);
92    arg_index->set_type(GLMessage::DataType::INT);
93    arg_index->add_intvalue(index);
94
95    // copy argument name
96    GLMessage_DataType *arg_name = glmsg.add_args();
97    arg_name->set_isarray(false);
98    arg_name->set_type(GLMessage::DataType::INT);
99    arg_name->add_intvalue((int)name);
100
101    // call function
102    glContext->hooks->gl.glBindAttribLocation(program, index, name);
103
104    fixupGLMessage(glContext, &glmsg);
105    glContext->traceGLMessage(&glmsg);
106}
107
108void GLTrace_glBindBuffer(GLenum target, GLuint buffer) {
109    GLMessage glmsg;
110    GLTraceContext *glContext = getGLTraceContext();
111
112    glmsg.set_function(GLMessage::glBindBuffer);
113
114    // copy argument target
115    GLMessage_DataType *arg_target = glmsg.add_args();
116    arg_target->set_isarray(false);
117    arg_target->set_type(GLMessage::DataType::ENUM);
118    arg_target->add_intvalue((int)target);
119
120    // copy argument buffer
121    GLMessage_DataType *arg_buffer = glmsg.add_args();
122    arg_buffer->set_isarray(false);
123    arg_buffer->set_type(GLMessage::DataType::INT);
124    arg_buffer->add_intvalue(buffer);
125
126    // call function
127    glContext->hooks->gl.glBindBuffer(target, buffer);
128
129    fixupGLMessage(glContext, &glmsg);
130    glContext->traceGLMessage(&glmsg);
131}
132
133void GLTrace_glBindFramebuffer(GLenum target, GLuint framebuffer) {
134    GLMessage glmsg;
135    GLTraceContext *glContext = getGLTraceContext();
136
137    glmsg.set_function(GLMessage::glBindFramebuffer);
138
139    // copy argument target
140    GLMessage_DataType *arg_target = glmsg.add_args();
141    arg_target->set_isarray(false);
142    arg_target->set_type(GLMessage::DataType::ENUM);
143    arg_target->add_intvalue((int)target);
144
145    // copy argument framebuffer
146    GLMessage_DataType *arg_framebuffer = glmsg.add_args();
147    arg_framebuffer->set_isarray(false);
148    arg_framebuffer->set_type(GLMessage::DataType::INT);
149    arg_framebuffer->add_intvalue(framebuffer);
150
151    // call function
152    glContext->hooks->gl.glBindFramebuffer(target, framebuffer);
153
154    fixupGLMessage(glContext, &glmsg);
155    glContext->traceGLMessage(&glmsg);
156}
157
158void GLTrace_glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
159    GLMessage glmsg;
160    GLTraceContext *glContext = getGLTraceContext();
161
162    glmsg.set_function(GLMessage::glBindRenderbuffer);
163
164    // copy argument target
165    GLMessage_DataType *arg_target = glmsg.add_args();
166    arg_target->set_isarray(false);
167    arg_target->set_type(GLMessage::DataType::ENUM);
168    arg_target->add_intvalue((int)target);
169
170    // copy argument renderbuffer
171    GLMessage_DataType *arg_renderbuffer = glmsg.add_args();
172    arg_renderbuffer->set_isarray(false);
173    arg_renderbuffer->set_type(GLMessage::DataType::INT);
174    arg_renderbuffer->add_intvalue(renderbuffer);
175
176    // call function
177    glContext->hooks->gl.glBindRenderbuffer(target, renderbuffer);
178
179    fixupGLMessage(glContext, &glmsg);
180    glContext->traceGLMessage(&glmsg);
181}
182
183void GLTrace_glBindTexture(GLenum target, GLuint texture) {
184    GLMessage glmsg;
185    GLTraceContext *glContext = getGLTraceContext();
186
187    glmsg.set_function(GLMessage::glBindTexture);
188
189    // copy argument target
190    GLMessage_DataType *arg_target = glmsg.add_args();
191    arg_target->set_isarray(false);
192    arg_target->set_type(GLMessage::DataType::ENUM);
193    arg_target->add_intvalue((int)target);
194
195    // copy argument texture
196    GLMessage_DataType *arg_texture = glmsg.add_args();
197    arg_texture->set_isarray(false);
198    arg_texture->set_type(GLMessage::DataType::INT);
199    arg_texture->add_intvalue(texture);
200
201    // call function
202    glContext->hooks->gl.glBindTexture(target, texture);
203
204    fixupGLMessage(glContext, &glmsg);
205    glContext->traceGLMessage(&glmsg);
206}
207
208void GLTrace_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
209    GLMessage glmsg;
210    GLTraceContext *glContext = getGLTraceContext();
211
212    glmsg.set_function(GLMessage::glBlendColor);
213
214    // copy argument red
215    GLMessage_DataType *arg_red = glmsg.add_args();
216    arg_red->set_isarray(false);
217    arg_red->set_type(GLMessage::DataType::FLOAT);
218    arg_red->add_floatvalue(red);
219
220    // copy argument green
221    GLMessage_DataType *arg_green = glmsg.add_args();
222    arg_green->set_isarray(false);
223    arg_green->set_type(GLMessage::DataType::FLOAT);
224    arg_green->add_floatvalue(green);
225
226    // copy argument blue
227    GLMessage_DataType *arg_blue = glmsg.add_args();
228    arg_blue->set_isarray(false);
229    arg_blue->set_type(GLMessage::DataType::FLOAT);
230    arg_blue->add_floatvalue(blue);
231
232    // copy argument alpha
233    GLMessage_DataType *arg_alpha = glmsg.add_args();
234    arg_alpha->set_isarray(false);
235    arg_alpha->set_type(GLMessage::DataType::FLOAT);
236    arg_alpha->add_floatvalue(alpha);
237
238    // call function
239    glContext->hooks->gl.glBlendColor(red, green, blue, alpha);
240
241    fixupGLMessage(glContext, &glmsg);
242    glContext->traceGLMessage(&glmsg);
243}
244
245void GLTrace_glBlendEquation(GLenum mode) {
246    GLMessage glmsg;
247    GLTraceContext *glContext = getGLTraceContext();
248
249    glmsg.set_function(GLMessage::glBlendEquation);
250
251    // copy argument mode
252    GLMessage_DataType *arg_mode = glmsg.add_args();
253    arg_mode->set_isarray(false);
254    arg_mode->set_type(GLMessage::DataType::ENUM);
255    arg_mode->add_intvalue((int)mode);
256
257    // call function
258    glContext->hooks->gl.glBlendEquation(mode);
259
260    fixupGLMessage(glContext, &glmsg);
261    glContext->traceGLMessage(&glmsg);
262}
263
264void GLTrace_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
265    GLMessage glmsg;
266    GLTraceContext *glContext = getGLTraceContext();
267
268    glmsg.set_function(GLMessage::glBlendEquationSeparate);
269
270    // copy argument modeRGB
271    GLMessage_DataType *arg_modeRGB = glmsg.add_args();
272    arg_modeRGB->set_isarray(false);
273    arg_modeRGB->set_type(GLMessage::DataType::ENUM);
274    arg_modeRGB->add_intvalue((int)modeRGB);
275
276    // copy argument modeAlpha
277    GLMessage_DataType *arg_modeAlpha = glmsg.add_args();
278    arg_modeAlpha->set_isarray(false);
279    arg_modeAlpha->set_type(GLMessage::DataType::ENUM);
280    arg_modeAlpha->add_intvalue((int)modeAlpha);
281
282    // call function
283    glContext->hooks->gl.glBlendEquationSeparate(modeRGB, modeAlpha);
284
285    fixupGLMessage(glContext, &glmsg);
286    glContext->traceGLMessage(&glmsg);
287}
288
289void GLTrace_glBlendFunc(GLenum sfactor, GLenum dfactor) {
290    GLMessage glmsg;
291    GLTraceContext *glContext = getGLTraceContext();
292
293    glmsg.set_function(GLMessage::glBlendFunc);
294
295    // copy argument sfactor
296    GLMessage_DataType *arg_sfactor = glmsg.add_args();
297    arg_sfactor->set_isarray(false);
298    arg_sfactor->set_type(GLMessage::DataType::ENUM);
299    arg_sfactor->add_intvalue((int)sfactor);
300
301    // copy argument dfactor
302    GLMessage_DataType *arg_dfactor = glmsg.add_args();
303    arg_dfactor->set_isarray(false);
304    arg_dfactor->set_type(GLMessage::DataType::ENUM);
305    arg_dfactor->add_intvalue((int)dfactor);
306
307    // call function
308    glContext->hooks->gl.glBlendFunc(sfactor, dfactor);
309
310    fixupGLMessage(glContext, &glmsg);
311    glContext->traceGLMessage(&glmsg);
312}
313
314void GLTrace_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
315    GLMessage glmsg;
316    GLTraceContext *glContext = getGLTraceContext();
317
318    glmsg.set_function(GLMessage::glBlendFuncSeparate);
319
320    // copy argument srcRGB
321    GLMessage_DataType *arg_srcRGB = glmsg.add_args();
322    arg_srcRGB->set_isarray(false);
323    arg_srcRGB->set_type(GLMessage::DataType::ENUM);
324    arg_srcRGB->add_intvalue((int)srcRGB);
325
326    // copy argument dstRGB
327    GLMessage_DataType *arg_dstRGB = glmsg.add_args();
328    arg_dstRGB->set_isarray(false);
329    arg_dstRGB->set_type(GLMessage::DataType::ENUM);
330    arg_dstRGB->add_intvalue((int)dstRGB);
331
332    // copy argument srcAlpha
333    GLMessage_DataType *arg_srcAlpha = glmsg.add_args();
334    arg_srcAlpha->set_isarray(false);
335    arg_srcAlpha->set_type(GLMessage::DataType::ENUM);
336    arg_srcAlpha->add_intvalue((int)srcAlpha);
337
338    // copy argument dstAlpha
339    GLMessage_DataType *arg_dstAlpha = glmsg.add_args();
340    arg_dstAlpha->set_isarray(false);
341    arg_dstAlpha->set_type(GLMessage::DataType::ENUM);
342    arg_dstAlpha->add_intvalue((int)dstAlpha);
343
344    // call function
345    glContext->hooks->gl.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
346
347    fixupGLMessage(glContext, &glmsg);
348    glContext->traceGLMessage(&glmsg);
349}
350
351void GLTrace_glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) {
352    GLMessage glmsg;
353    GLTraceContext *glContext = getGLTraceContext();
354
355    glmsg.set_function(GLMessage::glBufferData);
356
357    // copy argument target
358    GLMessage_DataType *arg_target = glmsg.add_args();
359    arg_target->set_isarray(false);
360    arg_target->set_type(GLMessage::DataType::ENUM);
361    arg_target->add_intvalue((int)target);
362
363    // copy argument size
364    GLMessage_DataType *arg_size = glmsg.add_args();
365    arg_size->set_isarray(false);
366    arg_size->set_type(GLMessage::DataType::INT);
367    arg_size->add_intvalue((int)size);
368
369    // copy argument data
370    GLMessage_DataType *arg_data = glmsg.add_args();
371    arg_data->set_isarray(false);
372    arg_data->set_type(GLMessage::DataType::INT);
373    arg_data->add_intvalue((int)data);
374
375    // copy argument usage
376    GLMessage_DataType *arg_usage = glmsg.add_args();
377    arg_usage->set_isarray(false);
378    arg_usage->set_type(GLMessage::DataType::ENUM);
379    arg_usage->add_intvalue((int)usage);
380
381    // call function
382    glContext->hooks->gl.glBufferData(target, size, data, usage);
383
384    fixupGLMessage(glContext, &glmsg);
385    glContext->traceGLMessage(&glmsg);
386}
387
388void GLTrace_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) {
389    GLMessage glmsg;
390    GLTraceContext *glContext = getGLTraceContext();
391
392    glmsg.set_function(GLMessage::glBufferSubData);
393
394    // copy argument target
395    GLMessage_DataType *arg_target = glmsg.add_args();
396    arg_target->set_isarray(false);
397    arg_target->set_type(GLMessage::DataType::ENUM);
398    arg_target->add_intvalue((int)target);
399
400    // copy argument offset
401    GLMessage_DataType *arg_offset = glmsg.add_args();
402    arg_offset->set_isarray(false);
403    arg_offset->set_type(GLMessage::DataType::INT);
404    arg_offset->add_intvalue((int)offset);
405
406    // copy argument size
407    GLMessage_DataType *arg_size = glmsg.add_args();
408    arg_size->set_isarray(false);
409    arg_size->set_type(GLMessage::DataType::INT);
410    arg_size->add_intvalue((int)size);
411
412    // copy argument data
413    GLMessage_DataType *arg_data = glmsg.add_args();
414    arg_data->set_isarray(false);
415    arg_data->set_type(GLMessage::DataType::INT);
416    arg_data->add_intvalue((int)data);
417
418    // call function
419    glContext->hooks->gl.glBufferSubData(target, offset, size, data);
420
421    fixupGLMessage(glContext, &glmsg);
422    glContext->traceGLMessage(&glmsg);
423}
424
425GLenum GLTrace_glCheckFramebufferStatus(GLenum target) {
426    GLMessage glmsg;
427    GLTraceContext *glContext = getGLTraceContext();
428
429    glmsg.set_function(GLMessage::glCheckFramebufferStatus);
430
431    // copy argument target
432    GLMessage_DataType *arg_target = glmsg.add_args();
433    arg_target->set_isarray(false);
434    arg_target->set_type(GLMessage::DataType::ENUM);
435    arg_target->add_intvalue((int)target);
436
437    // call function
438    GLenum retValue = glContext->hooks->gl.glCheckFramebufferStatus(target);
439
440    // set return value
441    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
442    rt->set_isarray(false);
443    rt->set_type(GLMessage::DataType::ENUM);
444    rt->add_intvalue((int)retValue);
445
446    fixupGLMessage(glContext, &glmsg);
447    glContext->traceGLMessage(&glmsg);
448
449    return retValue;
450}
451
452void GLTrace_glClear(GLbitfield mask) {
453    GLMessage glmsg;
454    GLTraceContext *glContext = getGLTraceContext();
455
456    glmsg.set_function(GLMessage::glClear);
457
458    // copy argument mask
459    GLMessage_DataType *arg_mask = glmsg.add_args();
460    arg_mask->set_isarray(false);
461    arg_mask->set_type(GLMessage::DataType::INT);
462    arg_mask->add_intvalue(mask);
463
464    // call function
465    glContext->hooks->gl.glClear(mask);
466
467    fixupGLMessage(glContext, &glmsg);
468    glContext->traceGLMessage(&glmsg);
469}
470
471void GLTrace_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
472    GLMessage glmsg;
473    GLTraceContext *glContext = getGLTraceContext();
474
475    glmsg.set_function(GLMessage::glClearColor);
476
477    // copy argument red
478    GLMessage_DataType *arg_red = glmsg.add_args();
479    arg_red->set_isarray(false);
480    arg_red->set_type(GLMessage::DataType::FLOAT);
481    arg_red->add_floatvalue(red);
482
483    // copy argument green
484    GLMessage_DataType *arg_green = glmsg.add_args();
485    arg_green->set_isarray(false);
486    arg_green->set_type(GLMessage::DataType::FLOAT);
487    arg_green->add_floatvalue(green);
488
489    // copy argument blue
490    GLMessage_DataType *arg_blue = glmsg.add_args();
491    arg_blue->set_isarray(false);
492    arg_blue->set_type(GLMessage::DataType::FLOAT);
493    arg_blue->add_floatvalue(blue);
494
495    // copy argument alpha
496    GLMessage_DataType *arg_alpha = glmsg.add_args();
497    arg_alpha->set_isarray(false);
498    arg_alpha->set_type(GLMessage::DataType::FLOAT);
499    arg_alpha->add_floatvalue(alpha);
500
501    // call function
502    glContext->hooks->gl.glClearColor(red, green, blue, alpha);
503
504    fixupGLMessage(glContext, &glmsg);
505    glContext->traceGLMessage(&glmsg);
506}
507
508void GLTrace_glClearDepthf(GLclampf depth) {
509    GLMessage glmsg;
510    GLTraceContext *glContext = getGLTraceContext();
511
512    glmsg.set_function(GLMessage::glClearDepthf);
513
514    // copy argument depth
515    GLMessage_DataType *arg_depth = glmsg.add_args();
516    arg_depth->set_isarray(false);
517    arg_depth->set_type(GLMessage::DataType::FLOAT);
518    arg_depth->add_floatvalue(depth);
519
520    // call function
521    glContext->hooks->gl.glClearDepthf(depth);
522
523    fixupGLMessage(glContext, &glmsg);
524    glContext->traceGLMessage(&glmsg);
525}
526
527void GLTrace_glClearStencil(GLint s) {
528    GLMessage glmsg;
529    GLTraceContext *glContext = getGLTraceContext();
530
531    glmsg.set_function(GLMessage::glClearStencil);
532
533    // copy argument s
534    GLMessage_DataType *arg_s = glmsg.add_args();
535    arg_s->set_isarray(false);
536    arg_s->set_type(GLMessage::DataType::INT);
537    arg_s->add_intvalue(s);
538
539    // call function
540    glContext->hooks->gl.glClearStencil(s);
541
542    fixupGLMessage(glContext, &glmsg);
543    glContext->traceGLMessage(&glmsg);
544}
545
546void GLTrace_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
547    GLMessage glmsg;
548    GLTraceContext *glContext = getGLTraceContext();
549
550    glmsg.set_function(GLMessage::glColorMask);
551
552    // copy argument red
553    GLMessage_DataType *arg_red = glmsg.add_args();
554    arg_red->set_isarray(false);
555    arg_red->set_type(GLMessage::DataType::BOOL);
556    arg_red->add_boolvalue(red);
557
558    // copy argument green
559    GLMessage_DataType *arg_green = glmsg.add_args();
560    arg_green->set_isarray(false);
561    arg_green->set_type(GLMessage::DataType::BOOL);
562    arg_green->add_boolvalue(green);
563
564    // copy argument blue
565    GLMessage_DataType *arg_blue = glmsg.add_args();
566    arg_blue->set_isarray(false);
567    arg_blue->set_type(GLMessage::DataType::BOOL);
568    arg_blue->add_boolvalue(blue);
569
570    // copy argument alpha
571    GLMessage_DataType *arg_alpha = glmsg.add_args();
572    arg_alpha->set_isarray(false);
573    arg_alpha->set_type(GLMessage::DataType::BOOL);
574    arg_alpha->add_boolvalue(alpha);
575
576    // call function
577    glContext->hooks->gl.glColorMask(red, green, blue, alpha);
578
579    fixupGLMessage(glContext, &glmsg);
580    glContext->traceGLMessage(&glmsg);
581}
582
583void GLTrace_glCompileShader(GLuint shader) {
584    GLMessage glmsg;
585    GLTraceContext *glContext = getGLTraceContext();
586
587    glmsg.set_function(GLMessage::glCompileShader);
588
589    // copy argument shader
590    GLMessage_DataType *arg_shader = glmsg.add_args();
591    arg_shader->set_isarray(false);
592    arg_shader->set_type(GLMessage::DataType::INT);
593    arg_shader->add_intvalue(shader);
594
595    // call function
596    glContext->hooks->gl.glCompileShader(shader);
597
598    fixupGLMessage(glContext, &glmsg);
599    glContext->traceGLMessage(&glmsg);
600}
601
602void GLTrace_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) {
603    GLMessage glmsg;
604    GLTraceContext *glContext = getGLTraceContext();
605
606    glmsg.set_function(GLMessage::glCompressedTexImage2D);
607
608    // copy argument target
609    GLMessage_DataType *arg_target = glmsg.add_args();
610    arg_target->set_isarray(false);
611    arg_target->set_type(GLMessage::DataType::ENUM);
612    arg_target->add_intvalue((int)target);
613
614    // copy argument level
615    GLMessage_DataType *arg_level = glmsg.add_args();
616    arg_level->set_isarray(false);
617    arg_level->set_type(GLMessage::DataType::INT);
618    arg_level->add_intvalue(level);
619
620    // copy argument internalformat
621    GLMessage_DataType *arg_internalformat = glmsg.add_args();
622    arg_internalformat->set_isarray(false);
623    arg_internalformat->set_type(GLMessage::DataType::ENUM);
624    arg_internalformat->add_intvalue((int)internalformat);
625
626    // copy argument width
627    GLMessage_DataType *arg_width = glmsg.add_args();
628    arg_width->set_isarray(false);
629    arg_width->set_type(GLMessage::DataType::INT);
630    arg_width->add_intvalue(width);
631
632    // copy argument height
633    GLMessage_DataType *arg_height = glmsg.add_args();
634    arg_height->set_isarray(false);
635    arg_height->set_type(GLMessage::DataType::INT);
636    arg_height->add_intvalue(height);
637
638    // copy argument border
639    GLMessage_DataType *arg_border = glmsg.add_args();
640    arg_border->set_isarray(false);
641    arg_border->set_type(GLMessage::DataType::INT);
642    arg_border->add_intvalue(border);
643
644    // copy argument imageSize
645    GLMessage_DataType *arg_imageSize = glmsg.add_args();
646    arg_imageSize->set_isarray(false);
647    arg_imageSize->set_type(GLMessage::DataType::INT);
648    arg_imageSize->add_intvalue(imageSize);
649
650    // copy argument data
651    GLMessage_DataType *arg_data = glmsg.add_args();
652    arg_data->set_isarray(false);
653    arg_data->set_type(GLMessage::DataType::INT);
654    arg_data->add_intvalue((int)data);
655
656    // call function
657    glContext->hooks->gl.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
658
659    fixupGLMessage(glContext, &glmsg);
660    glContext->traceGLMessage(&glmsg);
661}
662
663void GLTrace_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) {
664    GLMessage glmsg;
665    GLTraceContext *glContext = getGLTraceContext();
666
667    glmsg.set_function(GLMessage::glCompressedTexSubImage2D);
668
669    // copy argument target
670    GLMessage_DataType *arg_target = glmsg.add_args();
671    arg_target->set_isarray(false);
672    arg_target->set_type(GLMessage::DataType::ENUM);
673    arg_target->add_intvalue((int)target);
674
675    // copy argument level
676    GLMessage_DataType *arg_level = glmsg.add_args();
677    arg_level->set_isarray(false);
678    arg_level->set_type(GLMessage::DataType::INT);
679    arg_level->add_intvalue(level);
680
681    // copy argument xoffset
682    GLMessage_DataType *arg_xoffset = glmsg.add_args();
683    arg_xoffset->set_isarray(false);
684    arg_xoffset->set_type(GLMessage::DataType::INT);
685    arg_xoffset->add_intvalue(xoffset);
686
687    // copy argument yoffset
688    GLMessage_DataType *arg_yoffset = glmsg.add_args();
689    arg_yoffset->set_isarray(false);
690    arg_yoffset->set_type(GLMessage::DataType::INT);
691    arg_yoffset->add_intvalue(yoffset);
692
693    // copy argument width
694    GLMessage_DataType *arg_width = glmsg.add_args();
695    arg_width->set_isarray(false);
696    arg_width->set_type(GLMessage::DataType::INT);
697    arg_width->add_intvalue(width);
698
699    // copy argument height
700    GLMessage_DataType *arg_height = glmsg.add_args();
701    arg_height->set_isarray(false);
702    arg_height->set_type(GLMessage::DataType::INT);
703    arg_height->add_intvalue(height);
704
705    // copy argument format
706    GLMessage_DataType *arg_format = glmsg.add_args();
707    arg_format->set_isarray(false);
708    arg_format->set_type(GLMessage::DataType::ENUM);
709    arg_format->add_intvalue((int)format);
710
711    // copy argument imageSize
712    GLMessage_DataType *arg_imageSize = glmsg.add_args();
713    arg_imageSize->set_isarray(false);
714    arg_imageSize->set_type(GLMessage::DataType::INT);
715    arg_imageSize->add_intvalue(imageSize);
716
717    // copy argument data
718    GLMessage_DataType *arg_data = glmsg.add_args();
719    arg_data->set_isarray(false);
720    arg_data->set_type(GLMessage::DataType::INT);
721    arg_data->add_intvalue((int)data);
722
723    // call function
724    glContext->hooks->gl.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
725
726    fixupGLMessage(glContext, &glmsg);
727    glContext->traceGLMessage(&glmsg);
728}
729
730void GLTrace_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
731    GLMessage glmsg;
732    GLTraceContext *glContext = getGLTraceContext();
733
734    glmsg.set_function(GLMessage::glCopyTexImage2D);
735
736    // copy argument target
737    GLMessage_DataType *arg_target = glmsg.add_args();
738    arg_target->set_isarray(false);
739    arg_target->set_type(GLMessage::DataType::ENUM);
740    arg_target->add_intvalue((int)target);
741
742    // copy argument level
743    GLMessage_DataType *arg_level = glmsg.add_args();
744    arg_level->set_isarray(false);
745    arg_level->set_type(GLMessage::DataType::INT);
746    arg_level->add_intvalue(level);
747
748    // copy argument internalformat
749    GLMessage_DataType *arg_internalformat = glmsg.add_args();
750    arg_internalformat->set_isarray(false);
751    arg_internalformat->set_type(GLMessage::DataType::ENUM);
752    arg_internalformat->add_intvalue((int)internalformat);
753
754    // copy argument x
755    GLMessage_DataType *arg_x = glmsg.add_args();
756    arg_x->set_isarray(false);
757    arg_x->set_type(GLMessage::DataType::INT);
758    arg_x->add_intvalue(x);
759
760    // copy argument y
761    GLMessage_DataType *arg_y = glmsg.add_args();
762    arg_y->set_isarray(false);
763    arg_y->set_type(GLMessage::DataType::INT);
764    arg_y->add_intvalue(y);
765
766    // copy argument width
767    GLMessage_DataType *arg_width = glmsg.add_args();
768    arg_width->set_isarray(false);
769    arg_width->set_type(GLMessage::DataType::INT);
770    arg_width->add_intvalue(width);
771
772    // copy argument height
773    GLMessage_DataType *arg_height = glmsg.add_args();
774    arg_height->set_isarray(false);
775    arg_height->set_type(GLMessage::DataType::INT);
776    arg_height->add_intvalue(height);
777
778    // copy argument border
779    GLMessage_DataType *arg_border = glmsg.add_args();
780    arg_border->set_isarray(false);
781    arg_border->set_type(GLMessage::DataType::INT);
782    arg_border->add_intvalue(border);
783
784    // call function
785    glContext->hooks->gl.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
786
787    fixupGLMessage(glContext, &glmsg);
788    glContext->traceGLMessage(&glmsg);
789}
790
791void GLTrace_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
792    GLMessage glmsg;
793    GLTraceContext *glContext = getGLTraceContext();
794
795    glmsg.set_function(GLMessage::glCopyTexSubImage2D);
796
797    // copy argument target
798    GLMessage_DataType *arg_target = glmsg.add_args();
799    arg_target->set_isarray(false);
800    arg_target->set_type(GLMessage::DataType::ENUM);
801    arg_target->add_intvalue((int)target);
802
803    // copy argument level
804    GLMessage_DataType *arg_level = glmsg.add_args();
805    arg_level->set_isarray(false);
806    arg_level->set_type(GLMessage::DataType::INT);
807    arg_level->add_intvalue(level);
808
809    // copy argument xoffset
810    GLMessage_DataType *arg_xoffset = glmsg.add_args();
811    arg_xoffset->set_isarray(false);
812    arg_xoffset->set_type(GLMessage::DataType::INT);
813    arg_xoffset->add_intvalue(xoffset);
814
815    // copy argument yoffset
816    GLMessage_DataType *arg_yoffset = glmsg.add_args();
817    arg_yoffset->set_isarray(false);
818    arg_yoffset->set_type(GLMessage::DataType::INT);
819    arg_yoffset->add_intvalue(yoffset);
820
821    // copy argument x
822    GLMessage_DataType *arg_x = glmsg.add_args();
823    arg_x->set_isarray(false);
824    arg_x->set_type(GLMessage::DataType::INT);
825    arg_x->add_intvalue(x);
826
827    // copy argument y
828    GLMessage_DataType *arg_y = glmsg.add_args();
829    arg_y->set_isarray(false);
830    arg_y->set_type(GLMessage::DataType::INT);
831    arg_y->add_intvalue(y);
832
833    // copy argument width
834    GLMessage_DataType *arg_width = glmsg.add_args();
835    arg_width->set_isarray(false);
836    arg_width->set_type(GLMessage::DataType::INT);
837    arg_width->add_intvalue(width);
838
839    // copy argument height
840    GLMessage_DataType *arg_height = glmsg.add_args();
841    arg_height->set_isarray(false);
842    arg_height->set_type(GLMessage::DataType::INT);
843    arg_height->add_intvalue(height);
844
845    // call function
846    glContext->hooks->gl.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
847
848    fixupGLMessage(glContext, &glmsg);
849    glContext->traceGLMessage(&glmsg);
850}
851
852GLuint GLTrace_glCreateProgram(void) {
853    GLMessage glmsg;
854    GLTraceContext *glContext = getGLTraceContext();
855
856    glmsg.set_function(GLMessage::glCreateProgram);
857
858    // call function
859    GLuint retValue = glContext->hooks->gl.glCreateProgram();
860
861    // set return value
862    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
863    rt->set_isarray(false);
864    rt->set_type(GLMessage::DataType::INT);
865    rt->add_intvalue(retValue);
866
867    fixupGLMessage(glContext, &glmsg);
868    glContext->traceGLMessage(&glmsg);
869
870    return retValue;
871}
872
873GLuint GLTrace_glCreateShader(GLenum type) {
874    GLMessage glmsg;
875    GLTraceContext *glContext = getGLTraceContext();
876
877    glmsg.set_function(GLMessage::glCreateShader);
878
879    // copy argument type
880    GLMessage_DataType *arg_type = glmsg.add_args();
881    arg_type->set_isarray(false);
882    arg_type->set_type(GLMessage::DataType::ENUM);
883    arg_type->add_intvalue((int)type);
884
885    // call function
886    GLuint retValue = glContext->hooks->gl.glCreateShader(type);
887
888    // set return value
889    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
890    rt->set_isarray(false);
891    rt->set_type(GLMessage::DataType::INT);
892    rt->add_intvalue(retValue);
893
894    fixupGLMessage(glContext, &glmsg);
895    glContext->traceGLMessage(&glmsg);
896
897    return retValue;
898}
899
900void GLTrace_glCullFace(GLenum mode) {
901    GLMessage glmsg;
902    GLTraceContext *glContext = getGLTraceContext();
903
904    glmsg.set_function(GLMessage::glCullFace);
905
906    // copy argument mode
907    GLMessage_DataType *arg_mode = glmsg.add_args();
908    arg_mode->set_isarray(false);
909    arg_mode->set_type(GLMessage::DataType::ENUM);
910    arg_mode->add_intvalue((int)mode);
911
912    // call function
913    glContext->hooks->gl.glCullFace(mode);
914
915    fixupGLMessage(glContext, &glmsg);
916    glContext->traceGLMessage(&glmsg);
917}
918
919void GLTrace_glDeleteBuffers(GLsizei n, const GLuint* buffers) {
920    GLMessage glmsg;
921    GLTraceContext *glContext = getGLTraceContext();
922
923    glmsg.set_function(GLMessage::glDeleteBuffers);
924
925    // copy argument n
926    GLMessage_DataType *arg_n = glmsg.add_args();
927    arg_n->set_isarray(false);
928    arg_n->set_type(GLMessage::DataType::INT);
929    arg_n->add_intvalue(n);
930
931    // copy argument buffers
932    GLMessage_DataType *arg_buffers = glmsg.add_args();
933    arg_buffers->set_isarray(false);
934    arg_buffers->set_type(GLMessage::DataType::INT);
935    arg_buffers->add_intvalue((int)buffers);
936
937    // call function
938    glContext->hooks->gl.glDeleteBuffers(n, buffers);
939
940    fixupGLMessage(glContext, &glmsg);
941    glContext->traceGLMessage(&glmsg);
942}
943
944void GLTrace_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
945    GLMessage glmsg;
946    GLTraceContext *glContext = getGLTraceContext();
947
948    glmsg.set_function(GLMessage::glDeleteFramebuffers);
949
950    // copy argument n
951    GLMessage_DataType *arg_n = glmsg.add_args();
952    arg_n->set_isarray(false);
953    arg_n->set_type(GLMessage::DataType::INT);
954    arg_n->add_intvalue(n);
955
956    // copy argument framebuffers
957    GLMessage_DataType *arg_framebuffers = glmsg.add_args();
958    arg_framebuffers->set_isarray(false);
959    arg_framebuffers->set_type(GLMessage::DataType::INT);
960    arg_framebuffers->add_intvalue((int)framebuffers);
961
962    // call function
963    glContext->hooks->gl.glDeleteFramebuffers(n, framebuffers);
964
965    fixupGLMessage(glContext, &glmsg);
966    glContext->traceGLMessage(&glmsg);
967}
968
969void GLTrace_glDeleteProgram(GLuint program) {
970    GLMessage glmsg;
971    GLTraceContext *glContext = getGLTraceContext();
972
973    glmsg.set_function(GLMessage::glDeleteProgram);
974
975    // copy argument program
976    GLMessage_DataType *arg_program = glmsg.add_args();
977    arg_program->set_isarray(false);
978    arg_program->set_type(GLMessage::DataType::INT);
979    arg_program->add_intvalue(program);
980
981    // call function
982    glContext->hooks->gl.glDeleteProgram(program);
983
984    fixupGLMessage(glContext, &glmsg);
985    glContext->traceGLMessage(&glmsg);
986}
987
988void GLTrace_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
989    GLMessage glmsg;
990    GLTraceContext *glContext = getGLTraceContext();
991
992    glmsg.set_function(GLMessage::glDeleteRenderbuffers);
993
994    // copy argument n
995    GLMessage_DataType *arg_n = glmsg.add_args();
996    arg_n->set_isarray(false);
997    arg_n->set_type(GLMessage::DataType::INT);
998    arg_n->add_intvalue(n);
999
1000    // copy argument renderbuffers
1001    GLMessage_DataType *arg_renderbuffers = glmsg.add_args();
1002    arg_renderbuffers->set_isarray(false);
1003    arg_renderbuffers->set_type(GLMessage::DataType::INT);
1004    arg_renderbuffers->add_intvalue((int)renderbuffers);
1005
1006    // call function
1007    glContext->hooks->gl.glDeleteRenderbuffers(n, renderbuffers);
1008
1009    fixupGLMessage(glContext, &glmsg);
1010    glContext->traceGLMessage(&glmsg);
1011}
1012
1013void GLTrace_glDeleteShader(GLuint shader) {
1014    GLMessage glmsg;
1015    GLTraceContext *glContext = getGLTraceContext();
1016
1017    glmsg.set_function(GLMessage::glDeleteShader);
1018
1019    // copy argument shader
1020    GLMessage_DataType *arg_shader = glmsg.add_args();
1021    arg_shader->set_isarray(false);
1022    arg_shader->set_type(GLMessage::DataType::INT);
1023    arg_shader->add_intvalue(shader);
1024
1025    // call function
1026    glContext->hooks->gl.glDeleteShader(shader);
1027
1028    fixupGLMessage(glContext, &glmsg);
1029    glContext->traceGLMessage(&glmsg);
1030}
1031
1032void GLTrace_glDeleteTextures(GLsizei n, const GLuint* textures) {
1033    GLMessage glmsg;
1034    GLTraceContext *glContext = getGLTraceContext();
1035
1036    glmsg.set_function(GLMessage::glDeleteTextures);
1037
1038    // copy argument n
1039    GLMessage_DataType *arg_n = glmsg.add_args();
1040    arg_n->set_isarray(false);
1041    arg_n->set_type(GLMessage::DataType::INT);
1042    arg_n->add_intvalue(n);
1043
1044    // copy argument textures
1045    GLMessage_DataType *arg_textures = glmsg.add_args();
1046    arg_textures->set_isarray(false);
1047    arg_textures->set_type(GLMessage::DataType::INT);
1048    arg_textures->add_intvalue((int)textures);
1049
1050    // call function
1051    glContext->hooks->gl.glDeleteTextures(n, textures);
1052
1053    fixupGLMessage(glContext, &glmsg);
1054    glContext->traceGLMessage(&glmsg);
1055}
1056
1057void GLTrace_glDepthFunc(GLenum func) {
1058    GLMessage glmsg;
1059    GLTraceContext *glContext = getGLTraceContext();
1060
1061    glmsg.set_function(GLMessage::glDepthFunc);
1062
1063    // copy argument func
1064    GLMessage_DataType *arg_func = glmsg.add_args();
1065    arg_func->set_isarray(false);
1066    arg_func->set_type(GLMessage::DataType::ENUM);
1067    arg_func->add_intvalue((int)func);
1068
1069    // call function
1070    glContext->hooks->gl.glDepthFunc(func);
1071
1072    fixupGLMessage(glContext, &glmsg);
1073    glContext->traceGLMessage(&glmsg);
1074}
1075
1076void GLTrace_glDepthMask(GLboolean flag) {
1077    GLMessage glmsg;
1078    GLTraceContext *glContext = getGLTraceContext();
1079
1080    glmsg.set_function(GLMessage::glDepthMask);
1081
1082    // copy argument flag
1083    GLMessage_DataType *arg_flag = glmsg.add_args();
1084    arg_flag->set_isarray(false);
1085    arg_flag->set_type(GLMessage::DataType::BOOL);
1086    arg_flag->add_boolvalue(flag);
1087
1088    // call function
1089    glContext->hooks->gl.glDepthMask(flag);
1090
1091    fixupGLMessage(glContext, &glmsg);
1092    glContext->traceGLMessage(&glmsg);
1093}
1094
1095void GLTrace_glDepthRangef(GLclampf zNear, GLclampf zFar) {
1096    GLMessage glmsg;
1097    GLTraceContext *glContext = getGLTraceContext();
1098
1099    glmsg.set_function(GLMessage::glDepthRangef);
1100
1101    // copy argument zNear
1102    GLMessage_DataType *arg_zNear = glmsg.add_args();
1103    arg_zNear->set_isarray(false);
1104    arg_zNear->set_type(GLMessage::DataType::FLOAT);
1105    arg_zNear->add_floatvalue(zNear);
1106
1107    // copy argument zFar
1108    GLMessage_DataType *arg_zFar = glmsg.add_args();
1109    arg_zFar->set_isarray(false);
1110    arg_zFar->set_type(GLMessage::DataType::FLOAT);
1111    arg_zFar->add_floatvalue(zFar);
1112
1113    // call function
1114    glContext->hooks->gl.glDepthRangef(zNear, zFar);
1115
1116    fixupGLMessage(glContext, &glmsg);
1117    glContext->traceGLMessage(&glmsg);
1118}
1119
1120void GLTrace_glDetachShader(GLuint program, GLuint shader) {
1121    GLMessage glmsg;
1122    GLTraceContext *glContext = getGLTraceContext();
1123
1124    glmsg.set_function(GLMessage::glDetachShader);
1125
1126    // copy argument program
1127    GLMessage_DataType *arg_program = glmsg.add_args();
1128    arg_program->set_isarray(false);
1129    arg_program->set_type(GLMessage::DataType::INT);
1130    arg_program->add_intvalue(program);
1131
1132    // copy argument shader
1133    GLMessage_DataType *arg_shader = glmsg.add_args();
1134    arg_shader->set_isarray(false);
1135    arg_shader->set_type(GLMessage::DataType::INT);
1136    arg_shader->add_intvalue(shader);
1137
1138    // call function
1139    glContext->hooks->gl.glDetachShader(program, shader);
1140
1141    fixupGLMessage(glContext, &glmsg);
1142    glContext->traceGLMessage(&glmsg);
1143}
1144
1145void GLTrace_glDisable(GLenum cap) {
1146    GLMessage glmsg;
1147    GLTraceContext *glContext = getGLTraceContext();
1148
1149    glmsg.set_function(GLMessage::glDisable);
1150
1151    // copy argument cap
1152    GLMessage_DataType *arg_cap = glmsg.add_args();
1153    arg_cap->set_isarray(false);
1154    arg_cap->set_type(GLMessage::DataType::ENUM);
1155    arg_cap->add_intvalue((int)cap);
1156
1157    // call function
1158    glContext->hooks->gl.glDisable(cap);
1159
1160    fixupGLMessage(glContext, &glmsg);
1161    glContext->traceGLMessage(&glmsg);
1162}
1163
1164void GLTrace_glDisableVertexAttribArray(GLuint index) {
1165    GLMessage glmsg;
1166    GLTraceContext *glContext = getGLTraceContext();
1167
1168    glmsg.set_function(GLMessage::glDisableVertexAttribArray);
1169
1170    // copy argument index
1171    GLMessage_DataType *arg_index = glmsg.add_args();
1172    arg_index->set_isarray(false);
1173    arg_index->set_type(GLMessage::DataType::INT);
1174    arg_index->add_intvalue(index);
1175
1176    // call function
1177    glContext->hooks->gl.glDisableVertexAttribArray(index);
1178
1179    fixupGLMessage(glContext, &glmsg);
1180    glContext->traceGLMessage(&glmsg);
1181}
1182
1183void GLTrace_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
1184    GLMessage glmsg;
1185    GLTraceContext *glContext = getGLTraceContext();
1186
1187    glmsg.set_function(GLMessage::glDrawArrays);
1188
1189    // copy argument mode
1190    GLMessage_DataType *arg_mode = glmsg.add_args();
1191    arg_mode->set_isarray(false);
1192    arg_mode->set_type(GLMessage::DataType::ENUM);
1193    arg_mode->add_intvalue((int)mode);
1194
1195    // copy argument first
1196    GLMessage_DataType *arg_first = glmsg.add_args();
1197    arg_first->set_isarray(false);
1198    arg_first->set_type(GLMessage::DataType::INT);
1199    arg_first->add_intvalue(first);
1200
1201    // copy argument count
1202    GLMessage_DataType *arg_count = glmsg.add_args();
1203    arg_count->set_isarray(false);
1204    arg_count->set_type(GLMessage::DataType::INT);
1205    arg_count->add_intvalue(count);
1206
1207    // call function
1208    glContext->hooks->gl.glDrawArrays(mode, first, count);
1209
1210    fixupGLMessage(glContext, &glmsg);
1211    glContext->traceGLMessage(&glmsg);
1212}
1213
1214void GLTrace_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) {
1215    GLMessage glmsg;
1216    GLTraceContext *glContext = getGLTraceContext();
1217
1218    glmsg.set_function(GLMessage::glDrawElements);
1219
1220    // copy argument mode
1221    GLMessage_DataType *arg_mode = glmsg.add_args();
1222    arg_mode->set_isarray(false);
1223    arg_mode->set_type(GLMessage::DataType::ENUM);
1224    arg_mode->add_intvalue((int)mode);
1225
1226    // copy argument count
1227    GLMessage_DataType *arg_count = glmsg.add_args();
1228    arg_count->set_isarray(false);
1229    arg_count->set_type(GLMessage::DataType::INT);
1230    arg_count->add_intvalue(count);
1231
1232    // copy argument type
1233    GLMessage_DataType *arg_type = glmsg.add_args();
1234    arg_type->set_isarray(false);
1235    arg_type->set_type(GLMessage::DataType::ENUM);
1236    arg_type->add_intvalue((int)type);
1237
1238    // copy argument indices
1239    GLMessage_DataType *arg_indices = glmsg.add_args();
1240    arg_indices->set_isarray(false);
1241    arg_indices->set_type(GLMessage::DataType::INT);
1242    arg_indices->add_intvalue((int)indices);
1243
1244    // call function
1245    glContext->hooks->gl.glDrawElements(mode, count, type, indices);
1246
1247    fixupGLMessage(glContext, &glmsg);
1248    glContext->traceGLMessage(&glmsg);
1249}
1250
1251void GLTrace_glEnable(GLenum cap) {
1252    GLMessage glmsg;
1253    GLTraceContext *glContext = getGLTraceContext();
1254
1255    glmsg.set_function(GLMessage::glEnable);
1256
1257    // copy argument cap
1258    GLMessage_DataType *arg_cap = glmsg.add_args();
1259    arg_cap->set_isarray(false);
1260    arg_cap->set_type(GLMessage::DataType::ENUM);
1261    arg_cap->add_intvalue((int)cap);
1262
1263    // call function
1264    glContext->hooks->gl.glEnable(cap);
1265
1266    fixupGLMessage(glContext, &glmsg);
1267    glContext->traceGLMessage(&glmsg);
1268}
1269
1270void GLTrace_glEnableVertexAttribArray(GLuint index) {
1271    GLMessage glmsg;
1272    GLTraceContext *glContext = getGLTraceContext();
1273
1274    glmsg.set_function(GLMessage::glEnableVertexAttribArray);
1275
1276    // copy argument index
1277    GLMessage_DataType *arg_index = glmsg.add_args();
1278    arg_index->set_isarray(false);
1279    arg_index->set_type(GLMessage::DataType::INT);
1280    arg_index->add_intvalue(index);
1281
1282    // call function
1283    glContext->hooks->gl.glEnableVertexAttribArray(index);
1284
1285    fixupGLMessage(glContext, &glmsg);
1286    glContext->traceGLMessage(&glmsg);
1287}
1288
1289void GLTrace_glFinish(void) {
1290    GLMessage glmsg;
1291    GLTraceContext *glContext = getGLTraceContext();
1292
1293    glmsg.set_function(GLMessage::glFinish);
1294
1295    // call function
1296    glContext->hooks->gl.glFinish();
1297
1298    fixupGLMessage(glContext, &glmsg);
1299    glContext->traceGLMessage(&glmsg);
1300}
1301
1302void GLTrace_glFlush(void) {
1303    GLMessage glmsg;
1304    GLTraceContext *glContext = getGLTraceContext();
1305
1306    glmsg.set_function(GLMessage::glFlush);
1307
1308    // call function
1309    glContext->hooks->gl.glFlush();
1310
1311    fixupGLMessage(glContext, &glmsg);
1312    glContext->traceGLMessage(&glmsg);
1313}
1314
1315void GLTrace_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
1316    GLMessage glmsg;
1317    GLTraceContext *glContext = getGLTraceContext();
1318
1319    glmsg.set_function(GLMessage::glFramebufferRenderbuffer);
1320
1321    // copy argument target
1322    GLMessage_DataType *arg_target = glmsg.add_args();
1323    arg_target->set_isarray(false);
1324    arg_target->set_type(GLMessage::DataType::ENUM);
1325    arg_target->add_intvalue((int)target);
1326
1327    // copy argument attachment
1328    GLMessage_DataType *arg_attachment = glmsg.add_args();
1329    arg_attachment->set_isarray(false);
1330    arg_attachment->set_type(GLMessage::DataType::ENUM);
1331    arg_attachment->add_intvalue((int)attachment);
1332
1333    // copy argument renderbuffertarget
1334    GLMessage_DataType *arg_renderbuffertarget = glmsg.add_args();
1335    arg_renderbuffertarget->set_isarray(false);
1336    arg_renderbuffertarget->set_type(GLMessage::DataType::ENUM);
1337    arg_renderbuffertarget->add_intvalue((int)renderbuffertarget);
1338
1339    // copy argument renderbuffer
1340    GLMessage_DataType *arg_renderbuffer = glmsg.add_args();
1341    arg_renderbuffer->set_isarray(false);
1342    arg_renderbuffer->set_type(GLMessage::DataType::INT);
1343    arg_renderbuffer->add_intvalue(renderbuffer);
1344
1345    // call function
1346    glContext->hooks->gl.glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
1347
1348    fixupGLMessage(glContext, &glmsg);
1349    glContext->traceGLMessage(&glmsg);
1350}
1351
1352void GLTrace_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
1353    GLMessage glmsg;
1354    GLTraceContext *glContext = getGLTraceContext();
1355
1356    glmsg.set_function(GLMessage::glFramebufferTexture2D);
1357
1358    // copy argument target
1359    GLMessage_DataType *arg_target = glmsg.add_args();
1360    arg_target->set_isarray(false);
1361    arg_target->set_type(GLMessage::DataType::ENUM);
1362    arg_target->add_intvalue((int)target);
1363
1364    // copy argument attachment
1365    GLMessage_DataType *arg_attachment = glmsg.add_args();
1366    arg_attachment->set_isarray(false);
1367    arg_attachment->set_type(GLMessage::DataType::ENUM);
1368    arg_attachment->add_intvalue((int)attachment);
1369
1370    // copy argument textarget
1371    GLMessage_DataType *arg_textarget = glmsg.add_args();
1372    arg_textarget->set_isarray(false);
1373    arg_textarget->set_type(GLMessage::DataType::ENUM);
1374    arg_textarget->add_intvalue((int)textarget);
1375
1376    // copy argument texture
1377    GLMessage_DataType *arg_texture = glmsg.add_args();
1378    arg_texture->set_isarray(false);
1379    arg_texture->set_type(GLMessage::DataType::INT);
1380    arg_texture->add_intvalue(texture);
1381
1382    // copy argument level
1383    GLMessage_DataType *arg_level = glmsg.add_args();
1384    arg_level->set_isarray(false);
1385    arg_level->set_type(GLMessage::DataType::INT);
1386    arg_level->add_intvalue(level);
1387
1388    // call function
1389    glContext->hooks->gl.glFramebufferTexture2D(target, attachment, textarget, texture, level);
1390
1391    fixupGLMessage(glContext, &glmsg);
1392    glContext->traceGLMessage(&glmsg);
1393}
1394
1395void GLTrace_glFrontFace(GLenum mode) {
1396    GLMessage glmsg;
1397    GLTraceContext *glContext = getGLTraceContext();
1398
1399    glmsg.set_function(GLMessage::glFrontFace);
1400
1401    // copy argument mode
1402    GLMessage_DataType *arg_mode = glmsg.add_args();
1403    arg_mode->set_isarray(false);
1404    arg_mode->set_type(GLMessage::DataType::ENUM);
1405    arg_mode->add_intvalue((int)mode);
1406
1407    // call function
1408    glContext->hooks->gl.glFrontFace(mode);
1409
1410    fixupGLMessage(glContext, &glmsg);
1411    glContext->traceGLMessage(&glmsg);
1412}
1413
1414void GLTrace_glGenBuffers(GLsizei n, GLuint* buffers) {
1415    GLMessage glmsg;
1416    GLTraceContext *glContext = getGLTraceContext();
1417
1418    glmsg.set_function(GLMessage::glGenBuffers);
1419
1420    // copy argument n
1421    GLMessage_DataType *arg_n = glmsg.add_args();
1422    arg_n->set_isarray(false);
1423    arg_n->set_type(GLMessage::DataType::INT);
1424    arg_n->add_intvalue(n);
1425
1426    // copy argument buffers
1427    GLMessage_DataType *arg_buffers = glmsg.add_args();
1428    arg_buffers->set_isarray(false);
1429    arg_buffers->set_type(GLMessage::DataType::INT);
1430    arg_buffers->add_intvalue((int)buffers);
1431
1432    // call function
1433    glContext->hooks->gl.glGenBuffers(n, buffers);
1434
1435    fixupGLMessage(glContext, &glmsg);
1436    glContext->traceGLMessage(&glmsg);
1437}
1438
1439void GLTrace_glGenerateMipmap(GLenum target) {
1440    GLMessage glmsg;
1441    GLTraceContext *glContext = getGLTraceContext();
1442
1443    glmsg.set_function(GLMessage::glGenerateMipmap);
1444
1445    // copy argument target
1446    GLMessage_DataType *arg_target = glmsg.add_args();
1447    arg_target->set_isarray(false);
1448    arg_target->set_type(GLMessage::DataType::ENUM);
1449    arg_target->add_intvalue((int)target);
1450
1451    // call function
1452    glContext->hooks->gl.glGenerateMipmap(target);
1453
1454    fixupGLMessage(glContext, &glmsg);
1455    glContext->traceGLMessage(&glmsg);
1456}
1457
1458void GLTrace_glGenFramebuffers(GLsizei n, GLuint* framebuffers) {
1459    GLMessage glmsg;
1460    GLTraceContext *glContext = getGLTraceContext();
1461
1462    glmsg.set_function(GLMessage::glGenFramebuffers);
1463
1464    // copy argument n
1465    GLMessage_DataType *arg_n = glmsg.add_args();
1466    arg_n->set_isarray(false);
1467    arg_n->set_type(GLMessage::DataType::INT);
1468    arg_n->add_intvalue(n);
1469
1470    // copy argument framebuffers
1471    GLMessage_DataType *arg_framebuffers = glmsg.add_args();
1472    arg_framebuffers->set_isarray(false);
1473    arg_framebuffers->set_type(GLMessage::DataType::INT);
1474    arg_framebuffers->add_intvalue((int)framebuffers);
1475
1476    // call function
1477    glContext->hooks->gl.glGenFramebuffers(n, framebuffers);
1478
1479    fixupGLMessage(glContext, &glmsg);
1480    glContext->traceGLMessage(&glmsg);
1481}
1482
1483void GLTrace_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
1484    GLMessage glmsg;
1485    GLTraceContext *glContext = getGLTraceContext();
1486
1487    glmsg.set_function(GLMessage::glGenRenderbuffers);
1488
1489    // copy argument n
1490    GLMessage_DataType *arg_n = glmsg.add_args();
1491    arg_n->set_isarray(false);
1492    arg_n->set_type(GLMessage::DataType::INT);
1493    arg_n->add_intvalue(n);
1494
1495    // copy argument renderbuffers
1496    GLMessage_DataType *arg_renderbuffers = glmsg.add_args();
1497    arg_renderbuffers->set_isarray(false);
1498    arg_renderbuffers->set_type(GLMessage::DataType::INT);
1499    arg_renderbuffers->add_intvalue((int)renderbuffers);
1500
1501    // call function
1502    glContext->hooks->gl.glGenRenderbuffers(n, renderbuffers);
1503
1504    fixupGLMessage(glContext, &glmsg);
1505    glContext->traceGLMessage(&glmsg);
1506}
1507
1508void GLTrace_glGenTextures(GLsizei n, GLuint* textures) {
1509    GLMessage glmsg;
1510    GLTraceContext *glContext = getGLTraceContext();
1511
1512    glmsg.set_function(GLMessage::glGenTextures);
1513
1514    // copy argument n
1515    GLMessage_DataType *arg_n = glmsg.add_args();
1516    arg_n->set_isarray(false);
1517    arg_n->set_type(GLMessage::DataType::INT);
1518    arg_n->add_intvalue(n);
1519
1520    // copy argument textures
1521    GLMessage_DataType *arg_textures = glmsg.add_args();
1522    arg_textures->set_isarray(false);
1523    arg_textures->set_type(GLMessage::DataType::INT);
1524    arg_textures->add_intvalue((int)textures);
1525
1526    // call function
1527    glContext->hooks->gl.glGenTextures(n, textures);
1528
1529    fixupGLMessage(glContext, &glmsg);
1530    glContext->traceGLMessage(&glmsg);
1531}
1532
1533void GLTrace_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) {
1534    GLMessage glmsg;
1535    GLTraceContext *glContext = getGLTraceContext();
1536
1537    glmsg.set_function(GLMessage::glGetActiveAttrib);
1538
1539    // copy argument program
1540    GLMessage_DataType *arg_program = glmsg.add_args();
1541    arg_program->set_isarray(false);
1542    arg_program->set_type(GLMessage::DataType::INT);
1543    arg_program->add_intvalue(program);
1544
1545    // copy argument index
1546    GLMessage_DataType *arg_index = glmsg.add_args();
1547    arg_index->set_isarray(false);
1548    arg_index->set_type(GLMessage::DataType::INT);
1549    arg_index->add_intvalue(index);
1550
1551    // copy argument bufsize
1552    GLMessage_DataType *arg_bufsize = glmsg.add_args();
1553    arg_bufsize->set_isarray(false);
1554    arg_bufsize->set_type(GLMessage::DataType::INT);
1555    arg_bufsize->add_intvalue(bufsize);
1556
1557    // copy argument length
1558    GLMessage_DataType *arg_length = glmsg.add_args();
1559    arg_length->set_isarray(false);
1560    arg_length->set_type(GLMessage::DataType::INT);
1561    arg_length->add_intvalue((int)length);
1562
1563    // copy argument size
1564    GLMessage_DataType *arg_size = glmsg.add_args();
1565    arg_size->set_isarray(false);
1566    arg_size->set_type(GLMessage::DataType::INT);
1567    arg_size->add_intvalue((int)size);
1568
1569    // copy argument type
1570    GLMessage_DataType *arg_type = glmsg.add_args();
1571    arg_type->set_isarray(false);
1572    arg_type->set_type(GLMessage::DataType::INT);
1573    arg_type->add_intvalue((int)type);
1574
1575    // copy argument name
1576    GLMessage_DataType *arg_name = glmsg.add_args();
1577    arg_name->set_isarray(false);
1578    arg_name->set_type(GLMessage::DataType::INT);
1579    arg_name->add_intvalue((int)name);
1580
1581    // call function
1582    glContext->hooks->gl.glGetActiveAttrib(program, index, bufsize, length, size, type, name);
1583
1584    fixupGLMessage(glContext, &glmsg);
1585    glContext->traceGLMessage(&glmsg);
1586}
1587
1588void GLTrace_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) {
1589    GLMessage glmsg;
1590    GLTraceContext *glContext = getGLTraceContext();
1591
1592    glmsg.set_function(GLMessage::glGetActiveUniform);
1593
1594    // copy argument program
1595    GLMessage_DataType *arg_program = glmsg.add_args();
1596    arg_program->set_isarray(false);
1597    arg_program->set_type(GLMessage::DataType::INT);
1598    arg_program->add_intvalue(program);
1599
1600    // copy argument index
1601    GLMessage_DataType *arg_index = glmsg.add_args();
1602    arg_index->set_isarray(false);
1603    arg_index->set_type(GLMessage::DataType::INT);
1604    arg_index->add_intvalue(index);
1605
1606    // copy argument bufsize
1607    GLMessage_DataType *arg_bufsize = glmsg.add_args();
1608    arg_bufsize->set_isarray(false);
1609    arg_bufsize->set_type(GLMessage::DataType::INT);
1610    arg_bufsize->add_intvalue(bufsize);
1611
1612    // copy argument length
1613    GLMessage_DataType *arg_length = glmsg.add_args();
1614    arg_length->set_isarray(false);
1615    arg_length->set_type(GLMessage::DataType::INT);
1616    arg_length->add_intvalue((int)length);
1617
1618    // copy argument size
1619    GLMessage_DataType *arg_size = glmsg.add_args();
1620    arg_size->set_isarray(false);
1621    arg_size->set_type(GLMessage::DataType::INT);
1622    arg_size->add_intvalue((int)size);
1623
1624    // copy argument type
1625    GLMessage_DataType *arg_type = glmsg.add_args();
1626    arg_type->set_isarray(false);
1627    arg_type->set_type(GLMessage::DataType::INT);
1628    arg_type->add_intvalue((int)type);
1629
1630    // copy argument name
1631    GLMessage_DataType *arg_name = glmsg.add_args();
1632    arg_name->set_isarray(false);
1633    arg_name->set_type(GLMessage::DataType::INT);
1634    arg_name->add_intvalue((int)name);
1635
1636    // call function
1637    glContext->hooks->gl.glGetActiveUniform(program, index, bufsize, length, size, type, name);
1638
1639    fixupGLMessage(glContext, &glmsg);
1640    glContext->traceGLMessage(&glmsg);
1641}
1642
1643void GLTrace_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
1644    GLMessage glmsg;
1645    GLTraceContext *glContext = getGLTraceContext();
1646
1647    glmsg.set_function(GLMessage::glGetAttachedShaders);
1648
1649    // copy argument program
1650    GLMessage_DataType *arg_program = glmsg.add_args();
1651    arg_program->set_isarray(false);
1652    arg_program->set_type(GLMessage::DataType::INT);
1653    arg_program->add_intvalue(program);
1654
1655    // copy argument maxcount
1656    GLMessage_DataType *arg_maxcount = glmsg.add_args();
1657    arg_maxcount->set_isarray(false);
1658    arg_maxcount->set_type(GLMessage::DataType::INT);
1659    arg_maxcount->add_intvalue(maxcount);
1660
1661    // copy argument count
1662    GLMessage_DataType *arg_count = glmsg.add_args();
1663    arg_count->set_isarray(false);
1664    arg_count->set_type(GLMessage::DataType::INT);
1665    arg_count->add_intvalue((int)count);
1666
1667    // copy argument shaders
1668    GLMessage_DataType *arg_shaders = glmsg.add_args();
1669    arg_shaders->set_isarray(false);
1670    arg_shaders->set_type(GLMessage::DataType::INT);
1671    arg_shaders->add_intvalue((int)shaders);
1672
1673    // call function
1674    glContext->hooks->gl.glGetAttachedShaders(program, maxcount, count, shaders);
1675
1676    fixupGLMessage(glContext, &glmsg);
1677    glContext->traceGLMessage(&glmsg);
1678}
1679
1680int GLTrace_glGetAttribLocation(GLuint program, const GLchar* name) {
1681    GLMessage glmsg;
1682    GLTraceContext *glContext = getGLTraceContext();
1683
1684    glmsg.set_function(GLMessage::glGetAttribLocation);
1685
1686    // copy argument program
1687    GLMessage_DataType *arg_program = glmsg.add_args();
1688    arg_program->set_isarray(false);
1689    arg_program->set_type(GLMessage::DataType::INT);
1690    arg_program->add_intvalue(program);
1691
1692    // copy argument name
1693    GLMessage_DataType *arg_name = glmsg.add_args();
1694    arg_name->set_isarray(false);
1695    arg_name->set_type(GLMessage::DataType::INT);
1696    arg_name->add_intvalue((int)name);
1697
1698    // call function
1699    int retValue = glContext->hooks->gl.glGetAttribLocation(program, name);
1700
1701    // set return value
1702    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
1703    rt->set_isarray(false);
1704    rt->set_type(GLMessage::DataType::INT);
1705    rt->add_intvalue(retValue);
1706
1707    fixupGLMessage(glContext, &glmsg);
1708    glContext->traceGLMessage(&glmsg);
1709
1710    return retValue;
1711}
1712
1713void GLTrace_glGetBooleanv(GLenum pname, GLboolean* params) {
1714    GLMessage glmsg;
1715    GLTraceContext *glContext = getGLTraceContext();
1716
1717    glmsg.set_function(GLMessage::glGetBooleanv);
1718
1719    // copy argument pname
1720    GLMessage_DataType *arg_pname = glmsg.add_args();
1721    arg_pname->set_isarray(false);
1722    arg_pname->set_type(GLMessage::DataType::ENUM);
1723    arg_pname->add_intvalue((int)pname);
1724
1725    // copy argument params
1726    GLMessage_DataType *arg_params = glmsg.add_args();
1727    arg_params->set_isarray(false);
1728    arg_params->set_type(GLMessage::DataType::INT);
1729    arg_params->add_intvalue((int)params);
1730
1731    // call function
1732    glContext->hooks->gl.glGetBooleanv(pname, params);
1733
1734    fixupGLMessage(glContext, &glmsg);
1735    glContext->traceGLMessage(&glmsg);
1736}
1737
1738void GLTrace_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
1739    GLMessage glmsg;
1740    GLTraceContext *glContext = getGLTraceContext();
1741
1742    glmsg.set_function(GLMessage::glGetBufferParameteriv);
1743
1744    // copy argument target
1745    GLMessage_DataType *arg_target = glmsg.add_args();
1746    arg_target->set_isarray(false);
1747    arg_target->set_type(GLMessage::DataType::ENUM);
1748    arg_target->add_intvalue((int)target);
1749
1750    // copy argument pname
1751    GLMessage_DataType *arg_pname = glmsg.add_args();
1752    arg_pname->set_isarray(false);
1753    arg_pname->set_type(GLMessage::DataType::ENUM);
1754    arg_pname->add_intvalue((int)pname);
1755
1756    // copy argument params
1757    GLMessage_DataType *arg_params = glmsg.add_args();
1758    arg_params->set_isarray(false);
1759    arg_params->set_type(GLMessage::DataType::INT);
1760    arg_params->add_intvalue((int)params);
1761
1762    // call function
1763    glContext->hooks->gl.glGetBufferParameteriv(target, pname, params);
1764
1765    fixupGLMessage(glContext, &glmsg);
1766    glContext->traceGLMessage(&glmsg);
1767}
1768
1769GLenum GLTrace_glGetError(void) {
1770    GLMessage glmsg;
1771    GLTraceContext *glContext = getGLTraceContext();
1772
1773    glmsg.set_function(GLMessage::glGetError);
1774
1775    // call function
1776    GLenum retValue = glContext->hooks->gl.glGetError();
1777
1778    // set return value
1779    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
1780    rt->set_isarray(false);
1781    rt->set_type(GLMessage::DataType::ENUM);
1782    rt->add_intvalue((int)retValue);
1783
1784    fixupGLMessage(glContext, &glmsg);
1785    glContext->traceGLMessage(&glmsg);
1786
1787    return retValue;
1788}
1789
1790void GLTrace_glGetFloatv(GLenum pname, GLfloat* params) {
1791    GLMessage glmsg;
1792    GLTraceContext *glContext = getGLTraceContext();
1793
1794    glmsg.set_function(GLMessage::glGetFloatv);
1795
1796    // copy argument pname
1797    GLMessage_DataType *arg_pname = glmsg.add_args();
1798    arg_pname->set_isarray(false);
1799    arg_pname->set_type(GLMessage::DataType::ENUM);
1800    arg_pname->add_intvalue((int)pname);
1801
1802    // copy argument params
1803    GLMessage_DataType *arg_params = glmsg.add_args();
1804    arg_params->set_isarray(false);
1805    arg_params->set_type(GLMessage::DataType::INT);
1806    arg_params->add_intvalue((int)params);
1807
1808    // call function
1809    glContext->hooks->gl.glGetFloatv(pname, params);
1810
1811    fixupGLMessage(glContext, &glmsg);
1812    glContext->traceGLMessage(&glmsg);
1813}
1814
1815void GLTrace_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) {
1816    GLMessage glmsg;
1817    GLTraceContext *glContext = getGLTraceContext();
1818
1819    glmsg.set_function(GLMessage::glGetFramebufferAttachmentParameteriv);
1820
1821    // copy argument target
1822    GLMessage_DataType *arg_target = glmsg.add_args();
1823    arg_target->set_isarray(false);
1824    arg_target->set_type(GLMessage::DataType::ENUM);
1825    arg_target->add_intvalue((int)target);
1826
1827    // copy argument attachment
1828    GLMessage_DataType *arg_attachment = glmsg.add_args();
1829    arg_attachment->set_isarray(false);
1830    arg_attachment->set_type(GLMessage::DataType::ENUM);
1831    arg_attachment->add_intvalue((int)attachment);
1832
1833    // copy argument pname
1834    GLMessage_DataType *arg_pname = glmsg.add_args();
1835    arg_pname->set_isarray(false);
1836    arg_pname->set_type(GLMessage::DataType::ENUM);
1837    arg_pname->add_intvalue((int)pname);
1838
1839    // copy argument params
1840    GLMessage_DataType *arg_params = glmsg.add_args();
1841    arg_params->set_isarray(false);
1842    arg_params->set_type(GLMessage::DataType::INT);
1843    arg_params->add_intvalue((int)params);
1844
1845    // call function
1846    glContext->hooks->gl.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
1847
1848    fixupGLMessage(glContext, &glmsg);
1849    glContext->traceGLMessage(&glmsg);
1850}
1851
1852void GLTrace_glGetIntegerv(GLenum pname, GLint* params) {
1853    GLMessage glmsg;
1854    GLTraceContext *glContext = getGLTraceContext();
1855
1856    glmsg.set_function(GLMessage::glGetIntegerv);
1857
1858    // copy argument pname
1859    GLMessage_DataType *arg_pname = glmsg.add_args();
1860    arg_pname->set_isarray(false);
1861    arg_pname->set_type(GLMessage::DataType::ENUM);
1862    arg_pname->add_intvalue((int)pname);
1863
1864    // copy argument params
1865    GLMessage_DataType *arg_params = glmsg.add_args();
1866    arg_params->set_isarray(false);
1867    arg_params->set_type(GLMessage::DataType::INT);
1868    arg_params->add_intvalue((int)params);
1869
1870    // call function
1871    glContext->hooks->gl.glGetIntegerv(pname, params);
1872
1873    fixupGLMessage(glContext, &glmsg);
1874    glContext->traceGLMessage(&glmsg);
1875}
1876
1877void GLTrace_glGetProgramiv(GLuint program, GLenum pname, GLint* params) {
1878    GLMessage glmsg;
1879    GLTraceContext *glContext = getGLTraceContext();
1880
1881    glmsg.set_function(GLMessage::glGetProgramiv);
1882
1883    // copy argument program
1884    GLMessage_DataType *arg_program = glmsg.add_args();
1885    arg_program->set_isarray(false);
1886    arg_program->set_type(GLMessage::DataType::INT);
1887    arg_program->add_intvalue(program);
1888
1889    // copy argument pname
1890    GLMessage_DataType *arg_pname = glmsg.add_args();
1891    arg_pname->set_isarray(false);
1892    arg_pname->set_type(GLMessage::DataType::ENUM);
1893    arg_pname->add_intvalue((int)pname);
1894
1895    // copy argument params
1896    GLMessage_DataType *arg_params = glmsg.add_args();
1897    arg_params->set_isarray(false);
1898    arg_params->set_type(GLMessage::DataType::INT);
1899    arg_params->add_intvalue((int)params);
1900
1901    // call function
1902    glContext->hooks->gl.glGetProgramiv(program, pname, params);
1903
1904    fixupGLMessage(glContext, &glmsg);
1905    glContext->traceGLMessage(&glmsg);
1906}
1907
1908void GLTrace_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) {
1909    GLMessage glmsg;
1910    GLTraceContext *glContext = getGLTraceContext();
1911
1912    glmsg.set_function(GLMessage::glGetProgramInfoLog);
1913
1914    // copy argument program
1915    GLMessage_DataType *arg_program = glmsg.add_args();
1916    arg_program->set_isarray(false);
1917    arg_program->set_type(GLMessage::DataType::INT);
1918    arg_program->add_intvalue(program);
1919
1920    // copy argument bufsize
1921    GLMessage_DataType *arg_bufsize = glmsg.add_args();
1922    arg_bufsize->set_isarray(false);
1923    arg_bufsize->set_type(GLMessage::DataType::INT);
1924    arg_bufsize->add_intvalue(bufsize);
1925
1926    // copy argument length
1927    GLMessage_DataType *arg_length = glmsg.add_args();
1928    arg_length->set_isarray(false);
1929    arg_length->set_type(GLMessage::DataType::INT);
1930    arg_length->add_intvalue((int)length);
1931
1932    // copy argument infolog
1933    GLMessage_DataType *arg_infolog = glmsg.add_args();
1934    arg_infolog->set_isarray(false);
1935    arg_infolog->set_type(GLMessage::DataType::INT);
1936    arg_infolog->add_intvalue((int)infolog);
1937
1938    // call function
1939    glContext->hooks->gl.glGetProgramInfoLog(program, bufsize, length, infolog);
1940
1941    fixupGLMessage(glContext, &glmsg);
1942    glContext->traceGLMessage(&glmsg);
1943}
1944
1945void GLTrace_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) {
1946    GLMessage glmsg;
1947    GLTraceContext *glContext = getGLTraceContext();
1948
1949    glmsg.set_function(GLMessage::glGetRenderbufferParameteriv);
1950
1951    // copy argument target
1952    GLMessage_DataType *arg_target = glmsg.add_args();
1953    arg_target->set_isarray(false);
1954    arg_target->set_type(GLMessage::DataType::ENUM);
1955    arg_target->add_intvalue((int)target);
1956
1957    // copy argument pname
1958    GLMessage_DataType *arg_pname = glmsg.add_args();
1959    arg_pname->set_isarray(false);
1960    arg_pname->set_type(GLMessage::DataType::ENUM);
1961    arg_pname->add_intvalue((int)pname);
1962
1963    // copy argument params
1964    GLMessage_DataType *arg_params = glmsg.add_args();
1965    arg_params->set_isarray(false);
1966    arg_params->set_type(GLMessage::DataType::INT);
1967    arg_params->add_intvalue((int)params);
1968
1969    // call function
1970    glContext->hooks->gl.glGetRenderbufferParameteriv(target, pname, params);
1971
1972    fixupGLMessage(glContext, &glmsg);
1973    glContext->traceGLMessage(&glmsg);
1974}
1975
1976void GLTrace_glGetShaderiv(GLuint shader, GLenum pname, GLint* params) {
1977    GLMessage glmsg;
1978    GLTraceContext *glContext = getGLTraceContext();
1979
1980    glmsg.set_function(GLMessage::glGetShaderiv);
1981
1982    // copy argument shader
1983    GLMessage_DataType *arg_shader = glmsg.add_args();
1984    arg_shader->set_isarray(false);
1985    arg_shader->set_type(GLMessage::DataType::INT);
1986    arg_shader->add_intvalue(shader);
1987
1988    // copy argument pname
1989    GLMessage_DataType *arg_pname = glmsg.add_args();
1990    arg_pname->set_isarray(false);
1991    arg_pname->set_type(GLMessage::DataType::ENUM);
1992    arg_pname->add_intvalue((int)pname);
1993
1994    // copy argument params
1995    GLMessage_DataType *arg_params = glmsg.add_args();
1996    arg_params->set_isarray(false);
1997    arg_params->set_type(GLMessage::DataType::INT);
1998    arg_params->add_intvalue((int)params);
1999
2000    // call function
2001    glContext->hooks->gl.glGetShaderiv(shader, pname, params);
2002
2003    fixupGLMessage(glContext, &glmsg);
2004    glContext->traceGLMessage(&glmsg);
2005}
2006
2007void GLTrace_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) {
2008    GLMessage glmsg;
2009    GLTraceContext *glContext = getGLTraceContext();
2010
2011    glmsg.set_function(GLMessage::glGetShaderInfoLog);
2012
2013    // copy argument shader
2014    GLMessage_DataType *arg_shader = glmsg.add_args();
2015    arg_shader->set_isarray(false);
2016    arg_shader->set_type(GLMessage::DataType::INT);
2017    arg_shader->add_intvalue(shader);
2018
2019    // copy argument bufsize
2020    GLMessage_DataType *arg_bufsize = glmsg.add_args();
2021    arg_bufsize->set_isarray(false);
2022    arg_bufsize->set_type(GLMessage::DataType::INT);
2023    arg_bufsize->add_intvalue(bufsize);
2024
2025    // copy argument length
2026    GLMessage_DataType *arg_length = glmsg.add_args();
2027    arg_length->set_isarray(false);
2028    arg_length->set_type(GLMessage::DataType::INT);
2029    arg_length->add_intvalue((int)length);
2030
2031    // copy argument infolog
2032    GLMessage_DataType *arg_infolog = glmsg.add_args();
2033    arg_infolog->set_isarray(false);
2034    arg_infolog->set_type(GLMessage::DataType::INT);
2035    arg_infolog->add_intvalue((int)infolog);
2036
2037    // call function
2038    glContext->hooks->gl.glGetShaderInfoLog(shader, bufsize, length, infolog);
2039
2040    fixupGLMessage(glContext, &glmsg);
2041    glContext->traceGLMessage(&glmsg);
2042}
2043
2044void GLTrace_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
2045    GLMessage glmsg;
2046    GLTraceContext *glContext = getGLTraceContext();
2047
2048    glmsg.set_function(GLMessage::glGetShaderPrecisionFormat);
2049
2050    // copy argument shadertype
2051    GLMessage_DataType *arg_shadertype = glmsg.add_args();
2052    arg_shadertype->set_isarray(false);
2053    arg_shadertype->set_type(GLMessage::DataType::ENUM);
2054    arg_shadertype->add_intvalue((int)shadertype);
2055
2056    // copy argument precisiontype
2057    GLMessage_DataType *arg_precisiontype = glmsg.add_args();
2058    arg_precisiontype->set_isarray(false);
2059    arg_precisiontype->set_type(GLMessage::DataType::ENUM);
2060    arg_precisiontype->add_intvalue((int)precisiontype);
2061
2062    // copy argument range
2063    GLMessage_DataType *arg_range = glmsg.add_args();
2064    arg_range->set_isarray(false);
2065    arg_range->set_type(GLMessage::DataType::INT);
2066    arg_range->add_intvalue((int)range);
2067
2068    // copy argument precision
2069    GLMessage_DataType *arg_precision = glmsg.add_args();
2070    arg_precision->set_isarray(false);
2071    arg_precision->set_type(GLMessage::DataType::INT);
2072    arg_precision->add_intvalue((int)precision);
2073
2074    // call function
2075    glContext->hooks->gl.glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
2076
2077    fixupGLMessage(glContext, &glmsg);
2078    glContext->traceGLMessage(&glmsg);
2079}
2080
2081void GLTrace_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) {
2082    GLMessage glmsg;
2083    GLTraceContext *glContext = getGLTraceContext();
2084
2085    glmsg.set_function(GLMessage::glGetShaderSource);
2086
2087    // copy argument shader
2088    GLMessage_DataType *arg_shader = glmsg.add_args();
2089    arg_shader->set_isarray(false);
2090    arg_shader->set_type(GLMessage::DataType::INT);
2091    arg_shader->add_intvalue(shader);
2092
2093    // copy argument bufsize
2094    GLMessage_DataType *arg_bufsize = glmsg.add_args();
2095    arg_bufsize->set_isarray(false);
2096    arg_bufsize->set_type(GLMessage::DataType::INT);
2097    arg_bufsize->add_intvalue(bufsize);
2098
2099    // copy argument length
2100    GLMessage_DataType *arg_length = glmsg.add_args();
2101    arg_length->set_isarray(false);
2102    arg_length->set_type(GLMessage::DataType::INT);
2103    arg_length->add_intvalue((int)length);
2104
2105    // copy argument source
2106    GLMessage_DataType *arg_source = glmsg.add_args();
2107    arg_source->set_isarray(false);
2108    arg_source->set_type(GLMessage::DataType::INT);
2109    arg_source->add_intvalue((int)source);
2110
2111    // call function
2112    glContext->hooks->gl.glGetShaderSource(shader, bufsize, length, source);
2113
2114    fixupGLMessage(glContext, &glmsg);
2115    glContext->traceGLMessage(&glmsg);
2116}
2117
2118const GLubyte* GLTrace_glGetString(GLenum name) {
2119    GLMessage glmsg;
2120    GLTraceContext *glContext = getGLTraceContext();
2121
2122    glmsg.set_function(GLMessage::glGetString);
2123
2124    // copy argument name
2125    GLMessage_DataType *arg_name = glmsg.add_args();
2126    arg_name->set_isarray(false);
2127    arg_name->set_type(GLMessage::DataType::ENUM);
2128    arg_name->add_intvalue((int)name);
2129
2130    // call function
2131    const GLubyte* retValue = glContext->hooks->gl.glGetString(name);
2132
2133    // set return value
2134    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2135    rt->set_isarray(false);
2136    rt->set_type(GLMessage::DataType::INT);
2137    rt->add_intvalue((int)retValue);
2138
2139    fixupGLMessage(glContext, &glmsg);
2140    glContext->traceGLMessage(&glmsg);
2141
2142    return retValue;
2143}
2144
2145void GLTrace_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
2146    GLMessage glmsg;
2147    GLTraceContext *glContext = getGLTraceContext();
2148
2149    glmsg.set_function(GLMessage::glGetTexParameterfv);
2150
2151    // copy argument target
2152    GLMessage_DataType *arg_target = glmsg.add_args();
2153    arg_target->set_isarray(false);
2154    arg_target->set_type(GLMessage::DataType::ENUM);
2155    arg_target->add_intvalue((int)target);
2156
2157    // copy argument pname
2158    GLMessage_DataType *arg_pname = glmsg.add_args();
2159    arg_pname->set_isarray(false);
2160    arg_pname->set_type(GLMessage::DataType::ENUM);
2161    arg_pname->add_intvalue((int)pname);
2162
2163    // copy argument params
2164    GLMessage_DataType *arg_params = glmsg.add_args();
2165    arg_params->set_isarray(false);
2166    arg_params->set_type(GLMessage::DataType::INT);
2167    arg_params->add_intvalue((int)params);
2168
2169    // call function
2170    glContext->hooks->gl.glGetTexParameterfv(target, pname, params);
2171
2172    fixupGLMessage(glContext, &glmsg);
2173    glContext->traceGLMessage(&glmsg);
2174}
2175
2176void GLTrace_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
2177    GLMessage glmsg;
2178    GLTraceContext *glContext = getGLTraceContext();
2179
2180    glmsg.set_function(GLMessage::glGetTexParameteriv);
2181
2182    // copy argument target
2183    GLMessage_DataType *arg_target = glmsg.add_args();
2184    arg_target->set_isarray(false);
2185    arg_target->set_type(GLMessage::DataType::ENUM);
2186    arg_target->add_intvalue((int)target);
2187
2188    // copy argument pname
2189    GLMessage_DataType *arg_pname = glmsg.add_args();
2190    arg_pname->set_isarray(false);
2191    arg_pname->set_type(GLMessage::DataType::ENUM);
2192    arg_pname->add_intvalue((int)pname);
2193
2194    // copy argument params
2195    GLMessage_DataType *arg_params = glmsg.add_args();
2196    arg_params->set_isarray(false);
2197    arg_params->set_type(GLMessage::DataType::INT);
2198    arg_params->add_intvalue((int)params);
2199
2200    // call function
2201    glContext->hooks->gl.glGetTexParameteriv(target, pname, params);
2202
2203    fixupGLMessage(glContext, &glmsg);
2204    glContext->traceGLMessage(&glmsg);
2205}
2206
2207void GLTrace_glGetUniformfv(GLuint program, GLint location, GLfloat* params) {
2208    GLMessage glmsg;
2209    GLTraceContext *glContext = getGLTraceContext();
2210
2211    glmsg.set_function(GLMessage::glGetUniformfv);
2212
2213    // copy argument program
2214    GLMessage_DataType *arg_program = glmsg.add_args();
2215    arg_program->set_isarray(false);
2216    arg_program->set_type(GLMessage::DataType::INT);
2217    arg_program->add_intvalue(program);
2218
2219    // copy argument location
2220    GLMessage_DataType *arg_location = glmsg.add_args();
2221    arg_location->set_isarray(false);
2222    arg_location->set_type(GLMessage::DataType::INT);
2223    arg_location->add_intvalue(location);
2224
2225    // copy argument params
2226    GLMessage_DataType *arg_params = glmsg.add_args();
2227    arg_params->set_isarray(false);
2228    arg_params->set_type(GLMessage::DataType::INT);
2229    arg_params->add_intvalue((int)params);
2230
2231    // call function
2232    glContext->hooks->gl.glGetUniformfv(program, location, params);
2233
2234    fixupGLMessage(glContext, &glmsg);
2235    glContext->traceGLMessage(&glmsg);
2236}
2237
2238void GLTrace_glGetUniformiv(GLuint program, GLint location, GLint* params) {
2239    GLMessage glmsg;
2240    GLTraceContext *glContext = getGLTraceContext();
2241
2242    glmsg.set_function(GLMessage::glGetUniformiv);
2243
2244    // copy argument program
2245    GLMessage_DataType *arg_program = glmsg.add_args();
2246    arg_program->set_isarray(false);
2247    arg_program->set_type(GLMessage::DataType::INT);
2248    arg_program->add_intvalue(program);
2249
2250    // copy argument location
2251    GLMessage_DataType *arg_location = glmsg.add_args();
2252    arg_location->set_isarray(false);
2253    arg_location->set_type(GLMessage::DataType::INT);
2254    arg_location->add_intvalue(location);
2255
2256    // copy argument params
2257    GLMessage_DataType *arg_params = glmsg.add_args();
2258    arg_params->set_isarray(false);
2259    arg_params->set_type(GLMessage::DataType::INT);
2260    arg_params->add_intvalue((int)params);
2261
2262    // call function
2263    glContext->hooks->gl.glGetUniformiv(program, location, params);
2264
2265    fixupGLMessage(glContext, &glmsg);
2266    glContext->traceGLMessage(&glmsg);
2267}
2268
2269int GLTrace_glGetUniformLocation(GLuint program, const GLchar* name) {
2270    GLMessage glmsg;
2271    GLTraceContext *glContext = getGLTraceContext();
2272
2273    glmsg.set_function(GLMessage::glGetUniformLocation);
2274
2275    // copy argument program
2276    GLMessage_DataType *arg_program = glmsg.add_args();
2277    arg_program->set_isarray(false);
2278    arg_program->set_type(GLMessage::DataType::INT);
2279    arg_program->add_intvalue(program);
2280
2281    // copy argument name
2282    GLMessage_DataType *arg_name = glmsg.add_args();
2283    arg_name->set_isarray(false);
2284    arg_name->set_type(GLMessage::DataType::INT);
2285    arg_name->add_intvalue((int)name);
2286
2287    // call function
2288    int retValue = glContext->hooks->gl.glGetUniformLocation(program, name);
2289
2290    // set return value
2291    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2292    rt->set_isarray(false);
2293    rt->set_type(GLMessage::DataType::INT);
2294    rt->add_intvalue(retValue);
2295
2296    fixupGLMessage(glContext, &glmsg);
2297    glContext->traceGLMessage(&glmsg);
2298
2299    return retValue;
2300}
2301
2302void GLTrace_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) {
2303    GLMessage glmsg;
2304    GLTraceContext *glContext = getGLTraceContext();
2305
2306    glmsg.set_function(GLMessage::glGetVertexAttribfv);
2307
2308    // copy argument index
2309    GLMessage_DataType *arg_index = glmsg.add_args();
2310    arg_index->set_isarray(false);
2311    arg_index->set_type(GLMessage::DataType::INT);
2312    arg_index->add_intvalue(index);
2313
2314    // copy argument pname
2315    GLMessage_DataType *arg_pname = glmsg.add_args();
2316    arg_pname->set_isarray(false);
2317    arg_pname->set_type(GLMessage::DataType::ENUM);
2318    arg_pname->add_intvalue((int)pname);
2319
2320    // copy argument params
2321    GLMessage_DataType *arg_params = glmsg.add_args();
2322    arg_params->set_isarray(false);
2323    arg_params->set_type(GLMessage::DataType::INT);
2324    arg_params->add_intvalue((int)params);
2325
2326    // call function
2327    glContext->hooks->gl.glGetVertexAttribfv(index, pname, params);
2328
2329    fixupGLMessage(glContext, &glmsg);
2330    glContext->traceGLMessage(&glmsg);
2331}
2332
2333void GLTrace_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) {
2334    GLMessage glmsg;
2335    GLTraceContext *glContext = getGLTraceContext();
2336
2337    glmsg.set_function(GLMessage::glGetVertexAttribiv);
2338
2339    // copy argument index
2340    GLMessage_DataType *arg_index = glmsg.add_args();
2341    arg_index->set_isarray(false);
2342    arg_index->set_type(GLMessage::DataType::INT);
2343    arg_index->add_intvalue(index);
2344
2345    // copy argument pname
2346    GLMessage_DataType *arg_pname = glmsg.add_args();
2347    arg_pname->set_isarray(false);
2348    arg_pname->set_type(GLMessage::DataType::ENUM);
2349    arg_pname->add_intvalue((int)pname);
2350
2351    // copy argument params
2352    GLMessage_DataType *arg_params = glmsg.add_args();
2353    arg_params->set_isarray(false);
2354    arg_params->set_type(GLMessage::DataType::INT);
2355    arg_params->add_intvalue((int)params);
2356
2357    // call function
2358    glContext->hooks->gl.glGetVertexAttribiv(index, pname, params);
2359
2360    fixupGLMessage(glContext, &glmsg);
2361    glContext->traceGLMessage(&glmsg);
2362}
2363
2364void GLTrace_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer) {
2365    GLMessage glmsg;
2366    GLTraceContext *glContext = getGLTraceContext();
2367
2368    glmsg.set_function(GLMessage::glGetVertexAttribPointerv);
2369
2370    // copy argument index
2371    GLMessage_DataType *arg_index = glmsg.add_args();
2372    arg_index->set_isarray(false);
2373    arg_index->set_type(GLMessage::DataType::INT);
2374    arg_index->add_intvalue(index);
2375
2376    // copy argument pname
2377    GLMessage_DataType *arg_pname = glmsg.add_args();
2378    arg_pname->set_isarray(false);
2379    arg_pname->set_type(GLMessage::DataType::ENUM);
2380    arg_pname->add_intvalue((int)pname);
2381
2382    // copy argument pointer
2383    GLMessage_DataType *arg_pointer = glmsg.add_args();
2384    arg_pointer->set_isarray(false);
2385    arg_pointer->set_type(GLMessage::DataType::INT);
2386    arg_pointer->add_intvalue((int)pointer);
2387
2388    // call function
2389    glContext->hooks->gl.glGetVertexAttribPointerv(index, pname, pointer);
2390
2391    fixupGLMessage(glContext, &glmsg);
2392    glContext->traceGLMessage(&glmsg);
2393}
2394
2395void GLTrace_glHint(GLenum target, GLenum mode) {
2396    GLMessage glmsg;
2397    GLTraceContext *glContext = getGLTraceContext();
2398
2399    glmsg.set_function(GLMessage::glHint);
2400
2401    // copy argument target
2402    GLMessage_DataType *arg_target = glmsg.add_args();
2403    arg_target->set_isarray(false);
2404    arg_target->set_type(GLMessage::DataType::ENUM);
2405    arg_target->add_intvalue((int)target);
2406
2407    // copy argument mode
2408    GLMessage_DataType *arg_mode = glmsg.add_args();
2409    arg_mode->set_isarray(false);
2410    arg_mode->set_type(GLMessage::DataType::ENUM);
2411    arg_mode->add_intvalue((int)mode);
2412
2413    // call function
2414    glContext->hooks->gl.glHint(target, mode);
2415
2416    fixupGLMessage(glContext, &glmsg);
2417    glContext->traceGLMessage(&glmsg);
2418}
2419
2420GLboolean GLTrace_glIsBuffer(GLuint buffer) {
2421    GLMessage glmsg;
2422    GLTraceContext *glContext = getGLTraceContext();
2423
2424    glmsg.set_function(GLMessage::glIsBuffer);
2425
2426    // copy argument buffer
2427    GLMessage_DataType *arg_buffer = glmsg.add_args();
2428    arg_buffer->set_isarray(false);
2429    arg_buffer->set_type(GLMessage::DataType::INT);
2430    arg_buffer->add_intvalue(buffer);
2431
2432    // call function
2433    GLboolean retValue = glContext->hooks->gl.glIsBuffer(buffer);
2434
2435    // set return value
2436    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2437    rt->set_isarray(false);
2438    rt->set_type(GLMessage::DataType::BOOL);
2439    rt->add_boolvalue(retValue);
2440
2441    fixupGLMessage(glContext, &glmsg);
2442    glContext->traceGLMessage(&glmsg);
2443
2444    return retValue;
2445}
2446
2447GLboolean GLTrace_glIsEnabled(GLenum cap) {
2448    GLMessage glmsg;
2449    GLTraceContext *glContext = getGLTraceContext();
2450
2451    glmsg.set_function(GLMessage::glIsEnabled);
2452
2453    // copy argument cap
2454    GLMessage_DataType *arg_cap = glmsg.add_args();
2455    arg_cap->set_isarray(false);
2456    arg_cap->set_type(GLMessage::DataType::ENUM);
2457    arg_cap->add_intvalue((int)cap);
2458
2459    // call function
2460    GLboolean retValue = glContext->hooks->gl.glIsEnabled(cap);
2461
2462    // set return value
2463    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2464    rt->set_isarray(false);
2465    rt->set_type(GLMessage::DataType::BOOL);
2466    rt->add_boolvalue(retValue);
2467
2468    fixupGLMessage(glContext, &glmsg);
2469    glContext->traceGLMessage(&glmsg);
2470
2471    return retValue;
2472}
2473
2474GLboolean GLTrace_glIsFramebuffer(GLuint framebuffer) {
2475    GLMessage glmsg;
2476    GLTraceContext *glContext = getGLTraceContext();
2477
2478    glmsg.set_function(GLMessage::glIsFramebuffer);
2479
2480    // copy argument framebuffer
2481    GLMessage_DataType *arg_framebuffer = glmsg.add_args();
2482    arg_framebuffer->set_isarray(false);
2483    arg_framebuffer->set_type(GLMessage::DataType::INT);
2484    arg_framebuffer->add_intvalue(framebuffer);
2485
2486    // call function
2487    GLboolean retValue = glContext->hooks->gl.glIsFramebuffer(framebuffer);
2488
2489    // set return value
2490    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2491    rt->set_isarray(false);
2492    rt->set_type(GLMessage::DataType::BOOL);
2493    rt->add_boolvalue(retValue);
2494
2495    fixupGLMessage(glContext, &glmsg);
2496    glContext->traceGLMessage(&glmsg);
2497
2498    return retValue;
2499}
2500
2501GLboolean GLTrace_glIsProgram(GLuint program) {
2502    GLMessage glmsg;
2503    GLTraceContext *glContext = getGLTraceContext();
2504
2505    glmsg.set_function(GLMessage::glIsProgram);
2506
2507    // copy argument program
2508    GLMessage_DataType *arg_program = glmsg.add_args();
2509    arg_program->set_isarray(false);
2510    arg_program->set_type(GLMessage::DataType::INT);
2511    arg_program->add_intvalue(program);
2512
2513    // call function
2514    GLboolean retValue = glContext->hooks->gl.glIsProgram(program);
2515
2516    // set return value
2517    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2518    rt->set_isarray(false);
2519    rt->set_type(GLMessage::DataType::BOOL);
2520    rt->add_boolvalue(retValue);
2521
2522    fixupGLMessage(glContext, &glmsg);
2523    glContext->traceGLMessage(&glmsg);
2524
2525    return retValue;
2526}
2527
2528GLboolean GLTrace_glIsRenderbuffer(GLuint renderbuffer) {
2529    GLMessage glmsg;
2530    GLTraceContext *glContext = getGLTraceContext();
2531
2532    glmsg.set_function(GLMessage::glIsRenderbuffer);
2533
2534    // copy argument renderbuffer
2535    GLMessage_DataType *arg_renderbuffer = glmsg.add_args();
2536    arg_renderbuffer->set_isarray(false);
2537    arg_renderbuffer->set_type(GLMessage::DataType::INT);
2538    arg_renderbuffer->add_intvalue(renderbuffer);
2539
2540    // call function
2541    GLboolean retValue = glContext->hooks->gl.glIsRenderbuffer(renderbuffer);
2542
2543    // set return value
2544    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2545    rt->set_isarray(false);
2546    rt->set_type(GLMessage::DataType::BOOL);
2547    rt->add_boolvalue(retValue);
2548
2549    fixupGLMessage(glContext, &glmsg);
2550    glContext->traceGLMessage(&glmsg);
2551
2552    return retValue;
2553}
2554
2555GLboolean GLTrace_glIsShader(GLuint shader) {
2556    GLMessage glmsg;
2557    GLTraceContext *glContext = getGLTraceContext();
2558
2559    glmsg.set_function(GLMessage::glIsShader);
2560
2561    // copy argument shader
2562    GLMessage_DataType *arg_shader = glmsg.add_args();
2563    arg_shader->set_isarray(false);
2564    arg_shader->set_type(GLMessage::DataType::INT);
2565    arg_shader->add_intvalue(shader);
2566
2567    // call function
2568    GLboolean retValue = glContext->hooks->gl.glIsShader(shader);
2569
2570    // set return value
2571    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2572    rt->set_isarray(false);
2573    rt->set_type(GLMessage::DataType::BOOL);
2574    rt->add_boolvalue(retValue);
2575
2576    fixupGLMessage(glContext, &glmsg);
2577    glContext->traceGLMessage(&glmsg);
2578
2579    return retValue;
2580}
2581
2582GLboolean GLTrace_glIsTexture(GLuint texture) {
2583    GLMessage glmsg;
2584    GLTraceContext *glContext = getGLTraceContext();
2585
2586    glmsg.set_function(GLMessage::glIsTexture);
2587
2588    // copy argument texture
2589    GLMessage_DataType *arg_texture = glmsg.add_args();
2590    arg_texture->set_isarray(false);
2591    arg_texture->set_type(GLMessage::DataType::INT);
2592    arg_texture->add_intvalue(texture);
2593
2594    // call function
2595    GLboolean retValue = glContext->hooks->gl.glIsTexture(texture);
2596
2597    // set return value
2598    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
2599    rt->set_isarray(false);
2600    rt->set_type(GLMessage::DataType::BOOL);
2601    rt->add_boolvalue(retValue);
2602
2603    fixupGLMessage(glContext, &glmsg);
2604    glContext->traceGLMessage(&glmsg);
2605
2606    return retValue;
2607}
2608
2609void GLTrace_glLineWidth(GLfloat width) {
2610    GLMessage glmsg;
2611    GLTraceContext *glContext = getGLTraceContext();
2612
2613    glmsg.set_function(GLMessage::glLineWidth);
2614
2615    // copy argument width
2616    GLMessage_DataType *arg_width = glmsg.add_args();
2617    arg_width->set_isarray(false);
2618    arg_width->set_type(GLMessage::DataType::FLOAT);
2619    arg_width->add_floatvalue(width);
2620
2621    // call function
2622    glContext->hooks->gl.glLineWidth(width);
2623
2624    fixupGLMessage(glContext, &glmsg);
2625    glContext->traceGLMessage(&glmsg);
2626}
2627
2628void GLTrace_glLinkProgram(GLuint program) {
2629    GLMessage glmsg;
2630    GLTraceContext *glContext = getGLTraceContext();
2631
2632    glmsg.set_function(GLMessage::glLinkProgram);
2633
2634    // copy argument program
2635    GLMessage_DataType *arg_program = glmsg.add_args();
2636    arg_program->set_isarray(false);
2637    arg_program->set_type(GLMessage::DataType::INT);
2638    arg_program->add_intvalue(program);
2639
2640    // call function
2641    glContext->hooks->gl.glLinkProgram(program);
2642
2643    fixupGLMessage(glContext, &glmsg);
2644    glContext->traceGLMessage(&glmsg);
2645}
2646
2647void GLTrace_glPixelStorei(GLenum pname, GLint param) {
2648    GLMessage glmsg;
2649    GLTraceContext *glContext = getGLTraceContext();
2650
2651    glmsg.set_function(GLMessage::glPixelStorei);
2652
2653    // copy argument pname
2654    GLMessage_DataType *arg_pname = glmsg.add_args();
2655    arg_pname->set_isarray(false);
2656    arg_pname->set_type(GLMessage::DataType::ENUM);
2657    arg_pname->add_intvalue((int)pname);
2658
2659    // copy argument param
2660    GLMessage_DataType *arg_param = glmsg.add_args();
2661    arg_param->set_isarray(false);
2662    arg_param->set_type(GLMessage::DataType::INT);
2663    arg_param->add_intvalue(param);
2664
2665    // call function
2666    glContext->hooks->gl.glPixelStorei(pname, param);
2667
2668    fixupGLMessage(glContext, &glmsg);
2669    glContext->traceGLMessage(&glmsg);
2670}
2671
2672void GLTrace_glPolygonOffset(GLfloat factor, GLfloat units) {
2673    GLMessage glmsg;
2674    GLTraceContext *glContext = getGLTraceContext();
2675
2676    glmsg.set_function(GLMessage::glPolygonOffset);
2677
2678    // copy argument factor
2679    GLMessage_DataType *arg_factor = glmsg.add_args();
2680    arg_factor->set_isarray(false);
2681    arg_factor->set_type(GLMessage::DataType::FLOAT);
2682    arg_factor->add_floatvalue(factor);
2683
2684    // copy argument units
2685    GLMessage_DataType *arg_units = glmsg.add_args();
2686    arg_units->set_isarray(false);
2687    arg_units->set_type(GLMessage::DataType::FLOAT);
2688    arg_units->add_floatvalue(units);
2689
2690    // call function
2691    glContext->hooks->gl.glPolygonOffset(factor, units);
2692
2693    fixupGLMessage(glContext, &glmsg);
2694    glContext->traceGLMessage(&glmsg);
2695}
2696
2697void GLTrace_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) {
2698    GLMessage glmsg;
2699    GLTraceContext *glContext = getGLTraceContext();
2700
2701    glmsg.set_function(GLMessage::glReadPixels);
2702
2703    // copy argument x
2704    GLMessage_DataType *arg_x = glmsg.add_args();
2705    arg_x->set_isarray(false);
2706    arg_x->set_type(GLMessage::DataType::INT);
2707    arg_x->add_intvalue(x);
2708
2709    // copy argument y
2710    GLMessage_DataType *arg_y = glmsg.add_args();
2711    arg_y->set_isarray(false);
2712    arg_y->set_type(GLMessage::DataType::INT);
2713    arg_y->add_intvalue(y);
2714
2715    // copy argument width
2716    GLMessage_DataType *arg_width = glmsg.add_args();
2717    arg_width->set_isarray(false);
2718    arg_width->set_type(GLMessage::DataType::INT);
2719    arg_width->add_intvalue(width);
2720
2721    // copy argument height
2722    GLMessage_DataType *arg_height = glmsg.add_args();
2723    arg_height->set_isarray(false);
2724    arg_height->set_type(GLMessage::DataType::INT);
2725    arg_height->add_intvalue(height);
2726
2727    // copy argument format
2728    GLMessage_DataType *arg_format = glmsg.add_args();
2729    arg_format->set_isarray(false);
2730    arg_format->set_type(GLMessage::DataType::ENUM);
2731    arg_format->add_intvalue((int)format);
2732
2733    // copy argument type
2734    GLMessage_DataType *arg_type = glmsg.add_args();
2735    arg_type->set_isarray(false);
2736    arg_type->set_type(GLMessage::DataType::ENUM);
2737    arg_type->add_intvalue((int)type);
2738
2739    // copy argument pixels
2740    GLMessage_DataType *arg_pixels = glmsg.add_args();
2741    arg_pixels->set_isarray(false);
2742    arg_pixels->set_type(GLMessage::DataType::INT);
2743    arg_pixels->add_intvalue((int)pixels);
2744
2745    // call function
2746    glContext->hooks->gl.glReadPixels(x, y, width, height, format, type, pixels);
2747
2748    fixupGLMessage(glContext, &glmsg);
2749    glContext->traceGLMessage(&glmsg);
2750}
2751
2752void GLTrace_glReleaseShaderCompiler(void) {
2753    GLMessage glmsg;
2754    GLTraceContext *glContext = getGLTraceContext();
2755
2756    glmsg.set_function(GLMessage::glReleaseShaderCompiler);
2757
2758    // call function
2759    glContext->hooks->gl.glReleaseShaderCompiler();
2760
2761    fixupGLMessage(glContext, &glmsg);
2762    glContext->traceGLMessage(&glmsg);
2763}
2764
2765void GLTrace_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
2766    GLMessage glmsg;
2767    GLTraceContext *glContext = getGLTraceContext();
2768
2769    glmsg.set_function(GLMessage::glRenderbufferStorage);
2770
2771    // copy argument target
2772    GLMessage_DataType *arg_target = glmsg.add_args();
2773    arg_target->set_isarray(false);
2774    arg_target->set_type(GLMessage::DataType::ENUM);
2775    arg_target->add_intvalue((int)target);
2776
2777    // copy argument internalformat
2778    GLMessage_DataType *arg_internalformat = glmsg.add_args();
2779    arg_internalformat->set_isarray(false);
2780    arg_internalformat->set_type(GLMessage::DataType::ENUM);
2781    arg_internalformat->add_intvalue((int)internalformat);
2782
2783    // copy argument width
2784    GLMessage_DataType *arg_width = glmsg.add_args();
2785    arg_width->set_isarray(false);
2786    arg_width->set_type(GLMessage::DataType::INT);
2787    arg_width->add_intvalue(width);
2788
2789    // copy argument height
2790    GLMessage_DataType *arg_height = glmsg.add_args();
2791    arg_height->set_isarray(false);
2792    arg_height->set_type(GLMessage::DataType::INT);
2793    arg_height->add_intvalue(height);
2794
2795    // call function
2796    glContext->hooks->gl.glRenderbufferStorage(target, internalformat, width, height);
2797
2798    fixupGLMessage(glContext, &glmsg);
2799    glContext->traceGLMessage(&glmsg);
2800}
2801
2802void GLTrace_glSampleCoverage(GLclampf value, GLboolean invert) {
2803    GLMessage glmsg;
2804    GLTraceContext *glContext = getGLTraceContext();
2805
2806    glmsg.set_function(GLMessage::glSampleCoverage);
2807
2808    // copy argument value
2809    GLMessage_DataType *arg_value = glmsg.add_args();
2810    arg_value->set_isarray(false);
2811    arg_value->set_type(GLMessage::DataType::FLOAT);
2812    arg_value->add_floatvalue(value);
2813
2814    // copy argument invert
2815    GLMessage_DataType *arg_invert = glmsg.add_args();
2816    arg_invert->set_isarray(false);
2817    arg_invert->set_type(GLMessage::DataType::BOOL);
2818    arg_invert->add_boolvalue(invert);
2819
2820    // call function
2821    glContext->hooks->gl.glSampleCoverage(value, invert);
2822
2823    fixupGLMessage(glContext, &glmsg);
2824    glContext->traceGLMessage(&glmsg);
2825}
2826
2827void GLTrace_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
2828    GLMessage glmsg;
2829    GLTraceContext *glContext = getGLTraceContext();
2830
2831    glmsg.set_function(GLMessage::glScissor);
2832
2833    // copy argument x
2834    GLMessage_DataType *arg_x = glmsg.add_args();
2835    arg_x->set_isarray(false);
2836    arg_x->set_type(GLMessage::DataType::INT);
2837    arg_x->add_intvalue(x);
2838
2839    // copy argument y
2840    GLMessage_DataType *arg_y = glmsg.add_args();
2841    arg_y->set_isarray(false);
2842    arg_y->set_type(GLMessage::DataType::INT);
2843    arg_y->add_intvalue(y);
2844
2845    // copy argument width
2846    GLMessage_DataType *arg_width = glmsg.add_args();
2847    arg_width->set_isarray(false);
2848    arg_width->set_type(GLMessage::DataType::INT);
2849    arg_width->add_intvalue(width);
2850
2851    // copy argument height
2852    GLMessage_DataType *arg_height = glmsg.add_args();
2853    arg_height->set_isarray(false);
2854    arg_height->set_type(GLMessage::DataType::INT);
2855    arg_height->add_intvalue(height);
2856
2857    // call function
2858    glContext->hooks->gl.glScissor(x, y, width, height);
2859
2860    fixupGLMessage(glContext, &glmsg);
2861    glContext->traceGLMessage(&glmsg);
2862}
2863
2864void GLTrace_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length) {
2865    GLMessage glmsg;
2866    GLTraceContext *glContext = getGLTraceContext();
2867
2868    glmsg.set_function(GLMessage::glShaderBinary);
2869
2870    // copy argument n
2871    GLMessage_DataType *arg_n = glmsg.add_args();
2872    arg_n->set_isarray(false);
2873    arg_n->set_type(GLMessage::DataType::INT);
2874    arg_n->add_intvalue(n);
2875
2876    // copy argument shaders
2877    GLMessage_DataType *arg_shaders = glmsg.add_args();
2878    arg_shaders->set_isarray(false);
2879    arg_shaders->set_type(GLMessage::DataType::INT);
2880    arg_shaders->add_intvalue((int)shaders);
2881
2882    // copy argument binaryformat
2883    GLMessage_DataType *arg_binaryformat = glmsg.add_args();
2884    arg_binaryformat->set_isarray(false);
2885    arg_binaryformat->set_type(GLMessage::DataType::ENUM);
2886    arg_binaryformat->add_intvalue((int)binaryformat);
2887
2888    // copy argument binary
2889    GLMessage_DataType *arg_binary = glmsg.add_args();
2890    arg_binary->set_isarray(false);
2891    arg_binary->set_type(GLMessage::DataType::INT);
2892    arg_binary->add_intvalue((int)binary);
2893
2894    // copy argument length
2895    GLMessage_DataType *arg_length = glmsg.add_args();
2896    arg_length->set_isarray(false);
2897    arg_length->set_type(GLMessage::DataType::INT);
2898    arg_length->add_intvalue(length);
2899
2900    // call function
2901    glContext->hooks->gl.glShaderBinary(n, shaders, binaryformat, binary, length);
2902
2903    fixupGLMessage(glContext, &glmsg);
2904    glContext->traceGLMessage(&glmsg);
2905}
2906
2907void GLTrace_glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length) {
2908    GLMessage glmsg;
2909    GLTraceContext *glContext = getGLTraceContext();
2910
2911    glmsg.set_function(GLMessage::glShaderSource);
2912
2913    // copy argument shader
2914    GLMessage_DataType *arg_shader = glmsg.add_args();
2915    arg_shader->set_isarray(false);
2916    arg_shader->set_type(GLMessage::DataType::INT);
2917    arg_shader->add_intvalue(shader);
2918
2919    // copy argument count
2920    GLMessage_DataType *arg_count = glmsg.add_args();
2921    arg_count->set_isarray(false);
2922    arg_count->set_type(GLMessage::DataType::INT);
2923    arg_count->add_intvalue(count);
2924
2925    // copy argument string
2926    GLMessage_DataType *arg_string = glmsg.add_args();
2927    arg_string->set_isarray(false);
2928    arg_string->set_type(GLMessage::DataType::INT);
2929    arg_string->add_intvalue((int)string);
2930
2931    // copy argument length
2932    GLMessage_DataType *arg_length = glmsg.add_args();
2933    arg_length->set_isarray(false);
2934    arg_length->set_type(GLMessage::DataType::INT);
2935    arg_length->add_intvalue((int)length);
2936
2937    // call function
2938    glContext->hooks->gl.glShaderSource(shader, count, string, length);
2939
2940    fixupGLMessage(glContext, &glmsg);
2941    glContext->traceGLMessage(&glmsg);
2942}
2943
2944void GLTrace_glStencilFunc(GLenum func, GLint ref, GLuint mask) {
2945    GLMessage glmsg;
2946    GLTraceContext *glContext = getGLTraceContext();
2947
2948    glmsg.set_function(GLMessage::glStencilFunc);
2949
2950    // copy argument func
2951    GLMessage_DataType *arg_func = glmsg.add_args();
2952    arg_func->set_isarray(false);
2953    arg_func->set_type(GLMessage::DataType::ENUM);
2954    arg_func->add_intvalue((int)func);
2955
2956    // copy argument ref
2957    GLMessage_DataType *arg_ref = glmsg.add_args();
2958    arg_ref->set_isarray(false);
2959    arg_ref->set_type(GLMessage::DataType::INT);
2960    arg_ref->add_intvalue(ref);
2961
2962    // copy argument mask
2963    GLMessage_DataType *arg_mask = glmsg.add_args();
2964    arg_mask->set_isarray(false);
2965    arg_mask->set_type(GLMessage::DataType::INT);
2966    arg_mask->add_intvalue(mask);
2967
2968    // call function
2969    glContext->hooks->gl.glStencilFunc(func, ref, mask);
2970
2971    fixupGLMessage(glContext, &glmsg);
2972    glContext->traceGLMessage(&glmsg);
2973}
2974
2975void GLTrace_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
2976    GLMessage glmsg;
2977    GLTraceContext *glContext = getGLTraceContext();
2978
2979    glmsg.set_function(GLMessage::glStencilFuncSeparate);
2980
2981    // copy argument face
2982    GLMessage_DataType *arg_face = glmsg.add_args();
2983    arg_face->set_isarray(false);
2984    arg_face->set_type(GLMessage::DataType::ENUM);
2985    arg_face->add_intvalue((int)face);
2986
2987    // copy argument func
2988    GLMessage_DataType *arg_func = glmsg.add_args();
2989    arg_func->set_isarray(false);
2990    arg_func->set_type(GLMessage::DataType::ENUM);
2991    arg_func->add_intvalue((int)func);
2992
2993    // copy argument ref
2994    GLMessage_DataType *arg_ref = glmsg.add_args();
2995    arg_ref->set_isarray(false);
2996    arg_ref->set_type(GLMessage::DataType::INT);
2997    arg_ref->add_intvalue(ref);
2998
2999    // copy argument mask
3000    GLMessage_DataType *arg_mask = glmsg.add_args();
3001    arg_mask->set_isarray(false);
3002    arg_mask->set_type(GLMessage::DataType::INT);
3003    arg_mask->add_intvalue(mask);
3004
3005    // call function
3006    glContext->hooks->gl.glStencilFuncSeparate(face, func, ref, mask);
3007
3008    fixupGLMessage(glContext, &glmsg);
3009    glContext->traceGLMessage(&glmsg);
3010}
3011
3012void GLTrace_glStencilMask(GLuint mask) {
3013    GLMessage glmsg;
3014    GLTraceContext *glContext = getGLTraceContext();
3015
3016    glmsg.set_function(GLMessage::glStencilMask);
3017
3018    // copy argument mask
3019    GLMessage_DataType *arg_mask = glmsg.add_args();
3020    arg_mask->set_isarray(false);
3021    arg_mask->set_type(GLMessage::DataType::INT);
3022    arg_mask->add_intvalue(mask);
3023
3024    // call function
3025    glContext->hooks->gl.glStencilMask(mask);
3026
3027    fixupGLMessage(glContext, &glmsg);
3028    glContext->traceGLMessage(&glmsg);
3029}
3030
3031void GLTrace_glStencilMaskSeparate(GLenum face, GLuint mask) {
3032    GLMessage glmsg;
3033    GLTraceContext *glContext = getGLTraceContext();
3034
3035    glmsg.set_function(GLMessage::glStencilMaskSeparate);
3036
3037    // copy argument face
3038    GLMessage_DataType *arg_face = glmsg.add_args();
3039    arg_face->set_isarray(false);
3040    arg_face->set_type(GLMessage::DataType::ENUM);
3041    arg_face->add_intvalue((int)face);
3042
3043    // copy argument mask
3044    GLMessage_DataType *arg_mask = glmsg.add_args();
3045    arg_mask->set_isarray(false);
3046    arg_mask->set_type(GLMessage::DataType::INT);
3047    arg_mask->add_intvalue(mask);
3048
3049    // call function
3050    glContext->hooks->gl.glStencilMaskSeparate(face, mask);
3051
3052    fixupGLMessage(glContext, &glmsg);
3053    glContext->traceGLMessage(&glmsg);
3054}
3055
3056void GLTrace_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
3057    GLMessage glmsg;
3058    GLTraceContext *glContext = getGLTraceContext();
3059
3060    glmsg.set_function(GLMessage::glStencilOp);
3061
3062    // copy argument fail
3063    GLMessage_DataType *arg_fail = glmsg.add_args();
3064    arg_fail->set_isarray(false);
3065    arg_fail->set_type(GLMessage::DataType::ENUM);
3066    arg_fail->add_intvalue((int)fail);
3067
3068    // copy argument zfail
3069    GLMessage_DataType *arg_zfail = glmsg.add_args();
3070    arg_zfail->set_isarray(false);
3071    arg_zfail->set_type(GLMessage::DataType::ENUM);
3072    arg_zfail->add_intvalue((int)zfail);
3073
3074    // copy argument zpass
3075    GLMessage_DataType *arg_zpass = glmsg.add_args();
3076    arg_zpass->set_isarray(false);
3077    arg_zpass->set_type(GLMessage::DataType::ENUM);
3078    arg_zpass->add_intvalue((int)zpass);
3079
3080    // call function
3081    glContext->hooks->gl.glStencilOp(fail, zfail, zpass);
3082
3083    fixupGLMessage(glContext, &glmsg);
3084    glContext->traceGLMessage(&glmsg);
3085}
3086
3087void GLTrace_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
3088    GLMessage glmsg;
3089    GLTraceContext *glContext = getGLTraceContext();
3090
3091    glmsg.set_function(GLMessage::glStencilOpSeparate);
3092
3093    // copy argument face
3094    GLMessage_DataType *arg_face = glmsg.add_args();
3095    arg_face->set_isarray(false);
3096    arg_face->set_type(GLMessage::DataType::ENUM);
3097    arg_face->add_intvalue((int)face);
3098
3099    // copy argument fail
3100    GLMessage_DataType *arg_fail = glmsg.add_args();
3101    arg_fail->set_isarray(false);
3102    arg_fail->set_type(GLMessage::DataType::ENUM);
3103    arg_fail->add_intvalue((int)fail);
3104
3105    // copy argument zfail
3106    GLMessage_DataType *arg_zfail = glmsg.add_args();
3107    arg_zfail->set_isarray(false);
3108    arg_zfail->set_type(GLMessage::DataType::ENUM);
3109    arg_zfail->add_intvalue((int)zfail);
3110
3111    // copy argument zpass
3112    GLMessage_DataType *arg_zpass = glmsg.add_args();
3113    arg_zpass->set_isarray(false);
3114    arg_zpass->set_type(GLMessage::DataType::ENUM);
3115    arg_zpass->add_intvalue((int)zpass);
3116
3117    // call function
3118    glContext->hooks->gl.glStencilOpSeparate(face, fail, zfail, zpass);
3119
3120    fixupGLMessage(glContext, &glmsg);
3121    glContext->traceGLMessage(&glmsg);
3122}
3123
3124void GLTrace_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) {
3125    GLMessage glmsg;
3126    GLTraceContext *glContext = getGLTraceContext();
3127
3128    glmsg.set_function(GLMessage::glTexImage2D);
3129
3130    // copy argument target
3131    GLMessage_DataType *arg_target = glmsg.add_args();
3132    arg_target->set_isarray(false);
3133    arg_target->set_type(GLMessage::DataType::ENUM);
3134    arg_target->add_intvalue((int)target);
3135
3136    // copy argument level
3137    GLMessage_DataType *arg_level = glmsg.add_args();
3138    arg_level->set_isarray(false);
3139    arg_level->set_type(GLMessage::DataType::INT);
3140    arg_level->add_intvalue(level);
3141
3142    // copy argument internalformat
3143    GLMessage_DataType *arg_internalformat = glmsg.add_args();
3144    arg_internalformat->set_isarray(false);
3145    arg_internalformat->set_type(GLMessage::DataType::INT);
3146    arg_internalformat->add_intvalue(internalformat);
3147
3148    // copy argument width
3149    GLMessage_DataType *arg_width = glmsg.add_args();
3150    arg_width->set_isarray(false);
3151    arg_width->set_type(GLMessage::DataType::INT);
3152    arg_width->add_intvalue(width);
3153
3154    // copy argument height
3155    GLMessage_DataType *arg_height = glmsg.add_args();
3156    arg_height->set_isarray(false);
3157    arg_height->set_type(GLMessage::DataType::INT);
3158    arg_height->add_intvalue(height);
3159
3160    // copy argument border
3161    GLMessage_DataType *arg_border = glmsg.add_args();
3162    arg_border->set_isarray(false);
3163    arg_border->set_type(GLMessage::DataType::INT);
3164    arg_border->add_intvalue(border);
3165
3166    // copy argument format
3167    GLMessage_DataType *arg_format = glmsg.add_args();
3168    arg_format->set_isarray(false);
3169    arg_format->set_type(GLMessage::DataType::ENUM);
3170    arg_format->add_intvalue((int)format);
3171
3172    // copy argument type
3173    GLMessage_DataType *arg_type = glmsg.add_args();
3174    arg_type->set_isarray(false);
3175    arg_type->set_type(GLMessage::DataType::ENUM);
3176    arg_type->add_intvalue((int)type);
3177
3178    // copy argument pixels
3179    GLMessage_DataType *arg_pixels = glmsg.add_args();
3180    arg_pixels->set_isarray(false);
3181    arg_pixels->set_type(GLMessage::DataType::INT);
3182    arg_pixels->add_intvalue((int)pixels);
3183
3184    // call function
3185    glContext->hooks->gl.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
3186
3187    fixupGLMessage(glContext, &glmsg);
3188    glContext->traceGLMessage(&glmsg);
3189}
3190
3191void GLTrace_glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
3192    GLMessage glmsg;
3193    GLTraceContext *glContext = getGLTraceContext();
3194
3195    glmsg.set_function(GLMessage::glTexParameterf);
3196
3197    // copy argument target
3198    GLMessage_DataType *arg_target = glmsg.add_args();
3199    arg_target->set_isarray(false);
3200    arg_target->set_type(GLMessage::DataType::ENUM);
3201    arg_target->add_intvalue((int)target);
3202
3203    // copy argument pname
3204    GLMessage_DataType *arg_pname = glmsg.add_args();
3205    arg_pname->set_isarray(false);
3206    arg_pname->set_type(GLMessage::DataType::ENUM);
3207    arg_pname->add_intvalue((int)pname);
3208
3209    // copy argument param
3210    GLMessage_DataType *arg_param = glmsg.add_args();
3211    arg_param->set_isarray(false);
3212    arg_param->set_type(GLMessage::DataType::FLOAT);
3213    arg_param->add_floatvalue(param);
3214
3215    // call function
3216    glContext->hooks->gl.glTexParameterf(target, pname, param);
3217
3218    fixupGLMessage(glContext, &glmsg);
3219    glContext->traceGLMessage(&glmsg);
3220}
3221
3222void GLTrace_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) {
3223    GLMessage glmsg;
3224    GLTraceContext *glContext = getGLTraceContext();
3225
3226    glmsg.set_function(GLMessage::glTexParameterfv);
3227
3228    // copy argument target
3229    GLMessage_DataType *arg_target = glmsg.add_args();
3230    arg_target->set_isarray(false);
3231    arg_target->set_type(GLMessage::DataType::ENUM);
3232    arg_target->add_intvalue((int)target);
3233
3234    // copy argument pname
3235    GLMessage_DataType *arg_pname = glmsg.add_args();
3236    arg_pname->set_isarray(false);
3237    arg_pname->set_type(GLMessage::DataType::ENUM);
3238    arg_pname->add_intvalue((int)pname);
3239
3240    // copy argument params
3241    GLMessage_DataType *arg_params = glmsg.add_args();
3242    arg_params->set_isarray(false);
3243    arg_params->set_type(GLMessage::DataType::INT);
3244    arg_params->add_intvalue((int)params);
3245
3246    // call function
3247    glContext->hooks->gl.glTexParameterfv(target, pname, params);
3248
3249    fixupGLMessage(glContext, &glmsg);
3250    glContext->traceGLMessage(&glmsg);
3251}
3252
3253void GLTrace_glTexParameteri(GLenum target, GLenum pname, GLint param) {
3254    GLMessage glmsg;
3255    GLTraceContext *glContext = getGLTraceContext();
3256
3257    glmsg.set_function(GLMessage::glTexParameteri);
3258
3259    // copy argument target
3260    GLMessage_DataType *arg_target = glmsg.add_args();
3261    arg_target->set_isarray(false);
3262    arg_target->set_type(GLMessage::DataType::ENUM);
3263    arg_target->add_intvalue((int)target);
3264
3265    // copy argument pname
3266    GLMessage_DataType *arg_pname = glmsg.add_args();
3267    arg_pname->set_isarray(false);
3268    arg_pname->set_type(GLMessage::DataType::ENUM);
3269    arg_pname->add_intvalue((int)pname);
3270
3271    // copy argument param
3272    GLMessage_DataType *arg_param = glmsg.add_args();
3273    arg_param->set_isarray(false);
3274    arg_param->set_type(GLMessage::DataType::INT);
3275    arg_param->add_intvalue(param);
3276
3277    // call function
3278    glContext->hooks->gl.glTexParameteri(target, pname, param);
3279
3280    fixupGLMessage(glContext, &glmsg);
3281    glContext->traceGLMessage(&glmsg);
3282}
3283
3284void GLTrace_glTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
3285    GLMessage glmsg;
3286    GLTraceContext *glContext = getGLTraceContext();
3287
3288    glmsg.set_function(GLMessage::glTexParameteriv);
3289
3290    // copy argument target
3291    GLMessage_DataType *arg_target = glmsg.add_args();
3292    arg_target->set_isarray(false);
3293    arg_target->set_type(GLMessage::DataType::ENUM);
3294    arg_target->add_intvalue((int)target);
3295
3296    // copy argument pname
3297    GLMessage_DataType *arg_pname = glmsg.add_args();
3298    arg_pname->set_isarray(false);
3299    arg_pname->set_type(GLMessage::DataType::ENUM);
3300    arg_pname->add_intvalue((int)pname);
3301
3302    // copy argument params
3303    GLMessage_DataType *arg_params = glmsg.add_args();
3304    arg_params->set_isarray(false);
3305    arg_params->set_type(GLMessage::DataType::INT);
3306    arg_params->add_intvalue((int)params);
3307
3308    // call function
3309    glContext->hooks->gl.glTexParameteriv(target, pname, params);
3310
3311    fixupGLMessage(glContext, &glmsg);
3312    glContext->traceGLMessage(&glmsg);
3313}
3314
3315void GLTrace_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) {
3316    GLMessage glmsg;
3317    GLTraceContext *glContext = getGLTraceContext();
3318
3319    glmsg.set_function(GLMessage::glTexSubImage2D);
3320
3321    // copy argument target
3322    GLMessage_DataType *arg_target = glmsg.add_args();
3323    arg_target->set_isarray(false);
3324    arg_target->set_type(GLMessage::DataType::ENUM);
3325    arg_target->add_intvalue((int)target);
3326
3327    // copy argument level
3328    GLMessage_DataType *arg_level = glmsg.add_args();
3329    arg_level->set_isarray(false);
3330    arg_level->set_type(GLMessage::DataType::INT);
3331    arg_level->add_intvalue(level);
3332
3333    // copy argument xoffset
3334    GLMessage_DataType *arg_xoffset = glmsg.add_args();
3335    arg_xoffset->set_isarray(false);
3336    arg_xoffset->set_type(GLMessage::DataType::INT);
3337    arg_xoffset->add_intvalue(xoffset);
3338
3339    // copy argument yoffset
3340    GLMessage_DataType *arg_yoffset = glmsg.add_args();
3341    arg_yoffset->set_isarray(false);
3342    arg_yoffset->set_type(GLMessage::DataType::INT);
3343    arg_yoffset->add_intvalue(yoffset);
3344
3345    // copy argument width
3346    GLMessage_DataType *arg_width = glmsg.add_args();
3347    arg_width->set_isarray(false);
3348    arg_width->set_type(GLMessage::DataType::INT);
3349    arg_width->add_intvalue(width);
3350
3351    // copy argument height
3352    GLMessage_DataType *arg_height = glmsg.add_args();
3353    arg_height->set_isarray(false);
3354    arg_height->set_type(GLMessage::DataType::INT);
3355    arg_height->add_intvalue(height);
3356
3357    // copy argument format
3358    GLMessage_DataType *arg_format = glmsg.add_args();
3359    arg_format->set_isarray(false);
3360    arg_format->set_type(GLMessage::DataType::ENUM);
3361    arg_format->add_intvalue((int)format);
3362
3363    // copy argument type
3364    GLMessage_DataType *arg_type = glmsg.add_args();
3365    arg_type->set_isarray(false);
3366    arg_type->set_type(GLMessage::DataType::ENUM);
3367    arg_type->add_intvalue((int)type);
3368
3369    // copy argument pixels
3370    GLMessage_DataType *arg_pixels = glmsg.add_args();
3371    arg_pixels->set_isarray(false);
3372    arg_pixels->set_type(GLMessage::DataType::INT);
3373    arg_pixels->add_intvalue((int)pixels);
3374
3375    // call function
3376    glContext->hooks->gl.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
3377
3378    fixupGLMessage(glContext, &glmsg);
3379    glContext->traceGLMessage(&glmsg);
3380}
3381
3382void GLTrace_glUniform1f(GLint location, GLfloat x) {
3383    GLMessage glmsg;
3384    GLTraceContext *glContext = getGLTraceContext();
3385
3386    glmsg.set_function(GLMessage::glUniform1f);
3387
3388    // copy argument location
3389    GLMessage_DataType *arg_location = glmsg.add_args();
3390    arg_location->set_isarray(false);
3391    arg_location->set_type(GLMessage::DataType::INT);
3392    arg_location->add_intvalue(location);
3393
3394    // copy argument x
3395    GLMessage_DataType *arg_x = glmsg.add_args();
3396    arg_x->set_isarray(false);
3397    arg_x->set_type(GLMessage::DataType::FLOAT);
3398    arg_x->add_floatvalue(x);
3399
3400    // call function
3401    glContext->hooks->gl.glUniform1f(location, x);
3402
3403    fixupGLMessage(glContext, &glmsg);
3404    glContext->traceGLMessage(&glmsg);
3405}
3406
3407void GLTrace_glUniform1fv(GLint location, GLsizei count, const GLfloat* v) {
3408    GLMessage glmsg;
3409    GLTraceContext *glContext = getGLTraceContext();
3410
3411    glmsg.set_function(GLMessage::glUniform1fv);
3412
3413    // copy argument location
3414    GLMessage_DataType *arg_location = glmsg.add_args();
3415    arg_location->set_isarray(false);
3416    arg_location->set_type(GLMessage::DataType::INT);
3417    arg_location->add_intvalue(location);
3418
3419    // copy argument count
3420    GLMessage_DataType *arg_count = glmsg.add_args();
3421    arg_count->set_isarray(false);
3422    arg_count->set_type(GLMessage::DataType::INT);
3423    arg_count->add_intvalue(count);
3424
3425    // copy argument v
3426    GLMessage_DataType *arg_v = glmsg.add_args();
3427    arg_v->set_isarray(false);
3428    arg_v->set_type(GLMessage::DataType::INT);
3429    arg_v->add_intvalue((int)v);
3430
3431    // call function
3432    glContext->hooks->gl.glUniform1fv(location, count, v);
3433
3434    fixupGLMessage(glContext, &glmsg);
3435    glContext->traceGLMessage(&glmsg);
3436}
3437
3438void GLTrace_glUniform1i(GLint location, GLint x) {
3439    GLMessage glmsg;
3440    GLTraceContext *glContext = getGLTraceContext();
3441
3442    glmsg.set_function(GLMessage::glUniform1i);
3443
3444    // copy argument location
3445    GLMessage_DataType *arg_location = glmsg.add_args();
3446    arg_location->set_isarray(false);
3447    arg_location->set_type(GLMessage::DataType::INT);
3448    arg_location->add_intvalue(location);
3449
3450    // copy argument x
3451    GLMessage_DataType *arg_x = glmsg.add_args();
3452    arg_x->set_isarray(false);
3453    arg_x->set_type(GLMessage::DataType::INT);
3454    arg_x->add_intvalue(x);
3455
3456    // call function
3457    glContext->hooks->gl.glUniform1i(location, x);
3458
3459    fixupGLMessage(glContext, &glmsg);
3460    glContext->traceGLMessage(&glmsg);
3461}
3462
3463void GLTrace_glUniform1iv(GLint location, GLsizei count, const GLint* v) {
3464    GLMessage glmsg;
3465    GLTraceContext *glContext = getGLTraceContext();
3466
3467    glmsg.set_function(GLMessage::glUniform1iv);
3468
3469    // copy argument location
3470    GLMessage_DataType *arg_location = glmsg.add_args();
3471    arg_location->set_isarray(false);
3472    arg_location->set_type(GLMessage::DataType::INT);
3473    arg_location->add_intvalue(location);
3474
3475    // copy argument count
3476    GLMessage_DataType *arg_count = glmsg.add_args();
3477    arg_count->set_isarray(false);
3478    arg_count->set_type(GLMessage::DataType::INT);
3479    arg_count->add_intvalue(count);
3480
3481    // copy argument v
3482    GLMessage_DataType *arg_v = glmsg.add_args();
3483    arg_v->set_isarray(false);
3484    arg_v->set_type(GLMessage::DataType::INT);
3485    arg_v->add_intvalue((int)v);
3486
3487    // call function
3488    glContext->hooks->gl.glUniform1iv(location, count, v);
3489
3490    fixupGLMessage(glContext, &glmsg);
3491    glContext->traceGLMessage(&glmsg);
3492}
3493
3494void GLTrace_glUniform2f(GLint location, GLfloat x, GLfloat y) {
3495    GLMessage glmsg;
3496    GLTraceContext *glContext = getGLTraceContext();
3497
3498    glmsg.set_function(GLMessage::glUniform2f);
3499
3500    // copy argument location
3501    GLMessage_DataType *arg_location = glmsg.add_args();
3502    arg_location->set_isarray(false);
3503    arg_location->set_type(GLMessage::DataType::INT);
3504    arg_location->add_intvalue(location);
3505
3506    // copy argument x
3507    GLMessage_DataType *arg_x = glmsg.add_args();
3508    arg_x->set_isarray(false);
3509    arg_x->set_type(GLMessage::DataType::FLOAT);
3510    arg_x->add_floatvalue(x);
3511
3512    // copy argument y
3513    GLMessage_DataType *arg_y = glmsg.add_args();
3514    arg_y->set_isarray(false);
3515    arg_y->set_type(GLMessage::DataType::FLOAT);
3516    arg_y->add_floatvalue(y);
3517
3518    // call function
3519    glContext->hooks->gl.glUniform2f(location, x, y);
3520
3521    fixupGLMessage(glContext, &glmsg);
3522    glContext->traceGLMessage(&glmsg);
3523}
3524
3525void GLTrace_glUniform2fv(GLint location, GLsizei count, const GLfloat* v) {
3526    GLMessage glmsg;
3527    GLTraceContext *glContext = getGLTraceContext();
3528
3529    glmsg.set_function(GLMessage::glUniform2fv);
3530
3531    // copy argument location
3532    GLMessage_DataType *arg_location = glmsg.add_args();
3533    arg_location->set_isarray(false);
3534    arg_location->set_type(GLMessage::DataType::INT);
3535    arg_location->add_intvalue(location);
3536
3537    // copy argument count
3538    GLMessage_DataType *arg_count = glmsg.add_args();
3539    arg_count->set_isarray(false);
3540    arg_count->set_type(GLMessage::DataType::INT);
3541    arg_count->add_intvalue(count);
3542
3543    // copy argument v
3544    GLMessage_DataType *arg_v = glmsg.add_args();
3545    arg_v->set_isarray(false);
3546    arg_v->set_type(GLMessage::DataType::INT);
3547    arg_v->add_intvalue((int)v);
3548
3549    // call function
3550    glContext->hooks->gl.glUniform2fv(location, count, v);
3551
3552    fixupGLMessage(glContext, &glmsg);
3553    glContext->traceGLMessage(&glmsg);
3554}
3555
3556void GLTrace_glUniform2i(GLint location, GLint x, GLint y) {
3557    GLMessage glmsg;
3558    GLTraceContext *glContext = getGLTraceContext();
3559
3560    glmsg.set_function(GLMessage::glUniform2i);
3561
3562    // copy argument location
3563    GLMessage_DataType *arg_location = glmsg.add_args();
3564    arg_location->set_isarray(false);
3565    arg_location->set_type(GLMessage::DataType::INT);
3566    arg_location->add_intvalue(location);
3567
3568    // copy argument x
3569    GLMessage_DataType *arg_x = glmsg.add_args();
3570    arg_x->set_isarray(false);
3571    arg_x->set_type(GLMessage::DataType::INT);
3572    arg_x->add_intvalue(x);
3573
3574    // copy argument y
3575    GLMessage_DataType *arg_y = glmsg.add_args();
3576    arg_y->set_isarray(false);
3577    arg_y->set_type(GLMessage::DataType::INT);
3578    arg_y->add_intvalue(y);
3579
3580    // call function
3581    glContext->hooks->gl.glUniform2i(location, x, y);
3582
3583    fixupGLMessage(glContext, &glmsg);
3584    glContext->traceGLMessage(&glmsg);
3585}
3586
3587void GLTrace_glUniform2iv(GLint location, GLsizei count, const GLint* v) {
3588    GLMessage glmsg;
3589    GLTraceContext *glContext = getGLTraceContext();
3590
3591    glmsg.set_function(GLMessage::glUniform2iv);
3592
3593    // copy argument location
3594    GLMessage_DataType *arg_location = glmsg.add_args();
3595    arg_location->set_isarray(false);
3596    arg_location->set_type(GLMessage::DataType::INT);
3597    arg_location->add_intvalue(location);
3598
3599    // copy argument count
3600    GLMessage_DataType *arg_count = glmsg.add_args();
3601    arg_count->set_isarray(false);
3602    arg_count->set_type(GLMessage::DataType::INT);
3603    arg_count->add_intvalue(count);
3604
3605    // copy argument v
3606    GLMessage_DataType *arg_v = glmsg.add_args();
3607    arg_v->set_isarray(false);
3608    arg_v->set_type(GLMessage::DataType::INT);
3609    arg_v->add_intvalue((int)v);
3610
3611    // call function
3612    glContext->hooks->gl.glUniform2iv(location, count, v);
3613
3614    fixupGLMessage(glContext, &glmsg);
3615    glContext->traceGLMessage(&glmsg);
3616}
3617
3618void GLTrace_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
3619    GLMessage glmsg;
3620    GLTraceContext *glContext = getGLTraceContext();
3621
3622    glmsg.set_function(GLMessage::glUniform3f);
3623
3624    // copy argument location
3625    GLMessage_DataType *arg_location = glmsg.add_args();
3626    arg_location->set_isarray(false);
3627    arg_location->set_type(GLMessage::DataType::INT);
3628    arg_location->add_intvalue(location);
3629
3630    // copy argument x
3631    GLMessage_DataType *arg_x = glmsg.add_args();
3632    arg_x->set_isarray(false);
3633    arg_x->set_type(GLMessage::DataType::FLOAT);
3634    arg_x->add_floatvalue(x);
3635
3636    // copy argument y
3637    GLMessage_DataType *arg_y = glmsg.add_args();
3638    arg_y->set_isarray(false);
3639    arg_y->set_type(GLMessage::DataType::FLOAT);
3640    arg_y->add_floatvalue(y);
3641
3642    // copy argument z
3643    GLMessage_DataType *arg_z = glmsg.add_args();
3644    arg_z->set_isarray(false);
3645    arg_z->set_type(GLMessage::DataType::FLOAT);
3646    arg_z->add_floatvalue(z);
3647
3648    // call function
3649    glContext->hooks->gl.glUniform3f(location, x, y, z);
3650
3651    fixupGLMessage(glContext, &glmsg);
3652    glContext->traceGLMessage(&glmsg);
3653}
3654
3655void GLTrace_glUniform3fv(GLint location, GLsizei count, const GLfloat* v) {
3656    GLMessage glmsg;
3657    GLTraceContext *glContext = getGLTraceContext();
3658
3659    glmsg.set_function(GLMessage::glUniform3fv);
3660
3661    // copy argument location
3662    GLMessage_DataType *arg_location = glmsg.add_args();
3663    arg_location->set_isarray(false);
3664    arg_location->set_type(GLMessage::DataType::INT);
3665    arg_location->add_intvalue(location);
3666
3667    // copy argument count
3668    GLMessage_DataType *arg_count = glmsg.add_args();
3669    arg_count->set_isarray(false);
3670    arg_count->set_type(GLMessage::DataType::INT);
3671    arg_count->add_intvalue(count);
3672
3673    // copy argument v
3674    GLMessage_DataType *arg_v = glmsg.add_args();
3675    arg_v->set_isarray(false);
3676    arg_v->set_type(GLMessage::DataType::INT);
3677    arg_v->add_intvalue((int)v);
3678
3679    // call function
3680    glContext->hooks->gl.glUniform3fv(location, count, v);
3681
3682    fixupGLMessage(glContext, &glmsg);
3683    glContext->traceGLMessage(&glmsg);
3684}
3685
3686void GLTrace_glUniform3i(GLint location, GLint x, GLint y, GLint z) {
3687    GLMessage glmsg;
3688    GLTraceContext *glContext = getGLTraceContext();
3689
3690    glmsg.set_function(GLMessage::glUniform3i);
3691
3692    // copy argument location
3693    GLMessage_DataType *arg_location = glmsg.add_args();
3694    arg_location->set_isarray(false);
3695    arg_location->set_type(GLMessage::DataType::INT);
3696    arg_location->add_intvalue(location);
3697
3698    // copy argument x
3699    GLMessage_DataType *arg_x = glmsg.add_args();
3700    arg_x->set_isarray(false);
3701    arg_x->set_type(GLMessage::DataType::INT);
3702    arg_x->add_intvalue(x);
3703
3704    // copy argument y
3705    GLMessage_DataType *arg_y = glmsg.add_args();
3706    arg_y->set_isarray(false);
3707    arg_y->set_type(GLMessage::DataType::INT);
3708    arg_y->add_intvalue(y);
3709
3710    // copy argument z
3711    GLMessage_DataType *arg_z = glmsg.add_args();
3712    arg_z->set_isarray(false);
3713    arg_z->set_type(GLMessage::DataType::INT);
3714    arg_z->add_intvalue(z);
3715
3716    // call function
3717    glContext->hooks->gl.glUniform3i(location, x, y, z);
3718
3719    fixupGLMessage(glContext, &glmsg);
3720    glContext->traceGLMessage(&glmsg);
3721}
3722
3723void GLTrace_glUniform3iv(GLint location, GLsizei count, const GLint* v) {
3724    GLMessage glmsg;
3725    GLTraceContext *glContext = getGLTraceContext();
3726
3727    glmsg.set_function(GLMessage::glUniform3iv);
3728
3729    // copy argument location
3730    GLMessage_DataType *arg_location = glmsg.add_args();
3731    arg_location->set_isarray(false);
3732    arg_location->set_type(GLMessage::DataType::INT);
3733    arg_location->add_intvalue(location);
3734
3735    // copy argument count
3736    GLMessage_DataType *arg_count = glmsg.add_args();
3737    arg_count->set_isarray(false);
3738    arg_count->set_type(GLMessage::DataType::INT);
3739    arg_count->add_intvalue(count);
3740
3741    // copy argument v
3742    GLMessage_DataType *arg_v = glmsg.add_args();
3743    arg_v->set_isarray(false);
3744    arg_v->set_type(GLMessage::DataType::INT);
3745    arg_v->add_intvalue((int)v);
3746
3747    // call function
3748    glContext->hooks->gl.glUniform3iv(location, count, v);
3749
3750    fixupGLMessage(glContext, &glmsg);
3751    glContext->traceGLMessage(&glmsg);
3752}
3753
3754void GLTrace_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
3755    GLMessage glmsg;
3756    GLTraceContext *glContext = getGLTraceContext();
3757
3758    glmsg.set_function(GLMessage::glUniform4f);
3759
3760    // copy argument location
3761    GLMessage_DataType *arg_location = glmsg.add_args();
3762    arg_location->set_isarray(false);
3763    arg_location->set_type(GLMessage::DataType::INT);
3764    arg_location->add_intvalue(location);
3765
3766    // copy argument x
3767    GLMessage_DataType *arg_x = glmsg.add_args();
3768    arg_x->set_isarray(false);
3769    arg_x->set_type(GLMessage::DataType::FLOAT);
3770    arg_x->add_floatvalue(x);
3771
3772    // copy argument y
3773    GLMessage_DataType *arg_y = glmsg.add_args();
3774    arg_y->set_isarray(false);
3775    arg_y->set_type(GLMessage::DataType::FLOAT);
3776    arg_y->add_floatvalue(y);
3777
3778    // copy argument z
3779    GLMessage_DataType *arg_z = glmsg.add_args();
3780    arg_z->set_isarray(false);
3781    arg_z->set_type(GLMessage::DataType::FLOAT);
3782    arg_z->add_floatvalue(z);
3783
3784    // copy argument w
3785    GLMessage_DataType *arg_w = glmsg.add_args();
3786    arg_w->set_isarray(false);
3787    arg_w->set_type(GLMessage::DataType::FLOAT);
3788    arg_w->add_floatvalue(w);
3789
3790    // call function
3791    glContext->hooks->gl.glUniform4f(location, x, y, z, w);
3792
3793    fixupGLMessage(glContext, &glmsg);
3794    glContext->traceGLMessage(&glmsg);
3795}
3796
3797void GLTrace_glUniform4fv(GLint location, GLsizei count, const GLfloat* v) {
3798    GLMessage glmsg;
3799    GLTraceContext *glContext = getGLTraceContext();
3800
3801    glmsg.set_function(GLMessage::glUniform4fv);
3802
3803    // copy argument location
3804    GLMessage_DataType *arg_location = glmsg.add_args();
3805    arg_location->set_isarray(false);
3806    arg_location->set_type(GLMessage::DataType::INT);
3807    arg_location->add_intvalue(location);
3808
3809    // copy argument count
3810    GLMessage_DataType *arg_count = glmsg.add_args();
3811    arg_count->set_isarray(false);
3812    arg_count->set_type(GLMessage::DataType::INT);
3813    arg_count->add_intvalue(count);
3814
3815    // copy argument v
3816    GLMessage_DataType *arg_v = glmsg.add_args();
3817    arg_v->set_isarray(false);
3818    arg_v->set_type(GLMessage::DataType::INT);
3819    arg_v->add_intvalue((int)v);
3820
3821    // call function
3822    glContext->hooks->gl.glUniform4fv(location, count, v);
3823
3824    fixupGLMessage(glContext, &glmsg);
3825    glContext->traceGLMessage(&glmsg);
3826}
3827
3828void GLTrace_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
3829    GLMessage glmsg;
3830    GLTraceContext *glContext = getGLTraceContext();
3831
3832    glmsg.set_function(GLMessage::glUniform4i);
3833
3834    // copy argument location
3835    GLMessage_DataType *arg_location = glmsg.add_args();
3836    arg_location->set_isarray(false);
3837    arg_location->set_type(GLMessage::DataType::INT);
3838    arg_location->add_intvalue(location);
3839
3840    // copy argument x
3841    GLMessage_DataType *arg_x = glmsg.add_args();
3842    arg_x->set_isarray(false);
3843    arg_x->set_type(GLMessage::DataType::INT);
3844    arg_x->add_intvalue(x);
3845
3846    // copy argument y
3847    GLMessage_DataType *arg_y = glmsg.add_args();
3848    arg_y->set_isarray(false);
3849    arg_y->set_type(GLMessage::DataType::INT);
3850    arg_y->add_intvalue(y);
3851
3852    // copy argument z
3853    GLMessage_DataType *arg_z = glmsg.add_args();
3854    arg_z->set_isarray(false);
3855    arg_z->set_type(GLMessage::DataType::INT);
3856    arg_z->add_intvalue(z);
3857
3858    // copy argument w
3859    GLMessage_DataType *arg_w = glmsg.add_args();
3860    arg_w->set_isarray(false);
3861    arg_w->set_type(GLMessage::DataType::INT);
3862    arg_w->add_intvalue(w);
3863
3864    // call function
3865    glContext->hooks->gl.glUniform4i(location, x, y, z, w);
3866
3867    fixupGLMessage(glContext, &glmsg);
3868    glContext->traceGLMessage(&glmsg);
3869}
3870
3871void GLTrace_glUniform4iv(GLint location, GLsizei count, const GLint* v) {
3872    GLMessage glmsg;
3873    GLTraceContext *glContext = getGLTraceContext();
3874
3875    glmsg.set_function(GLMessage::glUniform4iv);
3876
3877    // copy argument location
3878    GLMessage_DataType *arg_location = glmsg.add_args();
3879    arg_location->set_isarray(false);
3880    arg_location->set_type(GLMessage::DataType::INT);
3881    arg_location->add_intvalue(location);
3882
3883    // copy argument count
3884    GLMessage_DataType *arg_count = glmsg.add_args();
3885    arg_count->set_isarray(false);
3886    arg_count->set_type(GLMessage::DataType::INT);
3887    arg_count->add_intvalue(count);
3888
3889    // copy argument v
3890    GLMessage_DataType *arg_v = glmsg.add_args();
3891    arg_v->set_isarray(false);
3892    arg_v->set_type(GLMessage::DataType::INT);
3893    arg_v->add_intvalue((int)v);
3894
3895    // call function
3896    glContext->hooks->gl.glUniform4iv(location, count, v);
3897
3898    fixupGLMessage(glContext, &glmsg);
3899    glContext->traceGLMessage(&glmsg);
3900}
3901
3902void GLTrace_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
3903    GLMessage glmsg;
3904    GLTraceContext *glContext = getGLTraceContext();
3905
3906    glmsg.set_function(GLMessage::glUniformMatrix2fv);
3907
3908    // copy argument location
3909    GLMessage_DataType *arg_location = glmsg.add_args();
3910    arg_location->set_isarray(false);
3911    arg_location->set_type(GLMessage::DataType::INT);
3912    arg_location->add_intvalue(location);
3913
3914    // copy argument count
3915    GLMessage_DataType *arg_count = glmsg.add_args();
3916    arg_count->set_isarray(false);
3917    arg_count->set_type(GLMessage::DataType::INT);
3918    arg_count->add_intvalue(count);
3919
3920    // copy argument transpose
3921    GLMessage_DataType *arg_transpose = glmsg.add_args();
3922    arg_transpose->set_isarray(false);
3923    arg_transpose->set_type(GLMessage::DataType::BOOL);
3924    arg_transpose->add_boolvalue(transpose);
3925
3926    // copy argument value
3927    GLMessage_DataType *arg_value = glmsg.add_args();
3928    arg_value->set_isarray(false);
3929    arg_value->set_type(GLMessage::DataType::INT);
3930    arg_value->add_intvalue((int)value);
3931
3932    // call function
3933    glContext->hooks->gl.glUniformMatrix2fv(location, count, transpose, value);
3934
3935    fixupGLMessage(glContext, &glmsg);
3936    glContext->traceGLMessage(&glmsg);
3937}
3938
3939void GLTrace_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
3940    GLMessage glmsg;
3941    GLTraceContext *glContext = getGLTraceContext();
3942
3943    glmsg.set_function(GLMessage::glUniformMatrix3fv);
3944
3945    // copy argument location
3946    GLMessage_DataType *arg_location = glmsg.add_args();
3947    arg_location->set_isarray(false);
3948    arg_location->set_type(GLMessage::DataType::INT);
3949    arg_location->add_intvalue(location);
3950
3951    // copy argument count
3952    GLMessage_DataType *arg_count = glmsg.add_args();
3953    arg_count->set_isarray(false);
3954    arg_count->set_type(GLMessage::DataType::INT);
3955    arg_count->add_intvalue(count);
3956
3957    // copy argument transpose
3958    GLMessage_DataType *arg_transpose = glmsg.add_args();
3959    arg_transpose->set_isarray(false);
3960    arg_transpose->set_type(GLMessage::DataType::BOOL);
3961    arg_transpose->add_boolvalue(transpose);
3962
3963    // copy argument value
3964    GLMessage_DataType *arg_value = glmsg.add_args();
3965    arg_value->set_isarray(false);
3966    arg_value->set_type(GLMessage::DataType::INT);
3967    arg_value->add_intvalue((int)value);
3968
3969    // call function
3970    glContext->hooks->gl.glUniformMatrix3fv(location, count, transpose, value);
3971
3972    fixupGLMessage(glContext, &glmsg);
3973    glContext->traceGLMessage(&glmsg);
3974}
3975
3976void GLTrace_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
3977    GLMessage glmsg;
3978    GLTraceContext *glContext = getGLTraceContext();
3979
3980    glmsg.set_function(GLMessage::glUniformMatrix4fv);
3981
3982    // copy argument location
3983    GLMessage_DataType *arg_location = glmsg.add_args();
3984    arg_location->set_isarray(false);
3985    arg_location->set_type(GLMessage::DataType::INT);
3986    arg_location->add_intvalue(location);
3987
3988    // copy argument count
3989    GLMessage_DataType *arg_count = glmsg.add_args();
3990    arg_count->set_isarray(false);
3991    arg_count->set_type(GLMessage::DataType::INT);
3992    arg_count->add_intvalue(count);
3993
3994    // copy argument transpose
3995    GLMessage_DataType *arg_transpose = glmsg.add_args();
3996    arg_transpose->set_isarray(false);
3997    arg_transpose->set_type(GLMessage::DataType::BOOL);
3998    arg_transpose->add_boolvalue(transpose);
3999
4000    // copy argument value
4001    GLMessage_DataType *arg_value = glmsg.add_args();
4002    arg_value->set_isarray(false);
4003    arg_value->set_type(GLMessage::DataType::INT);
4004    arg_value->add_intvalue((int)value);
4005
4006    // call function
4007    glContext->hooks->gl.glUniformMatrix4fv(location, count, transpose, value);
4008
4009    fixupGLMessage(glContext, &glmsg);
4010    glContext->traceGLMessage(&glmsg);
4011}
4012
4013void GLTrace_glUseProgram(GLuint program) {
4014    GLMessage glmsg;
4015    GLTraceContext *glContext = getGLTraceContext();
4016
4017    glmsg.set_function(GLMessage::glUseProgram);
4018
4019    // copy argument program
4020    GLMessage_DataType *arg_program = glmsg.add_args();
4021    arg_program->set_isarray(false);
4022    arg_program->set_type(GLMessage::DataType::INT);
4023    arg_program->add_intvalue(program);
4024
4025    // call function
4026    glContext->hooks->gl.glUseProgram(program);
4027
4028    fixupGLMessage(glContext, &glmsg);
4029    glContext->traceGLMessage(&glmsg);
4030}
4031
4032void GLTrace_glValidateProgram(GLuint program) {
4033    GLMessage glmsg;
4034    GLTraceContext *glContext = getGLTraceContext();
4035
4036    glmsg.set_function(GLMessage::glValidateProgram);
4037
4038    // copy argument program
4039    GLMessage_DataType *arg_program = glmsg.add_args();
4040    arg_program->set_isarray(false);
4041    arg_program->set_type(GLMessage::DataType::INT);
4042    arg_program->add_intvalue(program);
4043
4044    // call function
4045    glContext->hooks->gl.glValidateProgram(program);
4046
4047    fixupGLMessage(glContext, &glmsg);
4048    glContext->traceGLMessage(&glmsg);
4049}
4050
4051void GLTrace_glVertexAttrib1f(GLuint indx, GLfloat x) {
4052    GLMessage glmsg;
4053    GLTraceContext *glContext = getGLTraceContext();
4054
4055    glmsg.set_function(GLMessage::glVertexAttrib1f);
4056
4057    // copy argument indx
4058    GLMessage_DataType *arg_indx = glmsg.add_args();
4059    arg_indx->set_isarray(false);
4060    arg_indx->set_type(GLMessage::DataType::INT);
4061    arg_indx->add_intvalue(indx);
4062
4063    // copy argument x
4064    GLMessage_DataType *arg_x = glmsg.add_args();
4065    arg_x->set_isarray(false);
4066    arg_x->set_type(GLMessage::DataType::FLOAT);
4067    arg_x->add_floatvalue(x);
4068
4069    // call function
4070    glContext->hooks->gl.glVertexAttrib1f(indx, x);
4071
4072    fixupGLMessage(glContext, &glmsg);
4073    glContext->traceGLMessage(&glmsg);
4074}
4075
4076void GLTrace_glVertexAttrib1fv(GLuint indx, const GLfloat* values) {
4077    GLMessage glmsg;
4078    GLTraceContext *glContext = getGLTraceContext();
4079
4080    glmsg.set_function(GLMessage::glVertexAttrib1fv);
4081
4082    // copy argument indx
4083    GLMessage_DataType *arg_indx = glmsg.add_args();
4084    arg_indx->set_isarray(false);
4085    arg_indx->set_type(GLMessage::DataType::INT);
4086    arg_indx->add_intvalue(indx);
4087
4088    // copy argument values
4089    GLMessage_DataType *arg_values = glmsg.add_args();
4090    arg_values->set_isarray(false);
4091    arg_values->set_type(GLMessage::DataType::INT);
4092    arg_values->add_intvalue((int)values);
4093
4094    // call function
4095    glContext->hooks->gl.glVertexAttrib1fv(indx, values);
4096
4097    fixupGLMessage(glContext, &glmsg);
4098    glContext->traceGLMessage(&glmsg);
4099}
4100
4101void GLTrace_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
4102    GLMessage glmsg;
4103    GLTraceContext *glContext = getGLTraceContext();
4104
4105    glmsg.set_function(GLMessage::glVertexAttrib2f);
4106
4107    // copy argument indx
4108    GLMessage_DataType *arg_indx = glmsg.add_args();
4109    arg_indx->set_isarray(false);
4110    arg_indx->set_type(GLMessage::DataType::INT);
4111    arg_indx->add_intvalue(indx);
4112
4113    // copy argument x
4114    GLMessage_DataType *arg_x = glmsg.add_args();
4115    arg_x->set_isarray(false);
4116    arg_x->set_type(GLMessage::DataType::FLOAT);
4117    arg_x->add_floatvalue(x);
4118
4119    // copy argument y
4120    GLMessage_DataType *arg_y = glmsg.add_args();
4121    arg_y->set_isarray(false);
4122    arg_y->set_type(GLMessage::DataType::FLOAT);
4123    arg_y->add_floatvalue(y);
4124
4125    // call function
4126    glContext->hooks->gl.glVertexAttrib2f(indx, x, y);
4127
4128    fixupGLMessage(glContext, &glmsg);
4129    glContext->traceGLMessage(&glmsg);
4130}
4131
4132void GLTrace_glVertexAttrib2fv(GLuint indx, const GLfloat* values) {
4133    GLMessage glmsg;
4134    GLTraceContext *glContext = getGLTraceContext();
4135
4136    glmsg.set_function(GLMessage::glVertexAttrib2fv);
4137
4138    // copy argument indx
4139    GLMessage_DataType *arg_indx = glmsg.add_args();
4140    arg_indx->set_isarray(false);
4141    arg_indx->set_type(GLMessage::DataType::INT);
4142    arg_indx->add_intvalue(indx);
4143
4144    // copy argument values
4145    GLMessage_DataType *arg_values = glmsg.add_args();
4146    arg_values->set_isarray(false);
4147    arg_values->set_type(GLMessage::DataType::INT);
4148    arg_values->add_intvalue((int)values);
4149
4150    // call function
4151    glContext->hooks->gl.glVertexAttrib2fv(indx, values);
4152
4153    fixupGLMessage(glContext, &glmsg);
4154    glContext->traceGLMessage(&glmsg);
4155}
4156
4157void GLTrace_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
4158    GLMessage glmsg;
4159    GLTraceContext *glContext = getGLTraceContext();
4160
4161    glmsg.set_function(GLMessage::glVertexAttrib3f);
4162
4163    // copy argument indx
4164    GLMessage_DataType *arg_indx = glmsg.add_args();
4165    arg_indx->set_isarray(false);
4166    arg_indx->set_type(GLMessage::DataType::INT);
4167    arg_indx->add_intvalue(indx);
4168
4169    // copy argument x
4170    GLMessage_DataType *arg_x = glmsg.add_args();
4171    arg_x->set_isarray(false);
4172    arg_x->set_type(GLMessage::DataType::FLOAT);
4173    arg_x->add_floatvalue(x);
4174
4175    // copy argument y
4176    GLMessage_DataType *arg_y = glmsg.add_args();
4177    arg_y->set_isarray(false);
4178    arg_y->set_type(GLMessage::DataType::FLOAT);
4179    arg_y->add_floatvalue(y);
4180
4181    // copy argument z
4182    GLMessage_DataType *arg_z = glmsg.add_args();
4183    arg_z->set_isarray(false);
4184    arg_z->set_type(GLMessage::DataType::FLOAT);
4185    arg_z->add_floatvalue(z);
4186
4187    // call function
4188    glContext->hooks->gl.glVertexAttrib3f(indx, x, y, z);
4189
4190    fixupGLMessage(glContext, &glmsg);
4191    glContext->traceGLMessage(&glmsg);
4192}
4193
4194void GLTrace_glVertexAttrib3fv(GLuint indx, const GLfloat* values) {
4195    GLMessage glmsg;
4196    GLTraceContext *glContext = getGLTraceContext();
4197
4198    glmsg.set_function(GLMessage::glVertexAttrib3fv);
4199
4200    // copy argument indx
4201    GLMessage_DataType *arg_indx = glmsg.add_args();
4202    arg_indx->set_isarray(false);
4203    arg_indx->set_type(GLMessage::DataType::INT);
4204    arg_indx->add_intvalue(indx);
4205
4206    // copy argument values
4207    GLMessage_DataType *arg_values = glmsg.add_args();
4208    arg_values->set_isarray(false);
4209    arg_values->set_type(GLMessage::DataType::INT);
4210    arg_values->add_intvalue((int)values);
4211
4212    // call function
4213    glContext->hooks->gl.glVertexAttrib3fv(indx, values);
4214
4215    fixupGLMessage(glContext, &glmsg);
4216    glContext->traceGLMessage(&glmsg);
4217}
4218
4219void GLTrace_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
4220    GLMessage glmsg;
4221    GLTraceContext *glContext = getGLTraceContext();
4222
4223    glmsg.set_function(GLMessage::glVertexAttrib4f);
4224
4225    // copy argument indx
4226    GLMessage_DataType *arg_indx = glmsg.add_args();
4227    arg_indx->set_isarray(false);
4228    arg_indx->set_type(GLMessage::DataType::INT);
4229    arg_indx->add_intvalue(indx);
4230
4231    // copy argument x
4232    GLMessage_DataType *arg_x = glmsg.add_args();
4233    arg_x->set_isarray(false);
4234    arg_x->set_type(GLMessage::DataType::FLOAT);
4235    arg_x->add_floatvalue(x);
4236
4237    // copy argument y
4238    GLMessage_DataType *arg_y = glmsg.add_args();
4239    arg_y->set_isarray(false);
4240    arg_y->set_type(GLMessage::DataType::FLOAT);
4241    arg_y->add_floatvalue(y);
4242
4243    // copy argument z
4244    GLMessage_DataType *arg_z = glmsg.add_args();
4245    arg_z->set_isarray(false);
4246    arg_z->set_type(GLMessage::DataType::FLOAT);
4247    arg_z->add_floatvalue(z);
4248
4249    // copy argument w
4250    GLMessage_DataType *arg_w = glmsg.add_args();
4251    arg_w->set_isarray(false);
4252    arg_w->set_type(GLMessage::DataType::FLOAT);
4253    arg_w->add_floatvalue(w);
4254
4255    // call function
4256    glContext->hooks->gl.glVertexAttrib4f(indx, x, y, z, w);
4257
4258    fixupGLMessage(glContext, &glmsg);
4259    glContext->traceGLMessage(&glmsg);
4260}
4261
4262void GLTrace_glVertexAttrib4fv(GLuint indx, const GLfloat* values) {
4263    GLMessage glmsg;
4264    GLTraceContext *glContext = getGLTraceContext();
4265
4266    glmsg.set_function(GLMessage::glVertexAttrib4fv);
4267
4268    // copy argument indx
4269    GLMessage_DataType *arg_indx = glmsg.add_args();
4270    arg_indx->set_isarray(false);
4271    arg_indx->set_type(GLMessage::DataType::INT);
4272    arg_indx->add_intvalue(indx);
4273
4274    // copy argument values
4275    GLMessage_DataType *arg_values = glmsg.add_args();
4276    arg_values->set_isarray(false);
4277    arg_values->set_type(GLMessage::DataType::INT);
4278    arg_values->add_intvalue((int)values);
4279
4280    // call function
4281    glContext->hooks->gl.glVertexAttrib4fv(indx, values);
4282
4283    fixupGLMessage(glContext, &glmsg);
4284    glContext->traceGLMessage(&glmsg);
4285}
4286
4287void GLTrace_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr) {
4288    GLMessage glmsg;
4289    GLTraceContext *glContext = getGLTraceContext();
4290
4291    glmsg.set_function(GLMessage::glVertexAttribPointer);
4292
4293    // copy argument indx
4294    GLMessage_DataType *arg_indx = glmsg.add_args();
4295    arg_indx->set_isarray(false);
4296    arg_indx->set_type(GLMessage::DataType::INT);
4297    arg_indx->add_intvalue(indx);
4298
4299    // copy argument size
4300    GLMessage_DataType *arg_size = glmsg.add_args();
4301    arg_size->set_isarray(false);
4302    arg_size->set_type(GLMessage::DataType::INT);
4303    arg_size->add_intvalue(size);
4304
4305    // copy argument type
4306    GLMessage_DataType *arg_type = glmsg.add_args();
4307    arg_type->set_isarray(false);
4308    arg_type->set_type(GLMessage::DataType::ENUM);
4309    arg_type->add_intvalue((int)type);
4310
4311    // copy argument normalized
4312    GLMessage_DataType *arg_normalized = glmsg.add_args();
4313    arg_normalized->set_isarray(false);
4314    arg_normalized->set_type(GLMessage::DataType::BOOL);
4315    arg_normalized->add_boolvalue(normalized);
4316
4317    // copy argument stride
4318    GLMessage_DataType *arg_stride = glmsg.add_args();
4319    arg_stride->set_isarray(false);
4320    arg_stride->set_type(GLMessage::DataType::INT);
4321    arg_stride->add_intvalue(stride);
4322
4323    // copy argument ptr
4324    GLMessage_DataType *arg_ptr = glmsg.add_args();
4325    arg_ptr->set_isarray(false);
4326    arg_ptr->set_type(GLMessage::DataType::INT);
4327    arg_ptr->add_intvalue((int)ptr);
4328
4329    // call function
4330    glContext->hooks->gl.glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
4331
4332    fixupGLMessage(glContext, &glmsg);
4333    glContext->traceGLMessage(&glmsg);
4334}
4335
4336void GLTrace_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
4337    GLMessage glmsg;
4338    GLTraceContext *glContext = getGLTraceContext();
4339
4340    glmsg.set_function(GLMessage::glViewport);
4341
4342    // copy argument x
4343    GLMessage_DataType *arg_x = glmsg.add_args();
4344    arg_x->set_isarray(false);
4345    arg_x->set_type(GLMessage::DataType::INT);
4346    arg_x->add_intvalue(x);
4347
4348    // copy argument y
4349    GLMessage_DataType *arg_y = glmsg.add_args();
4350    arg_y->set_isarray(false);
4351    arg_y->set_type(GLMessage::DataType::INT);
4352    arg_y->add_intvalue(y);
4353
4354    // copy argument width
4355    GLMessage_DataType *arg_width = glmsg.add_args();
4356    arg_width->set_isarray(false);
4357    arg_width->set_type(GLMessage::DataType::INT);
4358    arg_width->add_intvalue(width);
4359
4360    // copy argument height
4361    GLMessage_DataType *arg_height = glmsg.add_args();
4362    arg_height->set_isarray(false);
4363    arg_height->set_type(GLMessage::DataType::INT);
4364    arg_height->add_intvalue(height);
4365
4366    // call function
4367    glContext->hooks->gl.glViewport(x, y, width, height);
4368
4369    fixupGLMessage(glContext, &glmsg);
4370    glContext->traceGLMessage(&glmsg);
4371}
4372
4373
4374// Definitions for GL2Ext APIs
4375
4376void GLTrace_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) {
4377    GLMessage glmsg;
4378    GLTraceContext *glContext = getGLTraceContext();
4379
4380    glmsg.set_function(GLMessage::glEGLImageTargetTexture2DOES);
4381
4382    // copy argument target
4383    GLMessage_DataType *arg_target = glmsg.add_args();
4384    arg_target->set_isarray(false);
4385    arg_target->set_type(GLMessage::DataType::ENUM);
4386    arg_target->add_intvalue((int)target);
4387
4388    // copy argument image
4389    GLMessage_DataType *arg_image = glmsg.add_args();
4390    arg_image->set_isarray(false);
4391    arg_image->set_type(GLMessage::DataType::INT);
4392    arg_image->add_intvalue((int)image);
4393
4394    // call function
4395    glContext->hooks->gl.glEGLImageTargetTexture2DOES(target, image);
4396
4397    fixupGLMessage(glContext, &glmsg);
4398    glContext->traceGLMessage(&glmsg);
4399}
4400
4401void GLTrace_glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) {
4402    GLMessage glmsg;
4403    GLTraceContext *glContext = getGLTraceContext();
4404
4405    glmsg.set_function(GLMessage::glEGLImageTargetRenderbufferStorageOES);
4406
4407    // copy argument target
4408    GLMessage_DataType *arg_target = glmsg.add_args();
4409    arg_target->set_isarray(false);
4410    arg_target->set_type(GLMessage::DataType::ENUM);
4411    arg_target->add_intvalue((int)target);
4412
4413    // copy argument image
4414    GLMessage_DataType *arg_image = glmsg.add_args();
4415    arg_image->set_isarray(false);
4416    arg_image->set_type(GLMessage::DataType::INT);
4417    arg_image->add_intvalue((int)image);
4418
4419    // call function
4420    glContext->hooks->gl.glEGLImageTargetRenderbufferStorageOES(target, image);
4421
4422    fixupGLMessage(glContext, &glmsg);
4423    glContext->traceGLMessage(&glmsg);
4424}
4425
4426void GLTrace_glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary) {
4427    GLMessage glmsg;
4428    GLTraceContext *glContext = getGLTraceContext();
4429
4430    glmsg.set_function(GLMessage::glGetProgramBinaryOES);
4431
4432    // copy argument program
4433    GLMessage_DataType *arg_program = glmsg.add_args();
4434    arg_program->set_isarray(false);
4435    arg_program->set_type(GLMessage::DataType::INT);
4436    arg_program->add_intvalue(program);
4437
4438    // copy argument bufSize
4439    GLMessage_DataType *arg_bufSize = glmsg.add_args();
4440    arg_bufSize->set_isarray(false);
4441    arg_bufSize->set_type(GLMessage::DataType::INT);
4442    arg_bufSize->add_intvalue(bufSize);
4443
4444    // copy argument length
4445    GLMessage_DataType *arg_length = glmsg.add_args();
4446    arg_length->set_isarray(false);
4447    arg_length->set_type(GLMessage::DataType::INT);
4448    arg_length->add_intvalue((int)length);
4449
4450    // copy argument binaryFormat
4451    GLMessage_DataType *arg_binaryFormat = glmsg.add_args();
4452    arg_binaryFormat->set_isarray(false);
4453    arg_binaryFormat->set_type(GLMessage::DataType::INT);
4454    arg_binaryFormat->add_intvalue((int)binaryFormat);
4455
4456    // copy argument binary
4457    GLMessage_DataType *arg_binary = glmsg.add_args();
4458    arg_binary->set_isarray(false);
4459    arg_binary->set_type(GLMessage::DataType::INT);
4460    arg_binary->add_intvalue((int)binary);
4461
4462    // call function
4463    glContext->hooks->gl.glGetProgramBinaryOES(program, bufSize, length, binaryFormat, binary);
4464
4465    fixupGLMessage(glContext, &glmsg);
4466    glContext->traceGLMessage(&glmsg);
4467}
4468
4469void GLTrace_glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLint length) {
4470    GLMessage glmsg;
4471    GLTraceContext *glContext = getGLTraceContext();
4472
4473    glmsg.set_function(GLMessage::glProgramBinaryOES);
4474
4475    // copy argument program
4476    GLMessage_DataType *arg_program = glmsg.add_args();
4477    arg_program->set_isarray(false);
4478    arg_program->set_type(GLMessage::DataType::INT);
4479    arg_program->add_intvalue(program);
4480
4481    // copy argument binaryFormat
4482    GLMessage_DataType *arg_binaryFormat = glmsg.add_args();
4483    arg_binaryFormat->set_isarray(false);
4484    arg_binaryFormat->set_type(GLMessage::DataType::ENUM);
4485    arg_binaryFormat->add_intvalue((int)binaryFormat);
4486
4487    // copy argument binary
4488    GLMessage_DataType *arg_binary = glmsg.add_args();
4489    arg_binary->set_isarray(false);
4490    arg_binary->set_type(GLMessage::DataType::INT);
4491    arg_binary->add_intvalue((int)binary);
4492
4493    // copy argument length
4494    GLMessage_DataType *arg_length = glmsg.add_args();
4495    arg_length->set_isarray(false);
4496    arg_length->set_type(GLMessage::DataType::INT);
4497    arg_length->add_intvalue(length);
4498
4499    // call function
4500    glContext->hooks->gl.glProgramBinaryOES(program, binaryFormat, binary, length);
4501
4502    fixupGLMessage(glContext, &glmsg);
4503    glContext->traceGLMessage(&glmsg);
4504}
4505
4506void* GLTrace_glMapBufferOES(GLenum target, GLenum access) {
4507    GLMessage glmsg;
4508    GLTraceContext *glContext = getGLTraceContext();
4509
4510    glmsg.set_function(GLMessage::glMapBufferOES);
4511
4512    // copy argument target
4513    GLMessage_DataType *arg_target = glmsg.add_args();
4514    arg_target->set_isarray(false);
4515    arg_target->set_type(GLMessage::DataType::ENUM);
4516    arg_target->add_intvalue((int)target);
4517
4518    // copy argument access
4519    GLMessage_DataType *arg_access = glmsg.add_args();
4520    arg_access->set_isarray(false);
4521    arg_access->set_type(GLMessage::DataType::ENUM);
4522    arg_access->add_intvalue((int)access);
4523
4524    // call function
4525    void* retValue = glContext->hooks->gl.glMapBufferOES(target, access);
4526
4527    // set return value
4528    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
4529    rt->set_isarray(false);
4530    rt->set_type(GLMessage::DataType::INT);
4531    rt->add_intvalue((int)retValue);
4532
4533    fixupGLMessage(glContext, &glmsg);
4534    glContext->traceGLMessage(&glmsg);
4535
4536    return retValue;
4537}
4538
4539GLboolean GLTrace_glUnmapBufferOES(GLenum target) {
4540    GLMessage glmsg;
4541    GLTraceContext *glContext = getGLTraceContext();
4542
4543    glmsg.set_function(GLMessage::glUnmapBufferOES);
4544
4545    // copy argument target
4546    GLMessage_DataType *arg_target = glmsg.add_args();
4547    arg_target->set_isarray(false);
4548    arg_target->set_type(GLMessage::DataType::ENUM);
4549    arg_target->add_intvalue((int)target);
4550
4551    // call function
4552    GLboolean retValue = glContext->hooks->gl.glUnmapBufferOES(target);
4553
4554    // set return value
4555    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
4556    rt->set_isarray(false);
4557    rt->set_type(GLMessage::DataType::BOOL);
4558    rt->add_boolvalue(retValue);
4559
4560    fixupGLMessage(glContext, &glmsg);
4561    glContext->traceGLMessage(&glmsg);
4562
4563    return retValue;
4564}
4565
4566void GLTrace_glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params) {
4567    GLMessage glmsg;
4568    GLTraceContext *glContext = getGLTraceContext();
4569
4570    glmsg.set_function(GLMessage::glGetBufferPointervOES);
4571
4572    // copy argument target
4573    GLMessage_DataType *arg_target = glmsg.add_args();
4574    arg_target->set_isarray(false);
4575    arg_target->set_type(GLMessage::DataType::ENUM);
4576    arg_target->add_intvalue((int)target);
4577
4578    // copy argument pname
4579    GLMessage_DataType *arg_pname = glmsg.add_args();
4580    arg_pname->set_isarray(false);
4581    arg_pname->set_type(GLMessage::DataType::ENUM);
4582    arg_pname->add_intvalue((int)pname);
4583
4584    // copy argument params
4585    GLMessage_DataType *arg_params = glmsg.add_args();
4586    arg_params->set_isarray(false);
4587    arg_params->set_type(GLMessage::DataType::INT);
4588    arg_params->add_intvalue((int)params);
4589
4590    // call function
4591    glContext->hooks->gl.glGetBufferPointervOES(target, pname, params);
4592
4593    fixupGLMessage(glContext, &glmsg);
4594    glContext->traceGLMessage(&glmsg);
4595}
4596
4597void GLTrace_glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) {
4598    GLMessage glmsg;
4599    GLTraceContext *glContext = getGLTraceContext();
4600
4601    glmsg.set_function(GLMessage::glTexImage3DOES);
4602
4603    // copy argument target
4604    GLMessage_DataType *arg_target = glmsg.add_args();
4605    arg_target->set_isarray(false);
4606    arg_target->set_type(GLMessage::DataType::ENUM);
4607    arg_target->add_intvalue((int)target);
4608
4609    // copy argument level
4610    GLMessage_DataType *arg_level = glmsg.add_args();
4611    arg_level->set_isarray(false);
4612    arg_level->set_type(GLMessage::DataType::INT);
4613    arg_level->add_intvalue(level);
4614
4615    // copy argument internalformat
4616    GLMessage_DataType *arg_internalformat = glmsg.add_args();
4617    arg_internalformat->set_isarray(false);
4618    arg_internalformat->set_type(GLMessage::DataType::ENUM);
4619    arg_internalformat->add_intvalue((int)internalformat);
4620
4621    // copy argument width
4622    GLMessage_DataType *arg_width = glmsg.add_args();
4623    arg_width->set_isarray(false);
4624    arg_width->set_type(GLMessage::DataType::INT);
4625    arg_width->add_intvalue(width);
4626
4627    // copy argument height
4628    GLMessage_DataType *arg_height = glmsg.add_args();
4629    arg_height->set_isarray(false);
4630    arg_height->set_type(GLMessage::DataType::INT);
4631    arg_height->add_intvalue(height);
4632
4633    // copy argument depth
4634    GLMessage_DataType *arg_depth = glmsg.add_args();
4635    arg_depth->set_isarray(false);
4636    arg_depth->set_type(GLMessage::DataType::INT);
4637    arg_depth->add_intvalue(depth);
4638
4639    // copy argument border
4640    GLMessage_DataType *arg_border = glmsg.add_args();
4641    arg_border->set_isarray(false);
4642    arg_border->set_type(GLMessage::DataType::INT);
4643    arg_border->add_intvalue(border);
4644
4645    // copy argument format
4646    GLMessage_DataType *arg_format = glmsg.add_args();
4647    arg_format->set_isarray(false);
4648    arg_format->set_type(GLMessage::DataType::ENUM);
4649    arg_format->add_intvalue((int)format);
4650
4651    // copy argument type
4652    GLMessage_DataType *arg_type = glmsg.add_args();
4653    arg_type->set_isarray(false);
4654    arg_type->set_type(GLMessage::DataType::ENUM);
4655    arg_type->add_intvalue((int)type);
4656
4657    // copy argument pixels
4658    GLMessage_DataType *arg_pixels = glmsg.add_args();
4659    arg_pixels->set_isarray(false);
4660    arg_pixels->set_type(GLMessage::DataType::INT);
4661    arg_pixels->add_intvalue((int)pixels);
4662
4663    // call function
4664    glContext->hooks->gl.glTexImage3DOES(target, level, internalformat, width, height, depth, border, format, type, pixels);
4665
4666    fixupGLMessage(glContext, &glmsg);
4667    glContext->traceGLMessage(&glmsg);
4668}
4669
4670void GLTrace_glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels) {
4671    GLMessage glmsg;
4672    GLTraceContext *glContext = getGLTraceContext();
4673
4674    glmsg.set_function(GLMessage::glTexSubImage3DOES);
4675
4676    // copy argument target
4677    GLMessage_DataType *arg_target = glmsg.add_args();
4678    arg_target->set_isarray(false);
4679    arg_target->set_type(GLMessage::DataType::ENUM);
4680    arg_target->add_intvalue((int)target);
4681
4682    // copy argument level
4683    GLMessage_DataType *arg_level = glmsg.add_args();
4684    arg_level->set_isarray(false);
4685    arg_level->set_type(GLMessage::DataType::INT);
4686    arg_level->add_intvalue(level);
4687
4688    // copy argument xoffset
4689    GLMessage_DataType *arg_xoffset = glmsg.add_args();
4690    arg_xoffset->set_isarray(false);
4691    arg_xoffset->set_type(GLMessage::DataType::INT);
4692    arg_xoffset->add_intvalue(xoffset);
4693
4694    // copy argument yoffset
4695    GLMessage_DataType *arg_yoffset = glmsg.add_args();
4696    arg_yoffset->set_isarray(false);
4697    arg_yoffset->set_type(GLMessage::DataType::INT);
4698    arg_yoffset->add_intvalue(yoffset);
4699
4700    // copy argument zoffset
4701    GLMessage_DataType *arg_zoffset = glmsg.add_args();
4702    arg_zoffset->set_isarray(false);
4703    arg_zoffset->set_type(GLMessage::DataType::INT);
4704    arg_zoffset->add_intvalue(zoffset);
4705
4706    // copy argument width
4707    GLMessage_DataType *arg_width = glmsg.add_args();
4708    arg_width->set_isarray(false);
4709    arg_width->set_type(GLMessage::DataType::INT);
4710    arg_width->add_intvalue(width);
4711
4712    // copy argument height
4713    GLMessage_DataType *arg_height = glmsg.add_args();
4714    arg_height->set_isarray(false);
4715    arg_height->set_type(GLMessage::DataType::INT);
4716    arg_height->add_intvalue(height);
4717
4718    // copy argument depth
4719    GLMessage_DataType *arg_depth = glmsg.add_args();
4720    arg_depth->set_isarray(false);
4721    arg_depth->set_type(GLMessage::DataType::INT);
4722    arg_depth->add_intvalue(depth);
4723
4724    // copy argument format
4725    GLMessage_DataType *arg_format = glmsg.add_args();
4726    arg_format->set_isarray(false);
4727    arg_format->set_type(GLMessage::DataType::ENUM);
4728    arg_format->add_intvalue((int)format);
4729
4730    // copy argument type
4731    GLMessage_DataType *arg_type = glmsg.add_args();
4732    arg_type->set_isarray(false);
4733    arg_type->set_type(GLMessage::DataType::ENUM);
4734    arg_type->add_intvalue((int)type);
4735
4736    // copy argument pixels
4737    GLMessage_DataType *arg_pixels = glmsg.add_args();
4738    arg_pixels->set_isarray(false);
4739    arg_pixels->set_type(GLMessage::DataType::INT);
4740    arg_pixels->add_intvalue((int)pixels);
4741
4742    // call function
4743    glContext->hooks->gl.glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
4744
4745    fixupGLMessage(glContext, &glmsg);
4746    glContext->traceGLMessage(&glmsg);
4747}
4748
4749void GLTrace_glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
4750    GLMessage glmsg;
4751    GLTraceContext *glContext = getGLTraceContext();
4752
4753    glmsg.set_function(GLMessage::glCopyTexSubImage3DOES);
4754
4755    // copy argument target
4756    GLMessage_DataType *arg_target = glmsg.add_args();
4757    arg_target->set_isarray(false);
4758    arg_target->set_type(GLMessage::DataType::ENUM);
4759    arg_target->add_intvalue((int)target);
4760
4761    // copy argument level
4762    GLMessage_DataType *arg_level = glmsg.add_args();
4763    arg_level->set_isarray(false);
4764    arg_level->set_type(GLMessage::DataType::INT);
4765    arg_level->add_intvalue(level);
4766
4767    // copy argument xoffset
4768    GLMessage_DataType *arg_xoffset = glmsg.add_args();
4769    arg_xoffset->set_isarray(false);
4770    arg_xoffset->set_type(GLMessage::DataType::INT);
4771    arg_xoffset->add_intvalue(xoffset);
4772
4773    // copy argument yoffset
4774    GLMessage_DataType *arg_yoffset = glmsg.add_args();
4775    arg_yoffset->set_isarray(false);
4776    arg_yoffset->set_type(GLMessage::DataType::INT);
4777    arg_yoffset->add_intvalue(yoffset);
4778
4779    // copy argument zoffset
4780    GLMessage_DataType *arg_zoffset = glmsg.add_args();
4781    arg_zoffset->set_isarray(false);
4782    arg_zoffset->set_type(GLMessage::DataType::INT);
4783    arg_zoffset->add_intvalue(zoffset);
4784
4785    // copy argument x
4786    GLMessage_DataType *arg_x = glmsg.add_args();
4787    arg_x->set_isarray(false);
4788    arg_x->set_type(GLMessage::DataType::INT);
4789    arg_x->add_intvalue(x);
4790
4791    // copy argument y
4792    GLMessage_DataType *arg_y = glmsg.add_args();
4793    arg_y->set_isarray(false);
4794    arg_y->set_type(GLMessage::DataType::INT);
4795    arg_y->add_intvalue(y);
4796
4797    // copy argument width
4798    GLMessage_DataType *arg_width = glmsg.add_args();
4799    arg_width->set_isarray(false);
4800    arg_width->set_type(GLMessage::DataType::INT);
4801    arg_width->add_intvalue(width);
4802
4803    // copy argument height
4804    GLMessage_DataType *arg_height = glmsg.add_args();
4805    arg_height->set_isarray(false);
4806    arg_height->set_type(GLMessage::DataType::INT);
4807    arg_height->add_intvalue(height);
4808
4809    // call function
4810    glContext->hooks->gl.glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
4811
4812    fixupGLMessage(glContext, &glmsg);
4813    glContext->traceGLMessage(&glmsg);
4814}
4815
4816void GLTrace_glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) {
4817    GLMessage glmsg;
4818    GLTraceContext *glContext = getGLTraceContext();
4819
4820    glmsg.set_function(GLMessage::glCompressedTexImage3DOES);
4821
4822    // copy argument target
4823    GLMessage_DataType *arg_target = glmsg.add_args();
4824    arg_target->set_isarray(false);
4825    arg_target->set_type(GLMessage::DataType::ENUM);
4826    arg_target->add_intvalue((int)target);
4827
4828    // copy argument level
4829    GLMessage_DataType *arg_level = glmsg.add_args();
4830    arg_level->set_isarray(false);
4831    arg_level->set_type(GLMessage::DataType::INT);
4832    arg_level->add_intvalue(level);
4833
4834    // copy argument internalformat
4835    GLMessage_DataType *arg_internalformat = glmsg.add_args();
4836    arg_internalformat->set_isarray(false);
4837    arg_internalformat->set_type(GLMessage::DataType::ENUM);
4838    arg_internalformat->add_intvalue((int)internalformat);
4839
4840    // copy argument width
4841    GLMessage_DataType *arg_width = glmsg.add_args();
4842    arg_width->set_isarray(false);
4843    arg_width->set_type(GLMessage::DataType::INT);
4844    arg_width->add_intvalue(width);
4845
4846    // copy argument height
4847    GLMessage_DataType *arg_height = glmsg.add_args();
4848    arg_height->set_isarray(false);
4849    arg_height->set_type(GLMessage::DataType::INT);
4850    arg_height->add_intvalue(height);
4851
4852    // copy argument depth
4853    GLMessage_DataType *arg_depth = glmsg.add_args();
4854    arg_depth->set_isarray(false);
4855    arg_depth->set_type(GLMessage::DataType::INT);
4856    arg_depth->add_intvalue(depth);
4857
4858    // copy argument border
4859    GLMessage_DataType *arg_border = glmsg.add_args();
4860    arg_border->set_isarray(false);
4861    arg_border->set_type(GLMessage::DataType::INT);
4862    arg_border->add_intvalue(border);
4863
4864    // copy argument imageSize
4865    GLMessage_DataType *arg_imageSize = glmsg.add_args();
4866    arg_imageSize->set_isarray(false);
4867    arg_imageSize->set_type(GLMessage::DataType::INT);
4868    arg_imageSize->add_intvalue(imageSize);
4869
4870    // copy argument data
4871    GLMessage_DataType *arg_data = glmsg.add_args();
4872    arg_data->set_isarray(false);
4873    arg_data->set_type(GLMessage::DataType::INT);
4874    arg_data->add_intvalue((int)data);
4875
4876    // call function
4877    glContext->hooks->gl.glCompressedTexImage3DOES(target, level, internalformat, width, height, depth, border, imageSize, data);
4878
4879    fixupGLMessage(glContext, &glmsg);
4880    glContext->traceGLMessage(&glmsg);
4881}
4882
4883void GLTrace_glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) {
4884    GLMessage glmsg;
4885    GLTraceContext *glContext = getGLTraceContext();
4886
4887    glmsg.set_function(GLMessage::glCompressedTexSubImage3DOES);
4888
4889    // copy argument target
4890    GLMessage_DataType *arg_target = glmsg.add_args();
4891    arg_target->set_isarray(false);
4892    arg_target->set_type(GLMessage::DataType::ENUM);
4893    arg_target->add_intvalue((int)target);
4894
4895    // copy argument level
4896    GLMessage_DataType *arg_level = glmsg.add_args();
4897    arg_level->set_isarray(false);
4898    arg_level->set_type(GLMessage::DataType::INT);
4899    arg_level->add_intvalue(level);
4900
4901    // copy argument xoffset
4902    GLMessage_DataType *arg_xoffset = glmsg.add_args();
4903    arg_xoffset->set_isarray(false);
4904    arg_xoffset->set_type(GLMessage::DataType::INT);
4905    arg_xoffset->add_intvalue(xoffset);
4906
4907    // copy argument yoffset
4908    GLMessage_DataType *arg_yoffset = glmsg.add_args();
4909    arg_yoffset->set_isarray(false);
4910    arg_yoffset->set_type(GLMessage::DataType::INT);
4911    arg_yoffset->add_intvalue(yoffset);
4912
4913    // copy argument zoffset
4914    GLMessage_DataType *arg_zoffset = glmsg.add_args();
4915    arg_zoffset->set_isarray(false);
4916    arg_zoffset->set_type(GLMessage::DataType::INT);
4917    arg_zoffset->add_intvalue(zoffset);
4918
4919    // copy argument width
4920    GLMessage_DataType *arg_width = glmsg.add_args();
4921    arg_width->set_isarray(false);
4922    arg_width->set_type(GLMessage::DataType::INT);
4923    arg_width->add_intvalue(width);
4924
4925    // copy argument height
4926    GLMessage_DataType *arg_height = glmsg.add_args();
4927    arg_height->set_isarray(false);
4928    arg_height->set_type(GLMessage::DataType::INT);
4929    arg_height->add_intvalue(height);
4930
4931    // copy argument depth
4932    GLMessage_DataType *arg_depth = glmsg.add_args();
4933    arg_depth->set_isarray(false);
4934    arg_depth->set_type(GLMessage::DataType::INT);
4935    arg_depth->add_intvalue(depth);
4936
4937    // copy argument format
4938    GLMessage_DataType *arg_format = glmsg.add_args();
4939    arg_format->set_isarray(false);
4940    arg_format->set_type(GLMessage::DataType::ENUM);
4941    arg_format->add_intvalue((int)format);
4942
4943    // copy argument imageSize
4944    GLMessage_DataType *arg_imageSize = glmsg.add_args();
4945    arg_imageSize->set_isarray(false);
4946    arg_imageSize->set_type(GLMessage::DataType::INT);
4947    arg_imageSize->add_intvalue(imageSize);
4948
4949    // copy argument data
4950    GLMessage_DataType *arg_data = glmsg.add_args();
4951    arg_data->set_isarray(false);
4952    arg_data->set_type(GLMessage::DataType::INT);
4953    arg_data->add_intvalue((int)data);
4954
4955    // call function
4956    glContext->hooks->gl.glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
4957
4958    fixupGLMessage(glContext, &glmsg);
4959    glContext->traceGLMessage(&glmsg);
4960}
4961
4962void GLTrace_glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {
4963    GLMessage glmsg;
4964    GLTraceContext *glContext = getGLTraceContext();
4965
4966    glmsg.set_function(GLMessage::glFramebufferTexture3DOES);
4967
4968    // copy argument target
4969    GLMessage_DataType *arg_target = glmsg.add_args();
4970    arg_target->set_isarray(false);
4971    arg_target->set_type(GLMessage::DataType::ENUM);
4972    arg_target->add_intvalue((int)target);
4973
4974    // copy argument attachment
4975    GLMessage_DataType *arg_attachment = glmsg.add_args();
4976    arg_attachment->set_isarray(false);
4977    arg_attachment->set_type(GLMessage::DataType::ENUM);
4978    arg_attachment->add_intvalue((int)attachment);
4979
4980    // copy argument textarget
4981    GLMessage_DataType *arg_textarget = glmsg.add_args();
4982    arg_textarget->set_isarray(false);
4983    arg_textarget->set_type(GLMessage::DataType::ENUM);
4984    arg_textarget->add_intvalue((int)textarget);
4985
4986    // copy argument texture
4987    GLMessage_DataType *arg_texture = glmsg.add_args();
4988    arg_texture->set_isarray(false);
4989    arg_texture->set_type(GLMessage::DataType::INT);
4990    arg_texture->add_intvalue(texture);
4991
4992    // copy argument level
4993    GLMessage_DataType *arg_level = glmsg.add_args();
4994    arg_level->set_isarray(false);
4995    arg_level->set_type(GLMessage::DataType::INT);
4996    arg_level->add_intvalue(level);
4997
4998    // copy argument zoffset
4999    GLMessage_DataType *arg_zoffset = glmsg.add_args();
5000    arg_zoffset->set_isarray(false);
5001    arg_zoffset->set_type(GLMessage::DataType::INT);
5002    arg_zoffset->add_intvalue(zoffset);
5003
5004    // call function
5005    glContext->hooks->gl.glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
5006
5007    fixupGLMessage(glContext, &glmsg);
5008    glContext->traceGLMessage(&glmsg);
5009}
5010
5011void GLTrace_glBindVertexArrayOES(GLuint array) {
5012    GLMessage glmsg;
5013    GLTraceContext *glContext = getGLTraceContext();
5014
5015    glmsg.set_function(GLMessage::glBindVertexArrayOES);
5016
5017    // copy argument array
5018    GLMessage_DataType *arg_array = glmsg.add_args();
5019    arg_array->set_isarray(false);
5020    arg_array->set_type(GLMessage::DataType::INT);
5021    arg_array->add_intvalue(array);
5022
5023    // call function
5024    glContext->hooks->gl.glBindVertexArrayOES(array);
5025
5026    fixupGLMessage(glContext, &glmsg);
5027    glContext->traceGLMessage(&glmsg);
5028}
5029
5030void GLTrace_glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays) {
5031    GLMessage glmsg;
5032    GLTraceContext *glContext = getGLTraceContext();
5033
5034    glmsg.set_function(GLMessage::glDeleteVertexArraysOES);
5035
5036    // copy argument n
5037    GLMessage_DataType *arg_n = glmsg.add_args();
5038    arg_n->set_isarray(false);
5039    arg_n->set_type(GLMessage::DataType::INT);
5040    arg_n->add_intvalue(n);
5041
5042    // copy argument arrays
5043    GLMessage_DataType *arg_arrays = glmsg.add_args();
5044    arg_arrays->set_isarray(false);
5045    arg_arrays->set_type(GLMessage::DataType::INT);
5046    arg_arrays->add_intvalue((int)arrays);
5047
5048    // call function
5049    glContext->hooks->gl.glDeleteVertexArraysOES(n, arrays);
5050
5051    fixupGLMessage(glContext, &glmsg);
5052    glContext->traceGLMessage(&glmsg);
5053}
5054
5055void GLTrace_glGenVertexArraysOES(GLsizei n, GLuint *arrays) {
5056    GLMessage glmsg;
5057    GLTraceContext *glContext = getGLTraceContext();
5058
5059    glmsg.set_function(GLMessage::glGenVertexArraysOES);
5060
5061    // copy argument n
5062    GLMessage_DataType *arg_n = glmsg.add_args();
5063    arg_n->set_isarray(false);
5064    arg_n->set_type(GLMessage::DataType::INT);
5065    arg_n->add_intvalue(n);
5066
5067    // copy argument arrays
5068    GLMessage_DataType *arg_arrays = glmsg.add_args();
5069    arg_arrays->set_isarray(false);
5070    arg_arrays->set_type(GLMessage::DataType::INT);
5071    arg_arrays->add_intvalue((int)arrays);
5072
5073    // call function
5074    glContext->hooks->gl.glGenVertexArraysOES(n, arrays);
5075
5076    fixupGLMessage(glContext, &glmsg);
5077    glContext->traceGLMessage(&glmsg);
5078}
5079
5080GLboolean GLTrace_glIsVertexArrayOES(GLuint array) {
5081    GLMessage glmsg;
5082    GLTraceContext *glContext = getGLTraceContext();
5083
5084    glmsg.set_function(GLMessage::glIsVertexArrayOES);
5085
5086    // copy argument array
5087    GLMessage_DataType *arg_array = glmsg.add_args();
5088    arg_array->set_isarray(false);
5089    arg_array->set_type(GLMessage::DataType::INT);
5090    arg_array->add_intvalue(array);
5091
5092    // call function
5093    GLboolean retValue = glContext->hooks->gl.glIsVertexArrayOES(array);
5094
5095    // set return value
5096    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
5097    rt->set_isarray(false);
5098    rt->set_type(GLMessage::DataType::BOOL);
5099    rt->add_boolvalue(retValue);
5100
5101    fixupGLMessage(glContext, &glmsg);
5102    glContext->traceGLMessage(&glmsg);
5103
5104    return retValue;
5105}
5106
5107void GLTrace_glGetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups) {
5108    GLMessage glmsg;
5109    GLTraceContext *glContext = getGLTraceContext();
5110
5111    glmsg.set_function(GLMessage::glGetPerfMonitorGroupsAMD);
5112
5113    // copy argument numGroups
5114    GLMessage_DataType *arg_numGroups = glmsg.add_args();
5115    arg_numGroups->set_isarray(false);
5116    arg_numGroups->set_type(GLMessage::DataType::INT);
5117    arg_numGroups->add_intvalue((int)numGroups);
5118
5119    // copy argument groupsSize
5120    GLMessage_DataType *arg_groupsSize = glmsg.add_args();
5121    arg_groupsSize->set_isarray(false);
5122    arg_groupsSize->set_type(GLMessage::DataType::INT);
5123    arg_groupsSize->add_intvalue(groupsSize);
5124
5125    // copy argument groups
5126    GLMessage_DataType *arg_groups = glmsg.add_args();
5127    arg_groups->set_isarray(false);
5128    arg_groups->set_type(GLMessage::DataType::INT);
5129    arg_groups->add_intvalue((int)groups);
5130
5131    // call function
5132    glContext->hooks->gl.glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
5133
5134    fixupGLMessage(glContext, &glmsg);
5135    glContext->traceGLMessage(&glmsg);
5136}
5137
5138void GLTrace_glGetPerfMonitorCountersAMD(GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters) {
5139    GLMessage glmsg;
5140    GLTraceContext *glContext = getGLTraceContext();
5141
5142    glmsg.set_function(GLMessage::glGetPerfMonitorCountersAMD);
5143
5144    // copy argument group
5145    GLMessage_DataType *arg_group = glmsg.add_args();
5146    arg_group->set_isarray(false);
5147    arg_group->set_type(GLMessage::DataType::INT);
5148    arg_group->add_intvalue(group);
5149
5150    // copy argument numCounters
5151    GLMessage_DataType *arg_numCounters = glmsg.add_args();
5152    arg_numCounters->set_isarray(false);
5153    arg_numCounters->set_type(GLMessage::DataType::INT);
5154    arg_numCounters->add_intvalue((int)numCounters);
5155
5156    // copy argument maxActiveCounters
5157    GLMessage_DataType *arg_maxActiveCounters = glmsg.add_args();
5158    arg_maxActiveCounters->set_isarray(false);
5159    arg_maxActiveCounters->set_type(GLMessage::DataType::INT);
5160    arg_maxActiveCounters->add_intvalue((int)maxActiveCounters);
5161
5162    // copy argument counterSize
5163    GLMessage_DataType *arg_counterSize = glmsg.add_args();
5164    arg_counterSize->set_isarray(false);
5165    arg_counterSize->set_type(GLMessage::DataType::INT);
5166    arg_counterSize->add_intvalue(counterSize);
5167
5168    // copy argument counters
5169    GLMessage_DataType *arg_counters = glmsg.add_args();
5170    arg_counters->set_isarray(false);
5171    arg_counters->set_type(GLMessage::DataType::INT);
5172    arg_counters->add_intvalue((int)counters);
5173
5174    // call function
5175    glContext->hooks->gl.glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters);
5176
5177    fixupGLMessage(glContext, &glmsg);
5178    glContext->traceGLMessage(&glmsg);
5179}
5180
5181void GLTrace_glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString) {
5182    GLMessage glmsg;
5183    GLTraceContext *glContext = getGLTraceContext();
5184
5185    glmsg.set_function(GLMessage::glGetPerfMonitorGroupStringAMD);
5186
5187    // copy argument group
5188    GLMessage_DataType *arg_group = glmsg.add_args();
5189    arg_group->set_isarray(false);
5190    arg_group->set_type(GLMessage::DataType::INT);
5191    arg_group->add_intvalue(group);
5192
5193    // copy argument bufSize
5194    GLMessage_DataType *arg_bufSize = glmsg.add_args();
5195    arg_bufSize->set_isarray(false);
5196    arg_bufSize->set_type(GLMessage::DataType::INT);
5197    arg_bufSize->add_intvalue(bufSize);
5198
5199    // copy argument length
5200    GLMessage_DataType *arg_length = glmsg.add_args();
5201    arg_length->set_isarray(false);
5202    arg_length->set_type(GLMessage::DataType::INT);
5203    arg_length->add_intvalue((int)length);
5204
5205    // copy argument groupString
5206    GLMessage_DataType *arg_groupString = glmsg.add_args();
5207    arg_groupString->set_isarray(false);
5208    arg_groupString->set_type(GLMessage::DataType::INT);
5209    arg_groupString->add_intvalue((int)groupString);
5210
5211    // call function
5212    glContext->hooks->gl.glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
5213
5214    fixupGLMessage(glContext, &glmsg);
5215    glContext->traceGLMessage(&glmsg);
5216}
5217
5218void GLTrace_glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString) {
5219    GLMessage glmsg;
5220    GLTraceContext *glContext = getGLTraceContext();
5221
5222    glmsg.set_function(GLMessage::glGetPerfMonitorCounterStringAMD);
5223
5224    // copy argument group
5225    GLMessage_DataType *arg_group = glmsg.add_args();
5226    arg_group->set_isarray(false);
5227    arg_group->set_type(GLMessage::DataType::INT);
5228    arg_group->add_intvalue(group);
5229
5230    // copy argument counter
5231    GLMessage_DataType *arg_counter = glmsg.add_args();
5232    arg_counter->set_isarray(false);
5233    arg_counter->set_type(GLMessage::DataType::INT);
5234    arg_counter->add_intvalue(counter);
5235
5236    // copy argument bufSize
5237    GLMessage_DataType *arg_bufSize = glmsg.add_args();
5238    arg_bufSize->set_isarray(false);
5239    arg_bufSize->set_type(GLMessage::DataType::INT);
5240    arg_bufSize->add_intvalue(bufSize);
5241
5242    // copy argument length
5243    GLMessage_DataType *arg_length = glmsg.add_args();
5244    arg_length->set_isarray(false);
5245    arg_length->set_type(GLMessage::DataType::INT);
5246    arg_length->add_intvalue((int)length);
5247
5248    // copy argument counterString
5249    GLMessage_DataType *arg_counterString = glmsg.add_args();
5250    arg_counterString->set_isarray(false);
5251    arg_counterString->set_type(GLMessage::DataType::INT);
5252    arg_counterString->add_intvalue((int)counterString);
5253
5254    // call function
5255    glContext->hooks->gl.glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
5256
5257    fixupGLMessage(glContext, &glmsg);
5258    glContext->traceGLMessage(&glmsg);
5259}
5260
5261void GLTrace_glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid *data) {
5262    GLMessage glmsg;
5263    GLTraceContext *glContext = getGLTraceContext();
5264
5265    glmsg.set_function(GLMessage::glGetPerfMonitorCounterInfoAMD);
5266
5267    // copy argument group
5268    GLMessage_DataType *arg_group = glmsg.add_args();
5269    arg_group->set_isarray(false);
5270    arg_group->set_type(GLMessage::DataType::INT);
5271    arg_group->add_intvalue(group);
5272
5273    // copy argument counter
5274    GLMessage_DataType *arg_counter = glmsg.add_args();
5275    arg_counter->set_isarray(false);
5276    arg_counter->set_type(GLMessage::DataType::INT);
5277    arg_counter->add_intvalue(counter);
5278
5279    // copy argument pname
5280    GLMessage_DataType *arg_pname = glmsg.add_args();
5281    arg_pname->set_isarray(false);
5282    arg_pname->set_type(GLMessage::DataType::ENUM);
5283    arg_pname->add_intvalue((int)pname);
5284
5285    // copy argument data
5286    GLMessage_DataType *arg_data = glmsg.add_args();
5287    arg_data->set_isarray(false);
5288    arg_data->set_type(GLMessage::DataType::INT);
5289    arg_data->add_intvalue((int)data);
5290
5291    // call function
5292    glContext->hooks->gl.glGetPerfMonitorCounterInfoAMD(group, counter, pname, data);
5293
5294    fixupGLMessage(glContext, &glmsg);
5295    glContext->traceGLMessage(&glmsg);
5296}
5297
5298void GLTrace_glGenPerfMonitorsAMD(GLsizei n, GLuint *monitors) {
5299    GLMessage glmsg;
5300    GLTraceContext *glContext = getGLTraceContext();
5301
5302    glmsg.set_function(GLMessage::glGenPerfMonitorsAMD);
5303
5304    // copy argument n
5305    GLMessage_DataType *arg_n = glmsg.add_args();
5306    arg_n->set_isarray(false);
5307    arg_n->set_type(GLMessage::DataType::INT);
5308    arg_n->add_intvalue(n);
5309
5310    // copy argument monitors
5311    GLMessage_DataType *arg_monitors = glmsg.add_args();
5312    arg_monitors->set_isarray(false);
5313    arg_monitors->set_type(GLMessage::DataType::INT);
5314    arg_monitors->add_intvalue((int)monitors);
5315
5316    // call function
5317    glContext->hooks->gl.glGenPerfMonitorsAMD(n, monitors);
5318
5319    fixupGLMessage(glContext, &glmsg);
5320    glContext->traceGLMessage(&glmsg);
5321}
5322
5323void GLTrace_glDeletePerfMonitorsAMD(GLsizei n, GLuint *monitors) {
5324    GLMessage glmsg;
5325    GLTraceContext *glContext = getGLTraceContext();
5326
5327    glmsg.set_function(GLMessage::glDeletePerfMonitorsAMD);
5328
5329    // copy argument n
5330    GLMessage_DataType *arg_n = glmsg.add_args();
5331    arg_n->set_isarray(false);
5332    arg_n->set_type(GLMessage::DataType::INT);
5333    arg_n->add_intvalue(n);
5334
5335    // copy argument monitors
5336    GLMessage_DataType *arg_monitors = glmsg.add_args();
5337    arg_monitors->set_isarray(false);
5338    arg_monitors->set_type(GLMessage::DataType::INT);
5339    arg_monitors->add_intvalue((int)monitors);
5340
5341    // call function
5342    glContext->hooks->gl.glDeletePerfMonitorsAMD(n, monitors);
5343
5344    fixupGLMessage(glContext, &glmsg);
5345    glContext->traceGLMessage(&glmsg);
5346}
5347
5348void GLTrace_glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *countersList) {
5349    GLMessage glmsg;
5350    GLTraceContext *glContext = getGLTraceContext();
5351
5352    glmsg.set_function(GLMessage::glSelectPerfMonitorCountersAMD);
5353
5354    // copy argument monitor
5355    GLMessage_DataType *arg_monitor = glmsg.add_args();
5356    arg_monitor->set_isarray(false);
5357    arg_monitor->set_type(GLMessage::DataType::INT);
5358    arg_monitor->add_intvalue(monitor);
5359
5360    // copy argument enable
5361    GLMessage_DataType *arg_enable = glmsg.add_args();
5362    arg_enable->set_isarray(false);
5363    arg_enable->set_type(GLMessage::DataType::BOOL);
5364    arg_enable->add_boolvalue(enable);
5365
5366    // copy argument group
5367    GLMessage_DataType *arg_group = glmsg.add_args();
5368    arg_group->set_isarray(false);
5369    arg_group->set_type(GLMessage::DataType::INT);
5370    arg_group->add_intvalue(group);
5371
5372    // copy argument numCounters
5373    GLMessage_DataType *arg_numCounters = glmsg.add_args();
5374    arg_numCounters->set_isarray(false);
5375    arg_numCounters->set_type(GLMessage::DataType::INT);
5376    arg_numCounters->add_intvalue(numCounters);
5377
5378    // copy argument countersList
5379    GLMessage_DataType *arg_countersList = glmsg.add_args();
5380    arg_countersList->set_isarray(false);
5381    arg_countersList->set_type(GLMessage::DataType::INT);
5382    arg_countersList->add_intvalue((int)countersList);
5383
5384    // call function
5385    glContext->hooks->gl.glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, countersList);
5386
5387    fixupGLMessage(glContext, &glmsg);
5388    glContext->traceGLMessage(&glmsg);
5389}
5390
5391void GLTrace_glBeginPerfMonitorAMD(GLuint monitor) {
5392    GLMessage glmsg;
5393    GLTraceContext *glContext = getGLTraceContext();
5394
5395    glmsg.set_function(GLMessage::glBeginPerfMonitorAMD);
5396
5397    // copy argument monitor
5398    GLMessage_DataType *arg_monitor = glmsg.add_args();
5399    arg_monitor->set_isarray(false);
5400    arg_monitor->set_type(GLMessage::DataType::INT);
5401    arg_monitor->add_intvalue(monitor);
5402
5403    // call function
5404    glContext->hooks->gl.glBeginPerfMonitorAMD(monitor);
5405
5406    fixupGLMessage(glContext, &glmsg);
5407    glContext->traceGLMessage(&glmsg);
5408}
5409
5410void GLTrace_glEndPerfMonitorAMD(GLuint monitor) {
5411    GLMessage glmsg;
5412    GLTraceContext *glContext = getGLTraceContext();
5413
5414    glmsg.set_function(GLMessage::glEndPerfMonitorAMD);
5415
5416    // copy argument monitor
5417    GLMessage_DataType *arg_monitor = glmsg.add_args();
5418    arg_monitor->set_isarray(false);
5419    arg_monitor->set_type(GLMessage::DataType::INT);
5420    arg_monitor->add_intvalue(monitor);
5421
5422    // call function
5423    glContext->hooks->gl.glEndPerfMonitorAMD(monitor);
5424
5425    fixupGLMessage(glContext, &glmsg);
5426    glContext->traceGLMessage(&glmsg);
5427}
5428
5429void GLTrace_glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten) {
5430    GLMessage glmsg;
5431    GLTraceContext *glContext = getGLTraceContext();
5432
5433    glmsg.set_function(GLMessage::glGetPerfMonitorCounterDataAMD);
5434
5435    // copy argument monitor
5436    GLMessage_DataType *arg_monitor = glmsg.add_args();
5437    arg_monitor->set_isarray(false);
5438    arg_monitor->set_type(GLMessage::DataType::INT);
5439    arg_monitor->add_intvalue(monitor);
5440
5441    // copy argument pname
5442    GLMessage_DataType *arg_pname = glmsg.add_args();
5443    arg_pname->set_isarray(false);
5444    arg_pname->set_type(GLMessage::DataType::ENUM);
5445    arg_pname->add_intvalue((int)pname);
5446
5447    // copy argument dataSize
5448    GLMessage_DataType *arg_dataSize = glmsg.add_args();
5449    arg_dataSize->set_isarray(false);
5450    arg_dataSize->set_type(GLMessage::DataType::INT);
5451    arg_dataSize->add_intvalue(dataSize);
5452
5453    // copy argument data
5454    GLMessage_DataType *arg_data = glmsg.add_args();
5455    arg_data->set_isarray(false);
5456    arg_data->set_type(GLMessage::DataType::INT);
5457    arg_data->add_intvalue((int)data);
5458
5459    // copy argument bytesWritten
5460    GLMessage_DataType *arg_bytesWritten = glmsg.add_args();
5461    arg_bytesWritten->set_isarray(false);
5462    arg_bytesWritten->set_type(GLMessage::DataType::INT);
5463    arg_bytesWritten->add_intvalue((int)bytesWritten);
5464
5465    // call function
5466    glContext->hooks->gl.glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
5467
5468    fixupGLMessage(glContext, &glmsg);
5469    glContext->traceGLMessage(&glmsg);
5470}
5471
5472void GLTrace_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) {
5473    GLMessage glmsg;
5474    GLTraceContext *glContext = getGLTraceContext();
5475
5476    glmsg.set_function(GLMessage::glDiscardFramebufferEXT);
5477
5478    // copy argument target
5479    GLMessage_DataType *arg_target = glmsg.add_args();
5480    arg_target->set_isarray(false);
5481    arg_target->set_type(GLMessage::DataType::ENUM);
5482    arg_target->add_intvalue((int)target);
5483
5484    // copy argument numAttachments
5485    GLMessage_DataType *arg_numAttachments = glmsg.add_args();
5486    arg_numAttachments->set_isarray(false);
5487    arg_numAttachments->set_type(GLMessage::DataType::INT);
5488    arg_numAttachments->add_intvalue(numAttachments);
5489
5490    // copy argument attachments
5491    GLMessage_DataType *arg_attachments = glmsg.add_args();
5492    arg_attachments->set_isarray(false);
5493    arg_attachments->set_type(GLMessage::DataType::INT);
5494    arg_attachments->add_intvalue((int)attachments);
5495
5496    // call function
5497    glContext->hooks->gl.glDiscardFramebufferEXT(target, numAttachments, attachments);
5498
5499    fixupGLMessage(glContext, &glmsg);
5500    glContext->traceGLMessage(&glmsg);
5501}
5502
5503void GLTrace_glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount) {
5504    GLMessage glmsg;
5505    GLTraceContext *glContext = getGLTraceContext();
5506
5507    glmsg.set_function(GLMessage::glMultiDrawArraysEXT);
5508
5509    // copy argument mode
5510    GLMessage_DataType *arg_mode = glmsg.add_args();
5511    arg_mode->set_isarray(false);
5512    arg_mode->set_type(GLMessage::DataType::ENUM);
5513    arg_mode->add_intvalue((int)mode);
5514
5515    // copy argument first
5516    GLMessage_DataType *arg_first = glmsg.add_args();
5517    arg_first->set_isarray(false);
5518    arg_first->set_type(GLMessage::DataType::INT);
5519    arg_first->add_intvalue((int)first);
5520
5521    // copy argument count
5522    GLMessage_DataType *arg_count = glmsg.add_args();
5523    arg_count->set_isarray(false);
5524    arg_count->set_type(GLMessage::DataType::INT);
5525    arg_count->add_intvalue((int)count);
5526
5527    // copy argument primcount
5528    GLMessage_DataType *arg_primcount = glmsg.add_args();
5529    arg_primcount->set_isarray(false);
5530    arg_primcount->set_type(GLMessage::DataType::INT);
5531    arg_primcount->add_intvalue(primcount);
5532
5533    // call function
5534    glContext->hooks->gl.glMultiDrawArraysEXT(mode, first, count, primcount);
5535
5536    fixupGLMessage(glContext, &glmsg);
5537    glContext->traceGLMessage(&glmsg);
5538}
5539
5540void GLTrace_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) {
5541    GLMessage glmsg;
5542    GLTraceContext *glContext = getGLTraceContext();
5543
5544    glmsg.set_function(GLMessage::glMultiDrawElementsEXT);
5545
5546    // copy argument mode
5547    GLMessage_DataType *arg_mode = glmsg.add_args();
5548    arg_mode->set_isarray(false);
5549    arg_mode->set_type(GLMessage::DataType::ENUM);
5550    arg_mode->add_intvalue((int)mode);
5551
5552    // copy argument count
5553    GLMessage_DataType *arg_count = glmsg.add_args();
5554    arg_count->set_isarray(false);
5555    arg_count->set_type(GLMessage::DataType::INT);
5556    arg_count->add_intvalue((int)count);
5557
5558    // copy argument type
5559    GLMessage_DataType *arg_type = glmsg.add_args();
5560    arg_type->set_isarray(false);
5561    arg_type->set_type(GLMessage::DataType::ENUM);
5562    arg_type->add_intvalue((int)type);
5563
5564    // copy argument indices
5565    GLMessage_DataType *arg_indices = glmsg.add_args();
5566    arg_indices->set_isarray(false);
5567    arg_indices->set_type(GLMessage::DataType::INT);
5568    arg_indices->add_intvalue((int)indices);
5569
5570    // copy argument primcount
5571    GLMessage_DataType *arg_primcount = glmsg.add_args();
5572    arg_primcount->set_isarray(false);
5573    arg_primcount->set_type(GLMessage::DataType::INT);
5574    arg_primcount->add_intvalue(primcount);
5575
5576    // call function
5577    glContext->hooks->gl.glMultiDrawElementsEXT(mode, count, type, indices, primcount);
5578
5579    fixupGLMessage(glContext, &glmsg);
5580    glContext->traceGLMessage(&glmsg);
5581}
5582
5583void GLTrace_glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {
5584    GLMessage glmsg;
5585    GLTraceContext *glContext = getGLTraceContext();
5586
5587    glmsg.set_function(GLMessage::glRenderbufferStorageMultisampleIMG);
5588
5589    // copy argument target
5590    GLMessage_DataType *arg_target = glmsg.add_args();
5591    arg_target->set_isarray(false);
5592    arg_target->set_type(GLMessage::DataType::ENUM);
5593    arg_target->add_intvalue((int)target);
5594
5595    // copy argument samples
5596    GLMessage_DataType *arg_samples = glmsg.add_args();
5597    arg_samples->set_isarray(false);
5598    arg_samples->set_type(GLMessage::DataType::INT);
5599    arg_samples->add_intvalue(samples);
5600
5601    // copy argument internalformat
5602    GLMessage_DataType *arg_internalformat = glmsg.add_args();
5603    arg_internalformat->set_isarray(false);
5604    arg_internalformat->set_type(GLMessage::DataType::ENUM);
5605    arg_internalformat->add_intvalue((int)internalformat);
5606
5607    // copy argument width
5608    GLMessage_DataType *arg_width = glmsg.add_args();
5609    arg_width->set_isarray(false);
5610    arg_width->set_type(GLMessage::DataType::INT);
5611    arg_width->add_intvalue(width);
5612
5613    // copy argument height
5614    GLMessage_DataType *arg_height = glmsg.add_args();
5615    arg_height->set_isarray(false);
5616    arg_height->set_type(GLMessage::DataType::INT);
5617    arg_height->add_intvalue(height);
5618
5619    // call function
5620    glContext->hooks->gl.glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
5621
5622    fixupGLMessage(glContext, &glmsg);
5623    glContext->traceGLMessage(&glmsg);
5624}
5625
5626void GLTrace_glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) {
5627    GLMessage glmsg;
5628    GLTraceContext *glContext = getGLTraceContext();
5629
5630    glmsg.set_function(GLMessage::glFramebufferTexture2DMultisampleIMG);
5631
5632    // copy argument target
5633    GLMessage_DataType *arg_target = glmsg.add_args();
5634    arg_target->set_isarray(false);
5635    arg_target->set_type(GLMessage::DataType::ENUM);
5636    arg_target->add_intvalue((int)target);
5637
5638    // copy argument attachment
5639    GLMessage_DataType *arg_attachment = glmsg.add_args();
5640    arg_attachment->set_isarray(false);
5641    arg_attachment->set_type(GLMessage::DataType::ENUM);
5642    arg_attachment->add_intvalue((int)attachment);
5643
5644    // copy argument textarget
5645    GLMessage_DataType *arg_textarget = glmsg.add_args();
5646    arg_textarget->set_isarray(false);
5647    arg_textarget->set_type(GLMessage::DataType::ENUM);
5648    arg_textarget->add_intvalue((int)textarget);
5649
5650    // copy argument texture
5651    GLMessage_DataType *arg_texture = glmsg.add_args();
5652    arg_texture->set_isarray(false);
5653    arg_texture->set_type(GLMessage::DataType::INT);
5654    arg_texture->add_intvalue(texture);
5655
5656    // copy argument level
5657    GLMessage_DataType *arg_level = glmsg.add_args();
5658    arg_level->set_isarray(false);
5659    arg_level->set_type(GLMessage::DataType::INT);
5660    arg_level->add_intvalue(level);
5661
5662    // copy argument samples
5663    GLMessage_DataType *arg_samples = glmsg.add_args();
5664    arg_samples->set_isarray(false);
5665    arg_samples->set_type(GLMessage::DataType::INT);
5666    arg_samples->add_intvalue(samples);
5667
5668    // call function
5669    glContext->hooks->gl.glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
5670
5671    fixupGLMessage(glContext, &glmsg);
5672    glContext->traceGLMessage(&glmsg);
5673}
5674
5675void GLTrace_glDeleteFencesNV(GLsizei n, const GLuint *fences) {
5676    GLMessage glmsg;
5677    GLTraceContext *glContext = getGLTraceContext();
5678
5679    glmsg.set_function(GLMessage::glDeleteFencesNV);
5680
5681    // copy argument n
5682    GLMessage_DataType *arg_n = glmsg.add_args();
5683    arg_n->set_isarray(false);
5684    arg_n->set_type(GLMessage::DataType::INT);
5685    arg_n->add_intvalue(n);
5686
5687    // copy argument fences
5688    GLMessage_DataType *arg_fences = glmsg.add_args();
5689    arg_fences->set_isarray(false);
5690    arg_fences->set_type(GLMessage::DataType::INT);
5691    arg_fences->add_intvalue((int)fences);
5692
5693    // call function
5694    glContext->hooks->gl.glDeleteFencesNV(n, fences);
5695
5696    fixupGLMessage(glContext, &glmsg);
5697    glContext->traceGLMessage(&glmsg);
5698}
5699
5700void GLTrace_glGenFencesNV(GLsizei n, GLuint *fences) {
5701    GLMessage glmsg;
5702    GLTraceContext *glContext = getGLTraceContext();
5703
5704    glmsg.set_function(GLMessage::glGenFencesNV);
5705
5706    // copy argument n
5707    GLMessage_DataType *arg_n = glmsg.add_args();
5708    arg_n->set_isarray(false);
5709    arg_n->set_type(GLMessage::DataType::INT);
5710    arg_n->add_intvalue(n);
5711
5712    // copy argument fences
5713    GLMessage_DataType *arg_fences = glmsg.add_args();
5714    arg_fences->set_isarray(false);
5715    arg_fences->set_type(GLMessage::DataType::INT);
5716    arg_fences->add_intvalue((int)fences);
5717
5718    // call function
5719    glContext->hooks->gl.glGenFencesNV(n, fences);
5720
5721    fixupGLMessage(glContext, &glmsg);
5722    glContext->traceGLMessage(&glmsg);
5723}
5724
5725GLboolean GLTrace_glIsFenceNV(GLuint fence) {
5726    GLMessage glmsg;
5727    GLTraceContext *glContext = getGLTraceContext();
5728
5729    glmsg.set_function(GLMessage::glIsFenceNV);
5730
5731    // copy argument fence
5732    GLMessage_DataType *arg_fence = glmsg.add_args();
5733    arg_fence->set_isarray(false);
5734    arg_fence->set_type(GLMessage::DataType::INT);
5735    arg_fence->add_intvalue(fence);
5736
5737    // call function
5738    GLboolean retValue = glContext->hooks->gl.glIsFenceNV(fence);
5739
5740    // set return value
5741    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
5742    rt->set_isarray(false);
5743    rt->set_type(GLMessage::DataType::BOOL);
5744    rt->add_boolvalue(retValue);
5745
5746    fixupGLMessage(glContext, &glmsg);
5747    glContext->traceGLMessage(&glmsg);
5748
5749    return retValue;
5750}
5751
5752GLboolean GLTrace_glTestFenceNV(GLuint fence) {
5753    GLMessage glmsg;
5754    GLTraceContext *glContext = getGLTraceContext();
5755
5756    glmsg.set_function(GLMessage::glTestFenceNV);
5757
5758    // copy argument fence
5759    GLMessage_DataType *arg_fence = glmsg.add_args();
5760    arg_fence->set_isarray(false);
5761    arg_fence->set_type(GLMessage::DataType::INT);
5762    arg_fence->add_intvalue(fence);
5763
5764    // call function
5765    GLboolean retValue = glContext->hooks->gl.glTestFenceNV(fence);
5766
5767    // set return value
5768    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
5769    rt->set_isarray(false);
5770    rt->set_type(GLMessage::DataType::BOOL);
5771    rt->add_boolvalue(retValue);
5772
5773    fixupGLMessage(glContext, &glmsg);
5774    glContext->traceGLMessage(&glmsg);
5775
5776    return retValue;
5777}
5778
5779void GLTrace_glGetFenceivNV(GLuint fence, GLenum pname, GLint *params) {
5780    GLMessage glmsg;
5781    GLTraceContext *glContext = getGLTraceContext();
5782
5783    glmsg.set_function(GLMessage::glGetFenceivNV);
5784
5785    // copy argument fence
5786    GLMessage_DataType *arg_fence = glmsg.add_args();
5787    arg_fence->set_isarray(false);
5788    arg_fence->set_type(GLMessage::DataType::INT);
5789    arg_fence->add_intvalue(fence);
5790
5791    // copy argument pname
5792    GLMessage_DataType *arg_pname = glmsg.add_args();
5793    arg_pname->set_isarray(false);
5794    arg_pname->set_type(GLMessage::DataType::ENUM);
5795    arg_pname->add_intvalue((int)pname);
5796
5797    // copy argument params
5798    GLMessage_DataType *arg_params = glmsg.add_args();
5799    arg_params->set_isarray(false);
5800    arg_params->set_type(GLMessage::DataType::INT);
5801    arg_params->add_intvalue((int)params);
5802
5803    // call function
5804    glContext->hooks->gl.glGetFenceivNV(fence, pname, params);
5805
5806    fixupGLMessage(glContext, &glmsg);
5807    glContext->traceGLMessage(&glmsg);
5808}
5809
5810void GLTrace_glFinishFenceNV(GLuint fence) {
5811    GLMessage glmsg;
5812    GLTraceContext *glContext = getGLTraceContext();
5813
5814    glmsg.set_function(GLMessage::glFinishFenceNV);
5815
5816    // copy argument fence
5817    GLMessage_DataType *arg_fence = glmsg.add_args();
5818    arg_fence->set_isarray(false);
5819    arg_fence->set_type(GLMessage::DataType::INT);
5820    arg_fence->add_intvalue(fence);
5821
5822    // call function
5823    glContext->hooks->gl.glFinishFenceNV(fence);
5824
5825    fixupGLMessage(glContext, &glmsg);
5826    glContext->traceGLMessage(&glmsg);
5827}
5828
5829void GLTrace_glSetFenceNV(GLuint fence, GLenum condition) {
5830    GLMessage glmsg;
5831    GLTraceContext *glContext = getGLTraceContext();
5832
5833    glmsg.set_function(GLMessage::glSetFenceNV);
5834
5835    // copy argument fence
5836    GLMessage_DataType *arg_fence = glmsg.add_args();
5837    arg_fence->set_isarray(false);
5838    arg_fence->set_type(GLMessage::DataType::INT);
5839    arg_fence->add_intvalue(fence);
5840
5841    // copy argument condition
5842    GLMessage_DataType *arg_condition = glmsg.add_args();
5843    arg_condition->set_isarray(false);
5844    arg_condition->set_type(GLMessage::DataType::ENUM);
5845    arg_condition->add_intvalue((int)condition);
5846
5847    // call function
5848    glContext->hooks->gl.glSetFenceNV(fence, condition);
5849
5850    fixupGLMessage(glContext, &glmsg);
5851    glContext->traceGLMessage(&glmsg);
5852}
5853
5854void GLTrace_glCoverageMaskNV(GLboolean mask) {
5855    GLMessage glmsg;
5856    GLTraceContext *glContext = getGLTraceContext();
5857
5858    glmsg.set_function(GLMessage::glCoverageMaskNV);
5859
5860    // copy argument mask
5861    GLMessage_DataType *arg_mask = glmsg.add_args();
5862    arg_mask->set_isarray(false);
5863    arg_mask->set_type(GLMessage::DataType::BOOL);
5864    arg_mask->add_boolvalue(mask);
5865
5866    // call function
5867    glContext->hooks->gl.glCoverageMaskNV(mask);
5868
5869    fixupGLMessage(glContext, &glmsg);
5870    glContext->traceGLMessage(&glmsg);
5871}
5872
5873void GLTrace_glCoverageOperationNV(GLenum operation) {
5874    GLMessage glmsg;
5875    GLTraceContext *glContext = getGLTraceContext();
5876
5877    glmsg.set_function(GLMessage::glCoverageOperationNV);
5878
5879    // copy argument operation
5880    GLMessage_DataType *arg_operation = glmsg.add_args();
5881    arg_operation->set_isarray(false);
5882    arg_operation->set_type(GLMessage::DataType::ENUM);
5883    arg_operation->add_intvalue((int)operation);
5884
5885    // call function
5886    glContext->hooks->gl.glCoverageOperationNV(operation);
5887
5888    fixupGLMessage(glContext, &glmsg);
5889    glContext->traceGLMessage(&glmsg);
5890}
5891
5892void GLTrace_glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls) {
5893    GLMessage glmsg;
5894    GLTraceContext *glContext = getGLTraceContext();
5895
5896    glmsg.set_function(GLMessage::glGetDriverControlsQCOM);
5897
5898    // copy argument num
5899    GLMessage_DataType *arg_num = glmsg.add_args();
5900    arg_num->set_isarray(false);
5901    arg_num->set_type(GLMessage::DataType::INT);
5902    arg_num->add_intvalue((int)num);
5903
5904    // copy argument size
5905    GLMessage_DataType *arg_size = glmsg.add_args();
5906    arg_size->set_isarray(false);
5907    arg_size->set_type(GLMessage::DataType::INT);
5908    arg_size->add_intvalue(size);
5909
5910    // copy argument driverControls
5911    GLMessage_DataType *arg_driverControls = glmsg.add_args();
5912    arg_driverControls->set_isarray(false);
5913    arg_driverControls->set_type(GLMessage::DataType::INT);
5914    arg_driverControls->add_intvalue((int)driverControls);
5915
5916    // call function
5917    glContext->hooks->gl.glGetDriverControlsQCOM(num, size, driverControls);
5918
5919    fixupGLMessage(glContext, &glmsg);
5920    glContext->traceGLMessage(&glmsg);
5921}
5922
5923void GLTrace_glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString) {
5924    GLMessage glmsg;
5925    GLTraceContext *glContext = getGLTraceContext();
5926
5927    glmsg.set_function(GLMessage::glGetDriverControlStringQCOM);
5928
5929    // copy argument driverControl
5930    GLMessage_DataType *arg_driverControl = glmsg.add_args();
5931    arg_driverControl->set_isarray(false);
5932    arg_driverControl->set_type(GLMessage::DataType::INT);
5933    arg_driverControl->add_intvalue(driverControl);
5934
5935    // copy argument bufSize
5936    GLMessage_DataType *arg_bufSize = glmsg.add_args();
5937    arg_bufSize->set_isarray(false);
5938    arg_bufSize->set_type(GLMessage::DataType::INT);
5939    arg_bufSize->add_intvalue(bufSize);
5940
5941    // copy argument length
5942    GLMessage_DataType *arg_length = glmsg.add_args();
5943    arg_length->set_isarray(false);
5944    arg_length->set_type(GLMessage::DataType::INT);
5945    arg_length->add_intvalue((int)length);
5946
5947    // copy argument driverControlString
5948    GLMessage_DataType *arg_driverControlString = glmsg.add_args();
5949    arg_driverControlString->set_isarray(false);
5950    arg_driverControlString->set_type(GLMessage::DataType::INT);
5951    arg_driverControlString->add_intvalue((int)driverControlString);
5952
5953    // call function
5954    glContext->hooks->gl.glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString);
5955
5956    fixupGLMessage(glContext, &glmsg);
5957    glContext->traceGLMessage(&glmsg);
5958}
5959
5960void GLTrace_glEnableDriverControlQCOM(GLuint driverControl) {
5961    GLMessage glmsg;
5962    GLTraceContext *glContext = getGLTraceContext();
5963
5964    glmsg.set_function(GLMessage::glEnableDriverControlQCOM);
5965
5966    // copy argument driverControl
5967    GLMessage_DataType *arg_driverControl = glmsg.add_args();
5968    arg_driverControl->set_isarray(false);
5969    arg_driverControl->set_type(GLMessage::DataType::INT);
5970    arg_driverControl->add_intvalue(driverControl);
5971
5972    // call function
5973    glContext->hooks->gl.glEnableDriverControlQCOM(driverControl);
5974
5975    fixupGLMessage(glContext, &glmsg);
5976    glContext->traceGLMessage(&glmsg);
5977}
5978
5979void GLTrace_glDisableDriverControlQCOM(GLuint driverControl) {
5980    GLMessage glmsg;
5981    GLTraceContext *glContext = getGLTraceContext();
5982
5983    glmsg.set_function(GLMessage::glDisableDriverControlQCOM);
5984
5985    // copy argument driverControl
5986    GLMessage_DataType *arg_driverControl = glmsg.add_args();
5987    arg_driverControl->set_isarray(false);
5988    arg_driverControl->set_type(GLMessage::DataType::INT);
5989    arg_driverControl->add_intvalue(driverControl);
5990
5991    // call function
5992    glContext->hooks->gl.glDisableDriverControlQCOM(driverControl);
5993
5994    fixupGLMessage(glContext, &glmsg);
5995    glContext->traceGLMessage(&glmsg);
5996}
5997
5998void GLTrace_glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures) {
5999    GLMessage glmsg;
6000    GLTraceContext *glContext = getGLTraceContext();
6001
6002    glmsg.set_function(GLMessage::glExtGetTexturesQCOM);
6003
6004    // copy argument textures
6005    GLMessage_DataType *arg_textures = glmsg.add_args();
6006    arg_textures->set_isarray(false);
6007    arg_textures->set_type(GLMessage::DataType::INT);
6008    arg_textures->add_intvalue((int)textures);
6009
6010    // copy argument maxTextures
6011    GLMessage_DataType *arg_maxTextures = glmsg.add_args();
6012    arg_maxTextures->set_isarray(false);
6013    arg_maxTextures->set_type(GLMessage::DataType::INT);
6014    arg_maxTextures->add_intvalue(maxTextures);
6015
6016    // copy argument numTextures
6017    GLMessage_DataType *arg_numTextures = glmsg.add_args();
6018    arg_numTextures->set_isarray(false);
6019    arg_numTextures->set_type(GLMessage::DataType::INT);
6020    arg_numTextures->add_intvalue((int)numTextures);
6021
6022    // call function
6023    glContext->hooks->gl.glExtGetTexturesQCOM(textures, maxTextures, numTextures);
6024
6025    fixupGLMessage(glContext, &glmsg);
6026    glContext->traceGLMessage(&glmsg);
6027}
6028
6029void GLTrace_glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers) {
6030    GLMessage glmsg;
6031    GLTraceContext *glContext = getGLTraceContext();
6032
6033    glmsg.set_function(GLMessage::glExtGetBuffersQCOM);
6034
6035    // copy argument buffers
6036    GLMessage_DataType *arg_buffers = glmsg.add_args();
6037    arg_buffers->set_isarray(false);
6038    arg_buffers->set_type(GLMessage::DataType::INT);
6039    arg_buffers->add_intvalue((int)buffers);
6040
6041    // copy argument maxBuffers
6042    GLMessage_DataType *arg_maxBuffers = glmsg.add_args();
6043    arg_maxBuffers->set_isarray(false);
6044    arg_maxBuffers->set_type(GLMessage::DataType::INT);
6045    arg_maxBuffers->add_intvalue(maxBuffers);
6046
6047    // copy argument numBuffers
6048    GLMessage_DataType *arg_numBuffers = glmsg.add_args();
6049    arg_numBuffers->set_isarray(false);
6050    arg_numBuffers->set_type(GLMessage::DataType::INT);
6051    arg_numBuffers->add_intvalue((int)numBuffers);
6052
6053    // call function
6054    glContext->hooks->gl.glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
6055
6056    fixupGLMessage(glContext, &glmsg);
6057    glContext->traceGLMessage(&glmsg);
6058}
6059
6060void GLTrace_glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers) {
6061    GLMessage glmsg;
6062    GLTraceContext *glContext = getGLTraceContext();
6063
6064    glmsg.set_function(GLMessage::glExtGetRenderbuffersQCOM);
6065
6066    // copy argument renderbuffers
6067    GLMessage_DataType *arg_renderbuffers = glmsg.add_args();
6068    arg_renderbuffers->set_isarray(false);
6069    arg_renderbuffers->set_type(GLMessage::DataType::INT);
6070    arg_renderbuffers->add_intvalue((int)renderbuffers);
6071
6072    // copy argument maxRenderbuffers
6073    GLMessage_DataType *arg_maxRenderbuffers = glmsg.add_args();
6074    arg_maxRenderbuffers->set_isarray(false);
6075    arg_maxRenderbuffers->set_type(GLMessage::DataType::INT);
6076    arg_maxRenderbuffers->add_intvalue(maxRenderbuffers);
6077
6078    // copy argument numRenderbuffers
6079    GLMessage_DataType *arg_numRenderbuffers = glmsg.add_args();
6080    arg_numRenderbuffers->set_isarray(false);
6081    arg_numRenderbuffers->set_type(GLMessage::DataType::INT);
6082    arg_numRenderbuffers->add_intvalue((int)numRenderbuffers);
6083
6084    // call function
6085    glContext->hooks->gl.glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
6086
6087    fixupGLMessage(glContext, &glmsg);
6088    glContext->traceGLMessage(&glmsg);
6089}
6090
6091void GLTrace_glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers) {
6092    GLMessage glmsg;
6093    GLTraceContext *glContext = getGLTraceContext();
6094
6095    glmsg.set_function(GLMessage::glExtGetFramebuffersQCOM);
6096
6097    // copy argument framebuffers
6098    GLMessage_DataType *arg_framebuffers = glmsg.add_args();
6099    arg_framebuffers->set_isarray(false);
6100    arg_framebuffers->set_type(GLMessage::DataType::INT);
6101    arg_framebuffers->add_intvalue((int)framebuffers);
6102
6103    // copy argument maxFramebuffers
6104    GLMessage_DataType *arg_maxFramebuffers = glmsg.add_args();
6105    arg_maxFramebuffers->set_isarray(false);
6106    arg_maxFramebuffers->set_type(GLMessage::DataType::INT);
6107    arg_maxFramebuffers->add_intvalue(maxFramebuffers);
6108
6109    // copy argument numFramebuffers
6110    GLMessage_DataType *arg_numFramebuffers = glmsg.add_args();
6111    arg_numFramebuffers->set_isarray(false);
6112    arg_numFramebuffers->set_type(GLMessage::DataType::INT);
6113    arg_numFramebuffers->add_intvalue((int)numFramebuffers);
6114
6115    // call function
6116    glContext->hooks->gl.glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
6117
6118    fixupGLMessage(glContext, &glmsg);
6119    glContext->traceGLMessage(&glmsg);
6120}
6121
6122void GLTrace_glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params) {
6123    GLMessage glmsg;
6124    GLTraceContext *glContext = getGLTraceContext();
6125
6126    glmsg.set_function(GLMessage::glExtGetTexLevelParameterivQCOM);
6127
6128    // copy argument texture
6129    GLMessage_DataType *arg_texture = glmsg.add_args();
6130    arg_texture->set_isarray(false);
6131    arg_texture->set_type(GLMessage::DataType::INT);
6132    arg_texture->add_intvalue(texture);
6133
6134    // copy argument face
6135    GLMessage_DataType *arg_face = glmsg.add_args();
6136    arg_face->set_isarray(false);
6137    arg_face->set_type(GLMessage::DataType::ENUM);
6138    arg_face->add_intvalue((int)face);
6139
6140    // copy argument level
6141    GLMessage_DataType *arg_level = glmsg.add_args();
6142    arg_level->set_isarray(false);
6143    arg_level->set_type(GLMessage::DataType::INT);
6144    arg_level->add_intvalue(level);
6145
6146    // copy argument pname
6147    GLMessage_DataType *arg_pname = glmsg.add_args();
6148    arg_pname->set_isarray(false);
6149    arg_pname->set_type(GLMessage::DataType::ENUM);
6150    arg_pname->add_intvalue((int)pname);
6151
6152    // copy argument params
6153    GLMessage_DataType *arg_params = glmsg.add_args();
6154    arg_params->set_isarray(false);
6155    arg_params->set_type(GLMessage::DataType::INT);
6156    arg_params->add_intvalue((int)params);
6157
6158    // call function
6159    glContext->hooks->gl.glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params);
6160
6161    fixupGLMessage(glContext, &glmsg);
6162    glContext->traceGLMessage(&glmsg);
6163}
6164
6165void GLTrace_glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param) {
6166    GLMessage glmsg;
6167    GLTraceContext *glContext = getGLTraceContext();
6168
6169    glmsg.set_function(GLMessage::glExtTexObjectStateOverrideiQCOM);
6170
6171    // copy argument target
6172    GLMessage_DataType *arg_target = glmsg.add_args();
6173    arg_target->set_isarray(false);
6174    arg_target->set_type(GLMessage::DataType::ENUM);
6175    arg_target->add_intvalue((int)target);
6176
6177    // copy argument pname
6178    GLMessage_DataType *arg_pname = glmsg.add_args();
6179    arg_pname->set_isarray(false);
6180    arg_pname->set_type(GLMessage::DataType::ENUM);
6181    arg_pname->add_intvalue((int)pname);
6182
6183    // copy argument param
6184    GLMessage_DataType *arg_param = glmsg.add_args();
6185    arg_param->set_isarray(false);
6186    arg_param->set_type(GLMessage::DataType::INT);
6187    arg_param->add_intvalue(param);
6188
6189    // call function
6190    glContext->hooks->gl.glExtTexObjectStateOverrideiQCOM(target, pname, param);
6191
6192    fixupGLMessage(glContext, &glmsg);
6193    glContext->traceGLMessage(&glmsg);
6194}
6195
6196void GLTrace_glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels) {
6197    GLMessage glmsg;
6198    GLTraceContext *glContext = getGLTraceContext();
6199
6200    glmsg.set_function(GLMessage::glExtGetTexSubImageQCOM);
6201
6202    // copy argument target
6203    GLMessage_DataType *arg_target = glmsg.add_args();
6204    arg_target->set_isarray(false);
6205    arg_target->set_type(GLMessage::DataType::ENUM);
6206    arg_target->add_intvalue((int)target);
6207
6208    // copy argument level
6209    GLMessage_DataType *arg_level = glmsg.add_args();
6210    arg_level->set_isarray(false);
6211    arg_level->set_type(GLMessage::DataType::INT);
6212    arg_level->add_intvalue(level);
6213
6214    // copy argument xoffset
6215    GLMessage_DataType *arg_xoffset = glmsg.add_args();
6216    arg_xoffset->set_isarray(false);
6217    arg_xoffset->set_type(GLMessage::DataType::INT);
6218    arg_xoffset->add_intvalue(xoffset);
6219
6220    // copy argument yoffset
6221    GLMessage_DataType *arg_yoffset = glmsg.add_args();
6222    arg_yoffset->set_isarray(false);
6223    arg_yoffset->set_type(GLMessage::DataType::INT);
6224    arg_yoffset->add_intvalue(yoffset);
6225
6226    // copy argument zoffset
6227    GLMessage_DataType *arg_zoffset = glmsg.add_args();
6228    arg_zoffset->set_isarray(false);
6229    arg_zoffset->set_type(GLMessage::DataType::INT);
6230    arg_zoffset->add_intvalue(zoffset);
6231
6232    // copy argument width
6233    GLMessage_DataType *arg_width = glmsg.add_args();
6234    arg_width->set_isarray(false);
6235    arg_width->set_type(GLMessage::DataType::INT);
6236    arg_width->add_intvalue(width);
6237
6238    // copy argument height
6239    GLMessage_DataType *arg_height = glmsg.add_args();
6240    arg_height->set_isarray(false);
6241    arg_height->set_type(GLMessage::DataType::INT);
6242    arg_height->add_intvalue(height);
6243
6244    // copy argument depth
6245    GLMessage_DataType *arg_depth = glmsg.add_args();
6246    arg_depth->set_isarray(false);
6247    arg_depth->set_type(GLMessage::DataType::INT);
6248    arg_depth->add_intvalue(depth);
6249
6250    // copy argument format
6251    GLMessage_DataType *arg_format = glmsg.add_args();
6252    arg_format->set_isarray(false);
6253    arg_format->set_type(GLMessage::DataType::ENUM);
6254    arg_format->add_intvalue((int)format);
6255
6256    // copy argument type
6257    GLMessage_DataType *arg_type = glmsg.add_args();
6258    arg_type->set_isarray(false);
6259    arg_type->set_type(GLMessage::DataType::ENUM);
6260    arg_type->add_intvalue((int)type);
6261
6262    // copy argument texels
6263    GLMessage_DataType *arg_texels = glmsg.add_args();
6264    arg_texels->set_isarray(false);
6265    arg_texels->set_type(GLMessage::DataType::INT);
6266    arg_texels->add_intvalue((int)texels);
6267
6268    // call function
6269    glContext->hooks->gl.glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
6270
6271    fixupGLMessage(glContext, &glmsg);
6272    glContext->traceGLMessage(&glmsg);
6273}
6274
6275void GLTrace_glExtGetBufferPointervQCOM(GLenum target, GLvoid **params) {
6276    GLMessage glmsg;
6277    GLTraceContext *glContext = getGLTraceContext();
6278
6279    glmsg.set_function(GLMessage::glExtGetBufferPointervQCOM);
6280
6281    // copy argument target
6282    GLMessage_DataType *arg_target = glmsg.add_args();
6283    arg_target->set_isarray(false);
6284    arg_target->set_type(GLMessage::DataType::ENUM);
6285    arg_target->add_intvalue((int)target);
6286
6287    // copy argument params
6288    GLMessage_DataType *arg_params = glmsg.add_args();
6289    arg_params->set_isarray(false);
6290    arg_params->set_type(GLMessage::DataType::INT);
6291    arg_params->add_intvalue((int)params);
6292
6293    // call function
6294    glContext->hooks->gl.glExtGetBufferPointervQCOM(target, params);
6295
6296    fixupGLMessage(glContext, &glmsg);
6297    glContext->traceGLMessage(&glmsg);
6298}
6299
6300void GLTrace_glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders) {
6301    GLMessage glmsg;
6302    GLTraceContext *glContext = getGLTraceContext();
6303
6304    glmsg.set_function(GLMessage::glExtGetShadersQCOM);
6305
6306    // copy argument shaders
6307    GLMessage_DataType *arg_shaders = glmsg.add_args();
6308    arg_shaders->set_isarray(false);
6309    arg_shaders->set_type(GLMessage::DataType::INT);
6310    arg_shaders->add_intvalue((int)shaders);
6311
6312    // copy argument maxShaders
6313    GLMessage_DataType *arg_maxShaders = glmsg.add_args();
6314    arg_maxShaders->set_isarray(false);
6315    arg_maxShaders->set_type(GLMessage::DataType::INT);
6316    arg_maxShaders->add_intvalue(maxShaders);
6317
6318    // copy argument numShaders
6319    GLMessage_DataType *arg_numShaders = glmsg.add_args();
6320    arg_numShaders->set_isarray(false);
6321    arg_numShaders->set_type(GLMessage::DataType::INT);
6322    arg_numShaders->add_intvalue((int)numShaders);
6323
6324    // call function
6325    glContext->hooks->gl.glExtGetShadersQCOM(shaders, maxShaders, numShaders);
6326
6327    fixupGLMessage(glContext, &glmsg);
6328    glContext->traceGLMessage(&glmsg);
6329}
6330
6331void GLTrace_glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms) {
6332    GLMessage glmsg;
6333    GLTraceContext *glContext = getGLTraceContext();
6334
6335    glmsg.set_function(GLMessage::glExtGetProgramsQCOM);
6336
6337    // copy argument programs
6338    GLMessage_DataType *arg_programs = glmsg.add_args();
6339    arg_programs->set_isarray(false);
6340    arg_programs->set_type(GLMessage::DataType::INT);
6341    arg_programs->add_intvalue((int)programs);
6342
6343    // copy argument maxPrograms
6344    GLMessage_DataType *arg_maxPrograms = glmsg.add_args();
6345    arg_maxPrograms->set_isarray(false);
6346    arg_maxPrograms->set_type(GLMessage::DataType::INT);
6347    arg_maxPrograms->add_intvalue(maxPrograms);
6348
6349    // copy argument numPrograms
6350    GLMessage_DataType *arg_numPrograms = glmsg.add_args();
6351    arg_numPrograms->set_isarray(false);
6352    arg_numPrograms->set_type(GLMessage::DataType::INT);
6353    arg_numPrograms->add_intvalue((int)numPrograms);
6354
6355    // call function
6356    glContext->hooks->gl.glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
6357
6358    fixupGLMessage(glContext, &glmsg);
6359    glContext->traceGLMessage(&glmsg);
6360}
6361
6362GLboolean GLTrace_glExtIsProgramBinaryQCOM(GLuint program) {
6363    GLMessage glmsg;
6364    GLTraceContext *glContext = getGLTraceContext();
6365
6366    glmsg.set_function(GLMessage::glExtIsProgramBinaryQCOM);
6367
6368    // copy argument program
6369    GLMessage_DataType *arg_program = glmsg.add_args();
6370    arg_program->set_isarray(false);
6371    arg_program->set_type(GLMessage::DataType::INT);
6372    arg_program->add_intvalue(program);
6373
6374    // call function
6375    GLboolean retValue = glContext->hooks->gl.glExtIsProgramBinaryQCOM(program);
6376
6377    // set return value
6378    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
6379    rt->set_isarray(false);
6380    rt->set_type(GLMessage::DataType::BOOL);
6381    rt->add_boolvalue(retValue);
6382
6383    fixupGLMessage(glContext, &glmsg);
6384    glContext->traceGLMessage(&glmsg);
6385
6386    return retValue;
6387}
6388
6389void GLTrace_glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length) {
6390    GLMessage glmsg;
6391    GLTraceContext *glContext = getGLTraceContext();
6392
6393    glmsg.set_function(GLMessage::glExtGetProgramBinarySourceQCOM);
6394
6395    // copy argument program
6396    GLMessage_DataType *arg_program = glmsg.add_args();
6397    arg_program->set_isarray(false);
6398    arg_program->set_type(GLMessage::DataType::INT);
6399    arg_program->add_intvalue(program);
6400
6401    // copy argument shadertype
6402    GLMessage_DataType *arg_shadertype = glmsg.add_args();
6403    arg_shadertype->set_isarray(false);
6404    arg_shadertype->set_type(GLMessage::DataType::ENUM);
6405    arg_shadertype->add_intvalue((int)shadertype);
6406
6407    // copy argument source
6408    GLMessage_DataType *arg_source = glmsg.add_args();
6409    arg_source->set_isarray(false);
6410    arg_source->set_type(GLMessage::DataType::INT);
6411    arg_source->add_intvalue((int)source);
6412
6413    // copy argument length
6414    GLMessage_DataType *arg_length = glmsg.add_args();
6415    arg_length->set_isarray(false);
6416    arg_length->set_type(GLMessage::DataType::INT);
6417    arg_length->add_intvalue((int)length);
6418
6419    // call function
6420    glContext->hooks->gl.glExtGetProgramBinarySourceQCOM(program, shadertype, source, length);
6421
6422    fixupGLMessage(glContext, &glmsg);
6423    glContext->traceGLMessage(&glmsg);
6424}
6425
6426void GLTrace_glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) {
6427    GLMessage glmsg;
6428    GLTraceContext *glContext = getGLTraceContext();
6429
6430    glmsg.set_function(GLMessage::glStartTilingQCOM);
6431
6432    // copy argument x
6433    GLMessage_DataType *arg_x = glmsg.add_args();
6434    arg_x->set_isarray(false);
6435    arg_x->set_type(GLMessage::DataType::INT);
6436    arg_x->add_intvalue(x);
6437
6438    // copy argument y
6439    GLMessage_DataType *arg_y = glmsg.add_args();
6440    arg_y->set_isarray(false);
6441    arg_y->set_type(GLMessage::DataType::INT);
6442    arg_y->add_intvalue(y);
6443
6444    // copy argument width
6445    GLMessage_DataType *arg_width = glmsg.add_args();
6446    arg_width->set_isarray(false);
6447    arg_width->set_type(GLMessage::DataType::INT);
6448    arg_width->add_intvalue(width);
6449
6450    // copy argument height
6451    GLMessage_DataType *arg_height = glmsg.add_args();
6452    arg_height->set_isarray(false);
6453    arg_height->set_type(GLMessage::DataType::INT);
6454    arg_height->add_intvalue(height);
6455
6456    // copy argument preserveMask
6457    GLMessage_DataType *arg_preserveMask = glmsg.add_args();
6458    arg_preserveMask->set_isarray(false);
6459    arg_preserveMask->set_type(GLMessage::DataType::INT);
6460    arg_preserveMask->add_intvalue(preserveMask);
6461
6462    // call function
6463    glContext->hooks->gl.glStartTilingQCOM(x, y, width, height, preserveMask);
6464
6465    fixupGLMessage(glContext, &glmsg);
6466    glContext->traceGLMessage(&glmsg);
6467}
6468
6469void GLTrace_glEndTilingQCOM(GLbitfield preserveMask) {
6470    GLMessage glmsg;
6471    GLTraceContext *glContext = getGLTraceContext();
6472
6473    glmsg.set_function(GLMessage::glEndTilingQCOM);
6474
6475    // copy argument preserveMask
6476    GLMessage_DataType *arg_preserveMask = glmsg.add_args();
6477    arg_preserveMask->set_isarray(false);
6478    arg_preserveMask->set_type(GLMessage::DataType::INT);
6479    arg_preserveMask->add_intvalue(preserveMask);
6480
6481    // call function
6482    glContext->hooks->gl.glEndTilingQCOM(preserveMask);
6483
6484    fixupGLMessage(glContext, &glmsg);
6485    glContext->traceGLMessage(&glmsg);
6486}
6487
6488
6489// Definitions for GL1 APIs
6490
6491void GLTrace_glAlphaFunc(GLenum func, GLclampf ref) {
6492    GLMessage glmsg;
6493    GLTraceContext *glContext = getGLTraceContext();
6494
6495    glmsg.set_function(GLMessage::glAlphaFunc);
6496
6497    // copy argument func
6498    GLMessage_DataType *arg_func = glmsg.add_args();
6499    arg_func->set_isarray(false);
6500    arg_func->set_type(GLMessage::DataType::ENUM);
6501    arg_func->add_intvalue((int)func);
6502
6503    // copy argument ref
6504    GLMessage_DataType *arg_ref = glmsg.add_args();
6505    arg_ref->set_isarray(false);
6506    arg_ref->set_type(GLMessage::DataType::FLOAT);
6507    arg_ref->add_floatvalue(ref);
6508
6509    // call function
6510    glContext->hooks->gl.glAlphaFunc(func, ref);
6511
6512    fixupGLMessage(glContext, &glmsg);
6513    glContext->traceGLMessage(&glmsg);
6514}
6515
6516void GLTrace_glClipPlanef(GLenum plane, const GLfloat *equation) {
6517    GLMessage glmsg;
6518    GLTraceContext *glContext = getGLTraceContext();
6519
6520    glmsg.set_function(GLMessage::glClipPlanef);
6521
6522    // copy argument plane
6523    GLMessage_DataType *arg_plane = glmsg.add_args();
6524    arg_plane->set_isarray(false);
6525    arg_plane->set_type(GLMessage::DataType::ENUM);
6526    arg_plane->add_intvalue((int)plane);
6527
6528    // copy argument equation
6529    GLMessage_DataType *arg_equation = glmsg.add_args();
6530    arg_equation->set_isarray(false);
6531    arg_equation->set_type(GLMessage::DataType::INT);
6532    arg_equation->add_intvalue((int)equation);
6533
6534    // call function
6535    glContext->hooks->gl.glClipPlanef(plane, equation);
6536
6537    fixupGLMessage(glContext, &glmsg);
6538    glContext->traceGLMessage(&glmsg);
6539}
6540
6541void GLTrace_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
6542    GLMessage glmsg;
6543    GLTraceContext *glContext = getGLTraceContext();
6544
6545    glmsg.set_function(GLMessage::glColor4f);
6546
6547    // copy argument red
6548    GLMessage_DataType *arg_red = glmsg.add_args();
6549    arg_red->set_isarray(false);
6550    arg_red->set_type(GLMessage::DataType::FLOAT);
6551    arg_red->add_floatvalue(red);
6552
6553    // copy argument green
6554    GLMessage_DataType *arg_green = glmsg.add_args();
6555    arg_green->set_isarray(false);
6556    arg_green->set_type(GLMessage::DataType::FLOAT);
6557    arg_green->add_floatvalue(green);
6558
6559    // copy argument blue
6560    GLMessage_DataType *arg_blue = glmsg.add_args();
6561    arg_blue->set_isarray(false);
6562    arg_blue->set_type(GLMessage::DataType::FLOAT);
6563    arg_blue->add_floatvalue(blue);
6564
6565    // copy argument alpha
6566    GLMessage_DataType *arg_alpha = glmsg.add_args();
6567    arg_alpha->set_isarray(false);
6568    arg_alpha->set_type(GLMessage::DataType::FLOAT);
6569    arg_alpha->add_floatvalue(alpha);
6570
6571    // call function
6572    glContext->hooks->gl.glColor4f(red, green, blue, alpha);
6573
6574    fixupGLMessage(glContext, &glmsg);
6575    glContext->traceGLMessage(&glmsg);
6576}
6577
6578void GLTrace_glFogf(GLenum pname, GLfloat param) {
6579    GLMessage glmsg;
6580    GLTraceContext *glContext = getGLTraceContext();
6581
6582    glmsg.set_function(GLMessage::glFogf);
6583
6584    // copy argument pname
6585    GLMessage_DataType *arg_pname = glmsg.add_args();
6586    arg_pname->set_isarray(false);
6587    arg_pname->set_type(GLMessage::DataType::ENUM);
6588    arg_pname->add_intvalue((int)pname);
6589
6590    // copy argument param
6591    GLMessage_DataType *arg_param = glmsg.add_args();
6592    arg_param->set_isarray(false);
6593    arg_param->set_type(GLMessage::DataType::FLOAT);
6594    arg_param->add_floatvalue(param);
6595
6596    // call function
6597    glContext->hooks->gl.glFogf(pname, param);
6598
6599    fixupGLMessage(glContext, &glmsg);
6600    glContext->traceGLMessage(&glmsg);
6601}
6602
6603void GLTrace_glFogfv(GLenum pname, const GLfloat *params) {
6604    GLMessage glmsg;
6605    GLTraceContext *glContext = getGLTraceContext();
6606
6607    glmsg.set_function(GLMessage::glFogfv);
6608
6609    // copy argument pname
6610    GLMessage_DataType *arg_pname = glmsg.add_args();
6611    arg_pname->set_isarray(false);
6612    arg_pname->set_type(GLMessage::DataType::ENUM);
6613    arg_pname->add_intvalue((int)pname);
6614
6615    // copy argument params
6616    GLMessage_DataType *arg_params = glmsg.add_args();
6617    arg_params->set_isarray(false);
6618    arg_params->set_type(GLMessage::DataType::INT);
6619    arg_params->add_intvalue((int)params);
6620
6621    // call function
6622    glContext->hooks->gl.glFogfv(pname, params);
6623
6624    fixupGLMessage(glContext, &glmsg);
6625    glContext->traceGLMessage(&glmsg);
6626}
6627
6628void GLTrace_glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
6629    GLMessage glmsg;
6630    GLTraceContext *glContext = getGLTraceContext();
6631
6632    glmsg.set_function(GLMessage::glFrustumf);
6633
6634    // copy argument left
6635    GLMessage_DataType *arg_left = glmsg.add_args();
6636    arg_left->set_isarray(false);
6637    arg_left->set_type(GLMessage::DataType::FLOAT);
6638    arg_left->add_floatvalue(left);
6639
6640    // copy argument right
6641    GLMessage_DataType *arg_right = glmsg.add_args();
6642    arg_right->set_isarray(false);
6643    arg_right->set_type(GLMessage::DataType::FLOAT);
6644    arg_right->add_floatvalue(right);
6645
6646    // copy argument bottom
6647    GLMessage_DataType *arg_bottom = glmsg.add_args();
6648    arg_bottom->set_isarray(false);
6649    arg_bottom->set_type(GLMessage::DataType::FLOAT);
6650    arg_bottom->add_floatvalue(bottom);
6651
6652    // copy argument top
6653    GLMessage_DataType *arg_top = glmsg.add_args();
6654    arg_top->set_isarray(false);
6655    arg_top->set_type(GLMessage::DataType::FLOAT);
6656    arg_top->add_floatvalue(top);
6657
6658    // copy argument zNear
6659    GLMessage_DataType *arg_zNear = glmsg.add_args();
6660    arg_zNear->set_isarray(false);
6661    arg_zNear->set_type(GLMessage::DataType::FLOAT);
6662    arg_zNear->add_floatvalue(zNear);
6663
6664    // copy argument zFar
6665    GLMessage_DataType *arg_zFar = glmsg.add_args();
6666    arg_zFar->set_isarray(false);
6667    arg_zFar->set_type(GLMessage::DataType::FLOAT);
6668    arg_zFar->add_floatvalue(zFar);
6669
6670    // call function
6671    glContext->hooks->gl.glFrustumf(left, right, bottom, top, zNear, zFar);
6672
6673    fixupGLMessage(glContext, &glmsg);
6674    glContext->traceGLMessage(&glmsg);
6675}
6676
6677void GLTrace_glGetClipPlanef(GLenum pname, GLfloat eqn[4]) {
6678    GLMessage glmsg;
6679    GLTraceContext *glContext = getGLTraceContext();
6680
6681    glmsg.set_function(GLMessage::glGetClipPlanef);
6682
6683    // copy argument pname
6684    GLMessage_DataType *arg_pname = glmsg.add_args();
6685    arg_pname->set_isarray(false);
6686    arg_pname->set_type(GLMessage::DataType::ENUM);
6687    arg_pname->add_intvalue((int)pname);
6688
6689    // copy argument eqn
6690    GLMessage_DataType *arg_eqn = glmsg.add_args();
6691    arg_eqn->set_isarray(false);
6692    arg_eqn->set_type(GLMessage::DataType::INT);
6693    arg_eqn->add_intvalue((int)eqn);
6694
6695    // call function
6696    glContext->hooks->gl.glGetClipPlanef(pname, eqn);
6697
6698    fixupGLMessage(glContext, &glmsg);
6699    glContext->traceGLMessage(&glmsg);
6700}
6701
6702void GLTrace_glGetLightfv(GLenum light, GLenum pname, GLfloat *params) {
6703    GLMessage glmsg;
6704    GLTraceContext *glContext = getGLTraceContext();
6705
6706    glmsg.set_function(GLMessage::glGetLightfv);
6707
6708    // copy argument light
6709    GLMessage_DataType *arg_light = glmsg.add_args();
6710    arg_light->set_isarray(false);
6711    arg_light->set_type(GLMessage::DataType::ENUM);
6712    arg_light->add_intvalue((int)light);
6713
6714    // copy argument pname
6715    GLMessage_DataType *arg_pname = glmsg.add_args();
6716    arg_pname->set_isarray(false);
6717    arg_pname->set_type(GLMessage::DataType::ENUM);
6718    arg_pname->add_intvalue((int)pname);
6719
6720    // copy argument params
6721    GLMessage_DataType *arg_params = glmsg.add_args();
6722    arg_params->set_isarray(false);
6723    arg_params->set_type(GLMessage::DataType::INT);
6724    arg_params->add_intvalue((int)params);
6725
6726    // call function
6727    glContext->hooks->gl.glGetLightfv(light, pname, params);
6728
6729    fixupGLMessage(glContext, &glmsg);
6730    glContext->traceGLMessage(&glmsg);
6731}
6732
6733void GLTrace_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) {
6734    GLMessage glmsg;
6735    GLTraceContext *glContext = getGLTraceContext();
6736
6737    glmsg.set_function(GLMessage::glGetMaterialfv);
6738
6739    // copy argument face
6740    GLMessage_DataType *arg_face = glmsg.add_args();
6741    arg_face->set_isarray(false);
6742    arg_face->set_type(GLMessage::DataType::ENUM);
6743    arg_face->add_intvalue((int)face);
6744
6745    // copy argument pname
6746    GLMessage_DataType *arg_pname = glmsg.add_args();
6747    arg_pname->set_isarray(false);
6748    arg_pname->set_type(GLMessage::DataType::ENUM);
6749    arg_pname->add_intvalue((int)pname);
6750
6751    // copy argument params
6752    GLMessage_DataType *arg_params = glmsg.add_args();
6753    arg_params->set_isarray(false);
6754    arg_params->set_type(GLMessage::DataType::INT);
6755    arg_params->add_intvalue((int)params);
6756
6757    // call function
6758    glContext->hooks->gl.glGetMaterialfv(face, pname, params);
6759
6760    fixupGLMessage(glContext, &glmsg);
6761    glContext->traceGLMessage(&glmsg);
6762}
6763
6764void GLTrace_glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params) {
6765    GLMessage glmsg;
6766    GLTraceContext *glContext = getGLTraceContext();
6767
6768    glmsg.set_function(GLMessage::glGetTexEnvfv);
6769
6770    // copy argument env
6771    GLMessage_DataType *arg_env = glmsg.add_args();
6772    arg_env->set_isarray(false);
6773    arg_env->set_type(GLMessage::DataType::ENUM);
6774    arg_env->add_intvalue((int)env);
6775
6776    // copy argument pname
6777    GLMessage_DataType *arg_pname = glmsg.add_args();
6778    arg_pname->set_isarray(false);
6779    arg_pname->set_type(GLMessage::DataType::ENUM);
6780    arg_pname->add_intvalue((int)pname);
6781
6782    // copy argument params
6783    GLMessage_DataType *arg_params = glmsg.add_args();
6784    arg_params->set_isarray(false);
6785    arg_params->set_type(GLMessage::DataType::INT);
6786    arg_params->add_intvalue((int)params);
6787
6788    // call function
6789    glContext->hooks->gl.glGetTexEnvfv(env, pname, params);
6790
6791    fixupGLMessage(glContext, &glmsg);
6792    glContext->traceGLMessage(&glmsg);
6793}
6794
6795void GLTrace_glLightModelf(GLenum pname, GLfloat param) {
6796    GLMessage glmsg;
6797    GLTraceContext *glContext = getGLTraceContext();
6798
6799    glmsg.set_function(GLMessage::glLightModelf);
6800
6801    // copy argument pname
6802    GLMessage_DataType *arg_pname = glmsg.add_args();
6803    arg_pname->set_isarray(false);
6804    arg_pname->set_type(GLMessage::DataType::ENUM);
6805    arg_pname->add_intvalue((int)pname);
6806
6807    // copy argument param
6808    GLMessage_DataType *arg_param = glmsg.add_args();
6809    arg_param->set_isarray(false);
6810    arg_param->set_type(GLMessage::DataType::FLOAT);
6811    arg_param->add_floatvalue(param);
6812
6813    // call function
6814    glContext->hooks->gl.glLightModelf(pname, param);
6815
6816    fixupGLMessage(glContext, &glmsg);
6817    glContext->traceGLMessage(&glmsg);
6818}
6819
6820void GLTrace_glLightModelfv(GLenum pname, const GLfloat *params) {
6821    GLMessage glmsg;
6822    GLTraceContext *glContext = getGLTraceContext();
6823
6824    glmsg.set_function(GLMessage::glLightModelfv);
6825
6826    // copy argument pname
6827    GLMessage_DataType *arg_pname = glmsg.add_args();
6828    arg_pname->set_isarray(false);
6829    arg_pname->set_type(GLMessage::DataType::ENUM);
6830    arg_pname->add_intvalue((int)pname);
6831
6832    // copy argument params
6833    GLMessage_DataType *arg_params = glmsg.add_args();
6834    arg_params->set_isarray(false);
6835    arg_params->set_type(GLMessage::DataType::INT);
6836    arg_params->add_intvalue((int)params);
6837
6838    // call function
6839    glContext->hooks->gl.glLightModelfv(pname, params);
6840
6841    fixupGLMessage(glContext, &glmsg);
6842    glContext->traceGLMessage(&glmsg);
6843}
6844
6845void GLTrace_glLightf(GLenum light, GLenum pname, GLfloat param) {
6846    GLMessage glmsg;
6847    GLTraceContext *glContext = getGLTraceContext();
6848
6849    glmsg.set_function(GLMessage::glLightf);
6850
6851    // copy argument light
6852    GLMessage_DataType *arg_light = glmsg.add_args();
6853    arg_light->set_isarray(false);
6854    arg_light->set_type(GLMessage::DataType::ENUM);
6855    arg_light->add_intvalue((int)light);
6856
6857    // copy argument pname
6858    GLMessage_DataType *arg_pname = glmsg.add_args();
6859    arg_pname->set_isarray(false);
6860    arg_pname->set_type(GLMessage::DataType::ENUM);
6861    arg_pname->add_intvalue((int)pname);
6862
6863    // copy argument param
6864    GLMessage_DataType *arg_param = glmsg.add_args();
6865    arg_param->set_isarray(false);
6866    arg_param->set_type(GLMessage::DataType::FLOAT);
6867    arg_param->add_floatvalue(param);
6868
6869    // call function
6870    glContext->hooks->gl.glLightf(light, pname, param);
6871
6872    fixupGLMessage(glContext, &glmsg);
6873    glContext->traceGLMessage(&glmsg);
6874}
6875
6876void GLTrace_glLightfv(GLenum light, GLenum pname, const GLfloat *params) {
6877    GLMessage glmsg;
6878    GLTraceContext *glContext = getGLTraceContext();
6879
6880    glmsg.set_function(GLMessage::glLightfv);
6881
6882    // copy argument light
6883    GLMessage_DataType *arg_light = glmsg.add_args();
6884    arg_light->set_isarray(false);
6885    arg_light->set_type(GLMessage::DataType::ENUM);
6886    arg_light->add_intvalue((int)light);
6887
6888    // copy argument pname
6889    GLMessage_DataType *arg_pname = glmsg.add_args();
6890    arg_pname->set_isarray(false);
6891    arg_pname->set_type(GLMessage::DataType::ENUM);
6892    arg_pname->add_intvalue((int)pname);
6893
6894    // copy argument params
6895    GLMessage_DataType *arg_params = glmsg.add_args();
6896    arg_params->set_isarray(false);
6897    arg_params->set_type(GLMessage::DataType::INT);
6898    arg_params->add_intvalue((int)params);
6899
6900    // call function
6901    glContext->hooks->gl.glLightfv(light, pname, params);
6902
6903    fixupGLMessage(glContext, &glmsg);
6904    glContext->traceGLMessage(&glmsg);
6905}
6906
6907void GLTrace_glLoadMatrixf(const GLfloat *m) {
6908    GLMessage glmsg;
6909    GLTraceContext *glContext = getGLTraceContext();
6910
6911    glmsg.set_function(GLMessage::glLoadMatrixf);
6912
6913    // copy argument m
6914    GLMessage_DataType *arg_m = glmsg.add_args();
6915    arg_m->set_isarray(false);
6916    arg_m->set_type(GLMessage::DataType::INT);
6917    arg_m->add_intvalue((int)m);
6918
6919    // call function
6920    glContext->hooks->gl.glLoadMatrixf(m);
6921
6922    fixupGLMessage(glContext, &glmsg);
6923    glContext->traceGLMessage(&glmsg);
6924}
6925
6926void GLTrace_glMaterialf(GLenum face, GLenum pname, GLfloat param) {
6927    GLMessage glmsg;
6928    GLTraceContext *glContext = getGLTraceContext();
6929
6930    glmsg.set_function(GLMessage::glMaterialf);
6931
6932    // copy argument face
6933    GLMessage_DataType *arg_face = glmsg.add_args();
6934    arg_face->set_isarray(false);
6935    arg_face->set_type(GLMessage::DataType::ENUM);
6936    arg_face->add_intvalue((int)face);
6937
6938    // copy argument pname
6939    GLMessage_DataType *arg_pname = glmsg.add_args();
6940    arg_pname->set_isarray(false);
6941    arg_pname->set_type(GLMessage::DataType::ENUM);
6942    arg_pname->add_intvalue((int)pname);
6943
6944    // copy argument param
6945    GLMessage_DataType *arg_param = glmsg.add_args();
6946    arg_param->set_isarray(false);
6947    arg_param->set_type(GLMessage::DataType::FLOAT);
6948    arg_param->add_floatvalue(param);
6949
6950    // call function
6951    glContext->hooks->gl.glMaterialf(face, pname, param);
6952
6953    fixupGLMessage(glContext, &glmsg);
6954    glContext->traceGLMessage(&glmsg);
6955}
6956
6957void GLTrace_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
6958    GLMessage glmsg;
6959    GLTraceContext *glContext = getGLTraceContext();
6960
6961    glmsg.set_function(GLMessage::glMaterialfv);
6962
6963    // copy argument face
6964    GLMessage_DataType *arg_face = glmsg.add_args();
6965    arg_face->set_isarray(false);
6966    arg_face->set_type(GLMessage::DataType::ENUM);
6967    arg_face->add_intvalue((int)face);
6968
6969    // copy argument pname
6970    GLMessage_DataType *arg_pname = glmsg.add_args();
6971    arg_pname->set_isarray(false);
6972    arg_pname->set_type(GLMessage::DataType::ENUM);
6973    arg_pname->add_intvalue((int)pname);
6974
6975    // copy argument params
6976    GLMessage_DataType *arg_params = glmsg.add_args();
6977    arg_params->set_isarray(false);
6978    arg_params->set_type(GLMessage::DataType::INT);
6979    arg_params->add_intvalue((int)params);
6980
6981    // call function
6982    glContext->hooks->gl.glMaterialfv(face, pname, params);
6983
6984    fixupGLMessage(glContext, &glmsg);
6985    glContext->traceGLMessage(&glmsg);
6986}
6987
6988void GLTrace_glMultMatrixf(const GLfloat *m) {
6989    GLMessage glmsg;
6990    GLTraceContext *glContext = getGLTraceContext();
6991
6992    glmsg.set_function(GLMessage::glMultMatrixf);
6993
6994    // copy argument m
6995    GLMessage_DataType *arg_m = glmsg.add_args();
6996    arg_m->set_isarray(false);
6997    arg_m->set_type(GLMessage::DataType::INT);
6998    arg_m->add_intvalue((int)m);
6999
7000    // call function
7001    glContext->hooks->gl.glMultMatrixf(m);
7002
7003    fixupGLMessage(glContext, &glmsg);
7004    glContext->traceGLMessage(&glmsg);
7005}
7006
7007void GLTrace_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
7008    GLMessage glmsg;
7009    GLTraceContext *glContext = getGLTraceContext();
7010
7011    glmsg.set_function(GLMessage::glMultiTexCoord4f);
7012
7013    // copy argument target
7014    GLMessage_DataType *arg_target = glmsg.add_args();
7015    arg_target->set_isarray(false);
7016    arg_target->set_type(GLMessage::DataType::ENUM);
7017    arg_target->add_intvalue((int)target);
7018
7019    // copy argument s
7020    GLMessage_DataType *arg_s = glmsg.add_args();
7021    arg_s->set_isarray(false);
7022    arg_s->set_type(GLMessage::DataType::FLOAT);
7023    arg_s->add_floatvalue(s);
7024
7025    // copy argument t
7026    GLMessage_DataType *arg_t = glmsg.add_args();
7027    arg_t->set_isarray(false);
7028    arg_t->set_type(GLMessage::DataType::FLOAT);
7029    arg_t->add_floatvalue(t);
7030
7031    // copy argument r
7032    GLMessage_DataType *arg_r = glmsg.add_args();
7033    arg_r->set_isarray(false);
7034    arg_r->set_type(GLMessage::DataType::FLOAT);
7035    arg_r->add_floatvalue(r);
7036
7037    // copy argument q
7038    GLMessage_DataType *arg_q = glmsg.add_args();
7039    arg_q->set_isarray(false);
7040    arg_q->set_type(GLMessage::DataType::FLOAT);
7041    arg_q->add_floatvalue(q);
7042
7043    // call function
7044    glContext->hooks->gl.glMultiTexCoord4f(target, s, t, r, q);
7045
7046    fixupGLMessage(glContext, &glmsg);
7047    glContext->traceGLMessage(&glmsg);
7048}
7049
7050void GLTrace_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
7051    GLMessage glmsg;
7052    GLTraceContext *glContext = getGLTraceContext();
7053
7054    glmsg.set_function(GLMessage::glNormal3f);
7055
7056    // copy argument nx
7057    GLMessage_DataType *arg_nx = glmsg.add_args();
7058    arg_nx->set_isarray(false);
7059    arg_nx->set_type(GLMessage::DataType::FLOAT);
7060    arg_nx->add_floatvalue(nx);
7061
7062    // copy argument ny
7063    GLMessage_DataType *arg_ny = glmsg.add_args();
7064    arg_ny->set_isarray(false);
7065    arg_ny->set_type(GLMessage::DataType::FLOAT);
7066    arg_ny->add_floatvalue(ny);
7067
7068    // copy argument nz
7069    GLMessage_DataType *arg_nz = glmsg.add_args();
7070    arg_nz->set_isarray(false);
7071    arg_nz->set_type(GLMessage::DataType::FLOAT);
7072    arg_nz->add_floatvalue(nz);
7073
7074    // call function
7075    glContext->hooks->gl.glNormal3f(nx, ny, nz);
7076
7077    fixupGLMessage(glContext, &glmsg);
7078    glContext->traceGLMessage(&glmsg);
7079}
7080
7081void GLTrace_glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
7082    GLMessage glmsg;
7083    GLTraceContext *glContext = getGLTraceContext();
7084
7085    glmsg.set_function(GLMessage::glOrthof);
7086
7087    // copy argument left
7088    GLMessage_DataType *arg_left = glmsg.add_args();
7089    arg_left->set_isarray(false);
7090    arg_left->set_type(GLMessage::DataType::FLOAT);
7091    arg_left->add_floatvalue(left);
7092
7093    // copy argument right
7094    GLMessage_DataType *arg_right = glmsg.add_args();
7095    arg_right->set_isarray(false);
7096    arg_right->set_type(GLMessage::DataType::FLOAT);
7097    arg_right->add_floatvalue(right);
7098
7099    // copy argument bottom
7100    GLMessage_DataType *arg_bottom = glmsg.add_args();
7101    arg_bottom->set_isarray(false);
7102    arg_bottom->set_type(GLMessage::DataType::FLOAT);
7103    arg_bottom->add_floatvalue(bottom);
7104
7105    // copy argument top
7106    GLMessage_DataType *arg_top = glmsg.add_args();
7107    arg_top->set_isarray(false);
7108    arg_top->set_type(GLMessage::DataType::FLOAT);
7109    arg_top->add_floatvalue(top);
7110
7111    // copy argument zNear
7112    GLMessage_DataType *arg_zNear = glmsg.add_args();
7113    arg_zNear->set_isarray(false);
7114    arg_zNear->set_type(GLMessage::DataType::FLOAT);
7115    arg_zNear->add_floatvalue(zNear);
7116
7117    // copy argument zFar
7118    GLMessage_DataType *arg_zFar = glmsg.add_args();
7119    arg_zFar->set_isarray(false);
7120    arg_zFar->set_type(GLMessage::DataType::FLOAT);
7121    arg_zFar->add_floatvalue(zFar);
7122
7123    // call function
7124    glContext->hooks->gl.glOrthof(left, right, bottom, top, zNear, zFar);
7125
7126    fixupGLMessage(glContext, &glmsg);
7127    glContext->traceGLMessage(&glmsg);
7128}
7129
7130void GLTrace_glPointParameterf(GLenum pname, GLfloat param) {
7131    GLMessage glmsg;
7132    GLTraceContext *glContext = getGLTraceContext();
7133
7134    glmsg.set_function(GLMessage::glPointParameterf);
7135
7136    // copy argument pname
7137    GLMessage_DataType *arg_pname = glmsg.add_args();
7138    arg_pname->set_isarray(false);
7139    arg_pname->set_type(GLMessage::DataType::ENUM);
7140    arg_pname->add_intvalue((int)pname);
7141
7142    // copy argument param
7143    GLMessage_DataType *arg_param = glmsg.add_args();
7144    arg_param->set_isarray(false);
7145    arg_param->set_type(GLMessage::DataType::FLOAT);
7146    arg_param->add_floatvalue(param);
7147
7148    // call function
7149    glContext->hooks->gl.glPointParameterf(pname, param);
7150
7151    fixupGLMessage(glContext, &glmsg);
7152    glContext->traceGLMessage(&glmsg);
7153}
7154
7155void GLTrace_glPointParameterfv(GLenum pname, const GLfloat *params) {
7156    GLMessage glmsg;
7157    GLTraceContext *glContext = getGLTraceContext();
7158
7159    glmsg.set_function(GLMessage::glPointParameterfv);
7160
7161    // copy argument pname
7162    GLMessage_DataType *arg_pname = glmsg.add_args();
7163    arg_pname->set_isarray(false);
7164    arg_pname->set_type(GLMessage::DataType::ENUM);
7165    arg_pname->add_intvalue((int)pname);
7166
7167    // copy argument params
7168    GLMessage_DataType *arg_params = glmsg.add_args();
7169    arg_params->set_isarray(false);
7170    arg_params->set_type(GLMessage::DataType::INT);
7171    arg_params->add_intvalue((int)params);
7172
7173    // call function
7174    glContext->hooks->gl.glPointParameterfv(pname, params);
7175
7176    fixupGLMessage(glContext, &glmsg);
7177    glContext->traceGLMessage(&glmsg);
7178}
7179
7180void GLTrace_glPointSize(GLfloat size) {
7181    GLMessage glmsg;
7182    GLTraceContext *glContext = getGLTraceContext();
7183
7184    glmsg.set_function(GLMessage::glPointSize);
7185
7186    // copy argument size
7187    GLMessage_DataType *arg_size = glmsg.add_args();
7188    arg_size->set_isarray(false);
7189    arg_size->set_type(GLMessage::DataType::FLOAT);
7190    arg_size->add_floatvalue(size);
7191
7192    // call function
7193    glContext->hooks->gl.glPointSize(size);
7194
7195    fixupGLMessage(glContext, &glmsg);
7196    glContext->traceGLMessage(&glmsg);
7197}
7198
7199void GLTrace_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
7200    GLMessage glmsg;
7201    GLTraceContext *glContext = getGLTraceContext();
7202
7203    glmsg.set_function(GLMessage::glRotatef);
7204
7205    // copy argument angle
7206    GLMessage_DataType *arg_angle = glmsg.add_args();
7207    arg_angle->set_isarray(false);
7208    arg_angle->set_type(GLMessage::DataType::FLOAT);
7209    arg_angle->add_floatvalue(angle);
7210
7211    // copy argument x
7212    GLMessage_DataType *arg_x = glmsg.add_args();
7213    arg_x->set_isarray(false);
7214    arg_x->set_type(GLMessage::DataType::FLOAT);
7215    arg_x->add_floatvalue(x);
7216
7217    // copy argument y
7218    GLMessage_DataType *arg_y = glmsg.add_args();
7219    arg_y->set_isarray(false);
7220    arg_y->set_type(GLMessage::DataType::FLOAT);
7221    arg_y->add_floatvalue(y);
7222
7223    // copy argument z
7224    GLMessage_DataType *arg_z = glmsg.add_args();
7225    arg_z->set_isarray(false);
7226    arg_z->set_type(GLMessage::DataType::FLOAT);
7227    arg_z->add_floatvalue(z);
7228
7229    // call function
7230    glContext->hooks->gl.glRotatef(angle, x, y, z);
7231
7232    fixupGLMessage(glContext, &glmsg);
7233    glContext->traceGLMessage(&glmsg);
7234}
7235
7236void GLTrace_glScalef(GLfloat x, GLfloat y, GLfloat z) {
7237    GLMessage glmsg;
7238    GLTraceContext *glContext = getGLTraceContext();
7239
7240    glmsg.set_function(GLMessage::glScalef);
7241
7242    // copy argument x
7243    GLMessage_DataType *arg_x = glmsg.add_args();
7244    arg_x->set_isarray(false);
7245    arg_x->set_type(GLMessage::DataType::FLOAT);
7246    arg_x->add_floatvalue(x);
7247
7248    // copy argument y
7249    GLMessage_DataType *arg_y = glmsg.add_args();
7250    arg_y->set_isarray(false);
7251    arg_y->set_type(GLMessage::DataType::FLOAT);
7252    arg_y->add_floatvalue(y);
7253
7254    // copy argument z
7255    GLMessage_DataType *arg_z = glmsg.add_args();
7256    arg_z->set_isarray(false);
7257    arg_z->set_type(GLMessage::DataType::FLOAT);
7258    arg_z->add_floatvalue(z);
7259
7260    // call function
7261    glContext->hooks->gl.glScalef(x, y, z);
7262
7263    fixupGLMessage(glContext, &glmsg);
7264    glContext->traceGLMessage(&glmsg);
7265}
7266
7267void GLTrace_glTexEnvf(GLenum target, GLenum pname, GLfloat param) {
7268    GLMessage glmsg;
7269    GLTraceContext *glContext = getGLTraceContext();
7270
7271    glmsg.set_function(GLMessage::glTexEnvf);
7272
7273    // copy argument target
7274    GLMessage_DataType *arg_target = glmsg.add_args();
7275    arg_target->set_isarray(false);
7276    arg_target->set_type(GLMessage::DataType::ENUM);
7277    arg_target->add_intvalue((int)target);
7278
7279    // copy argument pname
7280    GLMessage_DataType *arg_pname = glmsg.add_args();
7281    arg_pname->set_isarray(false);
7282    arg_pname->set_type(GLMessage::DataType::ENUM);
7283    arg_pname->add_intvalue((int)pname);
7284
7285    // copy argument param
7286    GLMessage_DataType *arg_param = glmsg.add_args();
7287    arg_param->set_isarray(false);
7288    arg_param->set_type(GLMessage::DataType::FLOAT);
7289    arg_param->add_floatvalue(param);
7290
7291    // call function
7292    glContext->hooks->gl.glTexEnvf(target, pname, param);
7293
7294    fixupGLMessage(glContext, &glmsg);
7295    glContext->traceGLMessage(&glmsg);
7296}
7297
7298void GLTrace_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {
7299    GLMessage glmsg;
7300    GLTraceContext *glContext = getGLTraceContext();
7301
7302    glmsg.set_function(GLMessage::glTexEnvfv);
7303
7304    // copy argument target
7305    GLMessage_DataType *arg_target = glmsg.add_args();
7306    arg_target->set_isarray(false);
7307    arg_target->set_type(GLMessage::DataType::ENUM);
7308    arg_target->add_intvalue((int)target);
7309
7310    // copy argument pname
7311    GLMessage_DataType *arg_pname = glmsg.add_args();
7312    arg_pname->set_isarray(false);
7313    arg_pname->set_type(GLMessage::DataType::ENUM);
7314    arg_pname->add_intvalue((int)pname);
7315
7316    // copy argument params
7317    GLMessage_DataType *arg_params = glmsg.add_args();
7318    arg_params->set_isarray(false);
7319    arg_params->set_type(GLMessage::DataType::INT);
7320    arg_params->add_intvalue((int)params);
7321
7322    // call function
7323    glContext->hooks->gl.glTexEnvfv(target, pname, params);
7324
7325    fixupGLMessage(glContext, &glmsg);
7326    glContext->traceGLMessage(&glmsg);
7327}
7328
7329void GLTrace_glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
7330    GLMessage glmsg;
7331    GLTraceContext *glContext = getGLTraceContext();
7332
7333    glmsg.set_function(GLMessage::glTranslatef);
7334
7335    // copy argument x
7336    GLMessage_DataType *arg_x = glmsg.add_args();
7337    arg_x->set_isarray(false);
7338    arg_x->set_type(GLMessage::DataType::FLOAT);
7339    arg_x->add_floatvalue(x);
7340
7341    // copy argument y
7342    GLMessage_DataType *arg_y = glmsg.add_args();
7343    arg_y->set_isarray(false);
7344    arg_y->set_type(GLMessage::DataType::FLOAT);
7345    arg_y->add_floatvalue(y);
7346
7347    // copy argument z
7348    GLMessage_DataType *arg_z = glmsg.add_args();
7349    arg_z->set_isarray(false);
7350    arg_z->set_type(GLMessage::DataType::FLOAT);
7351    arg_z->add_floatvalue(z);
7352
7353    // call function
7354    glContext->hooks->gl.glTranslatef(x, y, z);
7355
7356    fixupGLMessage(glContext, &glmsg);
7357    glContext->traceGLMessage(&glmsg);
7358}
7359
7360void GLTrace_glAlphaFuncx(GLenum func, GLclampx ref) {
7361    GLMessage glmsg;
7362    GLTraceContext *glContext = getGLTraceContext();
7363
7364    glmsg.set_function(GLMessage::glAlphaFuncx);
7365
7366    // copy argument func
7367    GLMessage_DataType *arg_func = glmsg.add_args();
7368    arg_func->set_isarray(false);
7369    arg_func->set_type(GLMessage::DataType::ENUM);
7370    arg_func->add_intvalue((int)func);
7371
7372    // copy argument ref
7373    GLMessage_DataType *arg_ref = glmsg.add_args();
7374    arg_ref->set_isarray(false);
7375    arg_ref->set_type(GLMessage::DataType::INT);
7376    arg_ref->add_intvalue(ref);
7377
7378    // call function
7379    glContext->hooks->gl.glAlphaFuncx(func, ref);
7380
7381    fixupGLMessage(glContext, &glmsg);
7382    glContext->traceGLMessage(&glmsg);
7383}
7384
7385void GLTrace_glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
7386    GLMessage glmsg;
7387    GLTraceContext *glContext = getGLTraceContext();
7388
7389    glmsg.set_function(GLMessage::glClearColorx);
7390
7391    // copy argument red
7392    GLMessage_DataType *arg_red = glmsg.add_args();
7393    arg_red->set_isarray(false);
7394    arg_red->set_type(GLMessage::DataType::INT);
7395    arg_red->add_intvalue(red);
7396
7397    // copy argument green
7398    GLMessage_DataType *arg_green = glmsg.add_args();
7399    arg_green->set_isarray(false);
7400    arg_green->set_type(GLMessage::DataType::INT);
7401    arg_green->add_intvalue(green);
7402
7403    // copy argument blue
7404    GLMessage_DataType *arg_blue = glmsg.add_args();
7405    arg_blue->set_isarray(false);
7406    arg_blue->set_type(GLMessage::DataType::INT);
7407    arg_blue->add_intvalue(blue);
7408
7409    // copy argument alpha
7410    GLMessage_DataType *arg_alpha = glmsg.add_args();
7411    arg_alpha->set_isarray(false);
7412    arg_alpha->set_type(GLMessage::DataType::INT);
7413    arg_alpha->add_intvalue(alpha);
7414
7415    // call function
7416    glContext->hooks->gl.glClearColorx(red, green, blue, alpha);
7417
7418    fixupGLMessage(glContext, &glmsg);
7419    glContext->traceGLMessage(&glmsg);
7420}
7421
7422void GLTrace_glClearDepthx(GLclampx depth) {
7423    GLMessage glmsg;
7424    GLTraceContext *glContext = getGLTraceContext();
7425
7426    glmsg.set_function(GLMessage::glClearDepthx);
7427
7428    // copy argument depth
7429    GLMessage_DataType *arg_depth = glmsg.add_args();
7430    arg_depth->set_isarray(false);
7431    arg_depth->set_type(GLMessage::DataType::INT);
7432    arg_depth->add_intvalue(depth);
7433
7434    // call function
7435    glContext->hooks->gl.glClearDepthx(depth);
7436
7437    fixupGLMessage(glContext, &glmsg);
7438    glContext->traceGLMessage(&glmsg);
7439}
7440
7441void GLTrace_glClientActiveTexture(GLenum texture) {
7442    GLMessage glmsg;
7443    GLTraceContext *glContext = getGLTraceContext();
7444
7445    glmsg.set_function(GLMessage::glClientActiveTexture);
7446
7447    // copy argument texture
7448    GLMessage_DataType *arg_texture = glmsg.add_args();
7449    arg_texture->set_isarray(false);
7450    arg_texture->set_type(GLMessage::DataType::ENUM);
7451    arg_texture->add_intvalue((int)texture);
7452
7453    // call function
7454    glContext->hooks->gl.glClientActiveTexture(texture);
7455
7456    fixupGLMessage(glContext, &glmsg);
7457    glContext->traceGLMessage(&glmsg);
7458}
7459
7460void GLTrace_glClipPlanex(GLenum plane, const GLfixed *equation) {
7461    GLMessage glmsg;
7462    GLTraceContext *glContext = getGLTraceContext();
7463
7464    glmsg.set_function(GLMessage::glClipPlanex);
7465
7466    // copy argument plane
7467    GLMessage_DataType *arg_plane = glmsg.add_args();
7468    arg_plane->set_isarray(false);
7469    arg_plane->set_type(GLMessage::DataType::ENUM);
7470    arg_plane->add_intvalue((int)plane);
7471
7472    // copy argument equation
7473    GLMessage_DataType *arg_equation = glmsg.add_args();
7474    arg_equation->set_isarray(false);
7475    arg_equation->set_type(GLMessage::DataType::INT);
7476    arg_equation->add_intvalue((int)equation);
7477
7478    // call function
7479    glContext->hooks->gl.glClipPlanex(plane, equation);
7480
7481    fixupGLMessage(glContext, &glmsg);
7482    glContext->traceGLMessage(&glmsg);
7483}
7484
7485void GLTrace_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
7486    GLMessage glmsg;
7487    GLTraceContext *glContext = getGLTraceContext();
7488
7489    glmsg.set_function(GLMessage::glColor4ub);
7490
7491    // copy argument red
7492    GLMessage_DataType *arg_red = glmsg.add_args();
7493    arg_red->set_isarray(false);
7494    arg_red->set_type(GLMessage::DataType::BYTE);
7495    arg_red->add_intvalue((int)red);
7496
7497    // copy argument green
7498    GLMessage_DataType *arg_green = glmsg.add_args();
7499    arg_green->set_isarray(false);
7500    arg_green->set_type(GLMessage::DataType::BYTE);
7501    arg_green->add_intvalue((int)green);
7502
7503    // copy argument blue
7504    GLMessage_DataType *arg_blue = glmsg.add_args();
7505    arg_blue->set_isarray(false);
7506    arg_blue->set_type(GLMessage::DataType::BYTE);
7507    arg_blue->add_intvalue((int)blue);
7508
7509    // copy argument alpha
7510    GLMessage_DataType *arg_alpha = glmsg.add_args();
7511    arg_alpha->set_isarray(false);
7512    arg_alpha->set_type(GLMessage::DataType::BYTE);
7513    arg_alpha->add_intvalue((int)alpha);
7514
7515    // call function
7516    glContext->hooks->gl.glColor4ub(red, green, blue, alpha);
7517
7518    fixupGLMessage(glContext, &glmsg);
7519    glContext->traceGLMessage(&glmsg);
7520}
7521
7522void GLTrace_glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) {
7523    GLMessage glmsg;
7524    GLTraceContext *glContext = getGLTraceContext();
7525
7526    glmsg.set_function(GLMessage::glColor4x);
7527
7528    // copy argument red
7529    GLMessage_DataType *arg_red = glmsg.add_args();
7530    arg_red->set_isarray(false);
7531    arg_red->set_type(GLMessage::DataType::INT);
7532    arg_red->add_intvalue(red);
7533
7534    // copy argument green
7535    GLMessage_DataType *arg_green = glmsg.add_args();
7536    arg_green->set_isarray(false);
7537    arg_green->set_type(GLMessage::DataType::INT);
7538    arg_green->add_intvalue(green);
7539
7540    // copy argument blue
7541    GLMessage_DataType *arg_blue = glmsg.add_args();
7542    arg_blue->set_isarray(false);
7543    arg_blue->set_type(GLMessage::DataType::INT);
7544    arg_blue->add_intvalue(blue);
7545
7546    // copy argument alpha
7547    GLMessage_DataType *arg_alpha = glmsg.add_args();
7548    arg_alpha->set_isarray(false);
7549    arg_alpha->set_type(GLMessage::DataType::INT);
7550    arg_alpha->add_intvalue(alpha);
7551
7552    // call function
7553    glContext->hooks->gl.glColor4x(red, green, blue, alpha);
7554
7555    fixupGLMessage(glContext, &glmsg);
7556    glContext->traceGLMessage(&glmsg);
7557}
7558
7559void GLTrace_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
7560    GLMessage glmsg;
7561    GLTraceContext *glContext = getGLTraceContext();
7562
7563    glmsg.set_function(GLMessage::glColorPointer);
7564
7565    // copy argument size
7566    GLMessage_DataType *arg_size = glmsg.add_args();
7567    arg_size->set_isarray(false);
7568    arg_size->set_type(GLMessage::DataType::INT);
7569    arg_size->add_intvalue(size);
7570
7571    // copy argument type
7572    GLMessage_DataType *arg_type = glmsg.add_args();
7573    arg_type->set_isarray(false);
7574    arg_type->set_type(GLMessage::DataType::ENUM);
7575    arg_type->add_intvalue((int)type);
7576
7577    // copy argument stride
7578    GLMessage_DataType *arg_stride = glmsg.add_args();
7579    arg_stride->set_isarray(false);
7580    arg_stride->set_type(GLMessage::DataType::INT);
7581    arg_stride->add_intvalue(stride);
7582
7583    // copy argument pointer
7584    GLMessage_DataType *arg_pointer = glmsg.add_args();
7585    arg_pointer->set_isarray(false);
7586    arg_pointer->set_type(GLMessage::DataType::INT);
7587    arg_pointer->add_intvalue((int)pointer);
7588
7589    // call function
7590    glContext->hooks->gl.glColorPointer(size, type, stride, pointer);
7591
7592    fixupGLMessage(glContext, &glmsg);
7593    glContext->traceGLMessage(&glmsg);
7594}
7595
7596void GLTrace_glDepthRangex(GLclampx zNear, GLclampx zFar) {
7597    GLMessage glmsg;
7598    GLTraceContext *glContext = getGLTraceContext();
7599
7600    glmsg.set_function(GLMessage::glDepthRangex);
7601
7602    // copy argument zNear
7603    GLMessage_DataType *arg_zNear = glmsg.add_args();
7604    arg_zNear->set_isarray(false);
7605    arg_zNear->set_type(GLMessage::DataType::INT);
7606    arg_zNear->add_intvalue(zNear);
7607
7608    // copy argument zFar
7609    GLMessage_DataType *arg_zFar = glmsg.add_args();
7610    arg_zFar->set_isarray(false);
7611    arg_zFar->set_type(GLMessage::DataType::INT);
7612    arg_zFar->add_intvalue(zFar);
7613
7614    // call function
7615    glContext->hooks->gl.glDepthRangex(zNear, zFar);
7616
7617    fixupGLMessage(glContext, &glmsg);
7618    glContext->traceGLMessage(&glmsg);
7619}
7620
7621void GLTrace_glDisableClientState(GLenum array) {
7622    GLMessage glmsg;
7623    GLTraceContext *glContext = getGLTraceContext();
7624
7625    glmsg.set_function(GLMessage::glDisableClientState);
7626
7627    // copy argument array
7628    GLMessage_DataType *arg_array = glmsg.add_args();
7629    arg_array->set_isarray(false);
7630    arg_array->set_type(GLMessage::DataType::ENUM);
7631    arg_array->add_intvalue((int)array);
7632
7633    // call function
7634    glContext->hooks->gl.glDisableClientState(array);
7635
7636    fixupGLMessage(glContext, &glmsg);
7637    glContext->traceGLMessage(&glmsg);
7638}
7639
7640void GLTrace_glEnableClientState(GLenum array) {
7641    GLMessage glmsg;
7642    GLTraceContext *glContext = getGLTraceContext();
7643
7644    glmsg.set_function(GLMessage::glEnableClientState);
7645
7646    // copy argument array
7647    GLMessage_DataType *arg_array = glmsg.add_args();
7648    arg_array->set_isarray(false);
7649    arg_array->set_type(GLMessage::DataType::ENUM);
7650    arg_array->add_intvalue((int)array);
7651
7652    // call function
7653    glContext->hooks->gl.glEnableClientState(array);
7654
7655    fixupGLMessage(glContext, &glmsg);
7656    glContext->traceGLMessage(&glmsg);
7657}
7658
7659void GLTrace_glFogx(GLenum pname, GLfixed param) {
7660    GLMessage glmsg;
7661    GLTraceContext *glContext = getGLTraceContext();
7662
7663    glmsg.set_function(GLMessage::glFogx);
7664
7665    // copy argument pname
7666    GLMessage_DataType *arg_pname = glmsg.add_args();
7667    arg_pname->set_isarray(false);
7668    arg_pname->set_type(GLMessage::DataType::ENUM);
7669    arg_pname->add_intvalue((int)pname);
7670
7671    // copy argument param
7672    GLMessage_DataType *arg_param = glmsg.add_args();
7673    arg_param->set_isarray(false);
7674    arg_param->set_type(GLMessage::DataType::INT);
7675    arg_param->add_intvalue(param);
7676
7677    // call function
7678    glContext->hooks->gl.glFogx(pname, param);
7679
7680    fixupGLMessage(glContext, &glmsg);
7681    glContext->traceGLMessage(&glmsg);
7682}
7683
7684void GLTrace_glFogxv(GLenum pname, const GLfixed *params) {
7685    GLMessage glmsg;
7686    GLTraceContext *glContext = getGLTraceContext();
7687
7688    glmsg.set_function(GLMessage::glFogxv);
7689
7690    // copy argument pname
7691    GLMessage_DataType *arg_pname = glmsg.add_args();
7692    arg_pname->set_isarray(false);
7693    arg_pname->set_type(GLMessage::DataType::ENUM);
7694    arg_pname->add_intvalue((int)pname);
7695
7696    // copy argument params
7697    GLMessage_DataType *arg_params = glmsg.add_args();
7698    arg_params->set_isarray(false);
7699    arg_params->set_type(GLMessage::DataType::INT);
7700    arg_params->add_intvalue((int)params);
7701
7702    // call function
7703    glContext->hooks->gl.glFogxv(pname, params);
7704
7705    fixupGLMessage(glContext, &glmsg);
7706    glContext->traceGLMessage(&glmsg);
7707}
7708
7709void GLTrace_glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) {
7710    GLMessage glmsg;
7711    GLTraceContext *glContext = getGLTraceContext();
7712
7713    glmsg.set_function(GLMessage::glFrustumx);
7714
7715    // copy argument left
7716    GLMessage_DataType *arg_left = glmsg.add_args();
7717    arg_left->set_isarray(false);
7718    arg_left->set_type(GLMessage::DataType::INT);
7719    arg_left->add_intvalue(left);
7720
7721    // copy argument right
7722    GLMessage_DataType *arg_right = glmsg.add_args();
7723    arg_right->set_isarray(false);
7724    arg_right->set_type(GLMessage::DataType::INT);
7725    arg_right->add_intvalue(right);
7726
7727    // copy argument bottom
7728    GLMessage_DataType *arg_bottom = glmsg.add_args();
7729    arg_bottom->set_isarray(false);
7730    arg_bottom->set_type(GLMessage::DataType::INT);
7731    arg_bottom->add_intvalue(bottom);
7732
7733    // copy argument top
7734    GLMessage_DataType *arg_top = glmsg.add_args();
7735    arg_top->set_isarray(false);
7736    arg_top->set_type(GLMessage::DataType::INT);
7737    arg_top->add_intvalue(top);
7738
7739    // copy argument zNear
7740    GLMessage_DataType *arg_zNear = glmsg.add_args();
7741    arg_zNear->set_isarray(false);
7742    arg_zNear->set_type(GLMessage::DataType::INT);
7743    arg_zNear->add_intvalue(zNear);
7744
7745    // copy argument zFar
7746    GLMessage_DataType *arg_zFar = glmsg.add_args();
7747    arg_zFar->set_isarray(false);
7748    arg_zFar->set_type(GLMessage::DataType::INT);
7749    arg_zFar->add_intvalue(zFar);
7750
7751    // call function
7752    glContext->hooks->gl.glFrustumx(left, right, bottom, top, zNear, zFar);
7753
7754    fixupGLMessage(glContext, &glmsg);
7755    glContext->traceGLMessage(&glmsg);
7756}
7757
7758void GLTrace_glGetClipPlanex(GLenum pname, GLfixed eqn[4]) {
7759    GLMessage glmsg;
7760    GLTraceContext *glContext = getGLTraceContext();
7761
7762    glmsg.set_function(GLMessage::glGetClipPlanex);
7763
7764    // copy argument pname
7765    GLMessage_DataType *arg_pname = glmsg.add_args();
7766    arg_pname->set_isarray(false);
7767    arg_pname->set_type(GLMessage::DataType::ENUM);
7768    arg_pname->add_intvalue((int)pname);
7769
7770    // copy argument eqn
7771    GLMessage_DataType *arg_eqn = glmsg.add_args();
7772    arg_eqn->set_isarray(false);
7773    arg_eqn->set_type(GLMessage::DataType::INT);
7774    arg_eqn->add_intvalue((int)eqn);
7775
7776    // call function
7777    glContext->hooks->gl.glGetClipPlanex(pname, eqn);
7778
7779    fixupGLMessage(glContext, &glmsg);
7780    glContext->traceGLMessage(&glmsg);
7781}
7782
7783void GLTrace_glGetFixedv(GLenum pname, GLfixed *params) {
7784    GLMessage glmsg;
7785    GLTraceContext *glContext = getGLTraceContext();
7786
7787    glmsg.set_function(GLMessage::glGetFixedv);
7788
7789    // copy argument pname
7790    GLMessage_DataType *arg_pname = glmsg.add_args();
7791    arg_pname->set_isarray(false);
7792    arg_pname->set_type(GLMessage::DataType::ENUM);
7793    arg_pname->add_intvalue((int)pname);
7794
7795    // copy argument params
7796    GLMessage_DataType *arg_params = glmsg.add_args();
7797    arg_params->set_isarray(false);
7798    arg_params->set_type(GLMessage::DataType::INT);
7799    arg_params->add_intvalue((int)params);
7800
7801    // call function
7802    glContext->hooks->gl.glGetFixedv(pname, params);
7803
7804    fixupGLMessage(glContext, &glmsg);
7805    glContext->traceGLMessage(&glmsg);
7806}
7807
7808void GLTrace_glGetLightxv(GLenum light, GLenum pname, GLfixed *params) {
7809    GLMessage glmsg;
7810    GLTraceContext *glContext = getGLTraceContext();
7811
7812    glmsg.set_function(GLMessage::glGetLightxv);
7813
7814    // copy argument light
7815    GLMessage_DataType *arg_light = glmsg.add_args();
7816    arg_light->set_isarray(false);
7817    arg_light->set_type(GLMessage::DataType::ENUM);
7818    arg_light->add_intvalue((int)light);
7819
7820    // copy argument pname
7821    GLMessage_DataType *arg_pname = glmsg.add_args();
7822    arg_pname->set_isarray(false);
7823    arg_pname->set_type(GLMessage::DataType::ENUM);
7824    arg_pname->add_intvalue((int)pname);
7825
7826    // copy argument params
7827    GLMessage_DataType *arg_params = glmsg.add_args();
7828    arg_params->set_isarray(false);
7829    arg_params->set_type(GLMessage::DataType::INT);
7830    arg_params->add_intvalue((int)params);
7831
7832    // call function
7833    glContext->hooks->gl.glGetLightxv(light, pname, params);
7834
7835    fixupGLMessage(glContext, &glmsg);
7836    glContext->traceGLMessage(&glmsg);
7837}
7838
7839void GLTrace_glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params) {
7840    GLMessage glmsg;
7841    GLTraceContext *glContext = getGLTraceContext();
7842
7843    glmsg.set_function(GLMessage::glGetMaterialxv);
7844
7845    // copy argument face
7846    GLMessage_DataType *arg_face = glmsg.add_args();
7847    arg_face->set_isarray(false);
7848    arg_face->set_type(GLMessage::DataType::ENUM);
7849    arg_face->add_intvalue((int)face);
7850
7851    // copy argument pname
7852    GLMessage_DataType *arg_pname = glmsg.add_args();
7853    arg_pname->set_isarray(false);
7854    arg_pname->set_type(GLMessage::DataType::ENUM);
7855    arg_pname->add_intvalue((int)pname);
7856
7857    // copy argument params
7858    GLMessage_DataType *arg_params = glmsg.add_args();
7859    arg_params->set_isarray(false);
7860    arg_params->set_type(GLMessage::DataType::INT);
7861    arg_params->add_intvalue((int)params);
7862
7863    // call function
7864    glContext->hooks->gl.glGetMaterialxv(face, pname, params);
7865
7866    fixupGLMessage(glContext, &glmsg);
7867    glContext->traceGLMessage(&glmsg);
7868}
7869
7870void GLTrace_glGetPointerv(GLenum pname, GLvoid **params) {
7871    GLMessage glmsg;
7872    GLTraceContext *glContext = getGLTraceContext();
7873
7874    glmsg.set_function(GLMessage::glGetPointerv);
7875
7876    // copy argument pname
7877    GLMessage_DataType *arg_pname = glmsg.add_args();
7878    arg_pname->set_isarray(false);
7879    arg_pname->set_type(GLMessage::DataType::ENUM);
7880    arg_pname->add_intvalue((int)pname);
7881
7882    // copy argument params
7883    GLMessage_DataType *arg_params = glmsg.add_args();
7884    arg_params->set_isarray(false);
7885    arg_params->set_type(GLMessage::DataType::INT);
7886    arg_params->add_intvalue((int)params);
7887
7888    // call function
7889    glContext->hooks->gl.glGetPointerv(pname, params);
7890
7891    fixupGLMessage(glContext, &glmsg);
7892    glContext->traceGLMessage(&glmsg);
7893}
7894
7895void GLTrace_glGetTexEnviv(GLenum env, GLenum pname, GLint *params) {
7896    GLMessage glmsg;
7897    GLTraceContext *glContext = getGLTraceContext();
7898
7899    glmsg.set_function(GLMessage::glGetTexEnviv);
7900
7901    // copy argument env
7902    GLMessage_DataType *arg_env = glmsg.add_args();
7903    arg_env->set_isarray(false);
7904    arg_env->set_type(GLMessage::DataType::ENUM);
7905    arg_env->add_intvalue((int)env);
7906
7907    // copy argument pname
7908    GLMessage_DataType *arg_pname = glmsg.add_args();
7909    arg_pname->set_isarray(false);
7910    arg_pname->set_type(GLMessage::DataType::ENUM);
7911    arg_pname->add_intvalue((int)pname);
7912
7913    // copy argument params
7914    GLMessage_DataType *arg_params = glmsg.add_args();
7915    arg_params->set_isarray(false);
7916    arg_params->set_type(GLMessage::DataType::INT);
7917    arg_params->add_intvalue((int)params);
7918
7919    // call function
7920    glContext->hooks->gl.glGetTexEnviv(env, pname, params);
7921
7922    fixupGLMessage(glContext, &glmsg);
7923    glContext->traceGLMessage(&glmsg);
7924}
7925
7926void GLTrace_glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params) {
7927    GLMessage glmsg;
7928    GLTraceContext *glContext = getGLTraceContext();
7929
7930    glmsg.set_function(GLMessage::glGetTexEnvxv);
7931
7932    // copy argument env
7933    GLMessage_DataType *arg_env = glmsg.add_args();
7934    arg_env->set_isarray(false);
7935    arg_env->set_type(GLMessage::DataType::ENUM);
7936    arg_env->add_intvalue((int)env);
7937
7938    // copy argument pname
7939    GLMessage_DataType *arg_pname = glmsg.add_args();
7940    arg_pname->set_isarray(false);
7941    arg_pname->set_type(GLMessage::DataType::ENUM);
7942    arg_pname->add_intvalue((int)pname);
7943
7944    // copy argument params
7945    GLMessage_DataType *arg_params = glmsg.add_args();
7946    arg_params->set_isarray(false);
7947    arg_params->set_type(GLMessage::DataType::INT);
7948    arg_params->add_intvalue((int)params);
7949
7950    // call function
7951    glContext->hooks->gl.glGetTexEnvxv(env, pname, params);
7952
7953    fixupGLMessage(glContext, &glmsg);
7954    glContext->traceGLMessage(&glmsg);
7955}
7956
7957void GLTrace_glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) {
7958    GLMessage glmsg;
7959    GLTraceContext *glContext = getGLTraceContext();
7960
7961    glmsg.set_function(GLMessage::glGetTexParameterxv);
7962
7963    // copy argument target
7964    GLMessage_DataType *arg_target = glmsg.add_args();
7965    arg_target->set_isarray(false);
7966    arg_target->set_type(GLMessage::DataType::ENUM);
7967    arg_target->add_intvalue((int)target);
7968
7969    // copy argument pname
7970    GLMessage_DataType *arg_pname = glmsg.add_args();
7971    arg_pname->set_isarray(false);
7972    arg_pname->set_type(GLMessage::DataType::ENUM);
7973    arg_pname->add_intvalue((int)pname);
7974
7975    // copy argument params
7976    GLMessage_DataType *arg_params = glmsg.add_args();
7977    arg_params->set_isarray(false);
7978    arg_params->set_type(GLMessage::DataType::INT);
7979    arg_params->add_intvalue((int)params);
7980
7981    // call function
7982    glContext->hooks->gl.glGetTexParameterxv(target, pname, params);
7983
7984    fixupGLMessage(glContext, &glmsg);
7985    glContext->traceGLMessage(&glmsg);
7986}
7987
7988void GLTrace_glLightModelx(GLenum pname, GLfixed param) {
7989    GLMessage glmsg;
7990    GLTraceContext *glContext = getGLTraceContext();
7991
7992    glmsg.set_function(GLMessage::glLightModelx);
7993
7994    // copy argument pname
7995    GLMessage_DataType *arg_pname = glmsg.add_args();
7996    arg_pname->set_isarray(false);
7997    arg_pname->set_type(GLMessage::DataType::ENUM);
7998    arg_pname->add_intvalue((int)pname);
7999
8000    // copy argument param
8001    GLMessage_DataType *arg_param = glmsg.add_args();
8002    arg_param->set_isarray(false);
8003    arg_param->set_type(GLMessage::DataType::INT);
8004    arg_param->add_intvalue(param);
8005
8006    // call function
8007    glContext->hooks->gl.glLightModelx(pname, param);
8008
8009    fixupGLMessage(glContext, &glmsg);
8010    glContext->traceGLMessage(&glmsg);
8011}
8012
8013void GLTrace_glLightModelxv(GLenum pname, const GLfixed *params) {
8014    GLMessage glmsg;
8015    GLTraceContext *glContext = getGLTraceContext();
8016
8017    glmsg.set_function(GLMessage::glLightModelxv);
8018
8019    // copy argument pname
8020    GLMessage_DataType *arg_pname = glmsg.add_args();
8021    arg_pname->set_isarray(false);
8022    arg_pname->set_type(GLMessage::DataType::ENUM);
8023    arg_pname->add_intvalue((int)pname);
8024
8025    // copy argument params
8026    GLMessage_DataType *arg_params = glmsg.add_args();
8027    arg_params->set_isarray(false);
8028    arg_params->set_type(GLMessage::DataType::INT);
8029    arg_params->add_intvalue((int)params);
8030
8031    // call function
8032    glContext->hooks->gl.glLightModelxv(pname, params);
8033
8034    fixupGLMessage(glContext, &glmsg);
8035    glContext->traceGLMessage(&glmsg);
8036}
8037
8038void GLTrace_glLightx(GLenum light, GLenum pname, GLfixed param) {
8039    GLMessage glmsg;
8040    GLTraceContext *glContext = getGLTraceContext();
8041
8042    glmsg.set_function(GLMessage::glLightx);
8043
8044    // copy argument light
8045    GLMessage_DataType *arg_light = glmsg.add_args();
8046    arg_light->set_isarray(false);
8047    arg_light->set_type(GLMessage::DataType::ENUM);
8048    arg_light->add_intvalue((int)light);
8049
8050    // copy argument pname
8051    GLMessage_DataType *arg_pname = glmsg.add_args();
8052    arg_pname->set_isarray(false);
8053    arg_pname->set_type(GLMessage::DataType::ENUM);
8054    arg_pname->add_intvalue((int)pname);
8055
8056    // copy argument param
8057    GLMessage_DataType *arg_param = glmsg.add_args();
8058    arg_param->set_isarray(false);
8059    arg_param->set_type(GLMessage::DataType::INT);
8060    arg_param->add_intvalue(param);
8061
8062    // call function
8063    glContext->hooks->gl.glLightx(light, pname, param);
8064
8065    fixupGLMessage(glContext, &glmsg);
8066    glContext->traceGLMessage(&glmsg);
8067}
8068
8069void GLTrace_glLightxv(GLenum light, GLenum pname, const GLfixed *params) {
8070    GLMessage glmsg;
8071    GLTraceContext *glContext = getGLTraceContext();
8072
8073    glmsg.set_function(GLMessage::glLightxv);
8074
8075    // copy argument light
8076    GLMessage_DataType *arg_light = glmsg.add_args();
8077    arg_light->set_isarray(false);
8078    arg_light->set_type(GLMessage::DataType::ENUM);
8079    arg_light->add_intvalue((int)light);
8080
8081    // copy argument pname
8082    GLMessage_DataType *arg_pname = glmsg.add_args();
8083    arg_pname->set_isarray(false);
8084    arg_pname->set_type(GLMessage::DataType::ENUM);
8085    arg_pname->add_intvalue((int)pname);
8086
8087    // copy argument params
8088    GLMessage_DataType *arg_params = glmsg.add_args();
8089    arg_params->set_isarray(false);
8090    arg_params->set_type(GLMessage::DataType::INT);
8091    arg_params->add_intvalue((int)params);
8092
8093    // call function
8094    glContext->hooks->gl.glLightxv(light, pname, params);
8095
8096    fixupGLMessage(glContext, &glmsg);
8097    glContext->traceGLMessage(&glmsg);
8098}
8099
8100void GLTrace_glLineWidthx(GLfixed width) {
8101    GLMessage glmsg;
8102    GLTraceContext *glContext = getGLTraceContext();
8103
8104    glmsg.set_function(GLMessage::glLineWidthx);
8105
8106    // copy argument width
8107    GLMessage_DataType *arg_width = glmsg.add_args();
8108    arg_width->set_isarray(false);
8109    arg_width->set_type(GLMessage::DataType::INT);
8110    arg_width->add_intvalue(width);
8111
8112    // call function
8113    glContext->hooks->gl.glLineWidthx(width);
8114
8115    fixupGLMessage(glContext, &glmsg);
8116    glContext->traceGLMessage(&glmsg);
8117}
8118
8119void GLTrace_glLoadIdentity(void) {
8120    GLMessage glmsg;
8121    GLTraceContext *glContext = getGLTraceContext();
8122
8123    glmsg.set_function(GLMessage::glLoadIdentity);
8124
8125    // call function
8126    glContext->hooks->gl.glLoadIdentity();
8127
8128    fixupGLMessage(glContext, &glmsg);
8129    glContext->traceGLMessage(&glmsg);
8130}
8131
8132void GLTrace_glLoadMatrixx(const GLfixed *m) {
8133    GLMessage glmsg;
8134    GLTraceContext *glContext = getGLTraceContext();
8135
8136    glmsg.set_function(GLMessage::glLoadMatrixx);
8137
8138    // copy argument m
8139    GLMessage_DataType *arg_m = glmsg.add_args();
8140    arg_m->set_isarray(false);
8141    arg_m->set_type(GLMessage::DataType::INT);
8142    arg_m->add_intvalue((int)m);
8143
8144    // call function
8145    glContext->hooks->gl.glLoadMatrixx(m);
8146
8147    fixupGLMessage(glContext, &glmsg);
8148    glContext->traceGLMessage(&glmsg);
8149}
8150
8151void GLTrace_glLogicOp(GLenum opcode) {
8152    GLMessage glmsg;
8153    GLTraceContext *glContext = getGLTraceContext();
8154
8155    glmsg.set_function(GLMessage::glLogicOp);
8156
8157    // copy argument opcode
8158    GLMessage_DataType *arg_opcode = glmsg.add_args();
8159    arg_opcode->set_isarray(false);
8160    arg_opcode->set_type(GLMessage::DataType::ENUM);
8161    arg_opcode->add_intvalue((int)opcode);
8162
8163    // call function
8164    glContext->hooks->gl.glLogicOp(opcode);
8165
8166    fixupGLMessage(glContext, &glmsg);
8167    glContext->traceGLMessage(&glmsg);
8168}
8169
8170void GLTrace_glMaterialx(GLenum face, GLenum pname, GLfixed param) {
8171    GLMessage glmsg;
8172    GLTraceContext *glContext = getGLTraceContext();
8173
8174    glmsg.set_function(GLMessage::glMaterialx);
8175
8176    // copy argument face
8177    GLMessage_DataType *arg_face = glmsg.add_args();
8178    arg_face->set_isarray(false);
8179    arg_face->set_type(GLMessage::DataType::ENUM);
8180    arg_face->add_intvalue((int)face);
8181
8182    // copy argument pname
8183    GLMessage_DataType *arg_pname = glmsg.add_args();
8184    arg_pname->set_isarray(false);
8185    arg_pname->set_type(GLMessage::DataType::ENUM);
8186    arg_pname->add_intvalue((int)pname);
8187
8188    // copy argument param
8189    GLMessage_DataType *arg_param = glmsg.add_args();
8190    arg_param->set_isarray(false);
8191    arg_param->set_type(GLMessage::DataType::INT);
8192    arg_param->add_intvalue(param);
8193
8194    // call function
8195    glContext->hooks->gl.glMaterialx(face, pname, param);
8196
8197    fixupGLMessage(glContext, &glmsg);
8198    glContext->traceGLMessage(&glmsg);
8199}
8200
8201void GLTrace_glMaterialxv(GLenum face, GLenum pname, const GLfixed *params) {
8202    GLMessage glmsg;
8203    GLTraceContext *glContext = getGLTraceContext();
8204
8205    glmsg.set_function(GLMessage::glMaterialxv);
8206
8207    // copy argument face
8208    GLMessage_DataType *arg_face = glmsg.add_args();
8209    arg_face->set_isarray(false);
8210    arg_face->set_type(GLMessage::DataType::ENUM);
8211    arg_face->add_intvalue((int)face);
8212
8213    // copy argument pname
8214    GLMessage_DataType *arg_pname = glmsg.add_args();
8215    arg_pname->set_isarray(false);
8216    arg_pname->set_type(GLMessage::DataType::ENUM);
8217    arg_pname->add_intvalue((int)pname);
8218
8219    // copy argument params
8220    GLMessage_DataType *arg_params = glmsg.add_args();
8221    arg_params->set_isarray(false);
8222    arg_params->set_type(GLMessage::DataType::INT);
8223    arg_params->add_intvalue((int)params);
8224
8225    // call function
8226    glContext->hooks->gl.glMaterialxv(face, pname, params);
8227
8228    fixupGLMessage(glContext, &glmsg);
8229    glContext->traceGLMessage(&glmsg);
8230}
8231
8232void GLTrace_glMatrixMode(GLenum mode) {
8233    GLMessage glmsg;
8234    GLTraceContext *glContext = getGLTraceContext();
8235
8236    glmsg.set_function(GLMessage::glMatrixMode);
8237
8238    // copy argument mode
8239    GLMessage_DataType *arg_mode = glmsg.add_args();
8240    arg_mode->set_isarray(false);
8241    arg_mode->set_type(GLMessage::DataType::ENUM);
8242    arg_mode->add_intvalue((int)mode);
8243
8244    // call function
8245    glContext->hooks->gl.glMatrixMode(mode);
8246
8247    fixupGLMessage(glContext, &glmsg);
8248    glContext->traceGLMessage(&glmsg);
8249}
8250
8251void GLTrace_glMultMatrixx(const GLfixed *m) {
8252    GLMessage glmsg;
8253    GLTraceContext *glContext = getGLTraceContext();
8254
8255    glmsg.set_function(GLMessage::glMultMatrixx);
8256
8257    // copy argument m
8258    GLMessage_DataType *arg_m = glmsg.add_args();
8259    arg_m->set_isarray(false);
8260    arg_m->set_type(GLMessage::DataType::INT);
8261    arg_m->add_intvalue((int)m);
8262
8263    // call function
8264    glContext->hooks->gl.glMultMatrixx(m);
8265
8266    fixupGLMessage(glContext, &glmsg);
8267    glContext->traceGLMessage(&glmsg);
8268}
8269
8270void GLTrace_glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) {
8271    GLMessage glmsg;
8272    GLTraceContext *glContext = getGLTraceContext();
8273
8274    glmsg.set_function(GLMessage::glMultiTexCoord4x);
8275
8276    // copy argument target
8277    GLMessage_DataType *arg_target = glmsg.add_args();
8278    arg_target->set_isarray(false);
8279    arg_target->set_type(GLMessage::DataType::ENUM);
8280    arg_target->add_intvalue((int)target);
8281
8282    // copy argument s
8283    GLMessage_DataType *arg_s = glmsg.add_args();
8284    arg_s->set_isarray(false);
8285    arg_s->set_type(GLMessage::DataType::INT);
8286    arg_s->add_intvalue(s);
8287
8288    // copy argument t
8289    GLMessage_DataType *arg_t = glmsg.add_args();
8290    arg_t->set_isarray(false);
8291    arg_t->set_type(GLMessage::DataType::INT);
8292    arg_t->add_intvalue(t);
8293
8294    // copy argument r
8295    GLMessage_DataType *arg_r = glmsg.add_args();
8296    arg_r->set_isarray(false);
8297    arg_r->set_type(GLMessage::DataType::INT);
8298    arg_r->add_intvalue(r);
8299
8300    // copy argument q
8301    GLMessage_DataType *arg_q = glmsg.add_args();
8302    arg_q->set_isarray(false);
8303    arg_q->set_type(GLMessage::DataType::INT);
8304    arg_q->add_intvalue(q);
8305
8306    // call function
8307    glContext->hooks->gl.glMultiTexCoord4x(target, s, t, r, q);
8308
8309    fixupGLMessage(glContext, &glmsg);
8310    glContext->traceGLMessage(&glmsg);
8311}
8312
8313void GLTrace_glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz) {
8314    GLMessage glmsg;
8315    GLTraceContext *glContext = getGLTraceContext();
8316
8317    glmsg.set_function(GLMessage::glNormal3x);
8318
8319    // copy argument nx
8320    GLMessage_DataType *arg_nx = glmsg.add_args();
8321    arg_nx->set_isarray(false);
8322    arg_nx->set_type(GLMessage::DataType::INT);
8323    arg_nx->add_intvalue(nx);
8324
8325    // copy argument ny
8326    GLMessage_DataType *arg_ny = glmsg.add_args();
8327    arg_ny->set_isarray(false);
8328    arg_ny->set_type(GLMessage::DataType::INT);
8329    arg_ny->add_intvalue(ny);
8330
8331    // copy argument nz
8332    GLMessage_DataType *arg_nz = glmsg.add_args();
8333    arg_nz->set_isarray(false);
8334    arg_nz->set_type(GLMessage::DataType::INT);
8335    arg_nz->add_intvalue(nz);
8336
8337    // call function
8338    glContext->hooks->gl.glNormal3x(nx, ny, nz);
8339
8340    fixupGLMessage(glContext, &glmsg);
8341    glContext->traceGLMessage(&glmsg);
8342}
8343
8344void GLTrace_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {
8345    GLMessage glmsg;
8346    GLTraceContext *glContext = getGLTraceContext();
8347
8348    glmsg.set_function(GLMessage::glNormalPointer);
8349
8350    // copy argument type
8351    GLMessage_DataType *arg_type = glmsg.add_args();
8352    arg_type->set_isarray(false);
8353    arg_type->set_type(GLMessage::DataType::ENUM);
8354    arg_type->add_intvalue((int)type);
8355
8356    // copy argument stride
8357    GLMessage_DataType *arg_stride = glmsg.add_args();
8358    arg_stride->set_isarray(false);
8359    arg_stride->set_type(GLMessage::DataType::INT);
8360    arg_stride->add_intvalue(stride);
8361
8362    // copy argument pointer
8363    GLMessage_DataType *arg_pointer = glmsg.add_args();
8364    arg_pointer->set_isarray(false);
8365    arg_pointer->set_type(GLMessage::DataType::INT);
8366    arg_pointer->add_intvalue((int)pointer);
8367
8368    // call function
8369    glContext->hooks->gl.glNormalPointer(type, stride, pointer);
8370
8371    fixupGLMessage(glContext, &glmsg);
8372    glContext->traceGLMessage(&glmsg);
8373}
8374
8375void GLTrace_glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) {
8376    GLMessage glmsg;
8377    GLTraceContext *glContext = getGLTraceContext();
8378
8379    glmsg.set_function(GLMessage::glOrthox);
8380
8381    // copy argument left
8382    GLMessage_DataType *arg_left = glmsg.add_args();
8383    arg_left->set_isarray(false);
8384    arg_left->set_type(GLMessage::DataType::INT);
8385    arg_left->add_intvalue(left);
8386
8387    // copy argument right
8388    GLMessage_DataType *arg_right = glmsg.add_args();
8389    arg_right->set_isarray(false);
8390    arg_right->set_type(GLMessage::DataType::INT);
8391    arg_right->add_intvalue(right);
8392
8393    // copy argument bottom
8394    GLMessage_DataType *arg_bottom = glmsg.add_args();
8395    arg_bottom->set_isarray(false);
8396    arg_bottom->set_type(GLMessage::DataType::INT);
8397    arg_bottom->add_intvalue(bottom);
8398
8399    // copy argument top
8400    GLMessage_DataType *arg_top = glmsg.add_args();
8401    arg_top->set_isarray(false);
8402    arg_top->set_type(GLMessage::DataType::INT);
8403    arg_top->add_intvalue(top);
8404
8405    // copy argument zNear
8406    GLMessage_DataType *arg_zNear = glmsg.add_args();
8407    arg_zNear->set_isarray(false);
8408    arg_zNear->set_type(GLMessage::DataType::INT);
8409    arg_zNear->add_intvalue(zNear);
8410
8411    // copy argument zFar
8412    GLMessage_DataType *arg_zFar = glmsg.add_args();
8413    arg_zFar->set_isarray(false);
8414    arg_zFar->set_type(GLMessage::DataType::INT);
8415    arg_zFar->add_intvalue(zFar);
8416
8417    // call function
8418    glContext->hooks->gl.glOrthox(left, right, bottom, top, zNear, zFar);
8419
8420    fixupGLMessage(glContext, &glmsg);
8421    glContext->traceGLMessage(&glmsg);
8422}
8423
8424void GLTrace_glPointParameterx(GLenum pname, GLfixed param) {
8425    GLMessage glmsg;
8426    GLTraceContext *glContext = getGLTraceContext();
8427
8428    glmsg.set_function(GLMessage::glPointParameterx);
8429
8430    // copy argument pname
8431    GLMessage_DataType *arg_pname = glmsg.add_args();
8432    arg_pname->set_isarray(false);
8433    arg_pname->set_type(GLMessage::DataType::ENUM);
8434    arg_pname->add_intvalue((int)pname);
8435
8436    // copy argument param
8437    GLMessage_DataType *arg_param = glmsg.add_args();
8438    arg_param->set_isarray(false);
8439    arg_param->set_type(GLMessage::DataType::INT);
8440    arg_param->add_intvalue(param);
8441
8442    // call function
8443    glContext->hooks->gl.glPointParameterx(pname, param);
8444
8445    fixupGLMessage(glContext, &glmsg);
8446    glContext->traceGLMessage(&glmsg);
8447}
8448
8449void GLTrace_glPointParameterxv(GLenum pname, const GLfixed *params) {
8450    GLMessage glmsg;
8451    GLTraceContext *glContext = getGLTraceContext();
8452
8453    glmsg.set_function(GLMessage::glPointParameterxv);
8454
8455    // copy argument pname
8456    GLMessage_DataType *arg_pname = glmsg.add_args();
8457    arg_pname->set_isarray(false);
8458    arg_pname->set_type(GLMessage::DataType::ENUM);
8459    arg_pname->add_intvalue((int)pname);
8460
8461    // copy argument params
8462    GLMessage_DataType *arg_params = glmsg.add_args();
8463    arg_params->set_isarray(false);
8464    arg_params->set_type(GLMessage::DataType::INT);
8465    arg_params->add_intvalue((int)params);
8466
8467    // call function
8468    glContext->hooks->gl.glPointParameterxv(pname, params);
8469
8470    fixupGLMessage(glContext, &glmsg);
8471    glContext->traceGLMessage(&glmsg);
8472}
8473
8474void GLTrace_glPointSizex(GLfixed size) {
8475    GLMessage glmsg;
8476    GLTraceContext *glContext = getGLTraceContext();
8477
8478    glmsg.set_function(GLMessage::glPointSizex);
8479
8480    // copy argument size
8481    GLMessage_DataType *arg_size = glmsg.add_args();
8482    arg_size->set_isarray(false);
8483    arg_size->set_type(GLMessage::DataType::INT);
8484    arg_size->add_intvalue(size);
8485
8486    // call function
8487    glContext->hooks->gl.glPointSizex(size);
8488
8489    fixupGLMessage(glContext, &glmsg);
8490    glContext->traceGLMessage(&glmsg);
8491}
8492
8493void GLTrace_glPolygonOffsetx(GLfixed factor, GLfixed units) {
8494    GLMessage glmsg;
8495    GLTraceContext *glContext = getGLTraceContext();
8496
8497    glmsg.set_function(GLMessage::glPolygonOffsetx);
8498
8499    // copy argument factor
8500    GLMessage_DataType *arg_factor = glmsg.add_args();
8501    arg_factor->set_isarray(false);
8502    arg_factor->set_type(GLMessage::DataType::INT);
8503    arg_factor->add_intvalue(factor);
8504
8505    // copy argument units
8506    GLMessage_DataType *arg_units = glmsg.add_args();
8507    arg_units->set_isarray(false);
8508    arg_units->set_type(GLMessage::DataType::INT);
8509    arg_units->add_intvalue(units);
8510
8511    // call function
8512    glContext->hooks->gl.glPolygonOffsetx(factor, units);
8513
8514    fixupGLMessage(glContext, &glmsg);
8515    glContext->traceGLMessage(&glmsg);
8516}
8517
8518void GLTrace_glPopMatrix(void) {
8519    GLMessage glmsg;
8520    GLTraceContext *glContext = getGLTraceContext();
8521
8522    glmsg.set_function(GLMessage::glPopMatrix);
8523
8524    // call function
8525    glContext->hooks->gl.glPopMatrix();
8526
8527    fixupGLMessage(glContext, &glmsg);
8528    glContext->traceGLMessage(&glmsg);
8529}
8530
8531void GLTrace_glPushMatrix(void) {
8532    GLMessage glmsg;
8533    GLTraceContext *glContext = getGLTraceContext();
8534
8535    glmsg.set_function(GLMessage::glPushMatrix);
8536
8537    // call function
8538    glContext->hooks->gl.glPushMatrix();
8539
8540    fixupGLMessage(glContext, &glmsg);
8541    glContext->traceGLMessage(&glmsg);
8542}
8543
8544void GLTrace_glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) {
8545    GLMessage glmsg;
8546    GLTraceContext *glContext = getGLTraceContext();
8547
8548    glmsg.set_function(GLMessage::glRotatex);
8549
8550    // copy argument angle
8551    GLMessage_DataType *arg_angle = glmsg.add_args();
8552    arg_angle->set_isarray(false);
8553    arg_angle->set_type(GLMessage::DataType::INT);
8554    arg_angle->add_intvalue(angle);
8555
8556    // copy argument x
8557    GLMessage_DataType *arg_x = glmsg.add_args();
8558    arg_x->set_isarray(false);
8559    arg_x->set_type(GLMessage::DataType::INT);
8560    arg_x->add_intvalue(x);
8561
8562    // copy argument y
8563    GLMessage_DataType *arg_y = glmsg.add_args();
8564    arg_y->set_isarray(false);
8565    arg_y->set_type(GLMessage::DataType::INT);
8566    arg_y->add_intvalue(y);
8567
8568    // copy argument z
8569    GLMessage_DataType *arg_z = glmsg.add_args();
8570    arg_z->set_isarray(false);
8571    arg_z->set_type(GLMessage::DataType::INT);
8572    arg_z->add_intvalue(z);
8573
8574    // call function
8575    glContext->hooks->gl.glRotatex(angle, x, y, z);
8576
8577    fixupGLMessage(glContext, &glmsg);
8578    glContext->traceGLMessage(&glmsg);
8579}
8580
8581void GLTrace_glSampleCoveragex(GLclampx value, GLboolean invert) {
8582    GLMessage glmsg;
8583    GLTraceContext *glContext = getGLTraceContext();
8584
8585    glmsg.set_function(GLMessage::glSampleCoveragex);
8586
8587    // copy argument value
8588    GLMessage_DataType *arg_value = glmsg.add_args();
8589    arg_value->set_isarray(false);
8590    arg_value->set_type(GLMessage::DataType::INT);
8591    arg_value->add_intvalue(value);
8592
8593    // copy argument invert
8594    GLMessage_DataType *arg_invert = glmsg.add_args();
8595    arg_invert->set_isarray(false);
8596    arg_invert->set_type(GLMessage::DataType::BOOL);
8597    arg_invert->add_boolvalue(invert);
8598
8599    // call function
8600    glContext->hooks->gl.glSampleCoveragex(value, invert);
8601
8602    fixupGLMessage(glContext, &glmsg);
8603    glContext->traceGLMessage(&glmsg);
8604}
8605
8606void GLTrace_glScalex(GLfixed x, GLfixed y, GLfixed z) {
8607    GLMessage glmsg;
8608    GLTraceContext *glContext = getGLTraceContext();
8609
8610    glmsg.set_function(GLMessage::glScalex);
8611
8612    // copy argument x
8613    GLMessage_DataType *arg_x = glmsg.add_args();
8614    arg_x->set_isarray(false);
8615    arg_x->set_type(GLMessage::DataType::INT);
8616    arg_x->add_intvalue(x);
8617
8618    // copy argument y
8619    GLMessage_DataType *arg_y = glmsg.add_args();
8620    arg_y->set_isarray(false);
8621    arg_y->set_type(GLMessage::DataType::INT);
8622    arg_y->add_intvalue(y);
8623
8624    // copy argument z
8625    GLMessage_DataType *arg_z = glmsg.add_args();
8626    arg_z->set_isarray(false);
8627    arg_z->set_type(GLMessage::DataType::INT);
8628    arg_z->add_intvalue(z);
8629
8630    // call function
8631    glContext->hooks->gl.glScalex(x, y, z);
8632
8633    fixupGLMessage(glContext, &glmsg);
8634    glContext->traceGLMessage(&glmsg);
8635}
8636
8637void GLTrace_glShadeModel(GLenum mode) {
8638    GLMessage glmsg;
8639    GLTraceContext *glContext = getGLTraceContext();
8640
8641    glmsg.set_function(GLMessage::glShadeModel);
8642
8643    // copy argument mode
8644    GLMessage_DataType *arg_mode = glmsg.add_args();
8645    arg_mode->set_isarray(false);
8646    arg_mode->set_type(GLMessage::DataType::ENUM);
8647    arg_mode->add_intvalue((int)mode);
8648
8649    // call function
8650    glContext->hooks->gl.glShadeModel(mode);
8651
8652    fixupGLMessage(glContext, &glmsg);
8653    glContext->traceGLMessage(&glmsg);
8654}
8655
8656void GLTrace_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
8657    GLMessage glmsg;
8658    GLTraceContext *glContext = getGLTraceContext();
8659
8660    glmsg.set_function(GLMessage::glTexCoordPointer);
8661
8662    // copy argument size
8663    GLMessage_DataType *arg_size = glmsg.add_args();
8664    arg_size->set_isarray(false);
8665    arg_size->set_type(GLMessage::DataType::INT);
8666    arg_size->add_intvalue(size);
8667
8668    // copy argument type
8669    GLMessage_DataType *arg_type = glmsg.add_args();
8670    arg_type->set_isarray(false);
8671    arg_type->set_type(GLMessage::DataType::ENUM);
8672    arg_type->add_intvalue((int)type);
8673
8674    // copy argument stride
8675    GLMessage_DataType *arg_stride = glmsg.add_args();
8676    arg_stride->set_isarray(false);
8677    arg_stride->set_type(GLMessage::DataType::INT);
8678    arg_stride->add_intvalue(stride);
8679
8680    // copy argument pointer
8681    GLMessage_DataType *arg_pointer = glmsg.add_args();
8682    arg_pointer->set_isarray(false);
8683    arg_pointer->set_type(GLMessage::DataType::INT);
8684    arg_pointer->add_intvalue((int)pointer);
8685
8686    // call function
8687    glContext->hooks->gl.glTexCoordPointer(size, type, stride, pointer);
8688
8689    fixupGLMessage(glContext, &glmsg);
8690    glContext->traceGLMessage(&glmsg);
8691}
8692
8693void GLTrace_glTexEnvi(GLenum target, GLenum pname, GLint param) {
8694    GLMessage glmsg;
8695    GLTraceContext *glContext = getGLTraceContext();
8696
8697    glmsg.set_function(GLMessage::glTexEnvi);
8698
8699    // copy argument target
8700    GLMessage_DataType *arg_target = glmsg.add_args();
8701    arg_target->set_isarray(false);
8702    arg_target->set_type(GLMessage::DataType::ENUM);
8703    arg_target->add_intvalue((int)target);
8704
8705    // copy argument pname
8706    GLMessage_DataType *arg_pname = glmsg.add_args();
8707    arg_pname->set_isarray(false);
8708    arg_pname->set_type(GLMessage::DataType::ENUM);
8709    arg_pname->add_intvalue((int)pname);
8710
8711    // copy argument param
8712    GLMessage_DataType *arg_param = glmsg.add_args();
8713    arg_param->set_isarray(false);
8714    arg_param->set_type(GLMessage::DataType::INT);
8715    arg_param->add_intvalue(param);
8716
8717    // call function
8718    glContext->hooks->gl.glTexEnvi(target, pname, param);
8719
8720    fixupGLMessage(glContext, &glmsg);
8721    glContext->traceGLMessage(&glmsg);
8722}
8723
8724void GLTrace_glTexEnvx(GLenum target, GLenum pname, GLfixed param) {
8725    GLMessage glmsg;
8726    GLTraceContext *glContext = getGLTraceContext();
8727
8728    glmsg.set_function(GLMessage::glTexEnvx);
8729
8730    // copy argument target
8731    GLMessage_DataType *arg_target = glmsg.add_args();
8732    arg_target->set_isarray(false);
8733    arg_target->set_type(GLMessage::DataType::ENUM);
8734    arg_target->add_intvalue((int)target);
8735
8736    // copy argument pname
8737    GLMessage_DataType *arg_pname = glmsg.add_args();
8738    arg_pname->set_isarray(false);
8739    arg_pname->set_type(GLMessage::DataType::ENUM);
8740    arg_pname->add_intvalue((int)pname);
8741
8742    // copy argument param
8743    GLMessage_DataType *arg_param = glmsg.add_args();
8744    arg_param->set_isarray(false);
8745    arg_param->set_type(GLMessage::DataType::INT);
8746    arg_param->add_intvalue(param);
8747
8748    // call function
8749    glContext->hooks->gl.glTexEnvx(target, pname, param);
8750
8751    fixupGLMessage(glContext, &glmsg);
8752    glContext->traceGLMessage(&glmsg);
8753}
8754
8755void GLTrace_glTexEnviv(GLenum target, GLenum pname, const GLint *params) {
8756    GLMessage glmsg;
8757    GLTraceContext *glContext = getGLTraceContext();
8758
8759    glmsg.set_function(GLMessage::glTexEnviv);
8760
8761    // copy argument target
8762    GLMessage_DataType *arg_target = glmsg.add_args();
8763    arg_target->set_isarray(false);
8764    arg_target->set_type(GLMessage::DataType::ENUM);
8765    arg_target->add_intvalue((int)target);
8766
8767    // copy argument pname
8768    GLMessage_DataType *arg_pname = glmsg.add_args();
8769    arg_pname->set_isarray(false);
8770    arg_pname->set_type(GLMessage::DataType::ENUM);
8771    arg_pname->add_intvalue((int)pname);
8772
8773    // copy argument params
8774    GLMessage_DataType *arg_params = glmsg.add_args();
8775    arg_params->set_isarray(false);
8776    arg_params->set_type(GLMessage::DataType::INT);
8777    arg_params->add_intvalue((int)params);
8778
8779    // call function
8780    glContext->hooks->gl.glTexEnviv(target, pname, params);
8781
8782    fixupGLMessage(glContext, &glmsg);
8783    glContext->traceGLMessage(&glmsg);
8784}
8785
8786void GLTrace_glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params) {
8787    GLMessage glmsg;
8788    GLTraceContext *glContext = getGLTraceContext();
8789
8790    glmsg.set_function(GLMessage::glTexEnvxv);
8791
8792    // copy argument target
8793    GLMessage_DataType *arg_target = glmsg.add_args();
8794    arg_target->set_isarray(false);
8795    arg_target->set_type(GLMessage::DataType::ENUM);
8796    arg_target->add_intvalue((int)target);
8797
8798    // copy argument pname
8799    GLMessage_DataType *arg_pname = glmsg.add_args();
8800    arg_pname->set_isarray(false);
8801    arg_pname->set_type(GLMessage::DataType::ENUM);
8802    arg_pname->add_intvalue((int)pname);
8803
8804    // copy argument params
8805    GLMessage_DataType *arg_params = glmsg.add_args();
8806    arg_params->set_isarray(false);
8807    arg_params->set_type(GLMessage::DataType::INT);
8808    arg_params->add_intvalue((int)params);
8809
8810    // call function
8811    glContext->hooks->gl.glTexEnvxv(target, pname, params);
8812
8813    fixupGLMessage(glContext, &glmsg);
8814    glContext->traceGLMessage(&glmsg);
8815}
8816
8817void GLTrace_glTexParameterx(GLenum target, GLenum pname, GLfixed param) {
8818    GLMessage glmsg;
8819    GLTraceContext *glContext = getGLTraceContext();
8820
8821    glmsg.set_function(GLMessage::glTexParameterx);
8822
8823    // copy argument target
8824    GLMessage_DataType *arg_target = glmsg.add_args();
8825    arg_target->set_isarray(false);
8826    arg_target->set_type(GLMessage::DataType::ENUM);
8827    arg_target->add_intvalue((int)target);
8828
8829    // copy argument pname
8830    GLMessage_DataType *arg_pname = glmsg.add_args();
8831    arg_pname->set_isarray(false);
8832    arg_pname->set_type(GLMessage::DataType::ENUM);
8833    arg_pname->add_intvalue((int)pname);
8834
8835    // copy argument param
8836    GLMessage_DataType *arg_param = glmsg.add_args();
8837    arg_param->set_isarray(false);
8838    arg_param->set_type(GLMessage::DataType::INT);
8839    arg_param->add_intvalue(param);
8840
8841    // call function
8842    glContext->hooks->gl.glTexParameterx(target, pname, param);
8843
8844    fixupGLMessage(glContext, &glmsg);
8845    glContext->traceGLMessage(&glmsg);
8846}
8847
8848void GLTrace_glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params) {
8849    GLMessage glmsg;
8850    GLTraceContext *glContext = getGLTraceContext();
8851
8852    glmsg.set_function(GLMessage::glTexParameterxv);
8853
8854    // copy argument target
8855    GLMessage_DataType *arg_target = glmsg.add_args();
8856    arg_target->set_isarray(false);
8857    arg_target->set_type(GLMessage::DataType::ENUM);
8858    arg_target->add_intvalue((int)target);
8859
8860    // copy argument pname
8861    GLMessage_DataType *arg_pname = glmsg.add_args();
8862    arg_pname->set_isarray(false);
8863    arg_pname->set_type(GLMessage::DataType::ENUM);
8864    arg_pname->add_intvalue((int)pname);
8865
8866    // copy argument params
8867    GLMessage_DataType *arg_params = glmsg.add_args();
8868    arg_params->set_isarray(false);
8869    arg_params->set_type(GLMessage::DataType::INT);
8870    arg_params->add_intvalue((int)params);
8871
8872    // call function
8873    glContext->hooks->gl.glTexParameterxv(target, pname, params);
8874
8875    fixupGLMessage(glContext, &glmsg);
8876    glContext->traceGLMessage(&glmsg);
8877}
8878
8879void GLTrace_glTranslatex(GLfixed x, GLfixed y, GLfixed z) {
8880    GLMessage glmsg;
8881    GLTraceContext *glContext = getGLTraceContext();
8882
8883    glmsg.set_function(GLMessage::glTranslatex);
8884
8885    // copy argument x
8886    GLMessage_DataType *arg_x = glmsg.add_args();
8887    arg_x->set_isarray(false);
8888    arg_x->set_type(GLMessage::DataType::INT);
8889    arg_x->add_intvalue(x);
8890
8891    // copy argument y
8892    GLMessage_DataType *arg_y = glmsg.add_args();
8893    arg_y->set_isarray(false);
8894    arg_y->set_type(GLMessage::DataType::INT);
8895    arg_y->add_intvalue(y);
8896
8897    // copy argument z
8898    GLMessage_DataType *arg_z = glmsg.add_args();
8899    arg_z->set_isarray(false);
8900    arg_z->set_type(GLMessage::DataType::INT);
8901    arg_z->add_intvalue(z);
8902
8903    // call function
8904    glContext->hooks->gl.glTranslatex(x, y, z);
8905
8906    fixupGLMessage(glContext, &glmsg);
8907    glContext->traceGLMessage(&glmsg);
8908}
8909
8910void GLTrace_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
8911    GLMessage glmsg;
8912    GLTraceContext *glContext = getGLTraceContext();
8913
8914    glmsg.set_function(GLMessage::glVertexPointer);
8915
8916    // copy argument size
8917    GLMessage_DataType *arg_size = glmsg.add_args();
8918    arg_size->set_isarray(false);
8919    arg_size->set_type(GLMessage::DataType::INT);
8920    arg_size->add_intvalue(size);
8921
8922    // copy argument type
8923    GLMessage_DataType *arg_type = glmsg.add_args();
8924    arg_type->set_isarray(false);
8925    arg_type->set_type(GLMessage::DataType::ENUM);
8926    arg_type->add_intvalue((int)type);
8927
8928    // copy argument stride
8929    GLMessage_DataType *arg_stride = glmsg.add_args();
8930    arg_stride->set_isarray(false);
8931    arg_stride->set_type(GLMessage::DataType::INT);
8932    arg_stride->add_intvalue(stride);
8933
8934    // copy argument pointer
8935    GLMessage_DataType *arg_pointer = glmsg.add_args();
8936    arg_pointer->set_isarray(false);
8937    arg_pointer->set_type(GLMessage::DataType::INT);
8938    arg_pointer->add_intvalue((int)pointer);
8939
8940    // call function
8941    glContext->hooks->gl.glVertexPointer(size, type, stride, pointer);
8942
8943    fixupGLMessage(glContext, &glmsg);
8944    glContext->traceGLMessage(&glmsg);
8945}
8946
8947void GLTrace_glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer) {
8948    GLMessage glmsg;
8949    GLTraceContext *glContext = getGLTraceContext();
8950
8951    glmsg.set_function(GLMessage::glPointSizePointerOES);
8952
8953    // copy argument type
8954    GLMessage_DataType *arg_type = glmsg.add_args();
8955    arg_type->set_isarray(false);
8956    arg_type->set_type(GLMessage::DataType::ENUM);
8957    arg_type->add_intvalue((int)type);
8958
8959    // copy argument stride
8960    GLMessage_DataType *arg_stride = glmsg.add_args();
8961    arg_stride->set_isarray(false);
8962    arg_stride->set_type(GLMessage::DataType::INT);
8963    arg_stride->add_intvalue(stride);
8964
8965    // copy argument pointer
8966    GLMessage_DataType *arg_pointer = glmsg.add_args();
8967    arg_pointer->set_isarray(false);
8968    arg_pointer->set_type(GLMessage::DataType::INT);
8969    arg_pointer->add_intvalue((int)pointer);
8970
8971    // call function
8972    glContext->hooks->gl.glPointSizePointerOES(type, stride, pointer);
8973
8974    fixupGLMessage(glContext, &glmsg);
8975    glContext->traceGLMessage(&glmsg);
8976}
8977
8978
8979// Definitions for GL1Ext APIs
8980
8981void GLTrace_glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha) {
8982    GLMessage glmsg;
8983    GLTraceContext *glContext = getGLTraceContext();
8984
8985    glmsg.set_function(GLMessage::glBlendEquationSeparateOES);
8986
8987    // copy argument modeRGB
8988    GLMessage_DataType *arg_modeRGB = glmsg.add_args();
8989    arg_modeRGB->set_isarray(false);
8990    arg_modeRGB->set_type(GLMessage::DataType::ENUM);
8991    arg_modeRGB->add_intvalue((int)modeRGB);
8992
8993    // copy argument modeAlpha
8994    GLMessage_DataType *arg_modeAlpha = glmsg.add_args();
8995    arg_modeAlpha->set_isarray(false);
8996    arg_modeAlpha->set_type(GLMessage::DataType::ENUM);
8997    arg_modeAlpha->add_intvalue((int)modeAlpha);
8998
8999    // call function
9000    glContext->hooks->gl.glBlendEquationSeparateOES(modeRGB, modeAlpha);
9001
9002    fixupGLMessage(glContext, &glmsg);
9003    glContext->traceGLMessage(&glmsg);
9004}
9005
9006void GLTrace_glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
9007    GLMessage glmsg;
9008    GLTraceContext *glContext = getGLTraceContext();
9009
9010    glmsg.set_function(GLMessage::glBlendFuncSeparateOES);
9011
9012    // copy argument srcRGB
9013    GLMessage_DataType *arg_srcRGB = glmsg.add_args();
9014    arg_srcRGB->set_isarray(false);
9015    arg_srcRGB->set_type(GLMessage::DataType::ENUM);
9016    arg_srcRGB->add_intvalue((int)srcRGB);
9017
9018    // copy argument dstRGB
9019    GLMessage_DataType *arg_dstRGB = glmsg.add_args();
9020    arg_dstRGB->set_isarray(false);
9021    arg_dstRGB->set_type(GLMessage::DataType::ENUM);
9022    arg_dstRGB->add_intvalue((int)dstRGB);
9023
9024    // copy argument srcAlpha
9025    GLMessage_DataType *arg_srcAlpha = glmsg.add_args();
9026    arg_srcAlpha->set_isarray(false);
9027    arg_srcAlpha->set_type(GLMessage::DataType::ENUM);
9028    arg_srcAlpha->add_intvalue((int)srcAlpha);
9029
9030    // copy argument dstAlpha
9031    GLMessage_DataType *arg_dstAlpha = glmsg.add_args();
9032    arg_dstAlpha->set_isarray(false);
9033    arg_dstAlpha->set_type(GLMessage::DataType::ENUM);
9034    arg_dstAlpha->add_intvalue((int)dstAlpha);
9035
9036    // call function
9037    glContext->hooks->gl.glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
9038
9039    fixupGLMessage(glContext, &glmsg);
9040    glContext->traceGLMessage(&glmsg);
9041}
9042
9043void GLTrace_glBlendEquationOES(GLenum mode) {
9044    GLMessage glmsg;
9045    GLTraceContext *glContext = getGLTraceContext();
9046
9047    glmsg.set_function(GLMessage::glBlendEquationOES);
9048
9049    // copy argument mode
9050    GLMessage_DataType *arg_mode = glmsg.add_args();
9051    arg_mode->set_isarray(false);
9052    arg_mode->set_type(GLMessage::DataType::ENUM);
9053    arg_mode->add_intvalue((int)mode);
9054
9055    // call function
9056    glContext->hooks->gl.glBlendEquationOES(mode);
9057
9058    fixupGLMessage(glContext, &glmsg);
9059    glContext->traceGLMessage(&glmsg);
9060}
9061
9062void GLTrace_glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) {
9063    GLMessage glmsg;
9064    GLTraceContext *glContext = getGLTraceContext();
9065
9066    glmsg.set_function(GLMessage::glDrawTexsOES);
9067
9068    // copy argument x
9069    GLMessage_DataType *arg_x = glmsg.add_args();
9070    arg_x->set_isarray(false);
9071    arg_x->set_type(GLMessage::DataType::INT);
9072    arg_x->add_intvalue(x);
9073
9074    // copy argument y
9075    GLMessage_DataType *arg_y = glmsg.add_args();
9076    arg_y->set_isarray(false);
9077    arg_y->set_type(GLMessage::DataType::INT);
9078    arg_y->add_intvalue(y);
9079
9080    // copy argument z
9081    GLMessage_DataType *arg_z = glmsg.add_args();
9082    arg_z->set_isarray(false);
9083    arg_z->set_type(GLMessage::DataType::INT);
9084    arg_z->add_intvalue(z);
9085
9086    // copy argument width
9087    GLMessage_DataType *arg_width = glmsg.add_args();
9088    arg_width->set_isarray(false);
9089    arg_width->set_type(GLMessage::DataType::INT);
9090    arg_width->add_intvalue(width);
9091
9092    // copy argument height
9093    GLMessage_DataType *arg_height = glmsg.add_args();
9094    arg_height->set_isarray(false);
9095    arg_height->set_type(GLMessage::DataType::INT);
9096    arg_height->add_intvalue(height);
9097
9098    // call function
9099    glContext->hooks->gl.glDrawTexsOES(x, y, z, width, height);
9100
9101    fixupGLMessage(glContext, &glmsg);
9102    glContext->traceGLMessage(&glmsg);
9103}
9104
9105void GLTrace_glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height) {
9106    GLMessage glmsg;
9107    GLTraceContext *glContext = getGLTraceContext();
9108
9109    glmsg.set_function(GLMessage::glDrawTexiOES);
9110
9111    // copy argument x
9112    GLMessage_DataType *arg_x = glmsg.add_args();
9113    arg_x->set_isarray(false);
9114    arg_x->set_type(GLMessage::DataType::INT);
9115    arg_x->add_intvalue(x);
9116
9117    // copy argument y
9118    GLMessage_DataType *arg_y = glmsg.add_args();
9119    arg_y->set_isarray(false);
9120    arg_y->set_type(GLMessage::DataType::INT);
9121    arg_y->add_intvalue(y);
9122
9123    // copy argument z
9124    GLMessage_DataType *arg_z = glmsg.add_args();
9125    arg_z->set_isarray(false);
9126    arg_z->set_type(GLMessage::DataType::INT);
9127    arg_z->add_intvalue(z);
9128
9129    // copy argument width
9130    GLMessage_DataType *arg_width = glmsg.add_args();
9131    arg_width->set_isarray(false);
9132    arg_width->set_type(GLMessage::DataType::INT);
9133    arg_width->add_intvalue(width);
9134
9135    // copy argument height
9136    GLMessage_DataType *arg_height = glmsg.add_args();
9137    arg_height->set_isarray(false);
9138    arg_height->set_type(GLMessage::DataType::INT);
9139    arg_height->add_intvalue(height);
9140
9141    // call function
9142    glContext->hooks->gl.glDrawTexiOES(x, y, z, width, height);
9143
9144    fixupGLMessage(glContext, &glmsg);
9145    glContext->traceGLMessage(&glmsg);
9146}
9147
9148void GLTrace_glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) {
9149    GLMessage glmsg;
9150    GLTraceContext *glContext = getGLTraceContext();
9151
9152    glmsg.set_function(GLMessage::glDrawTexxOES);
9153
9154    // copy argument x
9155    GLMessage_DataType *arg_x = glmsg.add_args();
9156    arg_x->set_isarray(false);
9157    arg_x->set_type(GLMessage::DataType::INT);
9158    arg_x->add_intvalue(x);
9159
9160    // copy argument y
9161    GLMessage_DataType *arg_y = glmsg.add_args();
9162    arg_y->set_isarray(false);
9163    arg_y->set_type(GLMessage::DataType::INT);
9164    arg_y->add_intvalue(y);
9165
9166    // copy argument z
9167    GLMessage_DataType *arg_z = glmsg.add_args();
9168    arg_z->set_isarray(false);
9169    arg_z->set_type(GLMessage::DataType::INT);
9170    arg_z->add_intvalue(z);
9171
9172    // copy argument width
9173    GLMessage_DataType *arg_width = glmsg.add_args();
9174    arg_width->set_isarray(false);
9175    arg_width->set_type(GLMessage::DataType::INT);
9176    arg_width->add_intvalue(width);
9177
9178    // copy argument height
9179    GLMessage_DataType *arg_height = glmsg.add_args();
9180    arg_height->set_isarray(false);
9181    arg_height->set_type(GLMessage::DataType::INT);
9182    arg_height->add_intvalue(height);
9183
9184    // call function
9185    glContext->hooks->gl.glDrawTexxOES(x, y, z, width, height);
9186
9187    fixupGLMessage(glContext, &glmsg);
9188    glContext->traceGLMessage(&glmsg);
9189}
9190
9191void GLTrace_glDrawTexsvOES(const GLshort *coords) {
9192    GLMessage glmsg;
9193    GLTraceContext *glContext = getGLTraceContext();
9194
9195    glmsg.set_function(GLMessage::glDrawTexsvOES);
9196
9197    // copy argument coords
9198    GLMessage_DataType *arg_coords = glmsg.add_args();
9199    arg_coords->set_isarray(false);
9200    arg_coords->set_type(GLMessage::DataType::INT);
9201    arg_coords->add_intvalue((int)coords);
9202
9203    // call function
9204    glContext->hooks->gl.glDrawTexsvOES(coords);
9205
9206    fixupGLMessage(glContext, &glmsg);
9207    glContext->traceGLMessage(&glmsg);
9208}
9209
9210void GLTrace_glDrawTexivOES(const GLint *coords) {
9211    GLMessage glmsg;
9212    GLTraceContext *glContext = getGLTraceContext();
9213
9214    glmsg.set_function(GLMessage::glDrawTexivOES);
9215
9216    // copy argument coords
9217    GLMessage_DataType *arg_coords = glmsg.add_args();
9218    arg_coords->set_isarray(false);
9219    arg_coords->set_type(GLMessage::DataType::INT);
9220    arg_coords->add_intvalue((int)coords);
9221
9222    // call function
9223    glContext->hooks->gl.glDrawTexivOES(coords);
9224
9225    fixupGLMessage(glContext, &glmsg);
9226    glContext->traceGLMessage(&glmsg);
9227}
9228
9229void GLTrace_glDrawTexxvOES(const GLfixed *coords) {
9230    GLMessage glmsg;
9231    GLTraceContext *glContext = getGLTraceContext();
9232
9233    glmsg.set_function(GLMessage::glDrawTexxvOES);
9234
9235    // copy argument coords
9236    GLMessage_DataType *arg_coords = glmsg.add_args();
9237    arg_coords->set_isarray(false);
9238    arg_coords->set_type(GLMessage::DataType::INT);
9239    arg_coords->add_intvalue((int)coords);
9240
9241    // call function
9242    glContext->hooks->gl.glDrawTexxvOES(coords);
9243
9244    fixupGLMessage(glContext, &glmsg);
9245    glContext->traceGLMessage(&glmsg);
9246}
9247
9248void GLTrace_glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) {
9249    GLMessage glmsg;
9250    GLTraceContext *glContext = getGLTraceContext();
9251
9252    glmsg.set_function(GLMessage::glDrawTexfOES);
9253
9254    // copy argument x
9255    GLMessage_DataType *arg_x = glmsg.add_args();
9256    arg_x->set_isarray(false);
9257    arg_x->set_type(GLMessage::DataType::FLOAT);
9258    arg_x->add_floatvalue(x);
9259
9260    // copy argument y
9261    GLMessage_DataType *arg_y = glmsg.add_args();
9262    arg_y->set_isarray(false);
9263    arg_y->set_type(GLMessage::DataType::FLOAT);
9264    arg_y->add_floatvalue(y);
9265
9266    // copy argument z
9267    GLMessage_DataType *arg_z = glmsg.add_args();
9268    arg_z->set_isarray(false);
9269    arg_z->set_type(GLMessage::DataType::FLOAT);
9270    arg_z->add_floatvalue(z);
9271
9272    // copy argument width
9273    GLMessage_DataType *arg_width = glmsg.add_args();
9274    arg_width->set_isarray(false);
9275    arg_width->set_type(GLMessage::DataType::FLOAT);
9276    arg_width->add_floatvalue(width);
9277
9278    // copy argument height
9279    GLMessage_DataType *arg_height = glmsg.add_args();
9280    arg_height->set_isarray(false);
9281    arg_height->set_type(GLMessage::DataType::FLOAT);
9282    arg_height->add_floatvalue(height);
9283
9284    // call function
9285    glContext->hooks->gl.glDrawTexfOES(x, y, z, width, height);
9286
9287    fixupGLMessage(glContext, &glmsg);
9288    glContext->traceGLMessage(&glmsg);
9289}
9290
9291void GLTrace_glDrawTexfvOES(const GLfloat *coords) {
9292    GLMessage glmsg;
9293    GLTraceContext *glContext = getGLTraceContext();
9294
9295    glmsg.set_function(GLMessage::glDrawTexfvOES);
9296
9297    // copy argument coords
9298    GLMessage_DataType *arg_coords = glmsg.add_args();
9299    arg_coords->set_isarray(false);
9300    arg_coords->set_type(GLMessage::DataType::INT);
9301    arg_coords->add_intvalue((int)coords);
9302
9303    // call function
9304    glContext->hooks->gl.glDrawTexfvOES(coords);
9305
9306    fixupGLMessage(glContext, &glmsg);
9307    glContext->traceGLMessage(&glmsg);
9308}
9309
9310void GLTrace_glAlphaFuncxOES(GLenum func, GLclampx ref) {
9311    GLMessage glmsg;
9312    GLTraceContext *glContext = getGLTraceContext();
9313
9314    glmsg.set_function(GLMessage::glAlphaFuncxOES);
9315
9316    // copy argument func
9317    GLMessage_DataType *arg_func = glmsg.add_args();
9318    arg_func->set_isarray(false);
9319    arg_func->set_type(GLMessage::DataType::ENUM);
9320    arg_func->add_intvalue((int)func);
9321
9322    // copy argument ref
9323    GLMessage_DataType *arg_ref = glmsg.add_args();
9324    arg_ref->set_isarray(false);
9325    arg_ref->set_type(GLMessage::DataType::INT);
9326    arg_ref->add_intvalue(ref);
9327
9328    // call function
9329    glContext->hooks->gl.glAlphaFuncxOES(func, ref);
9330
9331    fixupGLMessage(glContext, &glmsg);
9332    glContext->traceGLMessage(&glmsg);
9333}
9334
9335void GLTrace_glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
9336    GLMessage glmsg;
9337    GLTraceContext *glContext = getGLTraceContext();
9338
9339    glmsg.set_function(GLMessage::glClearColorxOES);
9340
9341    // copy argument red
9342    GLMessage_DataType *arg_red = glmsg.add_args();
9343    arg_red->set_isarray(false);
9344    arg_red->set_type(GLMessage::DataType::INT);
9345    arg_red->add_intvalue(red);
9346
9347    // copy argument green
9348    GLMessage_DataType *arg_green = glmsg.add_args();
9349    arg_green->set_isarray(false);
9350    arg_green->set_type(GLMessage::DataType::INT);
9351    arg_green->add_intvalue(green);
9352
9353    // copy argument blue
9354    GLMessage_DataType *arg_blue = glmsg.add_args();
9355    arg_blue->set_isarray(false);
9356    arg_blue->set_type(GLMessage::DataType::INT);
9357    arg_blue->add_intvalue(blue);
9358
9359    // copy argument alpha
9360    GLMessage_DataType *arg_alpha = glmsg.add_args();
9361    arg_alpha->set_isarray(false);
9362    arg_alpha->set_type(GLMessage::DataType::INT);
9363    arg_alpha->add_intvalue(alpha);
9364
9365    // call function
9366    glContext->hooks->gl.glClearColorxOES(red, green, blue, alpha);
9367
9368    fixupGLMessage(glContext, &glmsg);
9369    glContext->traceGLMessage(&glmsg);
9370}
9371
9372void GLTrace_glClearDepthxOES(GLclampx depth) {
9373    GLMessage glmsg;
9374    GLTraceContext *glContext = getGLTraceContext();
9375
9376    glmsg.set_function(GLMessage::glClearDepthxOES);
9377
9378    // copy argument depth
9379    GLMessage_DataType *arg_depth = glmsg.add_args();
9380    arg_depth->set_isarray(false);
9381    arg_depth->set_type(GLMessage::DataType::INT);
9382    arg_depth->add_intvalue(depth);
9383
9384    // call function
9385    glContext->hooks->gl.glClearDepthxOES(depth);
9386
9387    fixupGLMessage(glContext, &glmsg);
9388    glContext->traceGLMessage(&glmsg);
9389}
9390
9391void GLTrace_glClipPlanexOES(GLenum plane, const GLfixed *equation) {
9392    GLMessage glmsg;
9393    GLTraceContext *glContext = getGLTraceContext();
9394
9395    glmsg.set_function(GLMessage::glClipPlanexOES);
9396
9397    // copy argument plane
9398    GLMessage_DataType *arg_plane = glmsg.add_args();
9399    arg_plane->set_isarray(false);
9400    arg_plane->set_type(GLMessage::DataType::ENUM);
9401    arg_plane->add_intvalue((int)plane);
9402
9403    // copy argument equation
9404    GLMessage_DataType *arg_equation = glmsg.add_args();
9405    arg_equation->set_isarray(false);
9406    arg_equation->set_type(GLMessage::DataType::INT);
9407    arg_equation->add_intvalue((int)equation);
9408
9409    // call function
9410    glContext->hooks->gl.glClipPlanexOES(plane, equation);
9411
9412    fixupGLMessage(glContext, &glmsg);
9413    glContext->traceGLMessage(&glmsg);
9414}
9415
9416void GLTrace_glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) {
9417    GLMessage glmsg;
9418    GLTraceContext *glContext = getGLTraceContext();
9419
9420    glmsg.set_function(GLMessage::glColor4xOES);
9421
9422    // copy argument red
9423    GLMessage_DataType *arg_red = glmsg.add_args();
9424    arg_red->set_isarray(false);
9425    arg_red->set_type(GLMessage::DataType::INT);
9426    arg_red->add_intvalue(red);
9427
9428    // copy argument green
9429    GLMessage_DataType *arg_green = glmsg.add_args();
9430    arg_green->set_isarray(false);
9431    arg_green->set_type(GLMessage::DataType::INT);
9432    arg_green->add_intvalue(green);
9433
9434    // copy argument blue
9435    GLMessage_DataType *arg_blue = glmsg.add_args();
9436    arg_blue->set_isarray(false);
9437    arg_blue->set_type(GLMessage::DataType::INT);
9438    arg_blue->add_intvalue(blue);
9439
9440    // copy argument alpha
9441    GLMessage_DataType *arg_alpha = glmsg.add_args();
9442    arg_alpha->set_isarray(false);
9443    arg_alpha->set_type(GLMessage::DataType::INT);
9444    arg_alpha->add_intvalue(alpha);
9445
9446    // call function
9447    glContext->hooks->gl.glColor4xOES(red, green, blue, alpha);
9448
9449    fixupGLMessage(glContext, &glmsg);
9450    glContext->traceGLMessage(&glmsg);
9451}
9452
9453void GLTrace_glDepthRangexOES(GLclampx zNear, GLclampx zFar) {
9454    GLMessage glmsg;
9455    GLTraceContext *glContext = getGLTraceContext();
9456
9457    glmsg.set_function(GLMessage::glDepthRangexOES);
9458
9459    // copy argument zNear
9460    GLMessage_DataType *arg_zNear = glmsg.add_args();
9461    arg_zNear->set_isarray(false);
9462    arg_zNear->set_type(GLMessage::DataType::INT);
9463    arg_zNear->add_intvalue(zNear);
9464
9465    // copy argument zFar
9466    GLMessage_DataType *arg_zFar = glmsg.add_args();
9467    arg_zFar->set_isarray(false);
9468    arg_zFar->set_type(GLMessage::DataType::INT);
9469    arg_zFar->add_intvalue(zFar);
9470
9471    // call function
9472    glContext->hooks->gl.glDepthRangexOES(zNear, zFar);
9473
9474    fixupGLMessage(glContext, &glmsg);
9475    glContext->traceGLMessage(&glmsg);
9476}
9477
9478void GLTrace_glFogxOES(GLenum pname, GLfixed param) {
9479    GLMessage glmsg;
9480    GLTraceContext *glContext = getGLTraceContext();
9481
9482    glmsg.set_function(GLMessage::glFogxOES);
9483
9484    // copy argument pname
9485    GLMessage_DataType *arg_pname = glmsg.add_args();
9486    arg_pname->set_isarray(false);
9487    arg_pname->set_type(GLMessage::DataType::ENUM);
9488    arg_pname->add_intvalue((int)pname);
9489
9490    // copy argument param
9491    GLMessage_DataType *arg_param = glmsg.add_args();
9492    arg_param->set_isarray(false);
9493    arg_param->set_type(GLMessage::DataType::INT);
9494    arg_param->add_intvalue(param);
9495
9496    // call function
9497    glContext->hooks->gl.glFogxOES(pname, param);
9498
9499    fixupGLMessage(glContext, &glmsg);
9500    glContext->traceGLMessage(&glmsg);
9501}
9502
9503void GLTrace_glFogxvOES(GLenum pname, const GLfixed *params) {
9504    GLMessage glmsg;
9505    GLTraceContext *glContext = getGLTraceContext();
9506
9507    glmsg.set_function(GLMessage::glFogxvOES);
9508
9509    // copy argument pname
9510    GLMessage_DataType *arg_pname = glmsg.add_args();
9511    arg_pname->set_isarray(false);
9512    arg_pname->set_type(GLMessage::DataType::ENUM);
9513    arg_pname->add_intvalue((int)pname);
9514
9515    // copy argument params
9516    GLMessage_DataType *arg_params = glmsg.add_args();
9517    arg_params->set_isarray(false);
9518    arg_params->set_type(GLMessage::DataType::INT);
9519    arg_params->add_intvalue((int)params);
9520
9521    // call function
9522    glContext->hooks->gl.glFogxvOES(pname, params);
9523
9524    fixupGLMessage(glContext, &glmsg);
9525    glContext->traceGLMessage(&glmsg);
9526}
9527
9528void GLTrace_glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) {
9529    GLMessage glmsg;
9530    GLTraceContext *glContext = getGLTraceContext();
9531
9532    glmsg.set_function(GLMessage::glFrustumxOES);
9533
9534    // copy argument left
9535    GLMessage_DataType *arg_left = glmsg.add_args();
9536    arg_left->set_isarray(false);
9537    arg_left->set_type(GLMessage::DataType::INT);
9538    arg_left->add_intvalue(left);
9539
9540    // copy argument right
9541    GLMessage_DataType *arg_right = glmsg.add_args();
9542    arg_right->set_isarray(false);
9543    arg_right->set_type(GLMessage::DataType::INT);
9544    arg_right->add_intvalue(right);
9545
9546    // copy argument bottom
9547    GLMessage_DataType *arg_bottom = glmsg.add_args();
9548    arg_bottom->set_isarray(false);
9549    arg_bottom->set_type(GLMessage::DataType::INT);
9550    arg_bottom->add_intvalue(bottom);
9551
9552    // copy argument top
9553    GLMessage_DataType *arg_top = glmsg.add_args();
9554    arg_top->set_isarray(false);
9555    arg_top->set_type(GLMessage::DataType::INT);
9556    arg_top->add_intvalue(top);
9557
9558    // copy argument zNear
9559    GLMessage_DataType *arg_zNear = glmsg.add_args();
9560    arg_zNear->set_isarray(false);
9561    arg_zNear->set_type(GLMessage::DataType::INT);
9562    arg_zNear->add_intvalue(zNear);
9563
9564    // copy argument zFar
9565    GLMessage_DataType *arg_zFar = glmsg.add_args();
9566    arg_zFar->set_isarray(false);
9567    arg_zFar->set_type(GLMessage::DataType::INT);
9568    arg_zFar->add_intvalue(zFar);
9569
9570    // call function
9571    glContext->hooks->gl.glFrustumxOES(left, right, bottom, top, zNear, zFar);
9572
9573    fixupGLMessage(glContext, &glmsg);
9574    glContext->traceGLMessage(&glmsg);
9575}
9576
9577void GLTrace_glGetClipPlanexOES(GLenum pname, GLfixed eqn[4]) {
9578    GLMessage glmsg;
9579    GLTraceContext *glContext = getGLTraceContext();
9580
9581    glmsg.set_function(GLMessage::glGetClipPlanexOES);
9582
9583    // copy argument pname
9584    GLMessage_DataType *arg_pname = glmsg.add_args();
9585    arg_pname->set_isarray(false);
9586    arg_pname->set_type(GLMessage::DataType::ENUM);
9587    arg_pname->add_intvalue((int)pname);
9588
9589    // copy argument eqn
9590    GLMessage_DataType *arg_eqn = glmsg.add_args();
9591    arg_eqn->set_isarray(false);
9592    arg_eqn->set_type(GLMessage::DataType::INT);
9593    arg_eqn->add_intvalue((int)eqn);
9594
9595    // call function
9596    glContext->hooks->gl.glGetClipPlanexOES(pname, eqn);
9597
9598    fixupGLMessage(glContext, &glmsg);
9599    glContext->traceGLMessage(&glmsg);
9600}
9601
9602void GLTrace_glGetFixedvOES(GLenum pname, GLfixed *params) {
9603    GLMessage glmsg;
9604    GLTraceContext *glContext = getGLTraceContext();
9605
9606    glmsg.set_function(GLMessage::glGetFixedvOES);
9607
9608    // copy argument pname
9609    GLMessage_DataType *arg_pname = glmsg.add_args();
9610    arg_pname->set_isarray(false);
9611    arg_pname->set_type(GLMessage::DataType::ENUM);
9612    arg_pname->add_intvalue((int)pname);
9613
9614    // copy argument params
9615    GLMessage_DataType *arg_params = glmsg.add_args();
9616    arg_params->set_isarray(false);
9617    arg_params->set_type(GLMessage::DataType::INT);
9618    arg_params->add_intvalue((int)params);
9619
9620    // call function
9621    glContext->hooks->gl.glGetFixedvOES(pname, params);
9622
9623    fixupGLMessage(glContext, &glmsg);
9624    glContext->traceGLMessage(&glmsg);
9625}
9626
9627void GLTrace_glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params) {
9628    GLMessage glmsg;
9629    GLTraceContext *glContext = getGLTraceContext();
9630
9631    glmsg.set_function(GLMessage::glGetLightxvOES);
9632
9633    // copy argument light
9634    GLMessage_DataType *arg_light = glmsg.add_args();
9635    arg_light->set_isarray(false);
9636    arg_light->set_type(GLMessage::DataType::ENUM);
9637    arg_light->add_intvalue((int)light);
9638
9639    // copy argument pname
9640    GLMessage_DataType *arg_pname = glmsg.add_args();
9641    arg_pname->set_isarray(false);
9642    arg_pname->set_type(GLMessage::DataType::ENUM);
9643    arg_pname->add_intvalue((int)pname);
9644
9645    // copy argument params
9646    GLMessage_DataType *arg_params = glmsg.add_args();
9647    arg_params->set_isarray(false);
9648    arg_params->set_type(GLMessage::DataType::INT);
9649    arg_params->add_intvalue((int)params);
9650
9651    // call function
9652    glContext->hooks->gl.glGetLightxvOES(light, pname, params);
9653
9654    fixupGLMessage(glContext, &glmsg);
9655    glContext->traceGLMessage(&glmsg);
9656}
9657
9658void GLTrace_glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params) {
9659    GLMessage glmsg;
9660    GLTraceContext *glContext = getGLTraceContext();
9661
9662    glmsg.set_function(GLMessage::glGetMaterialxvOES);
9663
9664    // copy argument face
9665    GLMessage_DataType *arg_face = glmsg.add_args();
9666    arg_face->set_isarray(false);
9667    arg_face->set_type(GLMessage::DataType::ENUM);
9668    arg_face->add_intvalue((int)face);
9669
9670    // copy argument pname
9671    GLMessage_DataType *arg_pname = glmsg.add_args();
9672    arg_pname->set_isarray(false);
9673    arg_pname->set_type(GLMessage::DataType::ENUM);
9674    arg_pname->add_intvalue((int)pname);
9675
9676    // copy argument params
9677    GLMessage_DataType *arg_params = glmsg.add_args();
9678    arg_params->set_isarray(false);
9679    arg_params->set_type(GLMessage::DataType::INT);
9680    arg_params->add_intvalue((int)params);
9681
9682    // call function
9683    glContext->hooks->gl.glGetMaterialxvOES(face, pname, params);
9684
9685    fixupGLMessage(glContext, &glmsg);
9686    glContext->traceGLMessage(&glmsg);
9687}
9688
9689void GLTrace_glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params) {
9690    GLMessage glmsg;
9691    GLTraceContext *glContext = getGLTraceContext();
9692
9693    glmsg.set_function(GLMessage::glGetTexEnvxvOES);
9694
9695    // copy argument env
9696    GLMessage_DataType *arg_env = glmsg.add_args();
9697    arg_env->set_isarray(false);
9698    arg_env->set_type(GLMessage::DataType::ENUM);
9699    arg_env->add_intvalue((int)env);
9700
9701    // copy argument pname
9702    GLMessage_DataType *arg_pname = glmsg.add_args();
9703    arg_pname->set_isarray(false);
9704    arg_pname->set_type(GLMessage::DataType::ENUM);
9705    arg_pname->add_intvalue((int)pname);
9706
9707    // copy argument params
9708    GLMessage_DataType *arg_params = glmsg.add_args();
9709    arg_params->set_isarray(false);
9710    arg_params->set_type(GLMessage::DataType::INT);
9711    arg_params->add_intvalue((int)params);
9712
9713    // call function
9714    glContext->hooks->gl.glGetTexEnvxvOES(env, pname, params);
9715
9716    fixupGLMessage(glContext, &glmsg);
9717    glContext->traceGLMessage(&glmsg);
9718}
9719
9720void GLTrace_glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params) {
9721    GLMessage glmsg;
9722    GLTraceContext *glContext = getGLTraceContext();
9723
9724    glmsg.set_function(GLMessage::glGetTexParameterxvOES);
9725
9726    // copy argument target
9727    GLMessage_DataType *arg_target = glmsg.add_args();
9728    arg_target->set_isarray(false);
9729    arg_target->set_type(GLMessage::DataType::ENUM);
9730    arg_target->add_intvalue((int)target);
9731
9732    // copy argument pname
9733    GLMessage_DataType *arg_pname = glmsg.add_args();
9734    arg_pname->set_isarray(false);
9735    arg_pname->set_type(GLMessage::DataType::ENUM);
9736    arg_pname->add_intvalue((int)pname);
9737
9738    // copy argument params
9739    GLMessage_DataType *arg_params = glmsg.add_args();
9740    arg_params->set_isarray(false);
9741    arg_params->set_type(GLMessage::DataType::INT);
9742    arg_params->add_intvalue((int)params);
9743
9744    // call function
9745    glContext->hooks->gl.glGetTexParameterxvOES(target, pname, params);
9746
9747    fixupGLMessage(glContext, &glmsg);
9748    glContext->traceGLMessage(&glmsg);
9749}
9750
9751void GLTrace_glLightModelxOES(GLenum pname, GLfixed param) {
9752    GLMessage glmsg;
9753    GLTraceContext *glContext = getGLTraceContext();
9754
9755    glmsg.set_function(GLMessage::glLightModelxOES);
9756
9757    // copy argument pname
9758    GLMessage_DataType *arg_pname = glmsg.add_args();
9759    arg_pname->set_isarray(false);
9760    arg_pname->set_type(GLMessage::DataType::ENUM);
9761    arg_pname->add_intvalue((int)pname);
9762
9763    // copy argument param
9764    GLMessage_DataType *arg_param = glmsg.add_args();
9765    arg_param->set_isarray(false);
9766    arg_param->set_type(GLMessage::DataType::INT);
9767    arg_param->add_intvalue(param);
9768
9769    // call function
9770    glContext->hooks->gl.glLightModelxOES(pname, param);
9771
9772    fixupGLMessage(glContext, &glmsg);
9773    glContext->traceGLMessage(&glmsg);
9774}
9775
9776void GLTrace_glLightModelxvOES(GLenum pname, const GLfixed *params) {
9777    GLMessage glmsg;
9778    GLTraceContext *glContext = getGLTraceContext();
9779
9780    glmsg.set_function(GLMessage::glLightModelxvOES);
9781
9782    // copy argument pname
9783    GLMessage_DataType *arg_pname = glmsg.add_args();
9784    arg_pname->set_isarray(false);
9785    arg_pname->set_type(GLMessage::DataType::ENUM);
9786    arg_pname->add_intvalue((int)pname);
9787
9788    // copy argument params
9789    GLMessage_DataType *arg_params = glmsg.add_args();
9790    arg_params->set_isarray(false);
9791    arg_params->set_type(GLMessage::DataType::INT);
9792    arg_params->add_intvalue((int)params);
9793
9794    // call function
9795    glContext->hooks->gl.glLightModelxvOES(pname, params);
9796
9797    fixupGLMessage(glContext, &glmsg);
9798    glContext->traceGLMessage(&glmsg);
9799}
9800
9801void GLTrace_glLightxOES(GLenum light, GLenum pname, GLfixed param) {
9802    GLMessage glmsg;
9803    GLTraceContext *glContext = getGLTraceContext();
9804
9805    glmsg.set_function(GLMessage::glLightxOES);
9806
9807    // copy argument light
9808    GLMessage_DataType *arg_light = glmsg.add_args();
9809    arg_light->set_isarray(false);
9810    arg_light->set_type(GLMessage::DataType::ENUM);
9811    arg_light->add_intvalue((int)light);
9812
9813    // copy argument pname
9814    GLMessage_DataType *arg_pname = glmsg.add_args();
9815    arg_pname->set_isarray(false);
9816    arg_pname->set_type(GLMessage::DataType::ENUM);
9817    arg_pname->add_intvalue((int)pname);
9818
9819    // copy argument param
9820    GLMessage_DataType *arg_param = glmsg.add_args();
9821    arg_param->set_isarray(false);
9822    arg_param->set_type(GLMessage::DataType::INT);
9823    arg_param->add_intvalue(param);
9824
9825    // call function
9826    glContext->hooks->gl.glLightxOES(light, pname, param);
9827
9828    fixupGLMessage(glContext, &glmsg);
9829    glContext->traceGLMessage(&glmsg);
9830}
9831
9832void GLTrace_glLightxvOES(GLenum light, GLenum pname, const GLfixed *params) {
9833    GLMessage glmsg;
9834    GLTraceContext *glContext = getGLTraceContext();
9835
9836    glmsg.set_function(GLMessage::glLightxvOES);
9837
9838    // copy argument light
9839    GLMessage_DataType *arg_light = glmsg.add_args();
9840    arg_light->set_isarray(false);
9841    arg_light->set_type(GLMessage::DataType::ENUM);
9842    arg_light->add_intvalue((int)light);
9843
9844    // copy argument pname
9845    GLMessage_DataType *arg_pname = glmsg.add_args();
9846    arg_pname->set_isarray(false);
9847    arg_pname->set_type(GLMessage::DataType::ENUM);
9848    arg_pname->add_intvalue((int)pname);
9849
9850    // copy argument params
9851    GLMessage_DataType *arg_params = glmsg.add_args();
9852    arg_params->set_isarray(false);
9853    arg_params->set_type(GLMessage::DataType::INT);
9854    arg_params->add_intvalue((int)params);
9855
9856    // call function
9857    glContext->hooks->gl.glLightxvOES(light, pname, params);
9858
9859    fixupGLMessage(glContext, &glmsg);
9860    glContext->traceGLMessage(&glmsg);
9861}
9862
9863void GLTrace_glLineWidthxOES(GLfixed width) {
9864    GLMessage glmsg;
9865    GLTraceContext *glContext = getGLTraceContext();
9866
9867    glmsg.set_function(GLMessage::glLineWidthxOES);
9868
9869    // copy argument width
9870    GLMessage_DataType *arg_width = glmsg.add_args();
9871    arg_width->set_isarray(false);
9872    arg_width->set_type(GLMessage::DataType::INT);
9873    arg_width->add_intvalue(width);
9874
9875    // call function
9876    glContext->hooks->gl.glLineWidthxOES(width);
9877
9878    fixupGLMessage(glContext, &glmsg);
9879    glContext->traceGLMessage(&glmsg);
9880}
9881
9882void GLTrace_glLoadMatrixxOES(const GLfixed *m) {
9883    GLMessage glmsg;
9884    GLTraceContext *glContext = getGLTraceContext();
9885
9886    glmsg.set_function(GLMessage::glLoadMatrixxOES);
9887
9888    // copy argument m
9889    GLMessage_DataType *arg_m = glmsg.add_args();
9890    arg_m->set_isarray(false);
9891    arg_m->set_type(GLMessage::DataType::INT);
9892    arg_m->add_intvalue((int)m);
9893
9894    // call function
9895    glContext->hooks->gl.glLoadMatrixxOES(m);
9896
9897    fixupGLMessage(glContext, &glmsg);
9898    glContext->traceGLMessage(&glmsg);
9899}
9900
9901void GLTrace_glMaterialxOES(GLenum face, GLenum pname, GLfixed param) {
9902    GLMessage glmsg;
9903    GLTraceContext *glContext = getGLTraceContext();
9904
9905    glmsg.set_function(GLMessage::glMaterialxOES);
9906
9907    // copy argument face
9908    GLMessage_DataType *arg_face = glmsg.add_args();
9909    arg_face->set_isarray(false);
9910    arg_face->set_type(GLMessage::DataType::ENUM);
9911    arg_face->add_intvalue((int)face);
9912
9913    // copy argument pname
9914    GLMessage_DataType *arg_pname = glmsg.add_args();
9915    arg_pname->set_isarray(false);
9916    arg_pname->set_type(GLMessage::DataType::ENUM);
9917    arg_pname->add_intvalue((int)pname);
9918
9919    // copy argument param
9920    GLMessage_DataType *arg_param = glmsg.add_args();
9921    arg_param->set_isarray(false);
9922    arg_param->set_type(GLMessage::DataType::INT);
9923    arg_param->add_intvalue(param);
9924
9925    // call function
9926    glContext->hooks->gl.glMaterialxOES(face, pname, param);
9927
9928    fixupGLMessage(glContext, &glmsg);
9929    glContext->traceGLMessage(&glmsg);
9930}
9931
9932void GLTrace_glMaterialxvOES(GLenum face, GLenum pname, const GLfixed *params) {
9933    GLMessage glmsg;
9934    GLTraceContext *glContext = getGLTraceContext();
9935
9936    glmsg.set_function(GLMessage::glMaterialxvOES);
9937
9938    // copy argument face
9939    GLMessage_DataType *arg_face = glmsg.add_args();
9940    arg_face->set_isarray(false);
9941    arg_face->set_type(GLMessage::DataType::ENUM);
9942    arg_face->add_intvalue((int)face);
9943
9944    // copy argument pname
9945    GLMessage_DataType *arg_pname = glmsg.add_args();
9946    arg_pname->set_isarray(false);
9947    arg_pname->set_type(GLMessage::DataType::ENUM);
9948    arg_pname->add_intvalue((int)pname);
9949
9950    // copy argument params
9951    GLMessage_DataType *arg_params = glmsg.add_args();
9952    arg_params->set_isarray(false);
9953    arg_params->set_type(GLMessage::DataType::INT);
9954    arg_params->add_intvalue((int)params);
9955
9956    // call function
9957    glContext->hooks->gl.glMaterialxvOES(face, pname, params);
9958
9959    fixupGLMessage(glContext, &glmsg);
9960    glContext->traceGLMessage(&glmsg);
9961}
9962
9963void GLTrace_glMultMatrixxOES(const GLfixed *m) {
9964    GLMessage glmsg;
9965    GLTraceContext *glContext = getGLTraceContext();
9966
9967    glmsg.set_function(GLMessage::glMultMatrixxOES);
9968
9969    // copy argument m
9970    GLMessage_DataType *arg_m = glmsg.add_args();
9971    arg_m->set_isarray(false);
9972    arg_m->set_type(GLMessage::DataType::INT);
9973    arg_m->add_intvalue((int)m);
9974
9975    // call function
9976    glContext->hooks->gl.glMultMatrixxOES(m);
9977
9978    fixupGLMessage(glContext, &glmsg);
9979    glContext->traceGLMessage(&glmsg);
9980}
9981
9982void GLTrace_glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) {
9983    GLMessage glmsg;
9984    GLTraceContext *glContext = getGLTraceContext();
9985
9986    glmsg.set_function(GLMessage::glMultiTexCoord4xOES);
9987
9988    // copy argument target
9989    GLMessage_DataType *arg_target = glmsg.add_args();
9990    arg_target->set_isarray(false);
9991    arg_target->set_type(GLMessage::DataType::ENUM);
9992    arg_target->add_intvalue((int)target);
9993
9994    // copy argument s
9995    GLMessage_DataType *arg_s = glmsg.add_args();
9996    arg_s->set_isarray(false);
9997    arg_s->set_type(GLMessage::DataType::INT);
9998    arg_s->add_intvalue(s);
9999
10000    // copy argument t
10001    GLMessage_DataType *arg_t = glmsg.add_args();
10002    arg_t->set_isarray(false);
10003    arg_t->set_type(GLMessage::DataType::INT);
10004    arg_t->add_intvalue(t);
10005
10006    // copy argument r
10007    GLMessage_DataType *arg_r = glmsg.add_args();
10008    arg_r->set_isarray(false);
10009    arg_r->set_type(GLMessage::DataType::INT);
10010    arg_r->add_intvalue(r);
10011
10012    // copy argument q
10013    GLMessage_DataType *arg_q = glmsg.add_args();
10014    arg_q->set_isarray(false);
10015    arg_q->set_type(GLMessage::DataType::INT);
10016    arg_q->add_intvalue(q);
10017
10018    // call function
10019    glContext->hooks->gl.glMultiTexCoord4xOES(target, s, t, r, q);
10020
10021    fixupGLMessage(glContext, &glmsg);
10022    glContext->traceGLMessage(&glmsg);
10023}
10024
10025void GLTrace_glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz) {
10026    GLMessage glmsg;
10027    GLTraceContext *glContext = getGLTraceContext();
10028
10029    glmsg.set_function(GLMessage::glNormal3xOES);
10030
10031    // copy argument nx
10032    GLMessage_DataType *arg_nx = glmsg.add_args();
10033    arg_nx->set_isarray(false);
10034    arg_nx->set_type(GLMessage::DataType::INT);
10035    arg_nx->add_intvalue(nx);
10036
10037    // copy argument ny
10038    GLMessage_DataType *arg_ny = glmsg.add_args();
10039    arg_ny->set_isarray(false);
10040    arg_ny->set_type(GLMessage::DataType::INT);
10041    arg_ny->add_intvalue(ny);
10042
10043    // copy argument nz
10044    GLMessage_DataType *arg_nz = glmsg.add_args();
10045    arg_nz->set_isarray(false);
10046    arg_nz->set_type(GLMessage::DataType::INT);
10047    arg_nz->add_intvalue(nz);
10048
10049    // call function
10050    glContext->hooks->gl.glNormal3xOES(nx, ny, nz);
10051
10052    fixupGLMessage(glContext, &glmsg);
10053    glContext->traceGLMessage(&glmsg);
10054}
10055
10056void GLTrace_glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) {
10057    GLMessage glmsg;
10058    GLTraceContext *glContext = getGLTraceContext();
10059
10060    glmsg.set_function(GLMessage::glOrthoxOES);
10061
10062    // copy argument left
10063    GLMessage_DataType *arg_left = glmsg.add_args();
10064    arg_left->set_isarray(false);
10065    arg_left->set_type(GLMessage::DataType::INT);
10066    arg_left->add_intvalue(left);
10067
10068    // copy argument right
10069    GLMessage_DataType *arg_right = glmsg.add_args();
10070    arg_right->set_isarray(false);
10071    arg_right->set_type(GLMessage::DataType::INT);
10072    arg_right->add_intvalue(right);
10073
10074    // copy argument bottom
10075    GLMessage_DataType *arg_bottom = glmsg.add_args();
10076    arg_bottom->set_isarray(false);
10077    arg_bottom->set_type(GLMessage::DataType::INT);
10078    arg_bottom->add_intvalue(bottom);
10079
10080    // copy argument top
10081    GLMessage_DataType *arg_top = glmsg.add_args();
10082    arg_top->set_isarray(false);
10083    arg_top->set_type(GLMessage::DataType::INT);
10084    arg_top->add_intvalue(top);
10085
10086    // copy argument zNear
10087    GLMessage_DataType *arg_zNear = glmsg.add_args();
10088    arg_zNear->set_isarray(false);
10089    arg_zNear->set_type(GLMessage::DataType::INT);
10090    arg_zNear->add_intvalue(zNear);
10091
10092    // copy argument zFar
10093    GLMessage_DataType *arg_zFar = glmsg.add_args();
10094    arg_zFar->set_isarray(false);
10095    arg_zFar->set_type(GLMessage::DataType::INT);
10096    arg_zFar->add_intvalue(zFar);
10097
10098    // call function
10099    glContext->hooks->gl.glOrthoxOES(left, right, bottom, top, zNear, zFar);
10100
10101    fixupGLMessage(glContext, &glmsg);
10102    glContext->traceGLMessage(&glmsg);
10103}
10104
10105void GLTrace_glPointParameterxOES(GLenum pname, GLfixed param) {
10106    GLMessage glmsg;
10107    GLTraceContext *glContext = getGLTraceContext();
10108
10109    glmsg.set_function(GLMessage::glPointParameterxOES);
10110
10111    // copy argument pname
10112    GLMessage_DataType *arg_pname = glmsg.add_args();
10113    arg_pname->set_isarray(false);
10114    arg_pname->set_type(GLMessage::DataType::ENUM);
10115    arg_pname->add_intvalue((int)pname);
10116
10117    // copy argument param
10118    GLMessage_DataType *arg_param = glmsg.add_args();
10119    arg_param->set_isarray(false);
10120    arg_param->set_type(GLMessage::DataType::INT);
10121    arg_param->add_intvalue(param);
10122
10123    // call function
10124    glContext->hooks->gl.glPointParameterxOES(pname, param);
10125
10126    fixupGLMessage(glContext, &glmsg);
10127    glContext->traceGLMessage(&glmsg);
10128}
10129
10130void GLTrace_glPointParameterxvOES(GLenum pname, const GLfixed *params) {
10131    GLMessage glmsg;
10132    GLTraceContext *glContext = getGLTraceContext();
10133
10134    glmsg.set_function(GLMessage::glPointParameterxvOES);
10135
10136    // copy argument pname
10137    GLMessage_DataType *arg_pname = glmsg.add_args();
10138    arg_pname->set_isarray(false);
10139    arg_pname->set_type(GLMessage::DataType::ENUM);
10140    arg_pname->add_intvalue((int)pname);
10141
10142    // copy argument params
10143    GLMessage_DataType *arg_params = glmsg.add_args();
10144    arg_params->set_isarray(false);
10145    arg_params->set_type(GLMessage::DataType::INT);
10146    arg_params->add_intvalue((int)params);
10147
10148    // call function
10149    glContext->hooks->gl.glPointParameterxvOES(pname, params);
10150
10151    fixupGLMessage(glContext, &glmsg);
10152    glContext->traceGLMessage(&glmsg);
10153}
10154
10155void GLTrace_glPointSizexOES(GLfixed size) {
10156    GLMessage glmsg;
10157    GLTraceContext *glContext = getGLTraceContext();
10158
10159    glmsg.set_function(GLMessage::glPointSizexOES);
10160
10161    // copy argument size
10162    GLMessage_DataType *arg_size = glmsg.add_args();
10163    arg_size->set_isarray(false);
10164    arg_size->set_type(GLMessage::DataType::INT);
10165    arg_size->add_intvalue(size);
10166
10167    // call function
10168    glContext->hooks->gl.glPointSizexOES(size);
10169
10170    fixupGLMessage(glContext, &glmsg);
10171    glContext->traceGLMessage(&glmsg);
10172}
10173
10174void GLTrace_glPolygonOffsetxOES(GLfixed factor, GLfixed units) {
10175    GLMessage glmsg;
10176    GLTraceContext *glContext = getGLTraceContext();
10177
10178    glmsg.set_function(GLMessage::glPolygonOffsetxOES);
10179
10180    // copy argument factor
10181    GLMessage_DataType *arg_factor = glmsg.add_args();
10182    arg_factor->set_isarray(false);
10183    arg_factor->set_type(GLMessage::DataType::INT);
10184    arg_factor->add_intvalue(factor);
10185
10186    // copy argument units
10187    GLMessage_DataType *arg_units = glmsg.add_args();
10188    arg_units->set_isarray(false);
10189    arg_units->set_type(GLMessage::DataType::INT);
10190    arg_units->add_intvalue(units);
10191
10192    // call function
10193    glContext->hooks->gl.glPolygonOffsetxOES(factor, units);
10194
10195    fixupGLMessage(glContext, &glmsg);
10196    glContext->traceGLMessage(&glmsg);
10197}
10198
10199void GLTrace_glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) {
10200    GLMessage glmsg;
10201    GLTraceContext *glContext = getGLTraceContext();
10202
10203    glmsg.set_function(GLMessage::glRotatexOES);
10204
10205    // copy argument angle
10206    GLMessage_DataType *arg_angle = glmsg.add_args();
10207    arg_angle->set_isarray(false);
10208    arg_angle->set_type(GLMessage::DataType::INT);
10209    arg_angle->add_intvalue(angle);
10210
10211    // copy argument x
10212    GLMessage_DataType *arg_x = glmsg.add_args();
10213    arg_x->set_isarray(false);
10214    arg_x->set_type(GLMessage::DataType::INT);
10215    arg_x->add_intvalue(x);
10216
10217    // copy argument y
10218    GLMessage_DataType *arg_y = glmsg.add_args();
10219    arg_y->set_isarray(false);
10220    arg_y->set_type(GLMessage::DataType::INT);
10221    arg_y->add_intvalue(y);
10222
10223    // copy argument z
10224    GLMessage_DataType *arg_z = glmsg.add_args();
10225    arg_z->set_isarray(false);
10226    arg_z->set_type(GLMessage::DataType::INT);
10227    arg_z->add_intvalue(z);
10228
10229    // call function
10230    glContext->hooks->gl.glRotatexOES(angle, x, y, z);
10231
10232    fixupGLMessage(glContext, &glmsg);
10233    glContext->traceGLMessage(&glmsg);
10234}
10235
10236void GLTrace_glSampleCoveragexOES(GLclampx value, GLboolean invert) {
10237    GLMessage glmsg;
10238    GLTraceContext *glContext = getGLTraceContext();
10239
10240    glmsg.set_function(GLMessage::glSampleCoveragexOES);
10241
10242    // copy argument value
10243    GLMessage_DataType *arg_value = glmsg.add_args();
10244    arg_value->set_isarray(false);
10245    arg_value->set_type(GLMessage::DataType::INT);
10246    arg_value->add_intvalue(value);
10247
10248    // copy argument invert
10249    GLMessage_DataType *arg_invert = glmsg.add_args();
10250    arg_invert->set_isarray(false);
10251    arg_invert->set_type(GLMessage::DataType::BOOL);
10252    arg_invert->add_boolvalue(invert);
10253
10254    // call function
10255    glContext->hooks->gl.glSampleCoveragexOES(value, invert);
10256
10257    fixupGLMessage(glContext, &glmsg);
10258    glContext->traceGLMessage(&glmsg);
10259}
10260
10261void GLTrace_glScalexOES(GLfixed x, GLfixed y, GLfixed z) {
10262    GLMessage glmsg;
10263    GLTraceContext *glContext = getGLTraceContext();
10264
10265    glmsg.set_function(GLMessage::glScalexOES);
10266
10267    // copy argument x
10268    GLMessage_DataType *arg_x = glmsg.add_args();
10269    arg_x->set_isarray(false);
10270    arg_x->set_type(GLMessage::DataType::INT);
10271    arg_x->add_intvalue(x);
10272
10273    // copy argument y
10274    GLMessage_DataType *arg_y = glmsg.add_args();
10275    arg_y->set_isarray(false);
10276    arg_y->set_type(GLMessage::DataType::INT);
10277    arg_y->add_intvalue(y);
10278
10279    // copy argument z
10280    GLMessage_DataType *arg_z = glmsg.add_args();
10281    arg_z->set_isarray(false);
10282    arg_z->set_type(GLMessage::DataType::INT);
10283    arg_z->add_intvalue(z);
10284
10285    // call function
10286    glContext->hooks->gl.glScalexOES(x, y, z);
10287
10288    fixupGLMessage(glContext, &glmsg);
10289    glContext->traceGLMessage(&glmsg);
10290}
10291
10292void GLTrace_glTexEnvxOES(GLenum target, GLenum pname, GLfixed param) {
10293    GLMessage glmsg;
10294    GLTraceContext *glContext = getGLTraceContext();
10295
10296    glmsg.set_function(GLMessage::glTexEnvxOES);
10297
10298    // copy argument target
10299    GLMessage_DataType *arg_target = glmsg.add_args();
10300    arg_target->set_isarray(false);
10301    arg_target->set_type(GLMessage::DataType::ENUM);
10302    arg_target->add_intvalue((int)target);
10303
10304    // copy argument pname
10305    GLMessage_DataType *arg_pname = glmsg.add_args();
10306    arg_pname->set_isarray(false);
10307    arg_pname->set_type(GLMessage::DataType::ENUM);
10308    arg_pname->add_intvalue((int)pname);
10309
10310    // copy argument param
10311    GLMessage_DataType *arg_param = glmsg.add_args();
10312    arg_param->set_isarray(false);
10313    arg_param->set_type(GLMessage::DataType::INT);
10314    arg_param->add_intvalue(param);
10315
10316    // call function
10317    glContext->hooks->gl.glTexEnvxOES(target, pname, param);
10318
10319    fixupGLMessage(glContext, &glmsg);
10320    glContext->traceGLMessage(&glmsg);
10321}
10322
10323void GLTrace_glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params) {
10324    GLMessage glmsg;
10325    GLTraceContext *glContext = getGLTraceContext();
10326
10327    glmsg.set_function(GLMessage::glTexEnvxvOES);
10328
10329    // copy argument target
10330    GLMessage_DataType *arg_target = glmsg.add_args();
10331    arg_target->set_isarray(false);
10332    arg_target->set_type(GLMessage::DataType::ENUM);
10333    arg_target->add_intvalue((int)target);
10334
10335    // copy argument pname
10336    GLMessage_DataType *arg_pname = glmsg.add_args();
10337    arg_pname->set_isarray(false);
10338    arg_pname->set_type(GLMessage::DataType::ENUM);
10339    arg_pname->add_intvalue((int)pname);
10340
10341    // copy argument params
10342    GLMessage_DataType *arg_params = glmsg.add_args();
10343    arg_params->set_isarray(false);
10344    arg_params->set_type(GLMessage::DataType::INT);
10345    arg_params->add_intvalue((int)params);
10346
10347    // call function
10348    glContext->hooks->gl.glTexEnvxvOES(target, pname, params);
10349
10350    fixupGLMessage(glContext, &glmsg);
10351    glContext->traceGLMessage(&glmsg);
10352}
10353
10354void GLTrace_glTexParameterxOES(GLenum target, GLenum pname, GLfixed param) {
10355    GLMessage glmsg;
10356    GLTraceContext *glContext = getGLTraceContext();
10357
10358    glmsg.set_function(GLMessage::glTexParameterxOES);
10359
10360    // copy argument target
10361    GLMessage_DataType *arg_target = glmsg.add_args();
10362    arg_target->set_isarray(false);
10363    arg_target->set_type(GLMessage::DataType::ENUM);
10364    arg_target->add_intvalue((int)target);
10365
10366    // copy argument pname
10367    GLMessage_DataType *arg_pname = glmsg.add_args();
10368    arg_pname->set_isarray(false);
10369    arg_pname->set_type(GLMessage::DataType::ENUM);
10370    arg_pname->add_intvalue((int)pname);
10371
10372    // copy argument param
10373    GLMessage_DataType *arg_param = glmsg.add_args();
10374    arg_param->set_isarray(false);
10375    arg_param->set_type(GLMessage::DataType::INT);
10376    arg_param->add_intvalue(param);
10377
10378    // call function
10379    glContext->hooks->gl.glTexParameterxOES(target, pname, param);
10380
10381    fixupGLMessage(glContext, &glmsg);
10382    glContext->traceGLMessage(&glmsg);
10383}
10384
10385void GLTrace_glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params) {
10386    GLMessage glmsg;
10387    GLTraceContext *glContext = getGLTraceContext();
10388
10389    glmsg.set_function(GLMessage::glTexParameterxvOES);
10390
10391    // copy argument target
10392    GLMessage_DataType *arg_target = glmsg.add_args();
10393    arg_target->set_isarray(false);
10394    arg_target->set_type(GLMessage::DataType::ENUM);
10395    arg_target->add_intvalue((int)target);
10396
10397    // copy argument pname
10398    GLMessage_DataType *arg_pname = glmsg.add_args();
10399    arg_pname->set_isarray(false);
10400    arg_pname->set_type(GLMessage::DataType::ENUM);
10401    arg_pname->add_intvalue((int)pname);
10402
10403    // copy argument params
10404    GLMessage_DataType *arg_params = glmsg.add_args();
10405    arg_params->set_isarray(false);
10406    arg_params->set_type(GLMessage::DataType::INT);
10407    arg_params->add_intvalue((int)params);
10408
10409    // call function
10410    glContext->hooks->gl.glTexParameterxvOES(target, pname, params);
10411
10412    fixupGLMessage(glContext, &glmsg);
10413    glContext->traceGLMessage(&glmsg);
10414}
10415
10416void GLTrace_glTranslatexOES(GLfixed x, GLfixed y, GLfixed z) {
10417    GLMessage glmsg;
10418    GLTraceContext *glContext = getGLTraceContext();
10419
10420    glmsg.set_function(GLMessage::glTranslatexOES);
10421
10422    // copy argument x
10423    GLMessage_DataType *arg_x = glmsg.add_args();
10424    arg_x->set_isarray(false);
10425    arg_x->set_type(GLMessage::DataType::INT);
10426    arg_x->add_intvalue(x);
10427
10428    // copy argument y
10429    GLMessage_DataType *arg_y = glmsg.add_args();
10430    arg_y->set_isarray(false);
10431    arg_y->set_type(GLMessage::DataType::INT);
10432    arg_y->add_intvalue(y);
10433
10434    // copy argument z
10435    GLMessage_DataType *arg_z = glmsg.add_args();
10436    arg_z->set_isarray(false);
10437    arg_z->set_type(GLMessage::DataType::INT);
10438    arg_z->add_intvalue(z);
10439
10440    // call function
10441    glContext->hooks->gl.glTranslatexOES(x, y, z);
10442
10443    fixupGLMessage(glContext, &glmsg);
10444    glContext->traceGLMessage(&glmsg);
10445}
10446
10447GLboolean GLTrace_glIsRenderbufferOES(GLuint renderbuffer) {
10448    GLMessage glmsg;
10449    GLTraceContext *glContext = getGLTraceContext();
10450
10451    glmsg.set_function(GLMessage::glIsRenderbufferOES);
10452
10453    // copy argument renderbuffer
10454    GLMessage_DataType *arg_renderbuffer = glmsg.add_args();
10455    arg_renderbuffer->set_isarray(false);
10456    arg_renderbuffer->set_type(GLMessage::DataType::INT);
10457    arg_renderbuffer->add_intvalue(renderbuffer);
10458
10459    // call function
10460    GLboolean retValue = glContext->hooks->gl.glIsRenderbufferOES(renderbuffer);
10461
10462    // set return value
10463    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
10464    rt->set_isarray(false);
10465    rt->set_type(GLMessage::DataType::BOOL);
10466    rt->add_boolvalue(retValue);
10467
10468    fixupGLMessage(glContext, &glmsg);
10469    glContext->traceGLMessage(&glmsg);
10470
10471    return retValue;
10472}
10473
10474void GLTrace_glBindRenderbufferOES(GLenum target, GLuint renderbuffer) {
10475    GLMessage glmsg;
10476    GLTraceContext *glContext = getGLTraceContext();
10477
10478    glmsg.set_function(GLMessage::glBindRenderbufferOES);
10479
10480    // copy argument target
10481    GLMessage_DataType *arg_target = glmsg.add_args();
10482    arg_target->set_isarray(false);
10483    arg_target->set_type(GLMessage::DataType::ENUM);
10484    arg_target->add_intvalue((int)target);
10485
10486    // copy argument renderbuffer
10487    GLMessage_DataType *arg_renderbuffer = glmsg.add_args();
10488    arg_renderbuffer->set_isarray(false);
10489    arg_renderbuffer->set_type(GLMessage::DataType::INT);
10490    arg_renderbuffer->add_intvalue(renderbuffer);
10491
10492    // call function
10493    glContext->hooks->gl.glBindRenderbufferOES(target, renderbuffer);
10494
10495    fixupGLMessage(glContext, &glmsg);
10496    glContext->traceGLMessage(&glmsg);
10497}
10498
10499void GLTrace_glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers) {
10500    GLMessage glmsg;
10501    GLTraceContext *glContext = getGLTraceContext();
10502
10503    glmsg.set_function(GLMessage::glDeleteRenderbuffersOES);
10504
10505    // copy argument n
10506    GLMessage_DataType *arg_n = glmsg.add_args();
10507    arg_n->set_isarray(false);
10508    arg_n->set_type(GLMessage::DataType::INT);
10509    arg_n->add_intvalue(n);
10510
10511    // copy argument renderbuffers
10512    GLMessage_DataType *arg_renderbuffers = glmsg.add_args();
10513    arg_renderbuffers->set_isarray(false);
10514    arg_renderbuffers->set_type(GLMessage::DataType::INT);
10515    arg_renderbuffers->add_intvalue((int)renderbuffers);
10516
10517    // call function
10518    glContext->hooks->gl.glDeleteRenderbuffersOES(n, renderbuffers);
10519
10520    fixupGLMessage(glContext, &glmsg);
10521    glContext->traceGLMessage(&glmsg);
10522}
10523
10524void GLTrace_glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers) {
10525    GLMessage glmsg;
10526    GLTraceContext *glContext = getGLTraceContext();
10527
10528    glmsg.set_function(GLMessage::glGenRenderbuffersOES);
10529
10530    // copy argument n
10531    GLMessage_DataType *arg_n = glmsg.add_args();
10532    arg_n->set_isarray(false);
10533    arg_n->set_type(GLMessage::DataType::INT);
10534    arg_n->add_intvalue(n);
10535
10536    // copy argument renderbuffers
10537    GLMessage_DataType *arg_renderbuffers = glmsg.add_args();
10538    arg_renderbuffers->set_isarray(false);
10539    arg_renderbuffers->set_type(GLMessage::DataType::INT);
10540    arg_renderbuffers->add_intvalue((int)renderbuffers);
10541
10542    // call function
10543    glContext->hooks->gl.glGenRenderbuffersOES(n, renderbuffers);
10544
10545    fixupGLMessage(glContext, &glmsg);
10546    glContext->traceGLMessage(&glmsg);
10547}
10548
10549void GLTrace_glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
10550    GLMessage glmsg;
10551    GLTraceContext *glContext = getGLTraceContext();
10552
10553    glmsg.set_function(GLMessage::glRenderbufferStorageOES);
10554
10555    // copy argument target
10556    GLMessage_DataType *arg_target = glmsg.add_args();
10557    arg_target->set_isarray(false);
10558    arg_target->set_type(GLMessage::DataType::ENUM);
10559    arg_target->add_intvalue((int)target);
10560
10561    // copy argument internalformat
10562    GLMessage_DataType *arg_internalformat = glmsg.add_args();
10563    arg_internalformat->set_isarray(false);
10564    arg_internalformat->set_type(GLMessage::DataType::ENUM);
10565    arg_internalformat->add_intvalue((int)internalformat);
10566
10567    // copy argument width
10568    GLMessage_DataType *arg_width = glmsg.add_args();
10569    arg_width->set_isarray(false);
10570    arg_width->set_type(GLMessage::DataType::INT);
10571    arg_width->add_intvalue(width);
10572
10573    // copy argument height
10574    GLMessage_DataType *arg_height = glmsg.add_args();
10575    arg_height->set_isarray(false);
10576    arg_height->set_type(GLMessage::DataType::INT);
10577    arg_height->add_intvalue(height);
10578
10579    // call function
10580    glContext->hooks->gl.glRenderbufferStorageOES(target, internalformat, width, height);
10581
10582    fixupGLMessage(glContext, &glmsg);
10583    glContext->traceGLMessage(&glmsg);
10584}
10585
10586void GLTrace_glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params) {
10587    GLMessage glmsg;
10588    GLTraceContext *glContext = getGLTraceContext();
10589
10590    glmsg.set_function(GLMessage::glGetRenderbufferParameterivOES);
10591
10592    // copy argument target
10593    GLMessage_DataType *arg_target = glmsg.add_args();
10594    arg_target->set_isarray(false);
10595    arg_target->set_type(GLMessage::DataType::ENUM);
10596    arg_target->add_intvalue((int)target);
10597
10598    // copy argument pname
10599    GLMessage_DataType *arg_pname = glmsg.add_args();
10600    arg_pname->set_isarray(false);
10601    arg_pname->set_type(GLMessage::DataType::ENUM);
10602    arg_pname->add_intvalue((int)pname);
10603
10604    // copy argument params
10605    GLMessage_DataType *arg_params = glmsg.add_args();
10606    arg_params->set_isarray(false);
10607    arg_params->set_type(GLMessage::DataType::INT);
10608    arg_params->add_intvalue((int)params);
10609
10610    // call function
10611    glContext->hooks->gl.glGetRenderbufferParameterivOES(target, pname, params);
10612
10613    fixupGLMessage(glContext, &glmsg);
10614    glContext->traceGLMessage(&glmsg);
10615}
10616
10617GLboolean GLTrace_glIsFramebufferOES(GLuint framebuffer) {
10618    GLMessage glmsg;
10619    GLTraceContext *glContext = getGLTraceContext();
10620
10621    glmsg.set_function(GLMessage::glIsFramebufferOES);
10622
10623    // copy argument framebuffer
10624    GLMessage_DataType *arg_framebuffer = glmsg.add_args();
10625    arg_framebuffer->set_isarray(false);
10626    arg_framebuffer->set_type(GLMessage::DataType::INT);
10627    arg_framebuffer->add_intvalue(framebuffer);
10628
10629    // call function
10630    GLboolean retValue = glContext->hooks->gl.glIsFramebufferOES(framebuffer);
10631
10632    // set return value
10633    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
10634    rt->set_isarray(false);
10635    rt->set_type(GLMessage::DataType::BOOL);
10636    rt->add_boolvalue(retValue);
10637
10638    fixupGLMessage(glContext, &glmsg);
10639    glContext->traceGLMessage(&glmsg);
10640
10641    return retValue;
10642}
10643
10644void GLTrace_glBindFramebufferOES(GLenum target, GLuint framebuffer) {
10645    GLMessage glmsg;
10646    GLTraceContext *glContext = getGLTraceContext();
10647
10648    glmsg.set_function(GLMessage::glBindFramebufferOES);
10649
10650    // copy argument target
10651    GLMessage_DataType *arg_target = glmsg.add_args();
10652    arg_target->set_isarray(false);
10653    arg_target->set_type(GLMessage::DataType::ENUM);
10654    arg_target->add_intvalue((int)target);
10655
10656    // copy argument framebuffer
10657    GLMessage_DataType *arg_framebuffer = glmsg.add_args();
10658    arg_framebuffer->set_isarray(false);
10659    arg_framebuffer->set_type(GLMessage::DataType::INT);
10660    arg_framebuffer->add_intvalue(framebuffer);
10661
10662    // call function
10663    glContext->hooks->gl.glBindFramebufferOES(target, framebuffer);
10664
10665    fixupGLMessage(glContext, &glmsg);
10666    glContext->traceGLMessage(&glmsg);
10667}
10668
10669void GLTrace_glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers) {
10670    GLMessage glmsg;
10671    GLTraceContext *glContext = getGLTraceContext();
10672
10673    glmsg.set_function(GLMessage::glDeleteFramebuffersOES);
10674
10675    // copy argument n
10676    GLMessage_DataType *arg_n = glmsg.add_args();
10677    arg_n->set_isarray(false);
10678    arg_n->set_type(GLMessage::DataType::INT);
10679    arg_n->add_intvalue(n);
10680
10681    // copy argument framebuffers
10682    GLMessage_DataType *arg_framebuffers = glmsg.add_args();
10683    arg_framebuffers->set_isarray(false);
10684    arg_framebuffers->set_type(GLMessage::DataType::INT);
10685    arg_framebuffers->add_intvalue((int)framebuffers);
10686
10687    // call function
10688    glContext->hooks->gl.glDeleteFramebuffersOES(n, framebuffers);
10689
10690    fixupGLMessage(glContext, &glmsg);
10691    glContext->traceGLMessage(&glmsg);
10692}
10693
10694void GLTrace_glGenFramebuffersOES(GLsizei n, GLuint* framebuffers) {
10695    GLMessage glmsg;
10696    GLTraceContext *glContext = getGLTraceContext();
10697
10698    glmsg.set_function(GLMessage::glGenFramebuffersOES);
10699
10700    // copy argument n
10701    GLMessage_DataType *arg_n = glmsg.add_args();
10702    arg_n->set_isarray(false);
10703    arg_n->set_type(GLMessage::DataType::INT);
10704    arg_n->add_intvalue(n);
10705
10706    // copy argument framebuffers
10707    GLMessage_DataType *arg_framebuffers = glmsg.add_args();
10708    arg_framebuffers->set_isarray(false);
10709    arg_framebuffers->set_type(GLMessage::DataType::INT);
10710    arg_framebuffers->add_intvalue((int)framebuffers);
10711
10712    // call function
10713    glContext->hooks->gl.glGenFramebuffersOES(n, framebuffers);
10714
10715    fixupGLMessage(glContext, &glmsg);
10716    glContext->traceGLMessage(&glmsg);
10717}
10718
10719GLenum GLTrace_glCheckFramebufferStatusOES(GLenum target) {
10720    GLMessage glmsg;
10721    GLTraceContext *glContext = getGLTraceContext();
10722
10723    glmsg.set_function(GLMessage::glCheckFramebufferStatusOES);
10724
10725    // copy argument target
10726    GLMessage_DataType *arg_target = glmsg.add_args();
10727    arg_target->set_isarray(false);
10728    arg_target->set_type(GLMessage::DataType::ENUM);
10729    arg_target->add_intvalue((int)target);
10730
10731    // call function
10732    GLenum retValue = glContext->hooks->gl.glCheckFramebufferStatusOES(target);
10733
10734    // set return value
10735    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
10736    rt->set_isarray(false);
10737    rt->set_type(GLMessage::DataType::ENUM);
10738    rt->add_intvalue((int)retValue);
10739
10740    fixupGLMessage(glContext, &glmsg);
10741    glContext->traceGLMessage(&glmsg);
10742
10743    return retValue;
10744}
10745
10746void GLTrace_glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {
10747    GLMessage glmsg;
10748    GLTraceContext *glContext = getGLTraceContext();
10749
10750    glmsg.set_function(GLMessage::glFramebufferRenderbufferOES);
10751
10752    // copy argument target
10753    GLMessage_DataType *arg_target = glmsg.add_args();
10754    arg_target->set_isarray(false);
10755    arg_target->set_type(GLMessage::DataType::ENUM);
10756    arg_target->add_intvalue((int)target);
10757
10758    // copy argument attachment
10759    GLMessage_DataType *arg_attachment = glmsg.add_args();
10760    arg_attachment->set_isarray(false);
10761    arg_attachment->set_type(GLMessage::DataType::ENUM);
10762    arg_attachment->add_intvalue((int)attachment);
10763
10764    // copy argument renderbuffertarget
10765    GLMessage_DataType *arg_renderbuffertarget = glmsg.add_args();
10766    arg_renderbuffertarget->set_isarray(false);
10767    arg_renderbuffertarget->set_type(GLMessage::DataType::ENUM);
10768    arg_renderbuffertarget->add_intvalue((int)renderbuffertarget);
10769
10770    // copy argument renderbuffer
10771    GLMessage_DataType *arg_renderbuffer = glmsg.add_args();
10772    arg_renderbuffer->set_isarray(false);
10773    arg_renderbuffer->set_type(GLMessage::DataType::INT);
10774    arg_renderbuffer->add_intvalue(renderbuffer);
10775
10776    // call function
10777    glContext->hooks->gl.glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
10778
10779    fixupGLMessage(glContext, &glmsg);
10780    glContext->traceGLMessage(&glmsg);
10781}
10782
10783void GLTrace_glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {
10784    GLMessage glmsg;
10785    GLTraceContext *glContext = getGLTraceContext();
10786
10787    glmsg.set_function(GLMessage::glFramebufferTexture2DOES);
10788
10789    // copy argument target
10790    GLMessage_DataType *arg_target = glmsg.add_args();
10791    arg_target->set_isarray(false);
10792    arg_target->set_type(GLMessage::DataType::ENUM);
10793    arg_target->add_intvalue((int)target);
10794
10795    // copy argument attachment
10796    GLMessage_DataType *arg_attachment = glmsg.add_args();
10797    arg_attachment->set_isarray(false);
10798    arg_attachment->set_type(GLMessage::DataType::ENUM);
10799    arg_attachment->add_intvalue((int)attachment);
10800
10801    // copy argument textarget
10802    GLMessage_DataType *arg_textarget = glmsg.add_args();
10803    arg_textarget->set_isarray(false);
10804    arg_textarget->set_type(GLMessage::DataType::ENUM);
10805    arg_textarget->add_intvalue((int)textarget);
10806
10807    // copy argument texture
10808    GLMessage_DataType *arg_texture = glmsg.add_args();
10809    arg_texture->set_isarray(false);
10810    arg_texture->set_type(GLMessage::DataType::INT);
10811    arg_texture->add_intvalue(texture);
10812
10813    // copy argument level
10814    GLMessage_DataType *arg_level = glmsg.add_args();
10815    arg_level->set_isarray(false);
10816    arg_level->set_type(GLMessage::DataType::INT);
10817    arg_level->add_intvalue(level);
10818
10819    // call function
10820    glContext->hooks->gl.glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
10821
10822    fixupGLMessage(glContext, &glmsg);
10823    glContext->traceGLMessage(&glmsg);
10824}
10825
10826void GLTrace_glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params) {
10827    GLMessage glmsg;
10828    GLTraceContext *glContext = getGLTraceContext();
10829
10830    glmsg.set_function(GLMessage::glGetFramebufferAttachmentParameterivOES);
10831
10832    // copy argument target
10833    GLMessage_DataType *arg_target = glmsg.add_args();
10834    arg_target->set_isarray(false);
10835    arg_target->set_type(GLMessage::DataType::ENUM);
10836    arg_target->add_intvalue((int)target);
10837
10838    // copy argument attachment
10839    GLMessage_DataType *arg_attachment = glmsg.add_args();
10840    arg_attachment->set_isarray(false);
10841    arg_attachment->set_type(GLMessage::DataType::ENUM);
10842    arg_attachment->add_intvalue((int)attachment);
10843
10844    // copy argument pname
10845    GLMessage_DataType *arg_pname = glmsg.add_args();
10846    arg_pname->set_isarray(false);
10847    arg_pname->set_type(GLMessage::DataType::ENUM);
10848    arg_pname->add_intvalue((int)pname);
10849
10850    // copy argument params
10851    GLMessage_DataType *arg_params = glmsg.add_args();
10852    arg_params->set_isarray(false);
10853    arg_params->set_type(GLMessage::DataType::INT);
10854    arg_params->add_intvalue((int)params);
10855
10856    // call function
10857    glContext->hooks->gl.glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
10858
10859    fixupGLMessage(glContext, &glmsg);
10860    glContext->traceGLMessage(&glmsg);
10861}
10862
10863void GLTrace_glGenerateMipmapOES(GLenum target) {
10864    GLMessage glmsg;
10865    GLTraceContext *glContext = getGLTraceContext();
10866
10867    glmsg.set_function(GLMessage::glGenerateMipmapOES);
10868
10869    // copy argument target
10870    GLMessage_DataType *arg_target = glmsg.add_args();
10871    arg_target->set_isarray(false);
10872    arg_target->set_type(GLMessage::DataType::ENUM);
10873    arg_target->add_intvalue((int)target);
10874
10875    // call function
10876    glContext->hooks->gl.glGenerateMipmapOES(target);
10877
10878    fixupGLMessage(glContext, &glmsg);
10879    glContext->traceGLMessage(&glmsg);
10880}
10881
10882void GLTrace_glCurrentPaletteMatrixOES(GLuint matrixpaletteindex) {
10883    GLMessage glmsg;
10884    GLTraceContext *glContext = getGLTraceContext();
10885
10886    glmsg.set_function(GLMessage::glCurrentPaletteMatrixOES);
10887
10888    // copy argument matrixpaletteindex
10889    GLMessage_DataType *arg_matrixpaletteindex = glmsg.add_args();
10890    arg_matrixpaletteindex->set_isarray(false);
10891    arg_matrixpaletteindex->set_type(GLMessage::DataType::INT);
10892    arg_matrixpaletteindex->add_intvalue(matrixpaletteindex);
10893
10894    // call function
10895    glContext->hooks->gl.glCurrentPaletteMatrixOES(matrixpaletteindex);
10896
10897    fixupGLMessage(glContext, &glmsg);
10898    glContext->traceGLMessage(&glmsg);
10899}
10900
10901void GLTrace_glLoadPaletteFromModelViewMatrixOES(void) {
10902    GLMessage glmsg;
10903    GLTraceContext *glContext = getGLTraceContext();
10904
10905    glmsg.set_function(GLMessage::glLoadPaletteFromModelViewMatrixOES);
10906
10907    // call function
10908    glContext->hooks->gl.glLoadPaletteFromModelViewMatrixOES();
10909
10910    fixupGLMessage(glContext, &glmsg);
10911    glContext->traceGLMessage(&glmsg);
10912}
10913
10914void GLTrace_glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
10915    GLMessage glmsg;
10916    GLTraceContext *glContext = getGLTraceContext();
10917
10918    glmsg.set_function(GLMessage::glMatrixIndexPointerOES);
10919
10920    // copy argument size
10921    GLMessage_DataType *arg_size = glmsg.add_args();
10922    arg_size->set_isarray(false);
10923    arg_size->set_type(GLMessage::DataType::INT);
10924    arg_size->add_intvalue(size);
10925
10926    // copy argument type
10927    GLMessage_DataType *arg_type = glmsg.add_args();
10928    arg_type->set_isarray(false);
10929    arg_type->set_type(GLMessage::DataType::ENUM);
10930    arg_type->add_intvalue((int)type);
10931
10932    // copy argument stride
10933    GLMessage_DataType *arg_stride = glmsg.add_args();
10934    arg_stride->set_isarray(false);
10935    arg_stride->set_type(GLMessage::DataType::INT);
10936    arg_stride->add_intvalue(stride);
10937
10938    // copy argument pointer
10939    GLMessage_DataType *arg_pointer = glmsg.add_args();
10940    arg_pointer->set_isarray(false);
10941    arg_pointer->set_type(GLMessage::DataType::INT);
10942    arg_pointer->add_intvalue((int)pointer);
10943
10944    // call function
10945    glContext->hooks->gl.glMatrixIndexPointerOES(size, type, stride, pointer);
10946
10947    fixupGLMessage(glContext, &glmsg);
10948    glContext->traceGLMessage(&glmsg);
10949}
10950
10951void GLTrace_glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
10952    GLMessage glmsg;
10953    GLTraceContext *glContext = getGLTraceContext();
10954
10955    glmsg.set_function(GLMessage::glWeightPointerOES);
10956
10957    // copy argument size
10958    GLMessage_DataType *arg_size = glmsg.add_args();
10959    arg_size->set_isarray(false);
10960    arg_size->set_type(GLMessage::DataType::INT);
10961    arg_size->add_intvalue(size);
10962
10963    // copy argument type
10964    GLMessage_DataType *arg_type = glmsg.add_args();
10965    arg_type->set_isarray(false);
10966    arg_type->set_type(GLMessage::DataType::ENUM);
10967    arg_type->add_intvalue((int)type);
10968
10969    // copy argument stride
10970    GLMessage_DataType *arg_stride = glmsg.add_args();
10971    arg_stride->set_isarray(false);
10972    arg_stride->set_type(GLMessage::DataType::INT);
10973    arg_stride->add_intvalue(stride);
10974
10975    // copy argument pointer
10976    GLMessage_DataType *arg_pointer = glmsg.add_args();
10977    arg_pointer->set_isarray(false);
10978    arg_pointer->set_type(GLMessage::DataType::INT);
10979    arg_pointer->add_intvalue((int)pointer);
10980
10981    // call function
10982    glContext->hooks->gl.glWeightPointerOES(size, type, stride, pointer);
10983
10984    fixupGLMessage(glContext, &glmsg);
10985    glContext->traceGLMessage(&glmsg);
10986}
10987
10988GLbitfield GLTrace_glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]) {
10989    GLMessage glmsg;
10990    GLTraceContext *glContext = getGLTraceContext();
10991
10992    glmsg.set_function(GLMessage::glQueryMatrixxOES);
10993
10994    // copy argument mantissa
10995    GLMessage_DataType *arg_mantissa = glmsg.add_args();
10996    arg_mantissa->set_isarray(false);
10997    arg_mantissa->set_type(GLMessage::DataType::INT);
10998    arg_mantissa->add_intvalue((int)mantissa);
10999
11000    // copy argument exponent
11001    GLMessage_DataType *arg_exponent = glmsg.add_args();
11002    arg_exponent->set_isarray(false);
11003    arg_exponent->set_type(GLMessage::DataType::INT);
11004    arg_exponent->add_intvalue((int)exponent);
11005
11006    // call function
11007    GLbitfield retValue = glContext->hooks->gl.glQueryMatrixxOES(mantissa, exponent);
11008
11009    // set return value
11010    GLMessage_DataType *rt = glmsg.mutable_returnvalue();
11011    rt->set_isarray(false);
11012    rt->set_type(GLMessage::DataType::INT);
11013    rt->add_intvalue(retValue);
11014
11015    fixupGLMessage(glContext, &glmsg);
11016    glContext->traceGLMessage(&glmsg);
11017
11018    return retValue;
11019}
11020
11021void GLTrace_glDepthRangefOES(GLclampf zNear, GLclampf zFar) {
11022    GLMessage glmsg;
11023    GLTraceContext *glContext = getGLTraceContext();
11024
11025    glmsg.set_function(GLMessage::glDepthRangefOES);
11026
11027    // copy argument zNear
11028    GLMessage_DataType *arg_zNear = glmsg.add_args();
11029    arg_zNear->set_isarray(false);
11030    arg_zNear->set_type(GLMessage::DataType::FLOAT);
11031    arg_zNear->add_floatvalue(zNear);
11032
11033    // copy argument zFar
11034    GLMessage_DataType *arg_zFar = glmsg.add_args();
11035    arg_zFar->set_isarray(false);
11036    arg_zFar->set_type(GLMessage::DataType::FLOAT);
11037    arg_zFar->add_floatvalue(zFar);
11038
11039    // call function
11040    glContext->hooks->gl.glDepthRangefOES(zNear, zFar);
11041
11042    fixupGLMessage(glContext, &glmsg);
11043    glContext->traceGLMessage(&glmsg);
11044}
11045
11046void GLTrace_glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
11047    GLMessage glmsg;
11048    GLTraceContext *glContext = getGLTraceContext();
11049
11050    glmsg.set_function(GLMessage::glFrustumfOES);
11051
11052    // copy argument left
11053    GLMessage_DataType *arg_left = glmsg.add_args();
11054    arg_left->set_isarray(false);
11055    arg_left->set_type(GLMessage::DataType::FLOAT);
11056    arg_left->add_floatvalue(left);
11057
11058    // copy argument right
11059    GLMessage_DataType *arg_right = glmsg.add_args();
11060    arg_right->set_isarray(false);
11061    arg_right->set_type(GLMessage::DataType::FLOAT);
11062    arg_right->add_floatvalue(right);
11063
11064    // copy argument bottom
11065    GLMessage_DataType *arg_bottom = glmsg.add_args();
11066    arg_bottom->set_isarray(false);
11067    arg_bottom->set_type(GLMessage::DataType::FLOAT);
11068    arg_bottom->add_floatvalue(bottom);
11069
11070    // copy argument top
11071    GLMessage_DataType *arg_top = glmsg.add_args();
11072    arg_top->set_isarray(false);
11073    arg_top->set_type(GLMessage::DataType::FLOAT);
11074    arg_top->add_floatvalue(top);
11075
11076    // copy argument zNear
11077    GLMessage_DataType *arg_zNear = glmsg.add_args();
11078    arg_zNear->set_isarray(false);
11079    arg_zNear->set_type(GLMessage::DataType::FLOAT);
11080    arg_zNear->add_floatvalue(zNear);
11081
11082    // copy argument zFar
11083    GLMessage_DataType *arg_zFar = glmsg.add_args();
11084    arg_zFar->set_isarray(false);
11085    arg_zFar->set_type(GLMessage::DataType::FLOAT);
11086    arg_zFar->add_floatvalue(zFar);
11087
11088    // call function
11089    glContext->hooks->gl.glFrustumfOES(left, right, bottom, top, zNear, zFar);
11090
11091    fixupGLMessage(glContext, &glmsg);
11092    glContext->traceGLMessage(&glmsg);
11093}
11094
11095void GLTrace_glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
11096    GLMessage glmsg;
11097    GLTraceContext *glContext = getGLTraceContext();
11098
11099    glmsg.set_function(GLMessage::glOrthofOES);
11100
11101    // copy argument left
11102    GLMessage_DataType *arg_left = glmsg.add_args();
11103    arg_left->set_isarray(false);
11104    arg_left->set_type(GLMessage::DataType::FLOAT);
11105    arg_left->add_floatvalue(left);
11106
11107    // copy argument right
11108    GLMessage_DataType *arg_right = glmsg.add_args();
11109    arg_right->set_isarray(false);
11110    arg_right->set_type(GLMessage::DataType::FLOAT);
11111    arg_right->add_floatvalue(right);
11112
11113    // copy argument bottom
11114    GLMessage_DataType *arg_bottom = glmsg.add_args();
11115    arg_bottom->set_isarray(false);
11116    arg_bottom->set_type(GLMessage::DataType::FLOAT);
11117    arg_bottom->add_floatvalue(bottom);
11118
11119    // copy argument top
11120    GLMessage_DataType *arg_top = glmsg.add_args();
11121    arg_top->set_isarray(false);
11122    arg_top->set_type(GLMessage::DataType::FLOAT);
11123    arg_top->add_floatvalue(top);
11124
11125    // copy argument zNear
11126    GLMessage_DataType *arg_zNear = glmsg.add_args();
11127    arg_zNear->set_isarray(false);
11128    arg_zNear->set_type(GLMessage::DataType::FLOAT);
11129    arg_zNear->add_floatvalue(zNear);
11130
11131    // copy argument zFar
11132    GLMessage_DataType *arg_zFar = glmsg.add_args();
11133    arg_zFar->set_isarray(false);
11134    arg_zFar->set_type(GLMessage::DataType::FLOAT);
11135    arg_zFar->add_floatvalue(zFar);
11136
11137    // call function
11138    glContext->hooks->gl.glOrthofOES(left, right, bottom, top, zNear, zFar);
11139
11140    fixupGLMessage(glContext, &glmsg);
11141    glContext->traceGLMessage(&glmsg);
11142}
11143
11144void GLTrace_glClipPlanefOES(GLenum plane, const GLfloat *equation) {
11145    GLMessage glmsg;
11146    GLTraceContext *glContext = getGLTraceContext();
11147
11148    glmsg.set_function(GLMessage::glClipPlanefOES);
11149
11150    // copy argument plane
11151    GLMessage_DataType *arg_plane = glmsg.add_args();
11152    arg_plane->set_isarray(false);
11153    arg_plane->set_type(GLMessage::DataType::ENUM);
11154    arg_plane->add_intvalue((int)plane);
11155
11156    // copy argument equation
11157    GLMessage_DataType *arg_equation = glmsg.add_args();
11158    arg_equation->set_isarray(false);
11159    arg_equation->set_type(GLMessage::DataType::INT);
11160    arg_equation->add_intvalue((int)equation);
11161
11162    // call function
11163    glContext->hooks->gl.glClipPlanefOES(plane, equation);
11164
11165    fixupGLMessage(glContext, &glmsg);
11166    glContext->traceGLMessage(&glmsg);
11167}
11168
11169void GLTrace_glGetClipPlanefOES(GLenum pname, GLfloat eqn[4]) {
11170    GLMessage glmsg;
11171    GLTraceContext *glContext = getGLTraceContext();
11172
11173    glmsg.set_function(GLMessage::glGetClipPlanefOES);
11174
11175    // copy argument pname
11176    GLMessage_DataType *arg_pname = glmsg.add_args();
11177    arg_pname->set_isarray(false);
11178    arg_pname->set_type(GLMessage::DataType::ENUM);
11179    arg_pname->add_intvalue((int)pname);
11180
11181    // copy argument eqn
11182    GLMessage_DataType *arg_eqn = glmsg.add_args();
11183    arg_eqn->set_isarray(false);
11184    arg_eqn->set_type(GLMessage::DataType::INT);
11185    arg_eqn->add_intvalue((int)eqn);
11186
11187    // call function
11188    glContext->hooks->gl.glGetClipPlanefOES(pname, eqn);
11189
11190    fixupGLMessage(glContext, &glmsg);
11191    glContext->traceGLMessage(&glmsg);
11192}
11193
11194void GLTrace_glClearDepthfOES(GLclampf depth) {
11195    GLMessage glmsg;
11196    GLTraceContext *glContext = getGLTraceContext();
11197
11198    glmsg.set_function(GLMessage::glClearDepthfOES);
11199
11200    // copy argument depth
11201    GLMessage_DataType *arg_depth = glmsg.add_args();
11202    arg_depth->set_isarray(false);
11203    arg_depth->set_type(GLMessage::DataType::FLOAT);
11204    arg_depth->add_floatvalue(depth);
11205
11206    // call function
11207    glContext->hooks->gl.glClearDepthfOES(depth);
11208
11209    fixupGLMessage(glContext, &glmsg);
11210    glContext->traceGLMessage(&glmsg);
11211}
11212
11213void GLTrace_glTexGenfOES(GLenum coord, GLenum pname, GLfloat param) {
11214    GLMessage glmsg;
11215    GLTraceContext *glContext = getGLTraceContext();
11216
11217    glmsg.set_function(GLMessage::glTexGenfOES);
11218
11219    // copy argument coord
11220    GLMessage_DataType *arg_coord = glmsg.add_args();
11221    arg_coord->set_isarray(false);
11222    arg_coord->set_type(GLMessage::DataType::ENUM);
11223    arg_coord->add_intvalue((int)coord);
11224
11225    // copy argument pname
11226    GLMessage_DataType *arg_pname = glmsg.add_args();
11227    arg_pname->set_isarray(false);
11228    arg_pname->set_type(GLMessage::DataType::ENUM);
11229    arg_pname->add_intvalue((int)pname);
11230
11231    // copy argument param
11232    GLMessage_DataType *arg_param = glmsg.add_args();
11233    arg_param->set_isarray(false);
11234    arg_param->set_type(GLMessage::DataType::FLOAT);
11235    arg_param->add_floatvalue(param);
11236
11237    // call function
11238    glContext->hooks->gl.glTexGenfOES(coord, pname, param);
11239
11240    fixupGLMessage(glContext, &glmsg);
11241    glContext->traceGLMessage(&glmsg);
11242}
11243
11244void GLTrace_glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params) {
11245    GLMessage glmsg;
11246    GLTraceContext *glContext = getGLTraceContext();
11247
11248    glmsg.set_function(GLMessage::glTexGenfvOES);
11249
11250    // copy argument coord
11251    GLMessage_DataType *arg_coord = glmsg.add_args();
11252    arg_coord->set_isarray(false);
11253    arg_coord->set_type(GLMessage::DataType::ENUM);
11254    arg_coord->add_intvalue((int)coord);
11255
11256    // copy argument pname
11257    GLMessage_DataType *arg_pname = glmsg.add_args();
11258    arg_pname->set_isarray(false);
11259    arg_pname->set_type(GLMessage::DataType::ENUM);
11260    arg_pname->add_intvalue((int)pname);
11261
11262    // copy argument params
11263    GLMessage_DataType *arg_params = glmsg.add_args();
11264    arg_params->set_isarray(false);
11265    arg_params->set_type(GLMessage::DataType::INT);
11266    arg_params->add_intvalue((int)params);
11267
11268    // call function
11269    glContext->hooks->gl.glTexGenfvOES(coord, pname, params);
11270
11271    fixupGLMessage(glContext, &glmsg);
11272    glContext->traceGLMessage(&glmsg);
11273}
11274
11275void GLTrace_glTexGeniOES(GLenum coord, GLenum pname, GLint param) {
11276    GLMessage glmsg;
11277    GLTraceContext *glContext = getGLTraceContext();
11278
11279    glmsg.set_function(GLMessage::glTexGeniOES);
11280
11281    // copy argument coord
11282    GLMessage_DataType *arg_coord = glmsg.add_args();
11283    arg_coord->set_isarray(false);
11284    arg_coord->set_type(GLMessage::DataType::ENUM);
11285    arg_coord->add_intvalue((int)coord);
11286
11287    // copy argument pname
11288    GLMessage_DataType *arg_pname = glmsg.add_args();
11289    arg_pname->set_isarray(false);
11290    arg_pname->set_type(GLMessage::DataType::ENUM);
11291    arg_pname->add_intvalue((int)pname);
11292
11293    // copy argument param
11294    GLMessage_DataType *arg_param = glmsg.add_args();
11295    arg_param->set_isarray(false);
11296    arg_param->set_type(GLMessage::DataType::INT);
11297    arg_param->add_intvalue(param);
11298
11299    // call function
11300    glContext->hooks->gl.glTexGeniOES(coord, pname, param);
11301
11302    fixupGLMessage(glContext, &glmsg);
11303    glContext->traceGLMessage(&glmsg);
11304}
11305
11306void GLTrace_glTexGenivOES(GLenum coord, GLenum pname, const GLint *params) {
11307    GLMessage glmsg;
11308    GLTraceContext *glContext = getGLTraceContext();
11309
11310    glmsg.set_function(GLMessage::glTexGenivOES);
11311
11312    // copy argument coord
11313    GLMessage_DataType *arg_coord = glmsg.add_args();
11314    arg_coord->set_isarray(false);
11315    arg_coord->set_type(GLMessage::DataType::ENUM);
11316    arg_coord->add_intvalue((int)coord);
11317
11318    // copy argument pname
11319    GLMessage_DataType *arg_pname = glmsg.add_args();
11320    arg_pname->set_isarray(false);
11321    arg_pname->set_type(GLMessage::DataType::ENUM);
11322    arg_pname->add_intvalue((int)pname);
11323
11324    // copy argument params
11325    GLMessage_DataType *arg_params = glmsg.add_args();
11326    arg_params->set_isarray(false);
11327    arg_params->set_type(GLMessage::DataType::INT);
11328    arg_params->add_intvalue((int)params);
11329
11330    // call function
11331    glContext->hooks->gl.glTexGenivOES(coord, pname, params);
11332
11333    fixupGLMessage(glContext, &glmsg);
11334    glContext->traceGLMessage(&glmsg);
11335}
11336
11337void GLTrace_glTexGenxOES(GLenum coord, GLenum pname, GLfixed param) {
11338    GLMessage glmsg;
11339    GLTraceContext *glContext = getGLTraceContext();
11340
11341    glmsg.set_function(GLMessage::glTexGenxOES);
11342
11343    // copy argument coord
11344    GLMessage_DataType *arg_coord = glmsg.add_args();
11345    arg_coord->set_isarray(false);
11346    arg_coord->set_type(GLMessage::DataType::ENUM);
11347    arg_coord->add_intvalue((int)coord);
11348
11349    // copy argument pname
11350    GLMessage_DataType *arg_pname = glmsg.add_args();
11351    arg_pname->set_isarray(false);
11352    arg_pname->set_type(GLMessage::DataType::ENUM);
11353    arg_pname->add_intvalue((int)pname);
11354
11355    // copy argument param
11356    GLMessage_DataType *arg_param = glmsg.add_args();
11357    arg_param->set_isarray(false);
11358    arg_param->set_type(GLMessage::DataType::INT);
11359    arg_param->add_intvalue(param);
11360
11361    // call function
11362    glContext->hooks->gl.glTexGenxOES(coord, pname, param);
11363
11364    fixupGLMessage(glContext, &glmsg);
11365    glContext->traceGLMessage(&glmsg);
11366}
11367
11368void GLTrace_glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params) {
11369    GLMessage glmsg;
11370    GLTraceContext *glContext = getGLTraceContext();
11371
11372    glmsg.set_function(GLMessage::glTexGenxvOES);
11373
11374    // copy argument coord
11375    GLMessage_DataType *arg_coord = glmsg.add_args();
11376    arg_coord->set_isarray(false);
11377    arg_coord->set_type(GLMessage::DataType::ENUM);
11378    arg_coord->add_intvalue((int)coord);
11379
11380    // copy argument pname
11381    GLMessage_DataType *arg_pname = glmsg.add_args();
11382    arg_pname->set_isarray(false);
11383    arg_pname->set_type(GLMessage::DataType::ENUM);
11384    arg_pname->add_intvalue((int)pname);
11385
11386    // copy argument params
11387    GLMessage_DataType *arg_params = glmsg.add_args();
11388    arg_params->set_isarray(false);
11389    arg_params->set_type(GLMessage::DataType::INT);
11390    arg_params->add_intvalue((int)params);
11391
11392    // call function
11393    glContext->hooks->gl.glTexGenxvOES(coord, pname, params);
11394
11395    fixupGLMessage(glContext, &glmsg);
11396    glContext->traceGLMessage(&glmsg);
11397}
11398
11399void GLTrace_glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) {
11400    GLMessage glmsg;
11401    GLTraceContext *glContext = getGLTraceContext();
11402
11403    glmsg.set_function(GLMessage::glGetTexGenfvOES);
11404
11405    // copy argument coord
11406    GLMessage_DataType *arg_coord = glmsg.add_args();
11407    arg_coord->set_isarray(false);
11408    arg_coord->set_type(GLMessage::DataType::ENUM);
11409    arg_coord->add_intvalue((int)coord);
11410
11411    // copy argument pname
11412    GLMessage_DataType *arg_pname = glmsg.add_args();
11413    arg_pname->set_isarray(false);
11414    arg_pname->set_type(GLMessage::DataType::ENUM);
11415    arg_pname->add_intvalue((int)pname);
11416
11417    // copy argument params
11418    GLMessage_DataType *arg_params = glmsg.add_args();
11419    arg_params->set_isarray(false);
11420    arg_params->set_type(GLMessage::DataType::INT);
11421    arg_params->add_intvalue((int)params);
11422
11423    // call function
11424    glContext->hooks->gl.glGetTexGenfvOES(coord, pname, params);
11425
11426    fixupGLMessage(glContext, &glmsg);
11427    glContext->traceGLMessage(&glmsg);
11428}
11429
11430void GLTrace_glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params) {
11431    GLMessage glmsg;
11432    GLTraceContext *glContext = getGLTraceContext();
11433
11434    glmsg.set_function(GLMessage::glGetTexGenivOES);
11435
11436    // copy argument coord
11437    GLMessage_DataType *arg_coord = glmsg.add_args();
11438    arg_coord->set_isarray(false);
11439    arg_coord->set_type(GLMessage::DataType::ENUM);
11440    arg_coord->add_intvalue((int)coord);
11441
11442    // copy argument pname
11443    GLMessage_DataType *arg_pname = glmsg.add_args();
11444    arg_pname->set_isarray(false);
11445    arg_pname->set_type(GLMessage::DataType::ENUM);
11446    arg_pname->add_intvalue((int)pname);
11447
11448    // copy argument params
11449    GLMessage_DataType *arg_params = glmsg.add_args();
11450    arg_params->set_isarray(false);
11451    arg_params->set_type(GLMessage::DataType::INT);
11452    arg_params->add_intvalue((int)params);
11453
11454    // call function
11455    glContext->hooks->gl.glGetTexGenivOES(coord, pname, params);
11456
11457    fixupGLMessage(glContext, &glmsg);
11458    glContext->traceGLMessage(&glmsg);
11459}
11460
11461void GLTrace_glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) {
11462    GLMessage glmsg;
11463    GLTraceContext *glContext = getGLTraceContext();
11464
11465    glmsg.set_function(GLMessage::glGetTexGenxvOES);
11466
11467    // copy argument coord
11468    GLMessage_DataType *arg_coord = glmsg.add_args();
11469    arg_coord->set_isarray(false);
11470    arg_coord->set_type(GLMessage::DataType::ENUM);
11471    arg_coord->add_intvalue((int)coord);
11472
11473    // copy argument pname
11474    GLMessage_DataType *arg_pname = glmsg.add_args();
11475    arg_pname->set_isarray(false);
11476    arg_pname->set_type(GLMessage::DataType::ENUM);
11477    arg_pname->add_intvalue((int)pname);
11478
11479    // copy argument params
11480    GLMessage_DataType *arg_params = glmsg.add_args();
11481    arg_params->set_isarray(false);
11482    arg_params->set_type(GLMessage::DataType::INT);
11483    arg_params->add_intvalue((int)params);
11484
11485    // call function
11486    glContext->hooks->gl.glGetTexGenxvOES(coord, pname, params);
11487
11488    fixupGLMessage(glContext, &glmsg);
11489    glContext->traceGLMessage(&glmsg);
11490}
11491
11492void GLTrace_glClipPlanefIMG(GLenum p, const GLfloat *eqn) {
11493    GLMessage glmsg;
11494    GLTraceContext *glContext = getGLTraceContext();
11495
11496    glmsg.set_function(GLMessage::glClipPlanefIMG);
11497
11498    // copy argument p
11499    GLMessage_DataType *arg_p = glmsg.add_args();
11500    arg_p->set_isarray(false);
11501    arg_p->set_type(GLMessage::DataType::ENUM);
11502    arg_p->add_intvalue((int)p);
11503
11504    // copy argument eqn
11505    GLMessage_DataType *arg_eqn = glmsg.add_args();
11506    arg_eqn->set_isarray(false);
11507    arg_eqn->set_type(GLMessage::DataType::INT);
11508    arg_eqn->add_intvalue((int)eqn);
11509
11510    // call function
11511    glContext->hooks->gl.glClipPlanefIMG(p, eqn);
11512
11513    fixupGLMessage(glContext, &glmsg);
11514    glContext->traceGLMessage(&glmsg);
11515}
11516
11517void GLTrace_glClipPlanexIMG(GLenum p, const GLfixed *eqn) {
11518    GLMessage glmsg;
11519    GLTraceContext *glContext = getGLTraceContext();
11520
11521    glmsg.set_function(GLMessage::glClipPlanexIMG);
11522
11523    // copy argument p
11524    GLMessage_DataType *arg_p = glmsg.add_args();
11525    arg_p->set_isarray(false);
11526    arg_p->set_type(GLMessage::DataType::ENUM);
11527    arg_p->add_intvalue((int)p);
11528
11529    // copy argument eqn
11530    GLMessage_DataType *arg_eqn = glmsg.add_args();
11531    arg_eqn->set_isarray(false);
11532    arg_eqn->set_type(GLMessage::DataType::INT);
11533    arg_eqn->add_intvalue((int)eqn);
11534
11535    // call function
11536    glContext->hooks->gl.glClipPlanexIMG(p, eqn);
11537
11538    fixupGLMessage(glContext, &glmsg);
11539    glContext->traceGLMessage(&glmsg);
11540}
11541
11542
11543
11544}; // namespace gltrace
11545}; // namespace android
11546