gltrace_api.cpp revision 0469dd6d55fa331bfd7de9431da98b6340d82271
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 11922