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