gltrace_api.cpp revision 05df4504e57657994a89e424b6881ee26d0f313c
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 <utils/Timers.h> 21#include <GLES2/gl2.h> 22 23#include "gltrace.pb.h" 24#include "gltrace_context.h" 25#include "gltrace_fixup.h" 26#include "gltrace_transport.h" 27 28namespace android { 29namespace gltrace { 30 31// Definitions for GL2 APIs 32 33void GLTrace_glActiveTexture(GLenum texture) { 34 GLMessage glmsg; 35 GLTraceContext *glContext = getGLTraceContext(); 36 37 glmsg.set_function(GLMessage::glActiveTexture); 38 39 // copy argument texture 40 GLMessage_DataType *arg_texture = glmsg.add_args(); 41 arg_texture->set_isarray(false); 42 arg_texture->set_type(GLMessage::DataType::ENUM); 43 arg_texture->add_intvalue((int)texture); 44 45 // call function 46 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 47 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 48 glContext->hooks->gl.glActiveTexture(texture); 49 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 50 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 51 52 fixupGLMessage(glContext, wallStartTime, wallEndTime, 53 threadStartTime, threadEndTime, 54 &glmsg); 55 glContext->traceGLMessage(&glmsg); 56} 57 58void GLTrace_glAttachShader(GLuint program, GLuint shader) { 59 GLMessage glmsg; 60 GLTraceContext *glContext = getGLTraceContext(); 61 62 glmsg.set_function(GLMessage::glAttachShader); 63 64 // copy argument program 65 GLMessage_DataType *arg_program = glmsg.add_args(); 66 arg_program->set_isarray(false); 67 arg_program->set_type(GLMessage::DataType::INT); 68 arg_program->add_intvalue(program); 69 70 // copy argument shader 71 GLMessage_DataType *arg_shader = glmsg.add_args(); 72 arg_shader->set_isarray(false); 73 arg_shader->set_type(GLMessage::DataType::INT); 74 arg_shader->add_intvalue(shader); 75 76 // call function 77 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 78 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 79 glContext->hooks->gl.glAttachShader(program, shader); 80 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 81 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 82 83 fixupGLMessage(glContext, wallStartTime, wallEndTime, 84 threadStartTime, threadEndTime, 85 &glmsg); 86 glContext->traceGLMessage(&glmsg); 87} 88 89void GLTrace_glBindAttribLocation(GLuint program, GLuint index, const GLchar* name) { 90 GLMessage glmsg; 91 GLTraceContext *glContext = getGLTraceContext(); 92 93 glmsg.set_function(GLMessage::glBindAttribLocation); 94 95 // copy argument program 96 GLMessage_DataType *arg_program = glmsg.add_args(); 97 arg_program->set_isarray(false); 98 arg_program->set_type(GLMessage::DataType::INT); 99 arg_program->add_intvalue(program); 100 101 // copy argument index 102 GLMessage_DataType *arg_index = glmsg.add_args(); 103 arg_index->set_isarray(false); 104 arg_index->set_type(GLMessage::DataType::INT); 105 arg_index->add_intvalue(index); 106 107 // copy argument name 108 GLMessage_DataType *arg_name = glmsg.add_args(); 109 arg_name->set_isarray(false); 110 arg_name->set_type(GLMessage::DataType::INT); 111 arg_name->add_intvalue((int)name); 112 113 // call function 114 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 115 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 116 glContext->hooks->gl.glBindAttribLocation(program, index, name); 117 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 118 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 119 120 fixupGLMessage(glContext, wallStartTime, wallEndTime, 121 threadStartTime, threadEndTime, 122 &glmsg); 123 glContext->traceGLMessage(&glmsg); 124} 125 126void GLTrace_glBindBuffer(GLenum target, GLuint buffer) { 127 GLMessage glmsg; 128 GLTraceContext *glContext = getGLTraceContext(); 129 130 glmsg.set_function(GLMessage::glBindBuffer); 131 132 // copy argument target 133 GLMessage_DataType *arg_target = glmsg.add_args(); 134 arg_target->set_isarray(false); 135 arg_target->set_type(GLMessage::DataType::ENUM); 136 arg_target->add_intvalue((int)target); 137 138 // copy argument buffer 139 GLMessage_DataType *arg_buffer = glmsg.add_args(); 140 arg_buffer->set_isarray(false); 141 arg_buffer->set_type(GLMessage::DataType::INT); 142 arg_buffer->add_intvalue(buffer); 143 144 // call function 145 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 146 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 147 glContext->hooks->gl.glBindBuffer(target, buffer); 148 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 149 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 150 151 fixupGLMessage(glContext, wallStartTime, wallEndTime, 152 threadStartTime, threadEndTime, 153 &glmsg); 154 glContext->traceGLMessage(&glmsg); 155} 156 157void GLTrace_glBindFramebuffer(GLenum target, GLuint framebuffer) { 158 GLMessage glmsg; 159 GLTraceContext *glContext = getGLTraceContext(); 160 161 glmsg.set_function(GLMessage::glBindFramebuffer); 162 163 // copy argument target 164 GLMessage_DataType *arg_target = glmsg.add_args(); 165 arg_target->set_isarray(false); 166 arg_target->set_type(GLMessage::DataType::ENUM); 167 arg_target->add_intvalue((int)target); 168 169 // copy argument framebuffer 170 GLMessage_DataType *arg_framebuffer = glmsg.add_args(); 171 arg_framebuffer->set_isarray(false); 172 arg_framebuffer->set_type(GLMessage::DataType::INT); 173 arg_framebuffer->add_intvalue(framebuffer); 174 175 // call function 176 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 177 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 178 glContext->hooks->gl.glBindFramebuffer(target, framebuffer); 179 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 180 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 181 182 fixupGLMessage(glContext, wallStartTime, wallEndTime, 183 threadStartTime, threadEndTime, 184 &glmsg); 185 glContext->traceGLMessage(&glmsg); 186} 187 188void GLTrace_glBindRenderbuffer(GLenum target, GLuint renderbuffer) { 189 GLMessage glmsg; 190 GLTraceContext *glContext = getGLTraceContext(); 191 192 glmsg.set_function(GLMessage::glBindRenderbuffer); 193 194 // copy argument target 195 GLMessage_DataType *arg_target = glmsg.add_args(); 196 arg_target->set_isarray(false); 197 arg_target->set_type(GLMessage::DataType::ENUM); 198 arg_target->add_intvalue((int)target); 199 200 // copy argument renderbuffer 201 GLMessage_DataType *arg_renderbuffer = glmsg.add_args(); 202 arg_renderbuffer->set_isarray(false); 203 arg_renderbuffer->set_type(GLMessage::DataType::INT); 204 arg_renderbuffer->add_intvalue(renderbuffer); 205 206 // call function 207 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 208 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 209 glContext->hooks->gl.glBindRenderbuffer(target, renderbuffer); 210 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 211 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 212 213 fixupGLMessage(glContext, wallStartTime, wallEndTime, 214 threadStartTime, threadEndTime, 215 &glmsg); 216 glContext->traceGLMessage(&glmsg); 217} 218 219void GLTrace_glBindTexture(GLenum target, GLuint texture) { 220 GLMessage glmsg; 221 GLTraceContext *glContext = getGLTraceContext(); 222 223 glmsg.set_function(GLMessage::glBindTexture); 224 225 // copy argument target 226 GLMessage_DataType *arg_target = glmsg.add_args(); 227 arg_target->set_isarray(false); 228 arg_target->set_type(GLMessage::DataType::ENUM); 229 arg_target->add_intvalue((int)target); 230 231 // copy argument texture 232 GLMessage_DataType *arg_texture = glmsg.add_args(); 233 arg_texture->set_isarray(false); 234 arg_texture->set_type(GLMessage::DataType::INT); 235 arg_texture->add_intvalue(texture); 236 237 // call function 238 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 239 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 240 glContext->hooks->gl.glBindTexture(target, texture); 241 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 242 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 243 244 fixupGLMessage(glContext, wallStartTime, wallEndTime, 245 threadStartTime, threadEndTime, 246 &glmsg); 247 glContext->traceGLMessage(&glmsg); 248} 249 250void GLTrace_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { 251 GLMessage glmsg; 252 GLTraceContext *glContext = getGLTraceContext(); 253 254 glmsg.set_function(GLMessage::glBlendColor); 255 256 // copy argument red 257 GLMessage_DataType *arg_red = glmsg.add_args(); 258 arg_red->set_isarray(false); 259 arg_red->set_type(GLMessage::DataType::FLOAT); 260 arg_red->add_floatvalue(red); 261 262 // copy argument green 263 GLMessage_DataType *arg_green = glmsg.add_args(); 264 arg_green->set_isarray(false); 265 arg_green->set_type(GLMessage::DataType::FLOAT); 266 arg_green->add_floatvalue(green); 267 268 // copy argument blue 269 GLMessage_DataType *arg_blue = glmsg.add_args(); 270 arg_blue->set_isarray(false); 271 arg_blue->set_type(GLMessage::DataType::FLOAT); 272 arg_blue->add_floatvalue(blue); 273 274 // copy argument alpha 275 GLMessage_DataType *arg_alpha = glmsg.add_args(); 276 arg_alpha->set_isarray(false); 277 arg_alpha->set_type(GLMessage::DataType::FLOAT); 278 arg_alpha->add_floatvalue(alpha); 279 280 // call function 281 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 282 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 283 glContext->hooks->gl.glBlendColor(red, green, blue, alpha); 284 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 285 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 286 287 fixupGLMessage(glContext, wallStartTime, wallEndTime, 288 threadStartTime, threadEndTime, 289 &glmsg); 290 glContext->traceGLMessage(&glmsg); 291} 292 293void GLTrace_glBlendEquation(GLenum mode) { 294 GLMessage glmsg; 295 GLTraceContext *glContext = getGLTraceContext(); 296 297 glmsg.set_function(GLMessage::glBlendEquation); 298 299 // copy argument mode 300 GLMessage_DataType *arg_mode = glmsg.add_args(); 301 arg_mode->set_isarray(false); 302 arg_mode->set_type(GLMessage::DataType::ENUM); 303 arg_mode->add_intvalue((int)mode); 304 305 // call function 306 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 307 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 308 glContext->hooks->gl.glBlendEquation(mode); 309 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 310 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 311 312 fixupGLMessage(glContext, wallStartTime, wallEndTime, 313 threadStartTime, threadEndTime, 314 &glmsg); 315 glContext->traceGLMessage(&glmsg); 316} 317 318void GLTrace_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { 319 GLMessage glmsg; 320 GLTraceContext *glContext = getGLTraceContext(); 321 322 glmsg.set_function(GLMessage::glBlendEquationSeparate); 323 324 // copy argument modeRGB 325 GLMessage_DataType *arg_modeRGB = glmsg.add_args(); 326 arg_modeRGB->set_isarray(false); 327 arg_modeRGB->set_type(GLMessage::DataType::ENUM); 328 arg_modeRGB->add_intvalue((int)modeRGB); 329 330 // copy argument modeAlpha 331 GLMessage_DataType *arg_modeAlpha = glmsg.add_args(); 332 arg_modeAlpha->set_isarray(false); 333 arg_modeAlpha->set_type(GLMessage::DataType::ENUM); 334 arg_modeAlpha->add_intvalue((int)modeAlpha); 335 336 // call function 337 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 338 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 339 glContext->hooks->gl.glBlendEquationSeparate(modeRGB, modeAlpha); 340 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 341 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 342 343 fixupGLMessage(glContext, wallStartTime, wallEndTime, 344 threadStartTime, threadEndTime, 345 &glmsg); 346 glContext->traceGLMessage(&glmsg); 347} 348 349void GLTrace_glBlendFunc(GLenum sfactor, GLenum dfactor) { 350 GLMessage glmsg; 351 GLTraceContext *glContext = getGLTraceContext(); 352 353 glmsg.set_function(GLMessage::glBlendFunc); 354 355 // copy argument sfactor 356 GLMessage_DataType *arg_sfactor = glmsg.add_args(); 357 arg_sfactor->set_isarray(false); 358 arg_sfactor->set_type(GLMessage::DataType::ENUM); 359 arg_sfactor->add_intvalue((int)sfactor); 360 361 // copy argument dfactor 362 GLMessage_DataType *arg_dfactor = glmsg.add_args(); 363 arg_dfactor->set_isarray(false); 364 arg_dfactor->set_type(GLMessage::DataType::ENUM); 365 arg_dfactor->add_intvalue((int)dfactor); 366 367 // call function 368 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 369 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 370 glContext->hooks->gl.glBlendFunc(sfactor, dfactor); 371 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 372 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 373 374 fixupGLMessage(glContext, wallStartTime, wallEndTime, 375 threadStartTime, threadEndTime, 376 &glmsg); 377 glContext->traceGLMessage(&glmsg); 378} 379 380void GLTrace_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { 381 GLMessage glmsg; 382 GLTraceContext *glContext = getGLTraceContext(); 383 384 glmsg.set_function(GLMessage::glBlendFuncSeparate); 385 386 // copy argument srcRGB 387 GLMessage_DataType *arg_srcRGB = glmsg.add_args(); 388 arg_srcRGB->set_isarray(false); 389 arg_srcRGB->set_type(GLMessage::DataType::ENUM); 390 arg_srcRGB->add_intvalue((int)srcRGB); 391 392 // copy argument dstRGB 393 GLMessage_DataType *arg_dstRGB = glmsg.add_args(); 394 arg_dstRGB->set_isarray(false); 395 arg_dstRGB->set_type(GLMessage::DataType::ENUM); 396 arg_dstRGB->add_intvalue((int)dstRGB); 397 398 // copy argument srcAlpha 399 GLMessage_DataType *arg_srcAlpha = glmsg.add_args(); 400 arg_srcAlpha->set_isarray(false); 401 arg_srcAlpha->set_type(GLMessage::DataType::ENUM); 402 arg_srcAlpha->add_intvalue((int)srcAlpha); 403 404 // copy argument dstAlpha 405 GLMessage_DataType *arg_dstAlpha = glmsg.add_args(); 406 arg_dstAlpha->set_isarray(false); 407 arg_dstAlpha->set_type(GLMessage::DataType::ENUM); 408 arg_dstAlpha->add_intvalue((int)dstAlpha); 409 410 // call function 411 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 412 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 413 glContext->hooks->gl.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); 414 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 415 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 416 417 fixupGLMessage(glContext, wallStartTime, wallEndTime, 418 threadStartTime, threadEndTime, 419 &glmsg); 420 glContext->traceGLMessage(&glmsg); 421} 422 423void GLTrace_glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) { 424 GLMessage glmsg; 425 GLTraceContext *glContext = getGLTraceContext(); 426 427 glmsg.set_function(GLMessage::glBufferData); 428 429 // copy argument target 430 GLMessage_DataType *arg_target = glmsg.add_args(); 431 arg_target->set_isarray(false); 432 arg_target->set_type(GLMessage::DataType::ENUM); 433 arg_target->add_intvalue((int)target); 434 435 // copy argument size 436 GLMessage_DataType *arg_size = glmsg.add_args(); 437 arg_size->set_isarray(false); 438 arg_size->set_type(GLMessage::DataType::INT); 439 arg_size->add_intvalue((int)size); 440 441 // copy argument data 442 GLMessage_DataType *arg_data = glmsg.add_args(); 443 arg_data->set_isarray(false); 444 arg_data->set_type(GLMessage::DataType::INT); 445 arg_data->add_intvalue((int)data); 446 447 // copy argument usage 448 GLMessage_DataType *arg_usage = glmsg.add_args(); 449 arg_usage->set_isarray(false); 450 arg_usage->set_type(GLMessage::DataType::ENUM); 451 arg_usage->add_intvalue((int)usage); 452 453 // call function 454 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 455 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 456 glContext->hooks->gl.glBufferData(target, size, data, usage); 457 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 458 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 459 460 fixupGLMessage(glContext, wallStartTime, wallEndTime, 461 threadStartTime, threadEndTime, 462 &glmsg); 463 glContext->traceGLMessage(&glmsg); 464} 465 466void GLTrace_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) { 467 GLMessage glmsg; 468 GLTraceContext *glContext = getGLTraceContext(); 469 470 glmsg.set_function(GLMessage::glBufferSubData); 471 472 // copy argument target 473 GLMessage_DataType *arg_target = glmsg.add_args(); 474 arg_target->set_isarray(false); 475 arg_target->set_type(GLMessage::DataType::ENUM); 476 arg_target->add_intvalue((int)target); 477 478 // copy argument offset 479 GLMessage_DataType *arg_offset = glmsg.add_args(); 480 arg_offset->set_isarray(false); 481 arg_offset->set_type(GLMessage::DataType::INT); 482 arg_offset->add_intvalue((int)offset); 483 484 // copy argument size 485 GLMessage_DataType *arg_size = glmsg.add_args(); 486 arg_size->set_isarray(false); 487 arg_size->set_type(GLMessage::DataType::INT); 488 arg_size->add_intvalue((int)size); 489 490 // copy argument data 491 GLMessage_DataType *arg_data = glmsg.add_args(); 492 arg_data->set_isarray(false); 493 arg_data->set_type(GLMessage::DataType::INT); 494 arg_data->add_intvalue((int)data); 495 496 // call function 497 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 498 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 499 glContext->hooks->gl.glBufferSubData(target, offset, size, data); 500 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 501 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 502 503 fixupGLMessage(glContext, wallStartTime, wallEndTime, 504 threadStartTime, threadEndTime, 505 &glmsg); 506 glContext->traceGLMessage(&glmsg); 507} 508 509GLenum GLTrace_glCheckFramebufferStatus(GLenum target) { 510 GLMessage glmsg; 511 GLTraceContext *glContext = getGLTraceContext(); 512 513 glmsg.set_function(GLMessage::glCheckFramebufferStatus); 514 515 // copy argument target 516 GLMessage_DataType *arg_target = glmsg.add_args(); 517 arg_target->set_isarray(false); 518 arg_target->set_type(GLMessage::DataType::ENUM); 519 arg_target->add_intvalue((int)target); 520 521 // call function 522 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 523 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 524 GLenum retValue = glContext->hooks->gl.glCheckFramebufferStatus(target); 525 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 526 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 527 528 // set return value 529 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 530 rt->set_isarray(false); 531 rt->set_type(GLMessage::DataType::ENUM); 532 rt->add_intvalue((int)retValue); 533 534 fixupGLMessage(glContext, wallStartTime, wallEndTime, 535 threadStartTime, threadEndTime, 536 &glmsg); 537 glContext->traceGLMessage(&glmsg); 538 539 return retValue; 540} 541 542void GLTrace_glClear(GLbitfield mask) { 543 GLMessage glmsg; 544 GLTraceContext *glContext = getGLTraceContext(); 545 546 glmsg.set_function(GLMessage::glClear); 547 548 // copy argument mask 549 GLMessage_DataType *arg_mask = glmsg.add_args(); 550 arg_mask->set_isarray(false); 551 arg_mask->set_type(GLMessage::DataType::INT); 552 arg_mask->add_intvalue(mask); 553 554 // call function 555 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 556 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 557 glContext->hooks->gl.glClear(mask); 558 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 559 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 560 561 fixupGLMessage(glContext, wallStartTime, wallEndTime, 562 threadStartTime, threadEndTime, 563 &glmsg); 564 glContext->traceGLMessage(&glmsg); 565} 566 567void GLTrace_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) { 568 GLMessage glmsg; 569 GLTraceContext *glContext = getGLTraceContext(); 570 571 glmsg.set_function(GLMessage::glClearColor); 572 573 // copy argument red 574 GLMessage_DataType *arg_red = glmsg.add_args(); 575 arg_red->set_isarray(false); 576 arg_red->set_type(GLMessage::DataType::FLOAT); 577 arg_red->add_floatvalue(red); 578 579 // copy argument green 580 GLMessage_DataType *arg_green = glmsg.add_args(); 581 arg_green->set_isarray(false); 582 arg_green->set_type(GLMessage::DataType::FLOAT); 583 arg_green->add_floatvalue(green); 584 585 // copy argument blue 586 GLMessage_DataType *arg_blue = glmsg.add_args(); 587 arg_blue->set_isarray(false); 588 arg_blue->set_type(GLMessage::DataType::FLOAT); 589 arg_blue->add_floatvalue(blue); 590 591 // copy argument alpha 592 GLMessage_DataType *arg_alpha = glmsg.add_args(); 593 arg_alpha->set_isarray(false); 594 arg_alpha->set_type(GLMessage::DataType::FLOAT); 595 arg_alpha->add_floatvalue(alpha); 596 597 // call function 598 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 599 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 600 glContext->hooks->gl.glClearColor(red, green, blue, alpha); 601 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 602 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 603 604 fixupGLMessage(glContext, wallStartTime, wallEndTime, 605 threadStartTime, threadEndTime, 606 &glmsg); 607 glContext->traceGLMessage(&glmsg); 608} 609 610void GLTrace_glClearDepthf(GLclampf depth) { 611 GLMessage glmsg; 612 GLTraceContext *glContext = getGLTraceContext(); 613 614 glmsg.set_function(GLMessage::glClearDepthf); 615 616 // copy argument depth 617 GLMessage_DataType *arg_depth = glmsg.add_args(); 618 arg_depth->set_isarray(false); 619 arg_depth->set_type(GLMessage::DataType::FLOAT); 620 arg_depth->add_floatvalue(depth); 621 622 // call function 623 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 624 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 625 glContext->hooks->gl.glClearDepthf(depth); 626 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 627 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 628 629 fixupGLMessage(glContext, wallStartTime, wallEndTime, 630 threadStartTime, threadEndTime, 631 &glmsg); 632 glContext->traceGLMessage(&glmsg); 633} 634 635void GLTrace_glClearStencil(GLint s) { 636 GLMessage glmsg; 637 GLTraceContext *glContext = getGLTraceContext(); 638 639 glmsg.set_function(GLMessage::glClearStencil); 640 641 // copy argument s 642 GLMessage_DataType *arg_s = glmsg.add_args(); 643 arg_s->set_isarray(false); 644 arg_s->set_type(GLMessage::DataType::INT); 645 arg_s->add_intvalue(s); 646 647 // call function 648 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 649 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 650 glContext->hooks->gl.glClearStencil(s); 651 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 652 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 653 654 fixupGLMessage(glContext, wallStartTime, wallEndTime, 655 threadStartTime, threadEndTime, 656 &glmsg); 657 glContext->traceGLMessage(&glmsg); 658} 659 660void GLTrace_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { 661 GLMessage glmsg; 662 GLTraceContext *glContext = getGLTraceContext(); 663 664 glmsg.set_function(GLMessage::glColorMask); 665 666 // copy argument red 667 GLMessage_DataType *arg_red = glmsg.add_args(); 668 arg_red->set_isarray(false); 669 arg_red->set_type(GLMessage::DataType::BOOL); 670 arg_red->add_boolvalue(red); 671 672 // copy argument green 673 GLMessage_DataType *arg_green = glmsg.add_args(); 674 arg_green->set_isarray(false); 675 arg_green->set_type(GLMessage::DataType::BOOL); 676 arg_green->add_boolvalue(green); 677 678 // copy argument blue 679 GLMessage_DataType *arg_blue = glmsg.add_args(); 680 arg_blue->set_isarray(false); 681 arg_blue->set_type(GLMessage::DataType::BOOL); 682 arg_blue->add_boolvalue(blue); 683 684 // copy argument alpha 685 GLMessage_DataType *arg_alpha = glmsg.add_args(); 686 arg_alpha->set_isarray(false); 687 arg_alpha->set_type(GLMessage::DataType::BOOL); 688 arg_alpha->add_boolvalue(alpha); 689 690 // call function 691 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 692 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 693 glContext->hooks->gl.glColorMask(red, green, blue, alpha); 694 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 695 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 696 697 fixupGLMessage(glContext, wallStartTime, wallEndTime, 698 threadStartTime, threadEndTime, 699 &glmsg); 700 glContext->traceGLMessage(&glmsg); 701} 702 703void GLTrace_glCompileShader(GLuint shader) { 704 GLMessage glmsg; 705 GLTraceContext *glContext = getGLTraceContext(); 706 707 glmsg.set_function(GLMessage::glCompileShader); 708 709 // copy argument shader 710 GLMessage_DataType *arg_shader = glmsg.add_args(); 711 arg_shader->set_isarray(false); 712 arg_shader->set_type(GLMessage::DataType::INT); 713 arg_shader->add_intvalue(shader); 714 715 // call function 716 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 717 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 718 glContext->hooks->gl.glCompileShader(shader); 719 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 720 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 721 722 fixupGLMessage(glContext, wallStartTime, wallEndTime, 723 threadStartTime, threadEndTime, 724 &glmsg); 725 glContext->traceGLMessage(&glmsg); 726} 727 728void GLTrace_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) { 729 GLMessage glmsg; 730 GLTraceContext *glContext = getGLTraceContext(); 731 732 glmsg.set_function(GLMessage::glCompressedTexImage2D); 733 734 // copy argument target 735 GLMessage_DataType *arg_target = glmsg.add_args(); 736 arg_target->set_isarray(false); 737 arg_target->set_type(GLMessage::DataType::ENUM); 738 arg_target->add_intvalue((int)target); 739 740 // copy argument level 741 GLMessage_DataType *arg_level = glmsg.add_args(); 742 arg_level->set_isarray(false); 743 arg_level->set_type(GLMessage::DataType::INT); 744 arg_level->add_intvalue(level); 745 746 // copy argument internalformat 747 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 748 arg_internalformat->set_isarray(false); 749 arg_internalformat->set_type(GLMessage::DataType::ENUM); 750 arg_internalformat->add_intvalue((int)internalformat); 751 752 // copy argument width 753 GLMessage_DataType *arg_width = glmsg.add_args(); 754 arg_width->set_isarray(false); 755 arg_width->set_type(GLMessage::DataType::INT); 756 arg_width->add_intvalue(width); 757 758 // copy argument height 759 GLMessage_DataType *arg_height = glmsg.add_args(); 760 arg_height->set_isarray(false); 761 arg_height->set_type(GLMessage::DataType::INT); 762 arg_height->add_intvalue(height); 763 764 // copy argument border 765 GLMessage_DataType *arg_border = glmsg.add_args(); 766 arg_border->set_isarray(false); 767 arg_border->set_type(GLMessage::DataType::INT); 768 arg_border->add_intvalue(border); 769 770 // copy argument imageSize 771 GLMessage_DataType *arg_imageSize = glmsg.add_args(); 772 arg_imageSize->set_isarray(false); 773 arg_imageSize->set_type(GLMessage::DataType::INT); 774 arg_imageSize->add_intvalue(imageSize); 775 776 // copy argument data 777 GLMessage_DataType *arg_data = glmsg.add_args(); 778 arg_data->set_isarray(false); 779 arg_data->set_type(GLMessage::DataType::INT); 780 arg_data->add_intvalue((int)data); 781 782 // call function 783 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 784 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 785 glContext->hooks->gl.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); 786 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 787 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 788 789 fixupGLMessage(glContext, wallStartTime, wallEndTime, 790 threadStartTime, threadEndTime, 791 &glmsg); 792 glContext->traceGLMessage(&glmsg); 793} 794 795void GLTrace_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) { 796 GLMessage glmsg; 797 GLTraceContext *glContext = getGLTraceContext(); 798 799 glmsg.set_function(GLMessage::glCompressedTexSubImage2D); 800 801 // copy argument target 802 GLMessage_DataType *arg_target = glmsg.add_args(); 803 arg_target->set_isarray(false); 804 arg_target->set_type(GLMessage::DataType::ENUM); 805 arg_target->add_intvalue((int)target); 806 807 // copy argument level 808 GLMessage_DataType *arg_level = glmsg.add_args(); 809 arg_level->set_isarray(false); 810 arg_level->set_type(GLMessage::DataType::INT); 811 arg_level->add_intvalue(level); 812 813 // copy argument xoffset 814 GLMessage_DataType *arg_xoffset = glmsg.add_args(); 815 arg_xoffset->set_isarray(false); 816 arg_xoffset->set_type(GLMessage::DataType::INT); 817 arg_xoffset->add_intvalue(xoffset); 818 819 // copy argument yoffset 820 GLMessage_DataType *arg_yoffset = glmsg.add_args(); 821 arg_yoffset->set_isarray(false); 822 arg_yoffset->set_type(GLMessage::DataType::INT); 823 arg_yoffset->add_intvalue(yoffset); 824 825 // copy argument width 826 GLMessage_DataType *arg_width = glmsg.add_args(); 827 arg_width->set_isarray(false); 828 arg_width->set_type(GLMessage::DataType::INT); 829 arg_width->add_intvalue(width); 830 831 // copy argument height 832 GLMessage_DataType *arg_height = glmsg.add_args(); 833 arg_height->set_isarray(false); 834 arg_height->set_type(GLMessage::DataType::INT); 835 arg_height->add_intvalue(height); 836 837 // copy argument format 838 GLMessage_DataType *arg_format = glmsg.add_args(); 839 arg_format->set_isarray(false); 840 arg_format->set_type(GLMessage::DataType::ENUM); 841 arg_format->add_intvalue((int)format); 842 843 // copy argument imageSize 844 GLMessage_DataType *arg_imageSize = glmsg.add_args(); 845 arg_imageSize->set_isarray(false); 846 arg_imageSize->set_type(GLMessage::DataType::INT); 847 arg_imageSize->add_intvalue(imageSize); 848 849 // copy argument data 850 GLMessage_DataType *arg_data = glmsg.add_args(); 851 arg_data->set_isarray(false); 852 arg_data->set_type(GLMessage::DataType::INT); 853 arg_data->add_intvalue((int)data); 854 855 // call function 856 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 857 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 858 glContext->hooks->gl.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); 859 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 860 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 861 862 fixupGLMessage(glContext, wallStartTime, wallEndTime, 863 threadStartTime, threadEndTime, 864 &glmsg); 865 glContext->traceGLMessage(&glmsg); 866} 867 868void GLTrace_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { 869 GLMessage glmsg; 870 GLTraceContext *glContext = getGLTraceContext(); 871 872 glmsg.set_function(GLMessage::glCopyTexImage2D); 873 874 // copy argument target 875 GLMessage_DataType *arg_target = glmsg.add_args(); 876 arg_target->set_isarray(false); 877 arg_target->set_type(GLMessage::DataType::ENUM); 878 arg_target->add_intvalue((int)target); 879 880 // copy argument level 881 GLMessage_DataType *arg_level = glmsg.add_args(); 882 arg_level->set_isarray(false); 883 arg_level->set_type(GLMessage::DataType::INT); 884 arg_level->add_intvalue(level); 885 886 // copy argument internalformat 887 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 888 arg_internalformat->set_isarray(false); 889 arg_internalformat->set_type(GLMessage::DataType::ENUM); 890 arg_internalformat->add_intvalue((int)internalformat); 891 892 // copy argument x 893 GLMessage_DataType *arg_x = glmsg.add_args(); 894 arg_x->set_isarray(false); 895 arg_x->set_type(GLMessage::DataType::INT); 896 arg_x->add_intvalue(x); 897 898 // copy argument y 899 GLMessage_DataType *arg_y = glmsg.add_args(); 900 arg_y->set_isarray(false); 901 arg_y->set_type(GLMessage::DataType::INT); 902 arg_y->add_intvalue(y); 903 904 // copy argument width 905 GLMessage_DataType *arg_width = glmsg.add_args(); 906 arg_width->set_isarray(false); 907 arg_width->set_type(GLMessage::DataType::INT); 908 arg_width->add_intvalue(width); 909 910 // copy argument height 911 GLMessage_DataType *arg_height = glmsg.add_args(); 912 arg_height->set_isarray(false); 913 arg_height->set_type(GLMessage::DataType::INT); 914 arg_height->add_intvalue(height); 915 916 // copy argument border 917 GLMessage_DataType *arg_border = glmsg.add_args(); 918 arg_border->set_isarray(false); 919 arg_border->set_type(GLMessage::DataType::INT); 920 arg_border->add_intvalue(border); 921 922 // call function 923 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 924 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 925 glContext->hooks->gl.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); 926 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 927 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 928 929 fixupGLMessage(glContext, wallStartTime, wallEndTime, 930 threadStartTime, threadEndTime, 931 &glmsg); 932 glContext->traceGLMessage(&glmsg); 933} 934 935void GLTrace_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { 936 GLMessage glmsg; 937 GLTraceContext *glContext = getGLTraceContext(); 938 939 glmsg.set_function(GLMessage::glCopyTexSubImage2D); 940 941 // copy argument target 942 GLMessage_DataType *arg_target = glmsg.add_args(); 943 arg_target->set_isarray(false); 944 arg_target->set_type(GLMessage::DataType::ENUM); 945 arg_target->add_intvalue((int)target); 946 947 // copy argument level 948 GLMessage_DataType *arg_level = glmsg.add_args(); 949 arg_level->set_isarray(false); 950 arg_level->set_type(GLMessage::DataType::INT); 951 arg_level->add_intvalue(level); 952 953 // copy argument xoffset 954 GLMessage_DataType *arg_xoffset = glmsg.add_args(); 955 arg_xoffset->set_isarray(false); 956 arg_xoffset->set_type(GLMessage::DataType::INT); 957 arg_xoffset->add_intvalue(xoffset); 958 959 // copy argument yoffset 960 GLMessage_DataType *arg_yoffset = glmsg.add_args(); 961 arg_yoffset->set_isarray(false); 962 arg_yoffset->set_type(GLMessage::DataType::INT); 963 arg_yoffset->add_intvalue(yoffset); 964 965 // copy argument x 966 GLMessage_DataType *arg_x = glmsg.add_args(); 967 arg_x->set_isarray(false); 968 arg_x->set_type(GLMessage::DataType::INT); 969 arg_x->add_intvalue(x); 970 971 // copy argument y 972 GLMessage_DataType *arg_y = glmsg.add_args(); 973 arg_y->set_isarray(false); 974 arg_y->set_type(GLMessage::DataType::INT); 975 arg_y->add_intvalue(y); 976 977 // copy argument width 978 GLMessage_DataType *arg_width = glmsg.add_args(); 979 arg_width->set_isarray(false); 980 arg_width->set_type(GLMessage::DataType::INT); 981 arg_width->add_intvalue(width); 982 983 // copy argument height 984 GLMessage_DataType *arg_height = glmsg.add_args(); 985 arg_height->set_isarray(false); 986 arg_height->set_type(GLMessage::DataType::INT); 987 arg_height->add_intvalue(height); 988 989 // call function 990 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 991 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 992 glContext->hooks->gl.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); 993 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 994 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 995 996 fixupGLMessage(glContext, wallStartTime, wallEndTime, 997 threadStartTime, threadEndTime, 998 &glmsg); 999 glContext->traceGLMessage(&glmsg); 1000} 1001 1002GLuint GLTrace_glCreateProgram(void) { 1003 GLMessage glmsg; 1004 GLTraceContext *glContext = getGLTraceContext(); 1005 1006 glmsg.set_function(GLMessage::glCreateProgram); 1007 1008 // call function 1009 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1010 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1011 GLuint retValue = glContext->hooks->gl.glCreateProgram(); 1012 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1013 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1014 1015 // set return value 1016 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 1017 rt->set_isarray(false); 1018 rt->set_type(GLMessage::DataType::INT); 1019 rt->add_intvalue(retValue); 1020 1021 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1022 threadStartTime, threadEndTime, 1023 &glmsg); 1024 glContext->traceGLMessage(&glmsg); 1025 1026 return retValue; 1027} 1028 1029GLuint GLTrace_glCreateShader(GLenum type) { 1030 GLMessage glmsg; 1031 GLTraceContext *glContext = getGLTraceContext(); 1032 1033 glmsg.set_function(GLMessage::glCreateShader); 1034 1035 // copy argument type 1036 GLMessage_DataType *arg_type = glmsg.add_args(); 1037 arg_type->set_isarray(false); 1038 arg_type->set_type(GLMessage::DataType::ENUM); 1039 arg_type->add_intvalue((int)type); 1040 1041 // call function 1042 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1043 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1044 GLuint retValue = glContext->hooks->gl.glCreateShader(type); 1045 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1046 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1047 1048 // set return value 1049 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 1050 rt->set_isarray(false); 1051 rt->set_type(GLMessage::DataType::INT); 1052 rt->add_intvalue(retValue); 1053 1054 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1055 threadStartTime, threadEndTime, 1056 &glmsg); 1057 glContext->traceGLMessage(&glmsg); 1058 1059 return retValue; 1060} 1061 1062void GLTrace_glCullFace(GLenum mode) { 1063 GLMessage glmsg; 1064 GLTraceContext *glContext = getGLTraceContext(); 1065 1066 glmsg.set_function(GLMessage::glCullFace); 1067 1068 // copy argument mode 1069 GLMessage_DataType *arg_mode = glmsg.add_args(); 1070 arg_mode->set_isarray(false); 1071 arg_mode->set_type(GLMessage::DataType::ENUM); 1072 arg_mode->add_intvalue((int)mode); 1073 1074 // call function 1075 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1076 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1077 glContext->hooks->gl.glCullFace(mode); 1078 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1079 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1080 1081 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1082 threadStartTime, threadEndTime, 1083 &glmsg); 1084 glContext->traceGLMessage(&glmsg); 1085} 1086 1087void GLTrace_glDeleteBuffers(GLsizei n, const GLuint* buffers) { 1088 GLMessage glmsg; 1089 GLTraceContext *glContext = getGLTraceContext(); 1090 1091 glmsg.set_function(GLMessage::glDeleteBuffers); 1092 1093 // copy argument n 1094 GLMessage_DataType *arg_n = glmsg.add_args(); 1095 arg_n->set_isarray(false); 1096 arg_n->set_type(GLMessage::DataType::INT); 1097 arg_n->add_intvalue(n); 1098 1099 // copy argument buffers 1100 GLMessage_DataType *arg_buffers = glmsg.add_args(); 1101 arg_buffers->set_isarray(false); 1102 arg_buffers->set_type(GLMessage::DataType::INT); 1103 arg_buffers->add_intvalue((int)buffers); 1104 1105 // call function 1106 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1107 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1108 glContext->hooks->gl.glDeleteBuffers(n, buffers); 1109 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1110 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1111 1112 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1113 threadStartTime, threadEndTime, 1114 &glmsg); 1115 glContext->traceGLMessage(&glmsg); 1116} 1117 1118void GLTrace_glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) { 1119 GLMessage glmsg; 1120 GLTraceContext *glContext = getGLTraceContext(); 1121 1122 glmsg.set_function(GLMessage::glDeleteFramebuffers); 1123 1124 // copy argument n 1125 GLMessage_DataType *arg_n = glmsg.add_args(); 1126 arg_n->set_isarray(false); 1127 arg_n->set_type(GLMessage::DataType::INT); 1128 arg_n->add_intvalue(n); 1129 1130 // copy argument framebuffers 1131 GLMessage_DataType *arg_framebuffers = glmsg.add_args(); 1132 arg_framebuffers->set_isarray(false); 1133 arg_framebuffers->set_type(GLMessage::DataType::INT); 1134 arg_framebuffers->add_intvalue((int)framebuffers); 1135 1136 // call function 1137 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1138 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1139 glContext->hooks->gl.glDeleteFramebuffers(n, framebuffers); 1140 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1141 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1142 1143 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1144 threadStartTime, threadEndTime, 1145 &glmsg); 1146 glContext->traceGLMessage(&glmsg); 1147} 1148 1149void GLTrace_glDeleteProgram(GLuint program) { 1150 GLMessage glmsg; 1151 GLTraceContext *glContext = getGLTraceContext(); 1152 1153 glmsg.set_function(GLMessage::glDeleteProgram); 1154 1155 // copy argument program 1156 GLMessage_DataType *arg_program = glmsg.add_args(); 1157 arg_program->set_isarray(false); 1158 arg_program->set_type(GLMessage::DataType::INT); 1159 arg_program->add_intvalue(program); 1160 1161 // call function 1162 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1163 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1164 glContext->hooks->gl.glDeleteProgram(program); 1165 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1166 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1167 1168 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1169 threadStartTime, threadEndTime, 1170 &glmsg); 1171 glContext->traceGLMessage(&glmsg); 1172} 1173 1174void GLTrace_glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) { 1175 GLMessage glmsg; 1176 GLTraceContext *glContext = getGLTraceContext(); 1177 1178 glmsg.set_function(GLMessage::glDeleteRenderbuffers); 1179 1180 // copy argument n 1181 GLMessage_DataType *arg_n = glmsg.add_args(); 1182 arg_n->set_isarray(false); 1183 arg_n->set_type(GLMessage::DataType::INT); 1184 arg_n->add_intvalue(n); 1185 1186 // copy argument renderbuffers 1187 GLMessage_DataType *arg_renderbuffers = glmsg.add_args(); 1188 arg_renderbuffers->set_isarray(false); 1189 arg_renderbuffers->set_type(GLMessage::DataType::INT); 1190 arg_renderbuffers->add_intvalue((int)renderbuffers); 1191 1192 // call function 1193 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1194 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1195 glContext->hooks->gl.glDeleteRenderbuffers(n, renderbuffers); 1196 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1197 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1198 1199 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1200 threadStartTime, threadEndTime, 1201 &glmsg); 1202 glContext->traceGLMessage(&glmsg); 1203} 1204 1205void GLTrace_glDeleteShader(GLuint shader) { 1206 GLMessage glmsg; 1207 GLTraceContext *glContext = getGLTraceContext(); 1208 1209 glmsg.set_function(GLMessage::glDeleteShader); 1210 1211 // copy argument shader 1212 GLMessage_DataType *arg_shader = glmsg.add_args(); 1213 arg_shader->set_isarray(false); 1214 arg_shader->set_type(GLMessage::DataType::INT); 1215 arg_shader->add_intvalue(shader); 1216 1217 // call function 1218 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1219 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1220 glContext->hooks->gl.glDeleteShader(shader); 1221 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1222 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1223 1224 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1225 threadStartTime, threadEndTime, 1226 &glmsg); 1227 glContext->traceGLMessage(&glmsg); 1228} 1229 1230void GLTrace_glDeleteTextures(GLsizei n, const GLuint* textures) { 1231 GLMessage glmsg; 1232 GLTraceContext *glContext = getGLTraceContext(); 1233 1234 glmsg.set_function(GLMessage::glDeleteTextures); 1235 1236 // copy argument n 1237 GLMessage_DataType *arg_n = glmsg.add_args(); 1238 arg_n->set_isarray(false); 1239 arg_n->set_type(GLMessage::DataType::INT); 1240 arg_n->add_intvalue(n); 1241 1242 // copy argument textures 1243 GLMessage_DataType *arg_textures = glmsg.add_args(); 1244 arg_textures->set_isarray(false); 1245 arg_textures->set_type(GLMessage::DataType::INT); 1246 arg_textures->add_intvalue((int)textures); 1247 1248 // call function 1249 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1250 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1251 glContext->hooks->gl.glDeleteTextures(n, textures); 1252 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1253 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1254 1255 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1256 threadStartTime, threadEndTime, 1257 &glmsg); 1258 glContext->traceGLMessage(&glmsg); 1259} 1260 1261void GLTrace_glDepthFunc(GLenum func) { 1262 GLMessage glmsg; 1263 GLTraceContext *glContext = getGLTraceContext(); 1264 1265 glmsg.set_function(GLMessage::glDepthFunc); 1266 1267 // copy argument func 1268 GLMessage_DataType *arg_func = glmsg.add_args(); 1269 arg_func->set_isarray(false); 1270 arg_func->set_type(GLMessage::DataType::ENUM); 1271 arg_func->add_intvalue((int)func); 1272 1273 // call function 1274 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1275 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1276 glContext->hooks->gl.glDepthFunc(func); 1277 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1278 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1279 1280 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1281 threadStartTime, threadEndTime, 1282 &glmsg); 1283 glContext->traceGLMessage(&glmsg); 1284} 1285 1286void GLTrace_glDepthMask(GLboolean flag) { 1287 GLMessage glmsg; 1288 GLTraceContext *glContext = getGLTraceContext(); 1289 1290 glmsg.set_function(GLMessage::glDepthMask); 1291 1292 // copy argument flag 1293 GLMessage_DataType *arg_flag = glmsg.add_args(); 1294 arg_flag->set_isarray(false); 1295 arg_flag->set_type(GLMessage::DataType::BOOL); 1296 arg_flag->add_boolvalue(flag); 1297 1298 // call function 1299 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1300 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1301 glContext->hooks->gl.glDepthMask(flag); 1302 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1303 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1304 1305 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1306 threadStartTime, threadEndTime, 1307 &glmsg); 1308 glContext->traceGLMessage(&glmsg); 1309} 1310 1311void GLTrace_glDepthRangef(GLclampf zNear, GLclampf zFar) { 1312 GLMessage glmsg; 1313 GLTraceContext *glContext = getGLTraceContext(); 1314 1315 glmsg.set_function(GLMessage::glDepthRangef); 1316 1317 // copy argument zNear 1318 GLMessage_DataType *arg_zNear = glmsg.add_args(); 1319 arg_zNear->set_isarray(false); 1320 arg_zNear->set_type(GLMessage::DataType::FLOAT); 1321 arg_zNear->add_floatvalue(zNear); 1322 1323 // copy argument zFar 1324 GLMessage_DataType *arg_zFar = glmsg.add_args(); 1325 arg_zFar->set_isarray(false); 1326 arg_zFar->set_type(GLMessage::DataType::FLOAT); 1327 arg_zFar->add_floatvalue(zFar); 1328 1329 // call function 1330 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1331 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1332 glContext->hooks->gl.glDepthRangef(zNear, zFar); 1333 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1334 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1335 1336 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1337 threadStartTime, threadEndTime, 1338 &glmsg); 1339 glContext->traceGLMessage(&glmsg); 1340} 1341 1342void GLTrace_glDetachShader(GLuint program, GLuint shader) { 1343 GLMessage glmsg; 1344 GLTraceContext *glContext = getGLTraceContext(); 1345 1346 glmsg.set_function(GLMessage::glDetachShader); 1347 1348 // copy argument program 1349 GLMessage_DataType *arg_program = glmsg.add_args(); 1350 arg_program->set_isarray(false); 1351 arg_program->set_type(GLMessage::DataType::INT); 1352 arg_program->add_intvalue(program); 1353 1354 // copy argument shader 1355 GLMessage_DataType *arg_shader = glmsg.add_args(); 1356 arg_shader->set_isarray(false); 1357 arg_shader->set_type(GLMessage::DataType::INT); 1358 arg_shader->add_intvalue(shader); 1359 1360 // call function 1361 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1362 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1363 glContext->hooks->gl.glDetachShader(program, shader); 1364 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1365 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1366 1367 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1368 threadStartTime, threadEndTime, 1369 &glmsg); 1370 glContext->traceGLMessage(&glmsg); 1371} 1372 1373void GLTrace_glDisable(GLenum cap) { 1374 GLMessage glmsg; 1375 GLTraceContext *glContext = getGLTraceContext(); 1376 1377 glmsg.set_function(GLMessage::glDisable); 1378 1379 // copy argument cap 1380 GLMessage_DataType *arg_cap = glmsg.add_args(); 1381 arg_cap->set_isarray(false); 1382 arg_cap->set_type(GLMessage::DataType::ENUM); 1383 arg_cap->add_intvalue((int)cap); 1384 1385 // call function 1386 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1387 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1388 glContext->hooks->gl.glDisable(cap); 1389 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1390 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1391 1392 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1393 threadStartTime, threadEndTime, 1394 &glmsg); 1395 glContext->traceGLMessage(&glmsg); 1396} 1397 1398void GLTrace_glDisableVertexAttribArray(GLuint index) { 1399 GLMessage glmsg; 1400 GLTraceContext *glContext = getGLTraceContext(); 1401 1402 glmsg.set_function(GLMessage::glDisableVertexAttribArray); 1403 1404 // copy argument index 1405 GLMessage_DataType *arg_index = glmsg.add_args(); 1406 arg_index->set_isarray(false); 1407 arg_index->set_type(GLMessage::DataType::INT); 1408 arg_index->add_intvalue(index); 1409 1410 // call function 1411 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1412 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1413 glContext->hooks->gl.glDisableVertexAttribArray(index); 1414 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1415 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1416 1417 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1418 threadStartTime, threadEndTime, 1419 &glmsg); 1420 glContext->traceGLMessage(&glmsg); 1421} 1422 1423void GLTrace_glDrawArrays(GLenum mode, GLint first, GLsizei count) { 1424 GLMessage glmsg; 1425 GLTraceContext *glContext = getGLTraceContext(); 1426 1427 glmsg.set_function(GLMessage::glDrawArrays); 1428 1429 // copy argument mode 1430 GLMessage_DataType *arg_mode = glmsg.add_args(); 1431 arg_mode->set_isarray(false); 1432 arg_mode->set_type(GLMessage::DataType::ENUM); 1433 arg_mode->add_intvalue((int)mode); 1434 1435 // copy argument first 1436 GLMessage_DataType *arg_first = glmsg.add_args(); 1437 arg_first->set_isarray(false); 1438 arg_first->set_type(GLMessage::DataType::INT); 1439 arg_first->add_intvalue(first); 1440 1441 // copy argument count 1442 GLMessage_DataType *arg_count = glmsg.add_args(); 1443 arg_count->set_isarray(false); 1444 arg_count->set_type(GLMessage::DataType::INT); 1445 arg_count->add_intvalue(count); 1446 1447 // call function 1448 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1449 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1450 glContext->hooks->gl.glDrawArrays(mode, first, count); 1451 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1452 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1453 1454 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1455 threadStartTime, threadEndTime, 1456 &glmsg); 1457 glContext->traceGLMessage(&glmsg); 1458} 1459 1460void GLTrace_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) { 1461 GLMessage glmsg; 1462 GLTraceContext *glContext = getGLTraceContext(); 1463 1464 glmsg.set_function(GLMessage::glDrawElements); 1465 1466 // copy argument mode 1467 GLMessage_DataType *arg_mode = glmsg.add_args(); 1468 arg_mode->set_isarray(false); 1469 arg_mode->set_type(GLMessage::DataType::ENUM); 1470 arg_mode->add_intvalue((int)mode); 1471 1472 // copy argument count 1473 GLMessage_DataType *arg_count = glmsg.add_args(); 1474 arg_count->set_isarray(false); 1475 arg_count->set_type(GLMessage::DataType::INT); 1476 arg_count->add_intvalue(count); 1477 1478 // copy argument type 1479 GLMessage_DataType *arg_type = glmsg.add_args(); 1480 arg_type->set_isarray(false); 1481 arg_type->set_type(GLMessage::DataType::ENUM); 1482 arg_type->add_intvalue((int)type); 1483 1484 // copy argument indices 1485 GLMessage_DataType *arg_indices = glmsg.add_args(); 1486 arg_indices->set_isarray(false); 1487 arg_indices->set_type(GLMessage::DataType::INT); 1488 arg_indices->add_intvalue((int)indices); 1489 1490 // call function 1491 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1492 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1493 glContext->hooks->gl.glDrawElements(mode, count, type, indices); 1494 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1495 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1496 1497 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1498 threadStartTime, threadEndTime, 1499 &glmsg); 1500 glContext->traceGLMessage(&glmsg); 1501} 1502 1503void GLTrace_glEnable(GLenum cap) { 1504 GLMessage glmsg; 1505 GLTraceContext *glContext = getGLTraceContext(); 1506 1507 glmsg.set_function(GLMessage::glEnable); 1508 1509 // copy argument cap 1510 GLMessage_DataType *arg_cap = glmsg.add_args(); 1511 arg_cap->set_isarray(false); 1512 arg_cap->set_type(GLMessage::DataType::ENUM); 1513 arg_cap->add_intvalue((int)cap); 1514 1515 // call function 1516 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1517 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1518 glContext->hooks->gl.glEnable(cap); 1519 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1520 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1521 1522 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1523 threadStartTime, threadEndTime, 1524 &glmsg); 1525 glContext->traceGLMessage(&glmsg); 1526} 1527 1528void GLTrace_glEnableVertexAttribArray(GLuint index) { 1529 GLMessage glmsg; 1530 GLTraceContext *glContext = getGLTraceContext(); 1531 1532 glmsg.set_function(GLMessage::glEnableVertexAttribArray); 1533 1534 // copy argument index 1535 GLMessage_DataType *arg_index = glmsg.add_args(); 1536 arg_index->set_isarray(false); 1537 arg_index->set_type(GLMessage::DataType::INT); 1538 arg_index->add_intvalue(index); 1539 1540 // call function 1541 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1542 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1543 glContext->hooks->gl.glEnableVertexAttribArray(index); 1544 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1545 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1546 1547 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1548 threadStartTime, threadEndTime, 1549 &glmsg); 1550 glContext->traceGLMessage(&glmsg); 1551} 1552 1553void GLTrace_glFinish(void) { 1554 GLMessage glmsg; 1555 GLTraceContext *glContext = getGLTraceContext(); 1556 1557 glmsg.set_function(GLMessage::glFinish); 1558 1559 // call function 1560 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1561 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1562 glContext->hooks->gl.glFinish(); 1563 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1564 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1565 1566 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1567 threadStartTime, threadEndTime, 1568 &glmsg); 1569 glContext->traceGLMessage(&glmsg); 1570} 1571 1572void GLTrace_glFlush(void) { 1573 GLMessage glmsg; 1574 GLTraceContext *glContext = getGLTraceContext(); 1575 1576 glmsg.set_function(GLMessage::glFlush); 1577 1578 // call function 1579 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1580 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1581 glContext->hooks->gl.glFlush(); 1582 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1583 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1584 1585 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1586 threadStartTime, threadEndTime, 1587 &glmsg); 1588 glContext->traceGLMessage(&glmsg); 1589} 1590 1591void GLTrace_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { 1592 GLMessage glmsg; 1593 GLTraceContext *glContext = getGLTraceContext(); 1594 1595 glmsg.set_function(GLMessage::glFramebufferRenderbuffer); 1596 1597 // copy argument target 1598 GLMessage_DataType *arg_target = glmsg.add_args(); 1599 arg_target->set_isarray(false); 1600 arg_target->set_type(GLMessage::DataType::ENUM); 1601 arg_target->add_intvalue((int)target); 1602 1603 // copy argument attachment 1604 GLMessage_DataType *arg_attachment = glmsg.add_args(); 1605 arg_attachment->set_isarray(false); 1606 arg_attachment->set_type(GLMessage::DataType::ENUM); 1607 arg_attachment->add_intvalue((int)attachment); 1608 1609 // copy argument renderbuffertarget 1610 GLMessage_DataType *arg_renderbuffertarget = glmsg.add_args(); 1611 arg_renderbuffertarget->set_isarray(false); 1612 arg_renderbuffertarget->set_type(GLMessage::DataType::ENUM); 1613 arg_renderbuffertarget->add_intvalue((int)renderbuffertarget); 1614 1615 // copy argument renderbuffer 1616 GLMessage_DataType *arg_renderbuffer = glmsg.add_args(); 1617 arg_renderbuffer->set_isarray(false); 1618 arg_renderbuffer->set_type(GLMessage::DataType::INT); 1619 arg_renderbuffer->add_intvalue(renderbuffer); 1620 1621 // call function 1622 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1623 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1624 glContext->hooks->gl.glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); 1625 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1626 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1627 1628 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1629 threadStartTime, threadEndTime, 1630 &glmsg); 1631 glContext->traceGLMessage(&glmsg); 1632} 1633 1634void GLTrace_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { 1635 GLMessage glmsg; 1636 GLTraceContext *glContext = getGLTraceContext(); 1637 1638 glmsg.set_function(GLMessage::glFramebufferTexture2D); 1639 1640 // copy argument target 1641 GLMessage_DataType *arg_target = glmsg.add_args(); 1642 arg_target->set_isarray(false); 1643 arg_target->set_type(GLMessage::DataType::ENUM); 1644 arg_target->add_intvalue((int)target); 1645 1646 // copy argument attachment 1647 GLMessage_DataType *arg_attachment = glmsg.add_args(); 1648 arg_attachment->set_isarray(false); 1649 arg_attachment->set_type(GLMessage::DataType::ENUM); 1650 arg_attachment->add_intvalue((int)attachment); 1651 1652 // copy argument textarget 1653 GLMessage_DataType *arg_textarget = glmsg.add_args(); 1654 arg_textarget->set_isarray(false); 1655 arg_textarget->set_type(GLMessage::DataType::ENUM); 1656 arg_textarget->add_intvalue((int)textarget); 1657 1658 // copy argument texture 1659 GLMessage_DataType *arg_texture = glmsg.add_args(); 1660 arg_texture->set_isarray(false); 1661 arg_texture->set_type(GLMessage::DataType::INT); 1662 arg_texture->add_intvalue(texture); 1663 1664 // copy argument level 1665 GLMessage_DataType *arg_level = glmsg.add_args(); 1666 arg_level->set_isarray(false); 1667 arg_level->set_type(GLMessage::DataType::INT); 1668 arg_level->add_intvalue(level); 1669 1670 // call function 1671 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1672 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1673 glContext->hooks->gl.glFramebufferTexture2D(target, attachment, textarget, texture, level); 1674 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1675 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1676 1677 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1678 threadStartTime, threadEndTime, 1679 &glmsg); 1680 glContext->traceGLMessage(&glmsg); 1681} 1682 1683void GLTrace_glFrontFace(GLenum mode) { 1684 GLMessage glmsg; 1685 GLTraceContext *glContext = getGLTraceContext(); 1686 1687 glmsg.set_function(GLMessage::glFrontFace); 1688 1689 // copy argument mode 1690 GLMessage_DataType *arg_mode = glmsg.add_args(); 1691 arg_mode->set_isarray(false); 1692 arg_mode->set_type(GLMessage::DataType::ENUM); 1693 arg_mode->add_intvalue((int)mode); 1694 1695 // call function 1696 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1697 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1698 glContext->hooks->gl.glFrontFace(mode); 1699 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1700 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1701 1702 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1703 threadStartTime, threadEndTime, 1704 &glmsg); 1705 glContext->traceGLMessage(&glmsg); 1706} 1707 1708void GLTrace_glGenBuffers(GLsizei n, GLuint* buffers) { 1709 GLMessage glmsg; 1710 GLTraceContext *glContext = getGLTraceContext(); 1711 1712 glmsg.set_function(GLMessage::glGenBuffers); 1713 1714 // copy argument n 1715 GLMessage_DataType *arg_n = glmsg.add_args(); 1716 arg_n->set_isarray(false); 1717 arg_n->set_type(GLMessage::DataType::INT); 1718 arg_n->add_intvalue(n); 1719 1720 // copy argument buffers 1721 GLMessage_DataType *arg_buffers = glmsg.add_args(); 1722 arg_buffers->set_isarray(false); 1723 arg_buffers->set_type(GLMessage::DataType::INT); 1724 arg_buffers->add_intvalue((int)buffers); 1725 1726 // call function 1727 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1728 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1729 glContext->hooks->gl.glGenBuffers(n, buffers); 1730 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1731 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1732 1733 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1734 threadStartTime, threadEndTime, 1735 &glmsg); 1736 glContext->traceGLMessage(&glmsg); 1737} 1738 1739void GLTrace_glGenerateMipmap(GLenum target) { 1740 GLMessage glmsg; 1741 GLTraceContext *glContext = getGLTraceContext(); 1742 1743 glmsg.set_function(GLMessage::glGenerateMipmap); 1744 1745 // copy argument target 1746 GLMessage_DataType *arg_target = glmsg.add_args(); 1747 arg_target->set_isarray(false); 1748 arg_target->set_type(GLMessage::DataType::ENUM); 1749 arg_target->add_intvalue((int)target); 1750 1751 // call function 1752 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1753 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1754 glContext->hooks->gl.glGenerateMipmap(target); 1755 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1756 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1757 1758 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1759 threadStartTime, threadEndTime, 1760 &glmsg); 1761 glContext->traceGLMessage(&glmsg); 1762} 1763 1764void GLTrace_glGenFramebuffers(GLsizei n, GLuint* framebuffers) { 1765 GLMessage glmsg; 1766 GLTraceContext *glContext = getGLTraceContext(); 1767 1768 glmsg.set_function(GLMessage::glGenFramebuffers); 1769 1770 // copy argument n 1771 GLMessage_DataType *arg_n = glmsg.add_args(); 1772 arg_n->set_isarray(false); 1773 arg_n->set_type(GLMessage::DataType::INT); 1774 arg_n->add_intvalue(n); 1775 1776 // copy argument framebuffers 1777 GLMessage_DataType *arg_framebuffers = glmsg.add_args(); 1778 arg_framebuffers->set_isarray(false); 1779 arg_framebuffers->set_type(GLMessage::DataType::INT); 1780 arg_framebuffers->add_intvalue((int)framebuffers); 1781 1782 // call function 1783 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1784 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1785 glContext->hooks->gl.glGenFramebuffers(n, framebuffers); 1786 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1787 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1788 1789 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1790 threadStartTime, threadEndTime, 1791 &glmsg); 1792 glContext->traceGLMessage(&glmsg); 1793} 1794 1795void GLTrace_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) { 1796 GLMessage glmsg; 1797 GLTraceContext *glContext = getGLTraceContext(); 1798 1799 glmsg.set_function(GLMessage::glGenRenderbuffers); 1800 1801 // copy argument n 1802 GLMessage_DataType *arg_n = glmsg.add_args(); 1803 arg_n->set_isarray(false); 1804 arg_n->set_type(GLMessage::DataType::INT); 1805 arg_n->add_intvalue(n); 1806 1807 // copy argument renderbuffers 1808 GLMessage_DataType *arg_renderbuffers = glmsg.add_args(); 1809 arg_renderbuffers->set_isarray(false); 1810 arg_renderbuffers->set_type(GLMessage::DataType::INT); 1811 arg_renderbuffers->add_intvalue((int)renderbuffers); 1812 1813 // call function 1814 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1815 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1816 glContext->hooks->gl.glGenRenderbuffers(n, renderbuffers); 1817 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1818 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1819 1820 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1821 threadStartTime, threadEndTime, 1822 &glmsg); 1823 glContext->traceGLMessage(&glmsg); 1824} 1825 1826void GLTrace_glGenTextures(GLsizei n, GLuint* textures) { 1827 GLMessage glmsg; 1828 GLTraceContext *glContext = getGLTraceContext(); 1829 1830 glmsg.set_function(GLMessage::glGenTextures); 1831 1832 // copy argument n 1833 GLMessage_DataType *arg_n = glmsg.add_args(); 1834 arg_n->set_isarray(false); 1835 arg_n->set_type(GLMessage::DataType::INT); 1836 arg_n->add_intvalue(n); 1837 1838 // copy argument textures 1839 GLMessage_DataType *arg_textures = glmsg.add_args(); 1840 arg_textures->set_isarray(false); 1841 arg_textures->set_type(GLMessage::DataType::INT); 1842 arg_textures->add_intvalue((int)textures); 1843 1844 // call function 1845 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1846 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1847 glContext->hooks->gl.glGenTextures(n, textures); 1848 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1849 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1850 1851 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1852 threadStartTime, threadEndTime, 1853 &glmsg); 1854 glContext->traceGLMessage(&glmsg); 1855} 1856 1857void GLTrace_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { 1858 GLMessage glmsg; 1859 GLTraceContext *glContext = getGLTraceContext(); 1860 1861 glmsg.set_function(GLMessage::glGetActiveAttrib); 1862 1863 // copy argument program 1864 GLMessage_DataType *arg_program = glmsg.add_args(); 1865 arg_program->set_isarray(false); 1866 arg_program->set_type(GLMessage::DataType::INT); 1867 arg_program->add_intvalue(program); 1868 1869 // copy argument index 1870 GLMessage_DataType *arg_index = glmsg.add_args(); 1871 arg_index->set_isarray(false); 1872 arg_index->set_type(GLMessage::DataType::INT); 1873 arg_index->add_intvalue(index); 1874 1875 // copy argument bufsize 1876 GLMessage_DataType *arg_bufsize = glmsg.add_args(); 1877 arg_bufsize->set_isarray(false); 1878 arg_bufsize->set_type(GLMessage::DataType::INT); 1879 arg_bufsize->add_intvalue(bufsize); 1880 1881 // copy argument length 1882 GLMessage_DataType *arg_length = glmsg.add_args(); 1883 arg_length->set_isarray(false); 1884 arg_length->set_type(GLMessage::DataType::INT); 1885 arg_length->add_intvalue((int)length); 1886 1887 // copy argument size 1888 GLMessage_DataType *arg_size = glmsg.add_args(); 1889 arg_size->set_isarray(false); 1890 arg_size->set_type(GLMessage::DataType::INT); 1891 arg_size->add_intvalue((int)size); 1892 1893 // copy argument type 1894 GLMessage_DataType *arg_type = glmsg.add_args(); 1895 arg_type->set_isarray(false); 1896 arg_type->set_type(GLMessage::DataType::INT); 1897 arg_type->add_intvalue((int)type); 1898 1899 // copy argument name 1900 GLMessage_DataType *arg_name = glmsg.add_args(); 1901 arg_name->set_isarray(false); 1902 arg_name->set_type(GLMessage::DataType::INT); 1903 arg_name->add_intvalue((int)name); 1904 1905 // call function 1906 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1907 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1908 glContext->hooks->gl.glGetActiveAttrib(program, index, bufsize, length, size, type, name); 1909 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1910 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1911 1912 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1913 threadStartTime, threadEndTime, 1914 &glmsg); 1915 glContext->traceGLMessage(&glmsg); 1916} 1917 1918void GLTrace_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { 1919 GLMessage glmsg; 1920 GLTraceContext *glContext = getGLTraceContext(); 1921 1922 glmsg.set_function(GLMessage::glGetActiveUniform); 1923 1924 // copy argument program 1925 GLMessage_DataType *arg_program = glmsg.add_args(); 1926 arg_program->set_isarray(false); 1927 arg_program->set_type(GLMessage::DataType::INT); 1928 arg_program->add_intvalue(program); 1929 1930 // copy argument index 1931 GLMessage_DataType *arg_index = glmsg.add_args(); 1932 arg_index->set_isarray(false); 1933 arg_index->set_type(GLMessage::DataType::INT); 1934 arg_index->add_intvalue(index); 1935 1936 // copy argument bufsize 1937 GLMessage_DataType *arg_bufsize = glmsg.add_args(); 1938 arg_bufsize->set_isarray(false); 1939 arg_bufsize->set_type(GLMessage::DataType::INT); 1940 arg_bufsize->add_intvalue(bufsize); 1941 1942 // copy argument length 1943 GLMessage_DataType *arg_length = glmsg.add_args(); 1944 arg_length->set_isarray(false); 1945 arg_length->set_type(GLMessage::DataType::INT); 1946 arg_length->add_intvalue((int)length); 1947 1948 // copy argument size 1949 GLMessage_DataType *arg_size = glmsg.add_args(); 1950 arg_size->set_isarray(false); 1951 arg_size->set_type(GLMessage::DataType::INT); 1952 arg_size->add_intvalue((int)size); 1953 1954 // copy argument type 1955 GLMessage_DataType *arg_type = glmsg.add_args(); 1956 arg_type->set_isarray(false); 1957 arg_type->set_type(GLMessage::DataType::INT); 1958 arg_type->add_intvalue((int)type); 1959 1960 // copy argument name 1961 GLMessage_DataType *arg_name = glmsg.add_args(); 1962 arg_name->set_isarray(false); 1963 arg_name->set_type(GLMessage::DataType::INT); 1964 arg_name->add_intvalue((int)name); 1965 1966 // call function 1967 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 1968 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 1969 glContext->hooks->gl.glGetActiveUniform(program, index, bufsize, length, size, type, name); 1970 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 1971 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 1972 1973 fixupGLMessage(glContext, wallStartTime, wallEndTime, 1974 threadStartTime, threadEndTime, 1975 &glmsg); 1976 glContext->traceGLMessage(&glmsg); 1977} 1978 1979void GLTrace_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) { 1980 GLMessage glmsg; 1981 GLTraceContext *glContext = getGLTraceContext(); 1982 1983 glmsg.set_function(GLMessage::glGetAttachedShaders); 1984 1985 // copy argument program 1986 GLMessage_DataType *arg_program = glmsg.add_args(); 1987 arg_program->set_isarray(false); 1988 arg_program->set_type(GLMessage::DataType::INT); 1989 arg_program->add_intvalue(program); 1990 1991 // copy argument maxcount 1992 GLMessage_DataType *arg_maxcount = glmsg.add_args(); 1993 arg_maxcount->set_isarray(false); 1994 arg_maxcount->set_type(GLMessage::DataType::INT); 1995 arg_maxcount->add_intvalue(maxcount); 1996 1997 // copy argument count 1998 GLMessage_DataType *arg_count = glmsg.add_args(); 1999 arg_count->set_isarray(false); 2000 arg_count->set_type(GLMessage::DataType::INT); 2001 arg_count->add_intvalue((int)count); 2002 2003 // copy argument shaders 2004 GLMessage_DataType *arg_shaders = glmsg.add_args(); 2005 arg_shaders->set_isarray(false); 2006 arg_shaders->set_type(GLMessage::DataType::INT); 2007 arg_shaders->add_intvalue((int)shaders); 2008 2009 // call function 2010 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2011 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2012 glContext->hooks->gl.glGetAttachedShaders(program, maxcount, count, shaders); 2013 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2014 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2015 2016 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2017 threadStartTime, threadEndTime, 2018 &glmsg); 2019 glContext->traceGLMessage(&glmsg); 2020} 2021 2022int GLTrace_glGetAttribLocation(GLuint program, const GLchar* name) { 2023 GLMessage glmsg; 2024 GLTraceContext *glContext = getGLTraceContext(); 2025 2026 glmsg.set_function(GLMessage::glGetAttribLocation); 2027 2028 // copy argument program 2029 GLMessage_DataType *arg_program = glmsg.add_args(); 2030 arg_program->set_isarray(false); 2031 arg_program->set_type(GLMessage::DataType::INT); 2032 arg_program->add_intvalue(program); 2033 2034 // copy argument name 2035 GLMessage_DataType *arg_name = glmsg.add_args(); 2036 arg_name->set_isarray(false); 2037 arg_name->set_type(GLMessage::DataType::INT); 2038 arg_name->add_intvalue((int)name); 2039 2040 // call function 2041 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2042 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2043 int retValue = glContext->hooks->gl.glGetAttribLocation(program, name); 2044 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2045 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2046 2047 // set return value 2048 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 2049 rt->set_isarray(false); 2050 rt->set_type(GLMessage::DataType::INT); 2051 rt->add_intvalue(retValue); 2052 2053 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2054 threadStartTime, threadEndTime, 2055 &glmsg); 2056 glContext->traceGLMessage(&glmsg); 2057 2058 return retValue; 2059} 2060 2061void GLTrace_glGetBooleanv(GLenum pname, GLboolean* params) { 2062 GLMessage glmsg; 2063 GLTraceContext *glContext = getGLTraceContext(); 2064 2065 glmsg.set_function(GLMessage::glGetBooleanv); 2066 2067 // copy argument pname 2068 GLMessage_DataType *arg_pname = glmsg.add_args(); 2069 arg_pname->set_isarray(false); 2070 arg_pname->set_type(GLMessage::DataType::ENUM); 2071 arg_pname->add_intvalue((int)pname); 2072 2073 // copy argument params 2074 GLMessage_DataType *arg_params = glmsg.add_args(); 2075 arg_params->set_isarray(false); 2076 arg_params->set_type(GLMessage::DataType::INT); 2077 arg_params->add_intvalue((int)params); 2078 2079 // call function 2080 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2081 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2082 glContext->hooks->gl.glGetBooleanv(pname, params); 2083 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2084 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2085 2086 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2087 threadStartTime, threadEndTime, 2088 &glmsg); 2089 glContext->traceGLMessage(&glmsg); 2090} 2091 2092void GLTrace_glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { 2093 GLMessage glmsg; 2094 GLTraceContext *glContext = getGLTraceContext(); 2095 2096 glmsg.set_function(GLMessage::glGetBufferParameteriv); 2097 2098 // copy argument target 2099 GLMessage_DataType *arg_target = glmsg.add_args(); 2100 arg_target->set_isarray(false); 2101 arg_target->set_type(GLMessage::DataType::ENUM); 2102 arg_target->add_intvalue((int)target); 2103 2104 // copy argument pname 2105 GLMessage_DataType *arg_pname = glmsg.add_args(); 2106 arg_pname->set_isarray(false); 2107 arg_pname->set_type(GLMessage::DataType::ENUM); 2108 arg_pname->add_intvalue((int)pname); 2109 2110 // copy argument params 2111 GLMessage_DataType *arg_params = glmsg.add_args(); 2112 arg_params->set_isarray(false); 2113 arg_params->set_type(GLMessage::DataType::INT); 2114 arg_params->add_intvalue((int)params); 2115 2116 // call function 2117 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2118 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2119 glContext->hooks->gl.glGetBufferParameteriv(target, pname, params); 2120 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2121 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2122 2123 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2124 threadStartTime, threadEndTime, 2125 &glmsg); 2126 glContext->traceGLMessage(&glmsg); 2127} 2128 2129GLenum GLTrace_glGetError(void) { 2130 GLMessage glmsg; 2131 GLTraceContext *glContext = getGLTraceContext(); 2132 2133 glmsg.set_function(GLMessage::glGetError); 2134 2135 // call function 2136 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2137 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2138 GLenum retValue = glContext->hooks->gl.glGetError(); 2139 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2140 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2141 2142 // set return value 2143 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 2144 rt->set_isarray(false); 2145 rt->set_type(GLMessage::DataType::ENUM); 2146 rt->add_intvalue((int)retValue); 2147 2148 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2149 threadStartTime, threadEndTime, 2150 &glmsg); 2151 glContext->traceGLMessage(&glmsg); 2152 2153 return retValue; 2154} 2155 2156void GLTrace_glGetFloatv(GLenum pname, GLfloat* params) { 2157 GLMessage glmsg; 2158 GLTraceContext *glContext = getGLTraceContext(); 2159 2160 glmsg.set_function(GLMessage::glGetFloatv); 2161 2162 // copy argument pname 2163 GLMessage_DataType *arg_pname = glmsg.add_args(); 2164 arg_pname->set_isarray(false); 2165 arg_pname->set_type(GLMessage::DataType::ENUM); 2166 arg_pname->add_intvalue((int)pname); 2167 2168 // copy argument params 2169 GLMessage_DataType *arg_params = glmsg.add_args(); 2170 arg_params->set_isarray(false); 2171 arg_params->set_type(GLMessage::DataType::INT); 2172 arg_params->add_intvalue((int)params); 2173 2174 // call function 2175 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2176 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2177 glContext->hooks->gl.glGetFloatv(pname, params); 2178 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2179 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2180 2181 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2182 threadStartTime, threadEndTime, 2183 &glmsg); 2184 glContext->traceGLMessage(&glmsg); 2185} 2186 2187void GLTrace_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) { 2188 GLMessage glmsg; 2189 GLTraceContext *glContext = getGLTraceContext(); 2190 2191 glmsg.set_function(GLMessage::glGetFramebufferAttachmentParameteriv); 2192 2193 // copy argument target 2194 GLMessage_DataType *arg_target = glmsg.add_args(); 2195 arg_target->set_isarray(false); 2196 arg_target->set_type(GLMessage::DataType::ENUM); 2197 arg_target->add_intvalue((int)target); 2198 2199 // copy argument attachment 2200 GLMessage_DataType *arg_attachment = glmsg.add_args(); 2201 arg_attachment->set_isarray(false); 2202 arg_attachment->set_type(GLMessage::DataType::ENUM); 2203 arg_attachment->add_intvalue((int)attachment); 2204 2205 // copy argument pname 2206 GLMessage_DataType *arg_pname = glmsg.add_args(); 2207 arg_pname->set_isarray(false); 2208 arg_pname->set_type(GLMessage::DataType::ENUM); 2209 arg_pname->add_intvalue((int)pname); 2210 2211 // copy argument params 2212 GLMessage_DataType *arg_params = glmsg.add_args(); 2213 arg_params->set_isarray(false); 2214 arg_params->set_type(GLMessage::DataType::INT); 2215 arg_params->add_intvalue((int)params); 2216 2217 // call function 2218 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2219 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2220 glContext->hooks->gl.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); 2221 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2222 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2223 2224 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2225 threadStartTime, threadEndTime, 2226 &glmsg); 2227 glContext->traceGLMessage(&glmsg); 2228} 2229 2230void GLTrace_glGetIntegerv(GLenum pname, GLint* params) { 2231 GLMessage glmsg; 2232 GLTraceContext *glContext = getGLTraceContext(); 2233 2234 glmsg.set_function(GLMessage::glGetIntegerv); 2235 2236 // copy argument pname 2237 GLMessage_DataType *arg_pname = glmsg.add_args(); 2238 arg_pname->set_isarray(false); 2239 arg_pname->set_type(GLMessage::DataType::ENUM); 2240 arg_pname->add_intvalue((int)pname); 2241 2242 // copy argument params 2243 GLMessage_DataType *arg_params = glmsg.add_args(); 2244 arg_params->set_isarray(false); 2245 arg_params->set_type(GLMessage::DataType::INT); 2246 arg_params->add_intvalue((int)params); 2247 2248 // call function 2249 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2250 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2251 glContext->hooks->gl.glGetIntegerv(pname, params); 2252 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2253 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2254 2255 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2256 threadStartTime, threadEndTime, 2257 &glmsg); 2258 glContext->traceGLMessage(&glmsg); 2259} 2260 2261void GLTrace_glGetProgramiv(GLuint program, GLenum pname, GLint* params) { 2262 GLMessage glmsg; 2263 GLTraceContext *glContext = getGLTraceContext(); 2264 2265 glmsg.set_function(GLMessage::glGetProgramiv); 2266 2267 // copy argument program 2268 GLMessage_DataType *arg_program = glmsg.add_args(); 2269 arg_program->set_isarray(false); 2270 arg_program->set_type(GLMessage::DataType::INT); 2271 arg_program->add_intvalue(program); 2272 2273 // copy argument pname 2274 GLMessage_DataType *arg_pname = glmsg.add_args(); 2275 arg_pname->set_isarray(false); 2276 arg_pname->set_type(GLMessage::DataType::ENUM); 2277 arg_pname->add_intvalue((int)pname); 2278 2279 // copy argument params 2280 GLMessage_DataType *arg_params = glmsg.add_args(); 2281 arg_params->set_isarray(false); 2282 arg_params->set_type(GLMessage::DataType::INT); 2283 arg_params->add_intvalue((int)params); 2284 2285 // call function 2286 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2287 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2288 glContext->hooks->gl.glGetProgramiv(program, pname, params); 2289 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2290 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2291 2292 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2293 threadStartTime, threadEndTime, 2294 &glmsg); 2295 glContext->traceGLMessage(&glmsg); 2296} 2297 2298void GLTrace_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) { 2299 GLMessage glmsg; 2300 GLTraceContext *glContext = getGLTraceContext(); 2301 2302 glmsg.set_function(GLMessage::glGetProgramInfoLog); 2303 2304 // copy argument program 2305 GLMessage_DataType *arg_program = glmsg.add_args(); 2306 arg_program->set_isarray(false); 2307 arg_program->set_type(GLMessage::DataType::INT); 2308 arg_program->add_intvalue(program); 2309 2310 // copy argument bufsize 2311 GLMessage_DataType *arg_bufsize = glmsg.add_args(); 2312 arg_bufsize->set_isarray(false); 2313 arg_bufsize->set_type(GLMessage::DataType::INT); 2314 arg_bufsize->add_intvalue(bufsize); 2315 2316 // copy argument length 2317 GLMessage_DataType *arg_length = glmsg.add_args(); 2318 arg_length->set_isarray(false); 2319 arg_length->set_type(GLMessage::DataType::INT); 2320 arg_length->add_intvalue((int)length); 2321 2322 // copy argument infolog 2323 GLMessage_DataType *arg_infolog = glmsg.add_args(); 2324 arg_infolog->set_isarray(false); 2325 arg_infolog->set_type(GLMessage::DataType::INT); 2326 arg_infolog->add_intvalue((int)infolog); 2327 2328 // call function 2329 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2330 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2331 glContext->hooks->gl.glGetProgramInfoLog(program, bufsize, length, infolog); 2332 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2333 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2334 2335 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2336 threadStartTime, threadEndTime, 2337 &glmsg); 2338 glContext->traceGLMessage(&glmsg); 2339} 2340 2341void GLTrace_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) { 2342 GLMessage glmsg; 2343 GLTraceContext *glContext = getGLTraceContext(); 2344 2345 glmsg.set_function(GLMessage::glGetRenderbufferParameteriv); 2346 2347 // copy argument target 2348 GLMessage_DataType *arg_target = glmsg.add_args(); 2349 arg_target->set_isarray(false); 2350 arg_target->set_type(GLMessage::DataType::ENUM); 2351 arg_target->add_intvalue((int)target); 2352 2353 // copy argument pname 2354 GLMessage_DataType *arg_pname = glmsg.add_args(); 2355 arg_pname->set_isarray(false); 2356 arg_pname->set_type(GLMessage::DataType::ENUM); 2357 arg_pname->add_intvalue((int)pname); 2358 2359 // copy argument params 2360 GLMessage_DataType *arg_params = glmsg.add_args(); 2361 arg_params->set_isarray(false); 2362 arg_params->set_type(GLMessage::DataType::INT); 2363 arg_params->add_intvalue((int)params); 2364 2365 // call function 2366 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2367 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2368 glContext->hooks->gl.glGetRenderbufferParameteriv(target, pname, params); 2369 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2370 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2371 2372 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2373 threadStartTime, threadEndTime, 2374 &glmsg); 2375 glContext->traceGLMessage(&glmsg); 2376} 2377 2378void GLTrace_glGetShaderiv(GLuint shader, GLenum pname, GLint* params) { 2379 GLMessage glmsg; 2380 GLTraceContext *glContext = getGLTraceContext(); 2381 2382 glmsg.set_function(GLMessage::glGetShaderiv); 2383 2384 // copy argument shader 2385 GLMessage_DataType *arg_shader = glmsg.add_args(); 2386 arg_shader->set_isarray(false); 2387 arg_shader->set_type(GLMessage::DataType::INT); 2388 arg_shader->add_intvalue(shader); 2389 2390 // copy argument pname 2391 GLMessage_DataType *arg_pname = glmsg.add_args(); 2392 arg_pname->set_isarray(false); 2393 arg_pname->set_type(GLMessage::DataType::ENUM); 2394 arg_pname->add_intvalue((int)pname); 2395 2396 // copy argument params 2397 GLMessage_DataType *arg_params = glmsg.add_args(); 2398 arg_params->set_isarray(false); 2399 arg_params->set_type(GLMessage::DataType::INT); 2400 arg_params->add_intvalue((int)params); 2401 2402 // call function 2403 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2404 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2405 glContext->hooks->gl.glGetShaderiv(shader, pname, params); 2406 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2407 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2408 2409 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2410 threadStartTime, threadEndTime, 2411 &glmsg); 2412 glContext->traceGLMessage(&glmsg); 2413} 2414 2415void GLTrace_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) { 2416 GLMessage glmsg; 2417 GLTraceContext *glContext = getGLTraceContext(); 2418 2419 glmsg.set_function(GLMessage::glGetShaderInfoLog); 2420 2421 // copy argument shader 2422 GLMessage_DataType *arg_shader = glmsg.add_args(); 2423 arg_shader->set_isarray(false); 2424 arg_shader->set_type(GLMessage::DataType::INT); 2425 arg_shader->add_intvalue(shader); 2426 2427 // copy argument bufsize 2428 GLMessage_DataType *arg_bufsize = glmsg.add_args(); 2429 arg_bufsize->set_isarray(false); 2430 arg_bufsize->set_type(GLMessage::DataType::INT); 2431 arg_bufsize->add_intvalue(bufsize); 2432 2433 // copy argument length 2434 GLMessage_DataType *arg_length = glmsg.add_args(); 2435 arg_length->set_isarray(false); 2436 arg_length->set_type(GLMessage::DataType::INT); 2437 arg_length->add_intvalue((int)length); 2438 2439 // copy argument infolog 2440 GLMessage_DataType *arg_infolog = glmsg.add_args(); 2441 arg_infolog->set_isarray(false); 2442 arg_infolog->set_type(GLMessage::DataType::INT); 2443 arg_infolog->add_intvalue((int)infolog); 2444 2445 // call function 2446 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2447 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2448 glContext->hooks->gl.glGetShaderInfoLog(shader, bufsize, length, infolog); 2449 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2450 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2451 2452 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2453 threadStartTime, threadEndTime, 2454 &glmsg); 2455 glContext->traceGLMessage(&glmsg); 2456} 2457 2458void GLTrace_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { 2459 GLMessage glmsg; 2460 GLTraceContext *glContext = getGLTraceContext(); 2461 2462 glmsg.set_function(GLMessage::glGetShaderPrecisionFormat); 2463 2464 // copy argument shadertype 2465 GLMessage_DataType *arg_shadertype = glmsg.add_args(); 2466 arg_shadertype->set_isarray(false); 2467 arg_shadertype->set_type(GLMessage::DataType::ENUM); 2468 arg_shadertype->add_intvalue((int)shadertype); 2469 2470 // copy argument precisiontype 2471 GLMessage_DataType *arg_precisiontype = glmsg.add_args(); 2472 arg_precisiontype->set_isarray(false); 2473 arg_precisiontype->set_type(GLMessage::DataType::ENUM); 2474 arg_precisiontype->add_intvalue((int)precisiontype); 2475 2476 // copy argument range 2477 GLMessage_DataType *arg_range = glmsg.add_args(); 2478 arg_range->set_isarray(false); 2479 arg_range->set_type(GLMessage::DataType::INT); 2480 arg_range->add_intvalue((int)range); 2481 2482 // copy argument precision 2483 GLMessage_DataType *arg_precision = glmsg.add_args(); 2484 arg_precision->set_isarray(false); 2485 arg_precision->set_type(GLMessage::DataType::INT); 2486 arg_precision->add_intvalue((int)precision); 2487 2488 // call function 2489 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2490 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2491 glContext->hooks->gl.glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); 2492 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2493 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2494 2495 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2496 threadStartTime, threadEndTime, 2497 &glmsg); 2498 glContext->traceGLMessage(&glmsg); 2499} 2500 2501void GLTrace_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) { 2502 GLMessage glmsg; 2503 GLTraceContext *glContext = getGLTraceContext(); 2504 2505 glmsg.set_function(GLMessage::glGetShaderSource); 2506 2507 // copy argument shader 2508 GLMessage_DataType *arg_shader = glmsg.add_args(); 2509 arg_shader->set_isarray(false); 2510 arg_shader->set_type(GLMessage::DataType::INT); 2511 arg_shader->add_intvalue(shader); 2512 2513 // copy argument bufsize 2514 GLMessage_DataType *arg_bufsize = glmsg.add_args(); 2515 arg_bufsize->set_isarray(false); 2516 arg_bufsize->set_type(GLMessage::DataType::INT); 2517 arg_bufsize->add_intvalue(bufsize); 2518 2519 // copy argument length 2520 GLMessage_DataType *arg_length = glmsg.add_args(); 2521 arg_length->set_isarray(false); 2522 arg_length->set_type(GLMessage::DataType::INT); 2523 arg_length->add_intvalue((int)length); 2524 2525 // copy argument source 2526 GLMessage_DataType *arg_source = glmsg.add_args(); 2527 arg_source->set_isarray(false); 2528 arg_source->set_type(GLMessage::DataType::INT); 2529 arg_source->add_intvalue((int)source); 2530 2531 // call function 2532 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2533 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2534 glContext->hooks->gl.glGetShaderSource(shader, bufsize, length, source); 2535 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2536 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2537 2538 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2539 threadStartTime, threadEndTime, 2540 &glmsg); 2541 glContext->traceGLMessage(&glmsg); 2542} 2543 2544const GLubyte* GLTrace_glGetString(GLenum name) { 2545 GLMessage glmsg; 2546 GLTraceContext *glContext = getGLTraceContext(); 2547 2548 glmsg.set_function(GLMessage::glGetString); 2549 2550 // copy argument name 2551 GLMessage_DataType *arg_name = glmsg.add_args(); 2552 arg_name->set_isarray(false); 2553 arg_name->set_type(GLMessage::DataType::ENUM); 2554 arg_name->add_intvalue((int)name); 2555 2556 // call function 2557 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2558 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2559 const GLubyte* retValue = glContext->hooks->gl.glGetString(name); 2560 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2561 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2562 2563 // set return value 2564 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 2565 rt->set_isarray(false); 2566 rt->set_type(GLMessage::DataType::INT); 2567 rt->add_intvalue((int)retValue); 2568 2569 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2570 threadStartTime, threadEndTime, 2571 &glmsg); 2572 glContext->traceGLMessage(&glmsg); 2573 2574 return retValue; 2575} 2576 2577void GLTrace_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { 2578 GLMessage glmsg; 2579 GLTraceContext *glContext = getGLTraceContext(); 2580 2581 glmsg.set_function(GLMessage::glGetTexParameterfv); 2582 2583 // copy argument target 2584 GLMessage_DataType *arg_target = glmsg.add_args(); 2585 arg_target->set_isarray(false); 2586 arg_target->set_type(GLMessage::DataType::ENUM); 2587 arg_target->add_intvalue((int)target); 2588 2589 // copy argument pname 2590 GLMessage_DataType *arg_pname = glmsg.add_args(); 2591 arg_pname->set_isarray(false); 2592 arg_pname->set_type(GLMessage::DataType::ENUM); 2593 arg_pname->add_intvalue((int)pname); 2594 2595 // copy argument params 2596 GLMessage_DataType *arg_params = glmsg.add_args(); 2597 arg_params->set_isarray(false); 2598 arg_params->set_type(GLMessage::DataType::INT); 2599 arg_params->add_intvalue((int)params); 2600 2601 // call function 2602 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2603 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2604 glContext->hooks->gl.glGetTexParameterfv(target, pname, params); 2605 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2606 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2607 2608 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2609 threadStartTime, threadEndTime, 2610 &glmsg); 2611 glContext->traceGLMessage(&glmsg); 2612} 2613 2614void GLTrace_glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) { 2615 GLMessage glmsg; 2616 GLTraceContext *glContext = getGLTraceContext(); 2617 2618 glmsg.set_function(GLMessage::glGetTexParameteriv); 2619 2620 // copy argument target 2621 GLMessage_DataType *arg_target = glmsg.add_args(); 2622 arg_target->set_isarray(false); 2623 arg_target->set_type(GLMessage::DataType::ENUM); 2624 arg_target->add_intvalue((int)target); 2625 2626 // copy argument pname 2627 GLMessage_DataType *arg_pname = glmsg.add_args(); 2628 arg_pname->set_isarray(false); 2629 arg_pname->set_type(GLMessage::DataType::ENUM); 2630 arg_pname->add_intvalue((int)pname); 2631 2632 // copy argument params 2633 GLMessage_DataType *arg_params = glmsg.add_args(); 2634 arg_params->set_isarray(false); 2635 arg_params->set_type(GLMessage::DataType::INT); 2636 arg_params->add_intvalue((int)params); 2637 2638 // call function 2639 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2640 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2641 glContext->hooks->gl.glGetTexParameteriv(target, pname, params); 2642 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2643 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2644 2645 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2646 threadStartTime, threadEndTime, 2647 &glmsg); 2648 glContext->traceGLMessage(&glmsg); 2649} 2650 2651void GLTrace_glGetUniformfv(GLuint program, GLint location, GLfloat* params) { 2652 GLMessage glmsg; 2653 GLTraceContext *glContext = getGLTraceContext(); 2654 2655 glmsg.set_function(GLMessage::glGetUniformfv); 2656 2657 // copy argument program 2658 GLMessage_DataType *arg_program = glmsg.add_args(); 2659 arg_program->set_isarray(false); 2660 arg_program->set_type(GLMessage::DataType::INT); 2661 arg_program->add_intvalue(program); 2662 2663 // copy argument location 2664 GLMessage_DataType *arg_location = glmsg.add_args(); 2665 arg_location->set_isarray(false); 2666 arg_location->set_type(GLMessage::DataType::INT); 2667 arg_location->add_intvalue(location); 2668 2669 // copy argument params 2670 GLMessage_DataType *arg_params = glmsg.add_args(); 2671 arg_params->set_isarray(false); 2672 arg_params->set_type(GLMessage::DataType::INT); 2673 arg_params->add_intvalue((int)params); 2674 2675 // call function 2676 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2677 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2678 glContext->hooks->gl.glGetUniformfv(program, location, params); 2679 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2680 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2681 2682 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2683 threadStartTime, threadEndTime, 2684 &glmsg); 2685 glContext->traceGLMessage(&glmsg); 2686} 2687 2688void GLTrace_glGetUniformiv(GLuint program, GLint location, GLint* params) { 2689 GLMessage glmsg; 2690 GLTraceContext *glContext = getGLTraceContext(); 2691 2692 glmsg.set_function(GLMessage::glGetUniformiv); 2693 2694 // copy argument program 2695 GLMessage_DataType *arg_program = glmsg.add_args(); 2696 arg_program->set_isarray(false); 2697 arg_program->set_type(GLMessage::DataType::INT); 2698 arg_program->add_intvalue(program); 2699 2700 // copy argument location 2701 GLMessage_DataType *arg_location = glmsg.add_args(); 2702 arg_location->set_isarray(false); 2703 arg_location->set_type(GLMessage::DataType::INT); 2704 arg_location->add_intvalue(location); 2705 2706 // copy argument params 2707 GLMessage_DataType *arg_params = glmsg.add_args(); 2708 arg_params->set_isarray(false); 2709 arg_params->set_type(GLMessage::DataType::INT); 2710 arg_params->add_intvalue((int)params); 2711 2712 // call function 2713 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2714 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2715 glContext->hooks->gl.glGetUniformiv(program, location, params); 2716 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2717 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2718 2719 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2720 threadStartTime, threadEndTime, 2721 &glmsg); 2722 glContext->traceGLMessage(&glmsg); 2723} 2724 2725int GLTrace_glGetUniformLocation(GLuint program, const GLchar* name) { 2726 GLMessage glmsg; 2727 GLTraceContext *glContext = getGLTraceContext(); 2728 2729 glmsg.set_function(GLMessage::glGetUniformLocation); 2730 2731 // copy argument program 2732 GLMessage_DataType *arg_program = glmsg.add_args(); 2733 arg_program->set_isarray(false); 2734 arg_program->set_type(GLMessage::DataType::INT); 2735 arg_program->add_intvalue(program); 2736 2737 // copy argument name 2738 GLMessage_DataType *arg_name = glmsg.add_args(); 2739 arg_name->set_isarray(false); 2740 arg_name->set_type(GLMessage::DataType::INT); 2741 arg_name->add_intvalue((int)name); 2742 2743 // call function 2744 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2745 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2746 int retValue = glContext->hooks->gl.glGetUniformLocation(program, name); 2747 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2748 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2749 2750 // set return value 2751 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 2752 rt->set_isarray(false); 2753 rt->set_type(GLMessage::DataType::INT); 2754 rt->add_intvalue(retValue); 2755 2756 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2757 threadStartTime, threadEndTime, 2758 &glmsg); 2759 glContext->traceGLMessage(&glmsg); 2760 2761 return retValue; 2762} 2763 2764void GLTrace_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) { 2765 GLMessage glmsg; 2766 GLTraceContext *glContext = getGLTraceContext(); 2767 2768 glmsg.set_function(GLMessage::glGetVertexAttribfv); 2769 2770 // copy argument index 2771 GLMessage_DataType *arg_index = glmsg.add_args(); 2772 arg_index->set_isarray(false); 2773 arg_index->set_type(GLMessage::DataType::INT); 2774 arg_index->add_intvalue(index); 2775 2776 // copy argument pname 2777 GLMessage_DataType *arg_pname = glmsg.add_args(); 2778 arg_pname->set_isarray(false); 2779 arg_pname->set_type(GLMessage::DataType::ENUM); 2780 arg_pname->add_intvalue((int)pname); 2781 2782 // copy argument params 2783 GLMessage_DataType *arg_params = glmsg.add_args(); 2784 arg_params->set_isarray(false); 2785 arg_params->set_type(GLMessage::DataType::INT); 2786 arg_params->add_intvalue((int)params); 2787 2788 // call function 2789 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2790 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2791 glContext->hooks->gl.glGetVertexAttribfv(index, pname, params); 2792 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2793 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2794 2795 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2796 threadStartTime, threadEndTime, 2797 &glmsg); 2798 glContext->traceGLMessage(&glmsg); 2799} 2800 2801void GLTrace_glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) { 2802 GLMessage glmsg; 2803 GLTraceContext *glContext = getGLTraceContext(); 2804 2805 glmsg.set_function(GLMessage::glGetVertexAttribiv); 2806 2807 // copy argument index 2808 GLMessage_DataType *arg_index = glmsg.add_args(); 2809 arg_index->set_isarray(false); 2810 arg_index->set_type(GLMessage::DataType::INT); 2811 arg_index->add_intvalue(index); 2812 2813 // copy argument pname 2814 GLMessage_DataType *arg_pname = glmsg.add_args(); 2815 arg_pname->set_isarray(false); 2816 arg_pname->set_type(GLMessage::DataType::ENUM); 2817 arg_pname->add_intvalue((int)pname); 2818 2819 // copy argument params 2820 GLMessage_DataType *arg_params = glmsg.add_args(); 2821 arg_params->set_isarray(false); 2822 arg_params->set_type(GLMessage::DataType::INT); 2823 arg_params->add_intvalue((int)params); 2824 2825 // call function 2826 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2827 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2828 glContext->hooks->gl.glGetVertexAttribiv(index, pname, params); 2829 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2830 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2831 2832 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2833 threadStartTime, threadEndTime, 2834 &glmsg); 2835 glContext->traceGLMessage(&glmsg); 2836} 2837 2838void GLTrace_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer) { 2839 GLMessage glmsg; 2840 GLTraceContext *glContext = getGLTraceContext(); 2841 2842 glmsg.set_function(GLMessage::glGetVertexAttribPointerv); 2843 2844 // copy argument index 2845 GLMessage_DataType *arg_index = glmsg.add_args(); 2846 arg_index->set_isarray(false); 2847 arg_index->set_type(GLMessage::DataType::INT); 2848 arg_index->add_intvalue(index); 2849 2850 // copy argument pname 2851 GLMessage_DataType *arg_pname = glmsg.add_args(); 2852 arg_pname->set_isarray(false); 2853 arg_pname->set_type(GLMessage::DataType::ENUM); 2854 arg_pname->add_intvalue((int)pname); 2855 2856 // copy argument pointer 2857 GLMessage_DataType *arg_pointer = glmsg.add_args(); 2858 arg_pointer->set_isarray(false); 2859 arg_pointer->set_type(GLMessage::DataType::INT); 2860 arg_pointer->add_intvalue((int)pointer); 2861 2862 // call function 2863 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2864 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2865 glContext->hooks->gl.glGetVertexAttribPointerv(index, pname, pointer); 2866 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2867 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2868 2869 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2870 threadStartTime, threadEndTime, 2871 &glmsg); 2872 glContext->traceGLMessage(&glmsg); 2873} 2874 2875void GLTrace_glHint(GLenum target, GLenum mode) { 2876 GLMessage glmsg; 2877 GLTraceContext *glContext = getGLTraceContext(); 2878 2879 glmsg.set_function(GLMessage::glHint); 2880 2881 // copy argument target 2882 GLMessage_DataType *arg_target = glmsg.add_args(); 2883 arg_target->set_isarray(false); 2884 arg_target->set_type(GLMessage::DataType::ENUM); 2885 arg_target->add_intvalue((int)target); 2886 2887 // copy argument mode 2888 GLMessage_DataType *arg_mode = glmsg.add_args(); 2889 arg_mode->set_isarray(false); 2890 arg_mode->set_type(GLMessage::DataType::ENUM); 2891 arg_mode->add_intvalue((int)mode); 2892 2893 // call function 2894 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2895 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2896 glContext->hooks->gl.glHint(target, mode); 2897 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2898 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2899 2900 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2901 threadStartTime, threadEndTime, 2902 &glmsg); 2903 glContext->traceGLMessage(&glmsg); 2904} 2905 2906GLboolean GLTrace_glIsBuffer(GLuint buffer) { 2907 GLMessage glmsg; 2908 GLTraceContext *glContext = getGLTraceContext(); 2909 2910 glmsg.set_function(GLMessage::glIsBuffer); 2911 2912 // copy argument buffer 2913 GLMessage_DataType *arg_buffer = glmsg.add_args(); 2914 arg_buffer->set_isarray(false); 2915 arg_buffer->set_type(GLMessage::DataType::INT); 2916 arg_buffer->add_intvalue(buffer); 2917 2918 // call function 2919 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2920 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2921 GLboolean retValue = glContext->hooks->gl.glIsBuffer(buffer); 2922 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2923 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2924 2925 // set return value 2926 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 2927 rt->set_isarray(false); 2928 rt->set_type(GLMessage::DataType::BOOL); 2929 rt->add_boolvalue(retValue); 2930 2931 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2932 threadStartTime, threadEndTime, 2933 &glmsg); 2934 glContext->traceGLMessage(&glmsg); 2935 2936 return retValue; 2937} 2938 2939GLboolean GLTrace_glIsEnabled(GLenum cap) { 2940 GLMessage glmsg; 2941 GLTraceContext *glContext = getGLTraceContext(); 2942 2943 glmsg.set_function(GLMessage::glIsEnabled); 2944 2945 // copy argument cap 2946 GLMessage_DataType *arg_cap = glmsg.add_args(); 2947 arg_cap->set_isarray(false); 2948 arg_cap->set_type(GLMessage::DataType::ENUM); 2949 arg_cap->add_intvalue((int)cap); 2950 2951 // call function 2952 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2953 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2954 GLboolean retValue = glContext->hooks->gl.glIsEnabled(cap); 2955 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2956 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2957 2958 // set return value 2959 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 2960 rt->set_isarray(false); 2961 rt->set_type(GLMessage::DataType::BOOL); 2962 rt->add_boolvalue(retValue); 2963 2964 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2965 threadStartTime, threadEndTime, 2966 &glmsg); 2967 glContext->traceGLMessage(&glmsg); 2968 2969 return retValue; 2970} 2971 2972GLboolean GLTrace_glIsFramebuffer(GLuint framebuffer) { 2973 GLMessage glmsg; 2974 GLTraceContext *glContext = getGLTraceContext(); 2975 2976 glmsg.set_function(GLMessage::glIsFramebuffer); 2977 2978 // copy argument framebuffer 2979 GLMessage_DataType *arg_framebuffer = glmsg.add_args(); 2980 arg_framebuffer->set_isarray(false); 2981 arg_framebuffer->set_type(GLMessage::DataType::INT); 2982 arg_framebuffer->add_intvalue(framebuffer); 2983 2984 // call function 2985 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 2986 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 2987 GLboolean retValue = glContext->hooks->gl.glIsFramebuffer(framebuffer); 2988 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 2989 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 2990 2991 // set return value 2992 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 2993 rt->set_isarray(false); 2994 rt->set_type(GLMessage::DataType::BOOL); 2995 rt->add_boolvalue(retValue); 2996 2997 fixupGLMessage(glContext, wallStartTime, wallEndTime, 2998 threadStartTime, threadEndTime, 2999 &glmsg); 3000 glContext->traceGLMessage(&glmsg); 3001 3002 return retValue; 3003} 3004 3005GLboolean GLTrace_glIsProgram(GLuint program) { 3006 GLMessage glmsg; 3007 GLTraceContext *glContext = getGLTraceContext(); 3008 3009 glmsg.set_function(GLMessage::glIsProgram); 3010 3011 // copy argument program 3012 GLMessage_DataType *arg_program = glmsg.add_args(); 3013 arg_program->set_isarray(false); 3014 arg_program->set_type(GLMessage::DataType::INT); 3015 arg_program->add_intvalue(program); 3016 3017 // call function 3018 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3019 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3020 GLboolean retValue = glContext->hooks->gl.glIsProgram(program); 3021 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3022 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3023 3024 // set return value 3025 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 3026 rt->set_isarray(false); 3027 rt->set_type(GLMessage::DataType::BOOL); 3028 rt->add_boolvalue(retValue); 3029 3030 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3031 threadStartTime, threadEndTime, 3032 &glmsg); 3033 glContext->traceGLMessage(&glmsg); 3034 3035 return retValue; 3036} 3037 3038GLboolean GLTrace_glIsRenderbuffer(GLuint renderbuffer) { 3039 GLMessage glmsg; 3040 GLTraceContext *glContext = getGLTraceContext(); 3041 3042 glmsg.set_function(GLMessage::glIsRenderbuffer); 3043 3044 // copy argument renderbuffer 3045 GLMessage_DataType *arg_renderbuffer = glmsg.add_args(); 3046 arg_renderbuffer->set_isarray(false); 3047 arg_renderbuffer->set_type(GLMessage::DataType::INT); 3048 arg_renderbuffer->add_intvalue(renderbuffer); 3049 3050 // call function 3051 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3052 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3053 GLboolean retValue = glContext->hooks->gl.glIsRenderbuffer(renderbuffer); 3054 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3055 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3056 3057 // set return value 3058 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 3059 rt->set_isarray(false); 3060 rt->set_type(GLMessage::DataType::BOOL); 3061 rt->add_boolvalue(retValue); 3062 3063 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3064 threadStartTime, threadEndTime, 3065 &glmsg); 3066 glContext->traceGLMessage(&glmsg); 3067 3068 return retValue; 3069} 3070 3071GLboolean GLTrace_glIsShader(GLuint shader) { 3072 GLMessage glmsg; 3073 GLTraceContext *glContext = getGLTraceContext(); 3074 3075 glmsg.set_function(GLMessage::glIsShader); 3076 3077 // copy argument shader 3078 GLMessage_DataType *arg_shader = glmsg.add_args(); 3079 arg_shader->set_isarray(false); 3080 arg_shader->set_type(GLMessage::DataType::INT); 3081 arg_shader->add_intvalue(shader); 3082 3083 // call function 3084 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3085 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3086 GLboolean retValue = glContext->hooks->gl.glIsShader(shader); 3087 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3088 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3089 3090 // set return value 3091 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 3092 rt->set_isarray(false); 3093 rt->set_type(GLMessage::DataType::BOOL); 3094 rt->add_boolvalue(retValue); 3095 3096 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3097 threadStartTime, threadEndTime, 3098 &glmsg); 3099 glContext->traceGLMessage(&glmsg); 3100 3101 return retValue; 3102} 3103 3104GLboolean GLTrace_glIsTexture(GLuint texture) { 3105 GLMessage glmsg; 3106 GLTraceContext *glContext = getGLTraceContext(); 3107 3108 glmsg.set_function(GLMessage::glIsTexture); 3109 3110 // copy argument texture 3111 GLMessage_DataType *arg_texture = glmsg.add_args(); 3112 arg_texture->set_isarray(false); 3113 arg_texture->set_type(GLMessage::DataType::INT); 3114 arg_texture->add_intvalue(texture); 3115 3116 // call function 3117 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3118 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3119 GLboolean retValue = glContext->hooks->gl.glIsTexture(texture); 3120 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3121 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3122 3123 // set return value 3124 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 3125 rt->set_isarray(false); 3126 rt->set_type(GLMessage::DataType::BOOL); 3127 rt->add_boolvalue(retValue); 3128 3129 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3130 threadStartTime, threadEndTime, 3131 &glmsg); 3132 glContext->traceGLMessage(&glmsg); 3133 3134 return retValue; 3135} 3136 3137void GLTrace_glLineWidth(GLfloat width) { 3138 GLMessage glmsg; 3139 GLTraceContext *glContext = getGLTraceContext(); 3140 3141 glmsg.set_function(GLMessage::glLineWidth); 3142 3143 // copy argument width 3144 GLMessage_DataType *arg_width = glmsg.add_args(); 3145 arg_width->set_isarray(false); 3146 arg_width->set_type(GLMessage::DataType::FLOAT); 3147 arg_width->add_floatvalue(width); 3148 3149 // call function 3150 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3151 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3152 glContext->hooks->gl.glLineWidth(width); 3153 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3154 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3155 3156 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3157 threadStartTime, threadEndTime, 3158 &glmsg); 3159 glContext->traceGLMessage(&glmsg); 3160} 3161 3162void GLTrace_glLinkProgram(GLuint program) { 3163 GLMessage glmsg; 3164 GLTraceContext *glContext = getGLTraceContext(); 3165 3166 glmsg.set_function(GLMessage::glLinkProgram); 3167 3168 // copy argument program 3169 GLMessage_DataType *arg_program = glmsg.add_args(); 3170 arg_program->set_isarray(false); 3171 arg_program->set_type(GLMessage::DataType::INT); 3172 arg_program->add_intvalue(program); 3173 3174 // call function 3175 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3176 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3177 glContext->hooks->gl.glLinkProgram(program); 3178 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3179 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3180 3181 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3182 threadStartTime, threadEndTime, 3183 &glmsg); 3184 glContext->traceGLMessage(&glmsg); 3185} 3186 3187void GLTrace_glPixelStorei(GLenum pname, GLint param) { 3188 GLMessage glmsg; 3189 GLTraceContext *glContext = getGLTraceContext(); 3190 3191 glmsg.set_function(GLMessage::glPixelStorei); 3192 3193 // copy argument pname 3194 GLMessage_DataType *arg_pname = glmsg.add_args(); 3195 arg_pname->set_isarray(false); 3196 arg_pname->set_type(GLMessage::DataType::ENUM); 3197 arg_pname->add_intvalue((int)pname); 3198 3199 // copy argument param 3200 GLMessage_DataType *arg_param = glmsg.add_args(); 3201 arg_param->set_isarray(false); 3202 arg_param->set_type(GLMessage::DataType::INT); 3203 arg_param->add_intvalue(param); 3204 3205 // call function 3206 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3207 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3208 glContext->hooks->gl.glPixelStorei(pname, param); 3209 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3210 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3211 3212 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3213 threadStartTime, threadEndTime, 3214 &glmsg); 3215 glContext->traceGLMessage(&glmsg); 3216} 3217 3218void GLTrace_glPolygonOffset(GLfloat factor, GLfloat units) { 3219 GLMessage glmsg; 3220 GLTraceContext *glContext = getGLTraceContext(); 3221 3222 glmsg.set_function(GLMessage::glPolygonOffset); 3223 3224 // copy argument factor 3225 GLMessage_DataType *arg_factor = glmsg.add_args(); 3226 arg_factor->set_isarray(false); 3227 arg_factor->set_type(GLMessage::DataType::FLOAT); 3228 arg_factor->add_floatvalue(factor); 3229 3230 // copy argument units 3231 GLMessage_DataType *arg_units = glmsg.add_args(); 3232 arg_units->set_isarray(false); 3233 arg_units->set_type(GLMessage::DataType::FLOAT); 3234 arg_units->add_floatvalue(units); 3235 3236 // call function 3237 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3238 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3239 glContext->hooks->gl.glPolygonOffset(factor, units); 3240 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3241 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3242 3243 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3244 threadStartTime, threadEndTime, 3245 &glmsg); 3246 glContext->traceGLMessage(&glmsg); 3247} 3248 3249void GLTrace_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) { 3250 GLMessage glmsg; 3251 GLTraceContext *glContext = getGLTraceContext(); 3252 3253 glmsg.set_function(GLMessage::glReadPixels); 3254 3255 // copy argument x 3256 GLMessage_DataType *arg_x = glmsg.add_args(); 3257 arg_x->set_isarray(false); 3258 arg_x->set_type(GLMessage::DataType::INT); 3259 arg_x->add_intvalue(x); 3260 3261 // copy argument y 3262 GLMessage_DataType *arg_y = glmsg.add_args(); 3263 arg_y->set_isarray(false); 3264 arg_y->set_type(GLMessage::DataType::INT); 3265 arg_y->add_intvalue(y); 3266 3267 // copy argument width 3268 GLMessage_DataType *arg_width = glmsg.add_args(); 3269 arg_width->set_isarray(false); 3270 arg_width->set_type(GLMessage::DataType::INT); 3271 arg_width->add_intvalue(width); 3272 3273 // copy argument height 3274 GLMessage_DataType *arg_height = glmsg.add_args(); 3275 arg_height->set_isarray(false); 3276 arg_height->set_type(GLMessage::DataType::INT); 3277 arg_height->add_intvalue(height); 3278 3279 // copy argument format 3280 GLMessage_DataType *arg_format = glmsg.add_args(); 3281 arg_format->set_isarray(false); 3282 arg_format->set_type(GLMessage::DataType::ENUM); 3283 arg_format->add_intvalue((int)format); 3284 3285 // copy argument type 3286 GLMessage_DataType *arg_type = glmsg.add_args(); 3287 arg_type->set_isarray(false); 3288 arg_type->set_type(GLMessage::DataType::ENUM); 3289 arg_type->add_intvalue((int)type); 3290 3291 // copy argument pixels 3292 GLMessage_DataType *arg_pixels = glmsg.add_args(); 3293 arg_pixels->set_isarray(false); 3294 arg_pixels->set_type(GLMessage::DataType::INT); 3295 arg_pixels->add_intvalue((int)pixels); 3296 3297 // call function 3298 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3299 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3300 glContext->hooks->gl.glReadPixels(x, y, width, height, format, type, pixels); 3301 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3302 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3303 3304 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3305 threadStartTime, threadEndTime, 3306 &glmsg); 3307 glContext->traceGLMessage(&glmsg); 3308} 3309 3310void GLTrace_glReleaseShaderCompiler(void) { 3311 GLMessage glmsg; 3312 GLTraceContext *glContext = getGLTraceContext(); 3313 3314 glmsg.set_function(GLMessage::glReleaseShaderCompiler); 3315 3316 // call function 3317 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3318 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3319 glContext->hooks->gl.glReleaseShaderCompiler(); 3320 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3321 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3322 3323 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3324 threadStartTime, threadEndTime, 3325 &glmsg); 3326 glContext->traceGLMessage(&glmsg); 3327} 3328 3329void GLTrace_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { 3330 GLMessage glmsg; 3331 GLTraceContext *glContext = getGLTraceContext(); 3332 3333 glmsg.set_function(GLMessage::glRenderbufferStorage); 3334 3335 // copy argument target 3336 GLMessage_DataType *arg_target = glmsg.add_args(); 3337 arg_target->set_isarray(false); 3338 arg_target->set_type(GLMessage::DataType::ENUM); 3339 arg_target->add_intvalue((int)target); 3340 3341 // copy argument internalformat 3342 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 3343 arg_internalformat->set_isarray(false); 3344 arg_internalformat->set_type(GLMessage::DataType::ENUM); 3345 arg_internalformat->add_intvalue((int)internalformat); 3346 3347 // copy argument width 3348 GLMessage_DataType *arg_width = glmsg.add_args(); 3349 arg_width->set_isarray(false); 3350 arg_width->set_type(GLMessage::DataType::INT); 3351 arg_width->add_intvalue(width); 3352 3353 // copy argument height 3354 GLMessage_DataType *arg_height = glmsg.add_args(); 3355 arg_height->set_isarray(false); 3356 arg_height->set_type(GLMessage::DataType::INT); 3357 arg_height->add_intvalue(height); 3358 3359 // call function 3360 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3361 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3362 glContext->hooks->gl.glRenderbufferStorage(target, internalformat, width, height); 3363 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3364 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3365 3366 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3367 threadStartTime, threadEndTime, 3368 &glmsg); 3369 glContext->traceGLMessage(&glmsg); 3370} 3371 3372void GLTrace_glSampleCoverage(GLclampf value, GLboolean invert) { 3373 GLMessage glmsg; 3374 GLTraceContext *glContext = getGLTraceContext(); 3375 3376 glmsg.set_function(GLMessage::glSampleCoverage); 3377 3378 // copy argument value 3379 GLMessage_DataType *arg_value = glmsg.add_args(); 3380 arg_value->set_isarray(false); 3381 arg_value->set_type(GLMessage::DataType::FLOAT); 3382 arg_value->add_floatvalue(value); 3383 3384 // copy argument invert 3385 GLMessage_DataType *arg_invert = glmsg.add_args(); 3386 arg_invert->set_isarray(false); 3387 arg_invert->set_type(GLMessage::DataType::BOOL); 3388 arg_invert->add_boolvalue(invert); 3389 3390 // call function 3391 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3392 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3393 glContext->hooks->gl.glSampleCoverage(value, invert); 3394 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3395 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3396 3397 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3398 threadStartTime, threadEndTime, 3399 &glmsg); 3400 glContext->traceGLMessage(&glmsg); 3401} 3402 3403void GLTrace_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { 3404 GLMessage glmsg; 3405 GLTraceContext *glContext = getGLTraceContext(); 3406 3407 glmsg.set_function(GLMessage::glScissor); 3408 3409 // copy argument x 3410 GLMessage_DataType *arg_x = glmsg.add_args(); 3411 arg_x->set_isarray(false); 3412 arg_x->set_type(GLMessage::DataType::INT); 3413 arg_x->add_intvalue(x); 3414 3415 // copy argument y 3416 GLMessage_DataType *arg_y = glmsg.add_args(); 3417 arg_y->set_isarray(false); 3418 arg_y->set_type(GLMessage::DataType::INT); 3419 arg_y->add_intvalue(y); 3420 3421 // copy argument width 3422 GLMessage_DataType *arg_width = glmsg.add_args(); 3423 arg_width->set_isarray(false); 3424 arg_width->set_type(GLMessage::DataType::INT); 3425 arg_width->add_intvalue(width); 3426 3427 // copy argument height 3428 GLMessage_DataType *arg_height = glmsg.add_args(); 3429 arg_height->set_isarray(false); 3430 arg_height->set_type(GLMessage::DataType::INT); 3431 arg_height->add_intvalue(height); 3432 3433 // call function 3434 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3435 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3436 glContext->hooks->gl.glScissor(x, y, width, height); 3437 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3438 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3439 3440 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3441 threadStartTime, threadEndTime, 3442 &glmsg); 3443 glContext->traceGLMessage(&glmsg); 3444} 3445 3446void GLTrace_glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length) { 3447 GLMessage glmsg; 3448 GLTraceContext *glContext = getGLTraceContext(); 3449 3450 glmsg.set_function(GLMessage::glShaderBinary); 3451 3452 // copy argument n 3453 GLMessage_DataType *arg_n = glmsg.add_args(); 3454 arg_n->set_isarray(false); 3455 arg_n->set_type(GLMessage::DataType::INT); 3456 arg_n->add_intvalue(n); 3457 3458 // copy argument shaders 3459 GLMessage_DataType *arg_shaders = glmsg.add_args(); 3460 arg_shaders->set_isarray(false); 3461 arg_shaders->set_type(GLMessage::DataType::INT); 3462 arg_shaders->add_intvalue((int)shaders); 3463 3464 // copy argument binaryformat 3465 GLMessage_DataType *arg_binaryformat = glmsg.add_args(); 3466 arg_binaryformat->set_isarray(false); 3467 arg_binaryformat->set_type(GLMessage::DataType::ENUM); 3468 arg_binaryformat->add_intvalue((int)binaryformat); 3469 3470 // copy argument binary 3471 GLMessage_DataType *arg_binary = glmsg.add_args(); 3472 arg_binary->set_isarray(false); 3473 arg_binary->set_type(GLMessage::DataType::INT); 3474 arg_binary->add_intvalue((int)binary); 3475 3476 // copy argument length 3477 GLMessage_DataType *arg_length = glmsg.add_args(); 3478 arg_length->set_isarray(false); 3479 arg_length->set_type(GLMessage::DataType::INT); 3480 arg_length->add_intvalue(length); 3481 3482 // call function 3483 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3484 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3485 glContext->hooks->gl.glShaderBinary(n, shaders, binaryformat, binary, length); 3486 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3487 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3488 3489 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3490 threadStartTime, threadEndTime, 3491 &glmsg); 3492 glContext->traceGLMessage(&glmsg); 3493} 3494 3495void GLTrace_glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length) { 3496 GLMessage glmsg; 3497 GLTraceContext *glContext = getGLTraceContext(); 3498 3499 glmsg.set_function(GLMessage::glShaderSource); 3500 3501 // copy argument shader 3502 GLMessage_DataType *arg_shader = glmsg.add_args(); 3503 arg_shader->set_isarray(false); 3504 arg_shader->set_type(GLMessage::DataType::INT); 3505 arg_shader->add_intvalue(shader); 3506 3507 // copy argument count 3508 GLMessage_DataType *arg_count = glmsg.add_args(); 3509 arg_count->set_isarray(false); 3510 arg_count->set_type(GLMessage::DataType::INT); 3511 arg_count->add_intvalue(count); 3512 3513 // copy argument string 3514 GLMessage_DataType *arg_string = glmsg.add_args(); 3515 arg_string->set_isarray(false); 3516 arg_string->set_type(GLMessage::DataType::INT); 3517 arg_string->add_intvalue((int)string); 3518 3519 // copy argument length 3520 GLMessage_DataType *arg_length = glmsg.add_args(); 3521 arg_length->set_isarray(false); 3522 arg_length->set_type(GLMessage::DataType::INT); 3523 arg_length->add_intvalue((int)length); 3524 3525 // call function 3526 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3527 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3528 glContext->hooks->gl.glShaderSource(shader, count, string, length); 3529 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3530 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3531 3532 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3533 threadStartTime, threadEndTime, 3534 &glmsg); 3535 glContext->traceGLMessage(&glmsg); 3536} 3537 3538void GLTrace_glStencilFunc(GLenum func, GLint ref, GLuint mask) { 3539 GLMessage glmsg; 3540 GLTraceContext *glContext = getGLTraceContext(); 3541 3542 glmsg.set_function(GLMessage::glStencilFunc); 3543 3544 // copy argument func 3545 GLMessage_DataType *arg_func = glmsg.add_args(); 3546 arg_func->set_isarray(false); 3547 arg_func->set_type(GLMessage::DataType::ENUM); 3548 arg_func->add_intvalue((int)func); 3549 3550 // copy argument ref 3551 GLMessage_DataType *arg_ref = glmsg.add_args(); 3552 arg_ref->set_isarray(false); 3553 arg_ref->set_type(GLMessage::DataType::INT); 3554 arg_ref->add_intvalue(ref); 3555 3556 // copy argument mask 3557 GLMessage_DataType *arg_mask = glmsg.add_args(); 3558 arg_mask->set_isarray(false); 3559 arg_mask->set_type(GLMessage::DataType::INT); 3560 arg_mask->add_intvalue(mask); 3561 3562 // call function 3563 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3564 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3565 glContext->hooks->gl.glStencilFunc(func, ref, mask); 3566 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3567 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3568 3569 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3570 threadStartTime, threadEndTime, 3571 &glmsg); 3572 glContext->traceGLMessage(&glmsg); 3573} 3574 3575void GLTrace_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) { 3576 GLMessage glmsg; 3577 GLTraceContext *glContext = getGLTraceContext(); 3578 3579 glmsg.set_function(GLMessage::glStencilFuncSeparate); 3580 3581 // copy argument face 3582 GLMessage_DataType *arg_face = glmsg.add_args(); 3583 arg_face->set_isarray(false); 3584 arg_face->set_type(GLMessage::DataType::ENUM); 3585 arg_face->add_intvalue((int)face); 3586 3587 // copy argument func 3588 GLMessage_DataType *arg_func = glmsg.add_args(); 3589 arg_func->set_isarray(false); 3590 arg_func->set_type(GLMessage::DataType::ENUM); 3591 arg_func->add_intvalue((int)func); 3592 3593 // copy argument ref 3594 GLMessage_DataType *arg_ref = glmsg.add_args(); 3595 arg_ref->set_isarray(false); 3596 arg_ref->set_type(GLMessage::DataType::INT); 3597 arg_ref->add_intvalue(ref); 3598 3599 // copy argument mask 3600 GLMessage_DataType *arg_mask = glmsg.add_args(); 3601 arg_mask->set_isarray(false); 3602 arg_mask->set_type(GLMessage::DataType::INT); 3603 arg_mask->add_intvalue(mask); 3604 3605 // call function 3606 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3607 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3608 glContext->hooks->gl.glStencilFuncSeparate(face, func, ref, mask); 3609 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3610 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3611 3612 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3613 threadStartTime, threadEndTime, 3614 &glmsg); 3615 glContext->traceGLMessage(&glmsg); 3616} 3617 3618void GLTrace_glStencilMask(GLuint mask) { 3619 GLMessage glmsg; 3620 GLTraceContext *glContext = getGLTraceContext(); 3621 3622 glmsg.set_function(GLMessage::glStencilMask); 3623 3624 // copy argument mask 3625 GLMessage_DataType *arg_mask = glmsg.add_args(); 3626 arg_mask->set_isarray(false); 3627 arg_mask->set_type(GLMessage::DataType::INT); 3628 arg_mask->add_intvalue(mask); 3629 3630 // call function 3631 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3632 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3633 glContext->hooks->gl.glStencilMask(mask); 3634 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3635 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3636 3637 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3638 threadStartTime, threadEndTime, 3639 &glmsg); 3640 glContext->traceGLMessage(&glmsg); 3641} 3642 3643void GLTrace_glStencilMaskSeparate(GLenum face, GLuint mask) { 3644 GLMessage glmsg; 3645 GLTraceContext *glContext = getGLTraceContext(); 3646 3647 glmsg.set_function(GLMessage::glStencilMaskSeparate); 3648 3649 // copy argument face 3650 GLMessage_DataType *arg_face = glmsg.add_args(); 3651 arg_face->set_isarray(false); 3652 arg_face->set_type(GLMessage::DataType::ENUM); 3653 arg_face->add_intvalue((int)face); 3654 3655 // copy argument mask 3656 GLMessage_DataType *arg_mask = glmsg.add_args(); 3657 arg_mask->set_isarray(false); 3658 arg_mask->set_type(GLMessage::DataType::INT); 3659 arg_mask->add_intvalue(mask); 3660 3661 // call function 3662 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3663 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3664 glContext->hooks->gl.glStencilMaskSeparate(face, mask); 3665 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3666 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3667 3668 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3669 threadStartTime, threadEndTime, 3670 &glmsg); 3671 glContext->traceGLMessage(&glmsg); 3672} 3673 3674void GLTrace_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { 3675 GLMessage glmsg; 3676 GLTraceContext *glContext = getGLTraceContext(); 3677 3678 glmsg.set_function(GLMessage::glStencilOp); 3679 3680 // copy argument fail 3681 GLMessage_DataType *arg_fail = glmsg.add_args(); 3682 arg_fail->set_isarray(false); 3683 arg_fail->set_type(GLMessage::DataType::ENUM); 3684 arg_fail->add_intvalue((int)fail); 3685 3686 // copy argument zfail 3687 GLMessage_DataType *arg_zfail = glmsg.add_args(); 3688 arg_zfail->set_isarray(false); 3689 arg_zfail->set_type(GLMessage::DataType::ENUM); 3690 arg_zfail->add_intvalue((int)zfail); 3691 3692 // copy argument zpass 3693 GLMessage_DataType *arg_zpass = glmsg.add_args(); 3694 arg_zpass->set_isarray(false); 3695 arg_zpass->set_type(GLMessage::DataType::ENUM); 3696 arg_zpass->add_intvalue((int)zpass); 3697 3698 // call function 3699 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3700 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3701 glContext->hooks->gl.glStencilOp(fail, zfail, zpass); 3702 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3703 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3704 3705 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3706 threadStartTime, threadEndTime, 3707 &glmsg); 3708 glContext->traceGLMessage(&glmsg); 3709} 3710 3711void GLTrace_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { 3712 GLMessage glmsg; 3713 GLTraceContext *glContext = getGLTraceContext(); 3714 3715 glmsg.set_function(GLMessage::glStencilOpSeparate); 3716 3717 // copy argument face 3718 GLMessage_DataType *arg_face = glmsg.add_args(); 3719 arg_face->set_isarray(false); 3720 arg_face->set_type(GLMessage::DataType::ENUM); 3721 arg_face->add_intvalue((int)face); 3722 3723 // copy argument fail 3724 GLMessage_DataType *arg_fail = glmsg.add_args(); 3725 arg_fail->set_isarray(false); 3726 arg_fail->set_type(GLMessage::DataType::ENUM); 3727 arg_fail->add_intvalue((int)fail); 3728 3729 // copy argument zfail 3730 GLMessage_DataType *arg_zfail = glmsg.add_args(); 3731 arg_zfail->set_isarray(false); 3732 arg_zfail->set_type(GLMessage::DataType::ENUM); 3733 arg_zfail->add_intvalue((int)zfail); 3734 3735 // copy argument zpass 3736 GLMessage_DataType *arg_zpass = glmsg.add_args(); 3737 arg_zpass->set_isarray(false); 3738 arg_zpass->set_type(GLMessage::DataType::ENUM); 3739 arg_zpass->add_intvalue((int)zpass); 3740 3741 // call function 3742 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3743 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3744 glContext->hooks->gl.glStencilOpSeparate(face, fail, zfail, zpass); 3745 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3746 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3747 3748 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3749 threadStartTime, threadEndTime, 3750 &glmsg); 3751 glContext->traceGLMessage(&glmsg); 3752} 3753 3754void GLTrace_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { 3755 GLMessage glmsg; 3756 GLTraceContext *glContext = getGLTraceContext(); 3757 3758 glmsg.set_function(GLMessage::glTexImage2D); 3759 3760 // copy argument target 3761 GLMessage_DataType *arg_target = glmsg.add_args(); 3762 arg_target->set_isarray(false); 3763 arg_target->set_type(GLMessage::DataType::ENUM); 3764 arg_target->add_intvalue((int)target); 3765 3766 // copy argument level 3767 GLMessage_DataType *arg_level = glmsg.add_args(); 3768 arg_level->set_isarray(false); 3769 arg_level->set_type(GLMessage::DataType::INT); 3770 arg_level->add_intvalue(level); 3771 3772 // copy argument internalformat 3773 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 3774 arg_internalformat->set_isarray(false); 3775 arg_internalformat->set_type(GLMessage::DataType::INT); 3776 arg_internalformat->add_intvalue(internalformat); 3777 3778 // copy argument width 3779 GLMessage_DataType *arg_width = glmsg.add_args(); 3780 arg_width->set_isarray(false); 3781 arg_width->set_type(GLMessage::DataType::INT); 3782 arg_width->add_intvalue(width); 3783 3784 // copy argument height 3785 GLMessage_DataType *arg_height = glmsg.add_args(); 3786 arg_height->set_isarray(false); 3787 arg_height->set_type(GLMessage::DataType::INT); 3788 arg_height->add_intvalue(height); 3789 3790 // copy argument border 3791 GLMessage_DataType *arg_border = glmsg.add_args(); 3792 arg_border->set_isarray(false); 3793 arg_border->set_type(GLMessage::DataType::INT); 3794 arg_border->add_intvalue(border); 3795 3796 // copy argument format 3797 GLMessage_DataType *arg_format = glmsg.add_args(); 3798 arg_format->set_isarray(false); 3799 arg_format->set_type(GLMessage::DataType::ENUM); 3800 arg_format->add_intvalue((int)format); 3801 3802 // copy argument type 3803 GLMessage_DataType *arg_type = glmsg.add_args(); 3804 arg_type->set_isarray(false); 3805 arg_type->set_type(GLMessage::DataType::ENUM); 3806 arg_type->add_intvalue((int)type); 3807 3808 // copy argument pixels 3809 GLMessage_DataType *arg_pixels = glmsg.add_args(); 3810 arg_pixels->set_isarray(false); 3811 arg_pixels->set_type(GLMessage::DataType::INT); 3812 arg_pixels->add_intvalue((int)pixels); 3813 3814 // call function 3815 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3816 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3817 glContext->hooks->gl.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); 3818 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3819 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3820 3821 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3822 threadStartTime, threadEndTime, 3823 &glmsg); 3824 glContext->traceGLMessage(&glmsg); 3825} 3826 3827void GLTrace_glTexParameterf(GLenum target, GLenum pname, GLfloat param) { 3828 GLMessage glmsg; 3829 GLTraceContext *glContext = getGLTraceContext(); 3830 3831 glmsg.set_function(GLMessage::glTexParameterf); 3832 3833 // copy argument target 3834 GLMessage_DataType *arg_target = glmsg.add_args(); 3835 arg_target->set_isarray(false); 3836 arg_target->set_type(GLMessage::DataType::ENUM); 3837 arg_target->add_intvalue((int)target); 3838 3839 // copy argument pname 3840 GLMessage_DataType *arg_pname = glmsg.add_args(); 3841 arg_pname->set_isarray(false); 3842 arg_pname->set_type(GLMessage::DataType::ENUM); 3843 arg_pname->add_intvalue((int)pname); 3844 3845 // copy argument param 3846 GLMessage_DataType *arg_param = glmsg.add_args(); 3847 arg_param->set_isarray(false); 3848 arg_param->set_type(GLMessage::DataType::FLOAT); 3849 arg_param->add_floatvalue(param); 3850 3851 // call function 3852 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3853 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3854 glContext->hooks->gl.glTexParameterf(target, pname, param); 3855 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3856 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3857 3858 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3859 threadStartTime, threadEndTime, 3860 &glmsg); 3861 glContext->traceGLMessage(&glmsg); 3862} 3863 3864void GLTrace_glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) { 3865 GLMessage glmsg; 3866 GLTraceContext *glContext = getGLTraceContext(); 3867 3868 glmsg.set_function(GLMessage::glTexParameterfv); 3869 3870 // copy argument target 3871 GLMessage_DataType *arg_target = glmsg.add_args(); 3872 arg_target->set_isarray(false); 3873 arg_target->set_type(GLMessage::DataType::ENUM); 3874 arg_target->add_intvalue((int)target); 3875 3876 // copy argument pname 3877 GLMessage_DataType *arg_pname = glmsg.add_args(); 3878 arg_pname->set_isarray(false); 3879 arg_pname->set_type(GLMessage::DataType::ENUM); 3880 arg_pname->add_intvalue((int)pname); 3881 3882 // copy argument params 3883 GLMessage_DataType *arg_params = glmsg.add_args(); 3884 arg_params->set_isarray(false); 3885 arg_params->set_type(GLMessage::DataType::INT); 3886 arg_params->add_intvalue((int)params); 3887 3888 // call function 3889 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3890 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3891 glContext->hooks->gl.glTexParameterfv(target, pname, params); 3892 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3893 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3894 3895 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3896 threadStartTime, threadEndTime, 3897 &glmsg); 3898 glContext->traceGLMessage(&glmsg); 3899} 3900 3901void GLTrace_glTexParameteri(GLenum target, GLenum pname, GLint param) { 3902 GLMessage glmsg; 3903 GLTraceContext *glContext = getGLTraceContext(); 3904 3905 glmsg.set_function(GLMessage::glTexParameteri); 3906 3907 // copy argument target 3908 GLMessage_DataType *arg_target = glmsg.add_args(); 3909 arg_target->set_isarray(false); 3910 arg_target->set_type(GLMessage::DataType::ENUM); 3911 arg_target->add_intvalue((int)target); 3912 3913 // copy argument pname 3914 GLMessage_DataType *arg_pname = glmsg.add_args(); 3915 arg_pname->set_isarray(false); 3916 arg_pname->set_type(GLMessage::DataType::ENUM); 3917 arg_pname->add_intvalue((int)pname); 3918 3919 // copy argument param 3920 GLMessage_DataType *arg_param = glmsg.add_args(); 3921 arg_param->set_isarray(false); 3922 arg_param->set_type(GLMessage::DataType::INT); 3923 arg_param->add_intvalue(param); 3924 3925 // call function 3926 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3927 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3928 glContext->hooks->gl.glTexParameteri(target, pname, param); 3929 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3930 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3931 3932 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3933 threadStartTime, threadEndTime, 3934 &glmsg); 3935 glContext->traceGLMessage(&glmsg); 3936} 3937 3938void GLTrace_glTexParameteriv(GLenum target, GLenum pname, const GLint* params) { 3939 GLMessage glmsg; 3940 GLTraceContext *glContext = getGLTraceContext(); 3941 3942 glmsg.set_function(GLMessage::glTexParameteriv); 3943 3944 // copy argument target 3945 GLMessage_DataType *arg_target = glmsg.add_args(); 3946 arg_target->set_isarray(false); 3947 arg_target->set_type(GLMessage::DataType::ENUM); 3948 arg_target->add_intvalue((int)target); 3949 3950 // copy argument pname 3951 GLMessage_DataType *arg_pname = glmsg.add_args(); 3952 arg_pname->set_isarray(false); 3953 arg_pname->set_type(GLMessage::DataType::ENUM); 3954 arg_pname->add_intvalue((int)pname); 3955 3956 // copy argument params 3957 GLMessage_DataType *arg_params = glmsg.add_args(); 3958 arg_params->set_isarray(false); 3959 arg_params->set_type(GLMessage::DataType::INT); 3960 arg_params->add_intvalue((int)params); 3961 3962 // call function 3963 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 3964 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 3965 glContext->hooks->gl.glTexParameteriv(target, pname, params); 3966 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 3967 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 3968 3969 fixupGLMessage(glContext, wallStartTime, wallEndTime, 3970 threadStartTime, threadEndTime, 3971 &glmsg); 3972 glContext->traceGLMessage(&glmsg); 3973} 3974 3975void GLTrace_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) { 3976 GLMessage glmsg; 3977 GLTraceContext *glContext = getGLTraceContext(); 3978 3979 glmsg.set_function(GLMessage::glTexSubImage2D); 3980 3981 // copy argument target 3982 GLMessage_DataType *arg_target = glmsg.add_args(); 3983 arg_target->set_isarray(false); 3984 arg_target->set_type(GLMessage::DataType::ENUM); 3985 arg_target->add_intvalue((int)target); 3986 3987 // copy argument level 3988 GLMessage_DataType *arg_level = glmsg.add_args(); 3989 arg_level->set_isarray(false); 3990 arg_level->set_type(GLMessage::DataType::INT); 3991 arg_level->add_intvalue(level); 3992 3993 // copy argument xoffset 3994 GLMessage_DataType *arg_xoffset = glmsg.add_args(); 3995 arg_xoffset->set_isarray(false); 3996 arg_xoffset->set_type(GLMessage::DataType::INT); 3997 arg_xoffset->add_intvalue(xoffset); 3998 3999 // copy argument yoffset 4000 GLMessage_DataType *arg_yoffset = glmsg.add_args(); 4001 arg_yoffset->set_isarray(false); 4002 arg_yoffset->set_type(GLMessage::DataType::INT); 4003 arg_yoffset->add_intvalue(yoffset); 4004 4005 // copy argument width 4006 GLMessage_DataType *arg_width = glmsg.add_args(); 4007 arg_width->set_isarray(false); 4008 arg_width->set_type(GLMessage::DataType::INT); 4009 arg_width->add_intvalue(width); 4010 4011 // copy argument height 4012 GLMessage_DataType *arg_height = glmsg.add_args(); 4013 arg_height->set_isarray(false); 4014 arg_height->set_type(GLMessage::DataType::INT); 4015 arg_height->add_intvalue(height); 4016 4017 // copy argument format 4018 GLMessage_DataType *arg_format = glmsg.add_args(); 4019 arg_format->set_isarray(false); 4020 arg_format->set_type(GLMessage::DataType::ENUM); 4021 arg_format->add_intvalue((int)format); 4022 4023 // copy argument type 4024 GLMessage_DataType *arg_type = glmsg.add_args(); 4025 arg_type->set_isarray(false); 4026 arg_type->set_type(GLMessage::DataType::ENUM); 4027 arg_type->add_intvalue((int)type); 4028 4029 // copy argument pixels 4030 GLMessage_DataType *arg_pixels = glmsg.add_args(); 4031 arg_pixels->set_isarray(false); 4032 arg_pixels->set_type(GLMessage::DataType::INT); 4033 arg_pixels->add_intvalue((int)pixels); 4034 4035 // call function 4036 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4037 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4038 glContext->hooks->gl.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); 4039 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4040 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4041 4042 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4043 threadStartTime, threadEndTime, 4044 &glmsg); 4045 glContext->traceGLMessage(&glmsg); 4046} 4047 4048void GLTrace_glUniform1f(GLint location, GLfloat x) { 4049 GLMessage glmsg; 4050 GLTraceContext *glContext = getGLTraceContext(); 4051 4052 glmsg.set_function(GLMessage::glUniform1f); 4053 4054 // copy argument location 4055 GLMessage_DataType *arg_location = glmsg.add_args(); 4056 arg_location->set_isarray(false); 4057 arg_location->set_type(GLMessage::DataType::INT); 4058 arg_location->add_intvalue(location); 4059 4060 // copy argument x 4061 GLMessage_DataType *arg_x = glmsg.add_args(); 4062 arg_x->set_isarray(false); 4063 arg_x->set_type(GLMessage::DataType::FLOAT); 4064 arg_x->add_floatvalue(x); 4065 4066 // call function 4067 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4068 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4069 glContext->hooks->gl.glUniform1f(location, x); 4070 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4071 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4072 4073 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4074 threadStartTime, threadEndTime, 4075 &glmsg); 4076 glContext->traceGLMessage(&glmsg); 4077} 4078 4079void GLTrace_glUniform1fv(GLint location, GLsizei count, const GLfloat* v) { 4080 GLMessage glmsg; 4081 GLTraceContext *glContext = getGLTraceContext(); 4082 4083 glmsg.set_function(GLMessage::glUniform1fv); 4084 4085 // copy argument location 4086 GLMessage_DataType *arg_location = glmsg.add_args(); 4087 arg_location->set_isarray(false); 4088 arg_location->set_type(GLMessage::DataType::INT); 4089 arg_location->add_intvalue(location); 4090 4091 // copy argument count 4092 GLMessage_DataType *arg_count = glmsg.add_args(); 4093 arg_count->set_isarray(false); 4094 arg_count->set_type(GLMessage::DataType::INT); 4095 arg_count->add_intvalue(count); 4096 4097 // copy argument v 4098 GLMessage_DataType *arg_v = glmsg.add_args(); 4099 arg_v->set_isarray(false); 4100 arg_v->set_type(GLMessage::DataType::INT); 4101 arg_v->add_intvalue((int)v); 4102 4103 // call function 4104 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4105 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4106 glContext->hooks->gl.glUniform1fv(location, count, v); 4107 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4108 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4109 4110 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4111 threadStartTime, threadEndTime, 4112 &glmsg); 4113 glContext->traceGLMessage(&glmsg); 4114} 4115 4116void GLTrace_glUniform1i(GLint location, GLint x) { 4117 GLMessage glmsg; 4118 GLTraceContext *glContext = getGLTraceContext(); 4119 4120 glmsg.set_function(GLMessage::glUniform1i); 4121 4122 // copy argument location 4123 GLMessage_DataType *arg_location = glmsg.add_args(); 4124 arg_location->set_isarray(false); 4125 arg_location->set_type(GLMessage::DataType::INT); 4126 arg_location->add_intvalue(location); 4127 4128 // copy argument x 4129 GLMessage_DataType *arg_x = glmsg.add_args(); 4130 arg_x->set_isarray(false); 4131 arg_x->set_type(GLMessage::DataType::INT); 4132 arg_x->add_intvalue(x); 4133 4134 // call function 4135 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4136 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4137 glContext->hooks->gl.glUniform1i(location, x); 4138 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4139 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4140 4141 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4142 threadStartTime, threadEndTime, 4143 &glmsg); 4144 glContext->traceGLMessage(&glmsg); 4145} 4146 4147void GLTrace_glUniform1iv(GLint location, GLsizei count, const GLint* v) { 4148 GLMessage glmsg; 4149 GLTraceContext *glContext = getGLTraceContext(); 4150 4151 glmsg.set_function(GLMessage::glUniform1iv); 4152 4153 // copy argument location 4154 GLMessage_DataType *arg_location = glmsg.add_args(); 4155 arg_location->set_isarray(false); 4156 arg_location->set_type(GLMessage::DataType::INT); 4157 arg_location->add_intvalue(location); 4158 4159 // copy argument count 4160 GLMessage_DataType *arg_count = glmsg.add_args(); 4161 arg_count->set_isarray(false); 4162 arg_count->set_type(GLMessage::DataType::INT); 4163 arg_count->add_intvalue(count); 4164 4165 // copy argument v 4166 GLMessage_DataType *arg_v = glmsg.add_args(); 4167 arg_v->set_isarray(false); 4168 arg_v->set_type(GLMessage::DataType::INT); 4169 arg_v->add_intvalue((int)v); 4170 4171 // call function 4172 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4173 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4174 glContext->hooks->gl.glUniform1iv(location, count, v); 4175 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4176 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4177 4178 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4179 threadStartTime, threadEndTime, 4180 &glmsg); 4181 glContext->traceGLMessage(&glmsg); 4182} 4183 4184void GLTrace_glUniform2f(GLint location, GLfloat x, GLfloat y) { 4185 GLMessage glmsg; 4186 GLTraceContext *glContext = getGLTraceContext(); 4187 4188 glmsg.set_function(GLMessage::glUniform2f); 4189 4190 // copy argument location 4191 GLMessage_DataType *arg_location = glmsg.add_args(); 4192 arg_location->set_isarray(false); 4193 arg_location->set_type(GLMessage::DataType::INT); 4194 arg_location->add_intvalue(location); 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 // copy argument y 4203 GLMessage_DataType *arg_y = glmsg.add_args(); 4204 arg_y->set_isarray(false); 4205 arg_y->set_type(GLMessage::DataType::FLOAT); 4206 arg_y->add_floatvalue(y); 4207 4208 // call function 4209 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4210 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4211 glContext->hooks->gl.glUniform2f(location, x, y); 4212 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4213 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4214 4215 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4216 threadStartTime, threadEndTime, 4217 &glmsg); 4218 glContext->traceGLMessage(&glmsg); 4219} 4220 4221void GLTrace_glUniform2fv(GLint location, GLsizei count, const GLfloat* v) { 4222 GLMessage glmsg; 4223 GLTraceContext *glContext = getGLTraceContext(); 4224 4225 glmsg.set_function(GLMessage::glUniform2fv); 4226 4227 // copy argument location 4228 GLMessage_DataType *arg_location = glmsg.add_args(); 4229 arg_location->set_isarray(false); 4230 arg_location->set_type(GLMessage::DataType::INT); 4231 arg_location->add_intvalue(location); 4232 4233 // copy argument count 4234 GLMessage_DataType *arg_count = glmsg.add_args(); 4235 arg_count->set_isarray(false); 4236 arg_count->set_type(GLMessage::DataType::INT); 4237 arg_count->add_intvalue(count); 4238 4239 // copy argument v 4240 GLMessage_DataType *arg_v = glmsg.add_args(); 4241 arg_v->set_isarray(false); 4242 arg_v->set_type(GLMessage::DataType::INT); 4243 arg_v->add_intvalue((int)v); 4244 4245 // call function 4246 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4247 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4248 glContext->hooks->gl.glUniform2fv(location, count, v); 4249 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4250 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4251 4252 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4253 threadStartTime, threadEndTime, 4254 &glmsg); 4255 glContext->traceGLMessage(&glmsg); 4256} 4257 4258void GLTrace_glUniform2i(GLint location, GLint x, GLint y) { 4259 GLMessage glmsg; 4260 GLTraceContext *glContext = getGLTraceContext(); 4261 4262 glmsg.set_function(GLMessage::glUniform2i); 4263 4264 // copy argument location 4265 GLMessage_DataType *arg_location = glmsg.add_args(); 4266 arg_location->set_isarray(false); 4267 arg_location->set_type(GLMessage::DataType::INT); 4268 arg_location->add_intvalue(location); 4269 4270 // copy argument x 4271 GLMessage_DataType *arg_x = glmsg.add_args(); 4272 arg_x->set_isarray(false); 4273 arg_x->set_type(GLMessage::DataType::INT); 4274 arg_x->add_intvalue(x); 4275 4276 // copy argument y 4277 GLMessage_DataType *arg_y = glmsg.add_args(); 4278 arg_y->set_isarray(false); 4279 arg_y->set_type(GLMessage::DataType::INT); 4280 arg_y->add_intvalue(y); 4281 4282 // call function 4283 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4284 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4285 glContext->hooks->gl.glUniform2i(location, x, y); 4286 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4287 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4288 4289 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4290 threadStartTime, threadEndTime, 4291 &glmsg); 4292 glContext->traceGLMessage(&glmsg); 4293} 4294 4295void GLTrace_glUniform2iv(GLint location, GLsizei count, const GLint* v) { 4296 GLMessage glmsg; 4297 GLTraceContext *glContext = getGLTraceContext(); 4298 4299 glmsg.set_function(GLMessage::glUniform2iv); 4300 4301 // copy argument location 4302 GLMessage_DataType *arg_location = glmsg.add_args(); 4303 arg_location->set_isarray(false); 4304 arg_location->set_type(GLMessage::DataType::INT); 4305 arg_location->add_intvalue(location); 4306 4307 // copy argument count 4308 GLMessage_DataType *arg_count = glmsg.add_args(); 4309 arg_count->set_isarray(false); 4310 arg_count->set_type(GLMessage::DataType::INT); 4311 arg_count->add_intvalue(count); 4312 4313 // copy argument v 4314 GLMessage_DataType *arg_v = glmsg.add_args(); 4315 arg_v->set_isarray(false); 4316 arg_v->set_type(GLMessage::DataType::INT); 4317 arg_v->add_intvalue((int)v); 4318 4319 // call function 4320 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4321 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4322 glContext->hooks->gl.glUniform2iv(location, count, v); 4323 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4324 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4325 4326 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4327 threadStartTime, threadEndTime, 4328 &glmsg); 4329 glContext->traceGLMessage(&glmsg); 4330} 4331 4332void GLTrace_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) { 4333 GLMessage glmsg; 4334 GLTraceContext *glContext = getGLTraceContext(); 4335 4336 glmsg.set_function(GLMessage::glUniform3f); 4337 4338 // copy argument location 4339 GLMessage_DataType *arg_location = glmsg.add_args(); 4340 arg_location->set_isarray(false); 4341 arg_location->set_type(GLMessage::DataType::INT); 4342 arg_location->add_intvalue(location); 4343 4344 // copy argument x 4345 GLMessage_DataType *arg_x = glmsg.add_args(); 4346 arg_x->set_isarray(false); 4347 arg_x->set_type(GLMessage::DataType::FLOAT); 4348 arg_x->add_floatvalue(x); 4349 4350 // copy argument y 4351 GLMessage_DataType *arg_y = glmsg.add_args(); 4352 arg_y->set_isarray(false); 4353 arg_y->set_type(GLMessage::DataType::FLOAT); 4354 arg_y->add_floatvalue(y); 4355 4356 // copy argument z 4357 GLMessage_DataType *arg_z = glmsg.add_args(); 4358 arg_z->set_isarray(false); 4359 arg_z->set_type(GLMessage::DataType::FLOAT); 4360 arg_z->add_floatvalue(z); 4361 4362 // call function 4363 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4364 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4365 glContext->hooks->gl.glUniform3f(location, x, y, z); 4366 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4367 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4368 4369 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4370 threadStartTime, threadEndTime, 4371 &glmsg); 4372 glContext->traceGLMessage(&glmsg); 4373} 4374 4375void GLTrace_glUniform3fv(GLint location, GLsizei count, const GLfloat* v) { 4376 GLMessage glmsg; 4377 GLTraceContext *glContext = getGLTraceContext(); 4378 4379 glmsg.set_function(GLMessage::glUniform3fv); 4380 4381 // copy argument location 4382 GLMessage_DataType *arg_location = glmsg.add_args(); 4383 arg_location->set_isarray(false); 4384 arg_location->set_type(GLMessage::DataType::INT); 4385 arg_location->add_intvalue(location); 4386 4387 // copy argument count 4388 GLMessage_DataType *arg_count = glmsg.add_args(); 4389 arg_count->set_isarray(false); 4390 arg_count->set_type(GLMessage::DataType::INT); 4391 arg_count->add_intvalue(count); 4392 4393 // copy argument v 4394 GLMessage_DataType *arg_v = glmsg.add_args(); 4395 arg_v->set_isarray(false); 4396 arg_v->set_type(GLMessage::DataType::INT); 4397 arg_v->add_intvalue((int)v); 4398 4399 // call function 4400 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4401 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4402 glContext->hooks->gl.glUniform3fv(location, count, v); 4403 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4404 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4405 4406 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4407 threadStartTime, threadEndTime, 4408 &glmsg); 4409 glContext->traceGLMessage(&glmsg); 4410} 4411 4412void GLTrace_glUniform3i(GLint location, GLint x, GLint y, GLint z) { 4413 GLMessage glmsg; 4414 GLTraceContext *glContext = getGLTraceContext(); 4415 4416 glmsg.set_function(GLMessage::glUniform3i); 4417 4418 // copy argument location 4419 GLMessage_DataType *arg_location = glmsg.add_args(); 4420 arg_location->set_isarray(false); 4421 arg_location->set_type(GLMessage::DataType::INT); 4422 arg_location->add_intvalue(location); 4423 4424 // copy argument x 4425 GLMessage_DataType *arg_x = glmsg.add_args(); 4426 arg_x->set_isarray(false); 4427 arg_x->set_type(GLMessage::DataType::INT); 4428 arg_x->add_intvalue(x); 4429 4430 // copy argument y 4431 GLMessage_DataType *arg_y = glmsg.add_args(); 4432 arg_y->set_isarray(false); 4433 arg_y->set_type(GLMessage::DataType::INT); 4434 arg_y->add_intvalue(y); 4435 4436 // copy argument z 4437 GLMessage_DataType *arg_z = glmsg.add_args(); 4438 arg_z->set_isarray(false); 4439 arg_z->set_type(GLMessage::DataType::INT); 4440 arg_z->add_intvalue(z); 4441 4442 // call function 4443 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4444 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4445 glContext->hooks->gl.glUniform3i(location, x, y, z); 4446 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4447 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4448 4449 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4450 threadStartTime, threadEndTime, 4451 &glmsg); 4452 glContext->traceGLMessage(&glmsg); 4453} 4454 4455void GLTrace_glUniform3iv(GLint location, GLsizei count, const GLint* v) { 4456 GLMessage glmsg; 4457 GLTraceContext *glContext = getGLTraceContext(); 4458 4459 glmsg.set_function(GLMessage::glUniform3iv); 4460 4461 // copy argument location 4462 GLMessage_DataType *arg_location = glmsg.add_args(); 4463 arg_location->set_isarray(false); 4464 arg_location->set_type(GLMessage::DataType::INT); 4465 arg_location->add_intvalue(location); 4466 4467 // copy argument count 4468 GLMessage_DataType *arg_count = glmsg.add_args(); 4469 arg_count->set_isarray(false); 4470 arg_count->set_type(GLMessage::DataType::INT); 4471 arg_count->add_intvalue(count); 4472 4473 // copy argument v 4474 GLMessage_DataType *arg_v = glmsg.add_args(); 4475 arg_v->set_isarray(false); 4476 arg_v->set_type(GLMessage::DataType::INT); 4477 arg_v->add_intvalue((int)v); 4478 4479 // call function 4480 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4481 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4482 glContext->hooks->gl.glUniform3iv(location, count, v); 4483 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4484 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4485 4486 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4487 threadStartTime, threadEndTime, 4488 &glmsg); 4489 glContext->traceGLMessage(&glmsg); 4490} 4491 4492void GLTrace_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { 4493 GLMessage glmsg; 4494 GLTraceContext *glContext = getGLTraceContext(); 4495 4496 glmsg.set_function(GLMessage::glUniform4f); 4497 4498 // copy argument location 4499 GLMessage_DataType *arg_location = glmsg.add_args(); 4500 arg_location->set_isarray(false); 4501 arg_location->set_type(GLMessage::DataType::INT); 4502 arg_location->add_intvalue(location); 4503 4504 // copy argument x 4505 GLMessage_DataType *arg_x = glmsg.add_args(); 4506 arg_x->set_isarray(false); 4507 arg_x->set_type(GLMessage::DataType::FLOAT); 4508 arg_x->add_floatvalue(x); 4509 4510 // copy argument y 4511 GLMessage_DataType *arg_y = glmsg.add_args(); 4512 arg_y->set_isarray(false); 4513 arg_y->set_type(GLMessage::DataType::FLOAT); 4514 arg_y->add_floatvalue(y); 4515 4516 // copy argument z 4517 GLMessage_DataType *arg_z = glmsg.add_args(); 4518 arg_z->set_isarray(false); 4519 arg_z->set_type(GLMessage::DataType::FLOAT); 4520 arg_z->add_floatvalue(z); 4521 4522 // copy argument w 4523 GLMessage_DataType *arg_w = glmsg.add_args(); 4524 arg_w->set_isarray(false); 4525 arg_w->set_type(GLMessage::DataType::FLOAT); 4526 arg_w->add_floatvalue(w); 4527 4528 // call function 4529 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4530 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4531 glContext->hooks->gl.glUniform4f(location, x, y, z, w); 4532 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4533 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4534 4535 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4536 threadStartTime, threadEndTime, 4537 &glmsg); 4538 glContext->traceGLMessage(&glmsg); 4539} 4540 4541void GLTrace_glUniform4fv(GLint location, GLsizei count, const GLfloat* v) { 4542 GLMessage glmsg; 4543 GLTraceContext *glContext = getGLTraceContext(); 4544 4545 glmsg.set_function(GLMessage::glUniform4fv); 4546 4547 // copy argument location 4548 GLMessage_DataType *arg_location = glmsg.add_args(); 4549 arg_location->set_isarray(false); 4550 arg_location->set_type(GLMessage::DataType::INT); 4551 arg_location->add_intvalue(location); 4552 4553 // copy argument count 4554 GLMessage_DataType *arg_count = glmsg.add_args(); 4555 arg_count->set_isarray(false); 4556 arg_count->set_type(GLMessage::DataType::INT); 4557 arg_count->add_intvalue(count); 4558 4559 // copy argument v 4560 GLMessage_DataType *arg_v = glmsg.add_args(); 4561 arg_v->set_isarray(false); 4562 arg_v->set_type(GLMessage::DataType::INT); 4563 arg_v->add_intvalue((int)v); 4564 4565 // call function 4566 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4567 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4568 glContext->hooks->gl.glUniform4fv(location, count, v); 4569 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4570 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4571 4572 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4573 threadStartTime, threadEndTime, 4574 &glmsg); 4575 glContext->traceGLMessage(&glmsg); 4576} 4577 4578void GLTrace_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) { 4579 GLMessage glmsg; 4580 GLTraceContext *glContext = getGLTraceContext(); 4581 4582 glmsg.set_function(GLMessage::glUniform4i); 4583 4584 // copy argument location 4585 GLMessage_DataType *arg_location = glmsg.add_args(); 4586 arg_location->set_isarray(false); 4587 arg_location->set_type(GLMessage::DataType::INT); 4588 arg_location->add_intvalue(location); 4589 4590 // copy argument x 4591 GLMessage_DataType *arg_x = glmsg.add_args(); 4592 arg_x->set_isarray(false); 4593 arg_x->set_type(GLMessage::DataType::INT); 4594 arg_x->add_intvalue(x); 4595 4596 // copy argument y 4597 GLMessage_DataType *arg_y = glmsg.add_args(); 4598 arg_y->set_isarray(false); 4599 arg_y->set_type(GLMessage::DataType::INT); 4600 arg_y->add_intvalue(y); 4601 4602 // copy argument z 4603 GLMessage_DataType *arg_z = glmsg.add_args(); 4604 arg_z->set_isarray(false); 4605 arg_z->set_type(GLMessage::DataType::INT); 4606 arg_z->add_intvalue(z); 4607 4608 // copy argument w 4609 GLMessage_DataType *arg_w = glmsg.add_args(); 4610 arg_w->set_isarray(false); 4611 arg_w->set_type(GLMessage::DataType::INT); 4612 arg_w->add_intvalue(w); 4613 4614 // call function 4615 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4616 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4617 glContext->hooks->gl.glUniform4i(location, x, y, z, w); 4618 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4619 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4620 4621 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4622 threadStartTime, threadEndTime, 4623 &glmsg); 4624 glContext->traceGLMessage(&glmsg); 4625} 4626 4627void GLTrace_glUniform4iv(GLint location, GLsizei count, const GLint* v) { 4628 GLMessage glmsg; 4629 GLTraceContext *glContext = getGLTraceContext(); 4630 4631 glmsg.set_function(GLMessage::glUniform4iv); 4632 4633 // copy argument location 4634 GLMessage_DataType *arg_location = glmsg.add_args(); 4635 arg_location->set_isarray(false); 4636 arg_location->set_type(GLMessage::DataType::INT); 4637 arg_location->add_intvalue(location); 4638 4639 // copy argument count 4640 GLMessage_DataType *arg_count = glmsg.add_args(); 4641 arg_count->set_isarray(false); 4642 arg_count->set_type(GLMessage::DataType::INT); 4643 arg_count->add_intvalue(count); 4644 4645 // copy argument v 4646 GLMessage_DataType *arg_v = glmsg.add_args(); 4647 arg_v->set_isarray(false); 4648 arg_v->set_type(GLMessage::DataType::INT); 4649 arg_v->add_intvalue((int)v); 4650 4651 // call function 4652 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4653 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4654 glContext->hooks->gl.glUniform4iv(location, count, v); 4655 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4656 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4657 4658 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4659 threadStartTime, threadEndTime, 4660 &glmsg); 4661 glContext->traceGLMessage(&glmsg); 4662} 4663 4664void GLTrace_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { 4665 GLMessage glmsg; 4666 GLTraceContext *glContext = getGLTraceContext(); 4667 4668 glmsg.set_function(GLMessage::glUniformMatrix2fv); 4669 4670 // copy argument location 4671 GLMessage_DataType *arg_location = glmsg.add_args(); 4672 arg_location->set_isarray(false); 4673 arg_location->set_type(GLMessage::DataType::INT); 4674 arg_location->add_intvalue(location); 4675 4676 // copy argument count 4677 GLMessage_DataType *arg_count = glmsg.add_args(); 4678 arg_count->set_isarray(false); 4679 arg_count->set_type(GLMessage::DataType::INT); 4680 arg_count->add_intvalue(count); 4681 4682 // copy argument transpose 4683 GLMessage_DataType *arg_transpose = glmsg.add_args(); 4684 arg_transpose->set_isarray(false); 4685 arg_transpose->set_type(GLMessage::DataType::BOOL); 4686 arg_transpose->add_boolvalue(transpose); 4687 4688 // copy argument value 4689 GLMessage_DataType *arg_value = glmsg.add_args(); 4690 arg_value->set_isarray(false); 4691 arg_value->set_type(GLMessage::DataType::INT); 4692 arg_value->add_intvalue((int)value); 4693 4694 // call function 4695 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4696 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4697 glContext->hooks->gl.glUniformMatrix2fv(location, count, transpose, value); 4698 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4699 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4700 4701 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4702 threadStartTime, threadEndTime, 4703 &glmsg); 4704 glContext->traceGLMessage(&glmsg); 4705} 4706 4707void GLTrace_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { 4708 GLMessage glmsg; 4709 GLTraceContext *glContext = getGLTraceContext(); 4710 4711 glmsg.set_function(GLMessage::glUniformMatrix3fv); 4712 4713 // copy argument location 4714 GLMessage_DataType *arg_location = glmsg.add_args(); 4715 arg_location->set_isarray(false); 4716 arg_location->set_type(GLMessage::DataType::INT); 4717 arg_location->add_intvalue(location); 4718 4719 // copy argument count 4720 GLMessage_DataType *arg_count = glmsg.add_args(); 4721 arg_count->set_isarray(false); 4722 arg_count->set_type(GLMessage::DataType::INT); 4723 arg_count->add_intvalue(count); 4724 4725 // copy argument transpose 4726 GLMessage_DataType *arg_transpose = glmsg.add_args(); 4727 arg_transpose->set_isarray(false); 4728 arg_transpose->set_type(GLMessage::DataType::BOOL); 4729 arg_transpose->add_boolvalue(transpose); 4730 4731 // copy argument value 4732 GLMessage_DataType *arg_value = glmsg.add_args(); 4733 arg_value->set_isarray(false); 4734 arg_value->set_type(GLMessage::DataType::INT); 4735 arg_value->add_intvalue((int)value); 4736 4737 // call function 4738 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4739 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4740 glContext->hooks->gl.glUniformMatrix3fv(location, count, transpose, value); 4741 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4742 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4743 4744 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4745 threadStartTime, threadEndTime, 4746 &glmsg); 4747 glContext->traceGLMessage(&glmsg); 4748} 4749 4750void GLTrace_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { 4751 GLMessage glmsg; 4752 GLTraceContext *glContext = getGLTraceContext(); 4753 4754 glmsg.set_function(GLMessage::glUniformMatrix4fv); 4755 4756 // copy argument location 4757 GLMessage_DataType *arg_location = glmsg.add_args(); 4758 arg_location->set_isarray(false); 4759 arg_location->set_type(GLMessage::DataType::INT); 4760 arg_location->add_intvalue(location); 4761 4762 // copy argument count 4763 GLMessage_DataType *arg_count = glmsg.add_args(); 4764 arg_count->set_isarray(false); 4765 arg_count->set_type(GLMessage::DataType::INT); 4766 arg_count->add_intvalue(count); 4767 4768 // copy argument transpose 4769 GLMessage_DataType *arg_transpose = glmsg.add_args(); 4770 arg_transpose->set_isarray(false); 4771 arg_transpose->set_type(GLMessage::DataType::BOOL); 4772 arg_transpose->add_boolvalue(transpose); 4773 4774 // copy argument value 4775 GLMessage_DataType *arg_value = glmsg.add_args(); 4776 arg_value->set_isarray(false); 4777 arg_value->set_type(GLMessage::DataType::INT); 4778 arg_value->add_intvalue((int)value); 4779 4780 // call function 4781 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4782 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4783 glContext->hooks->gl.glUniformMatrix4fv(location, count, transpose, value); 4784 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4785 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4786 4787 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4788 threadStartTime, threadEndTime, 4789 &glmsg); 4790 glContext->traceGLMessage(&glmsg); 4791} 4792 4793void GLTrace_glUseProgram(GLuint program) { 4794 GLMessage glmsg; 4795 GLTraceContext *glContext = getGLTraceContext(); 4796 4797 glmsg.set_function(GLMessage::glUseProgram); 4798 4799 // copy argument program 4800 GLMessage_DataType *arg_program = glmsg.add_args(); 4801 arg_program->set_isarray(false); 4802 arg_program->set_type(GLMessage::DataType::INT); 4803 arg_program->add_intvalue(program); 4804 4805 // call function 4806 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4807 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4808 glContext->hooks->gl.glUseProgram(program); 4809 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4810 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4811 4812 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4813 threadStartTime, threadEndTime, 4814 &glmsg); 4815 glContext->traceGLMessage(&glmsg); 4816} 4817 4818void GLTrace_glValidateProgram(GLuint program) { 4819 GLMessage glmsg; 4820 GLTraceContext *glContext = getGLTraceContext(); 4821 4822 glmsg.set_function(GLMessage::glValidateProgram); 4823 4824 // copy argument program 4825 GLMessage_DataType *arg_program = glmsg.add_args(); 4826 arg_program->set_isarray(false); 4827 arg_program->set_type(GLMessage::DataType::INT); 4828 arg_program->add_intvalue(program); 4829 4830 // call function 4831 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4832 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4833 glContext->hooks->gl.glValidateProgram(program); 4834 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4835 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4836 4837 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4838 threadStartTime, threadEndTime, 4839 &glmsg); 4840 glContext->traceGLMessage(&glmsg); 4841} 4842 4843void GLTrace_glVertexAttrib1f(GLuint indx, GLfloat x) { 4844 GLMessage glmsg; 4845 GLTraceContext *glContext = getGLTraceContext(); 4846 4847 glmsg.set_function(GLMessage::glVertexAttrib1f); 4848 4849 // copy argument indx 4850 GLMessage_DataType *arg_indx = glmsg.add_args(); 4851 arg_indx->set_isarray(false); 4852 arg_indx->set_type(GLMessage::DataType::INT); 4853 arg_indx->add_intvalue(indx); 4854 4855 // copy argument x 4856 GLMessage_DataType *arg_x = glmsg.add_args(); 4857 arg_x->set_isarray(false); 4858 arg_x->set_type(GLMessage::DataType::FLOAT); 4859 arg_x->add_floatvalue(x); 4860 4861 // call function 4862 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4863 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4864 glContext->hooks->gl.glVertexAttrib1f(indx, x); 4865 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4866 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4867 4868 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4869 threadStartTime, threadEndTime, 4870 &glmsg); 4871 glContext->traceGLMessage(&glmsg); 4872} 4873 4874void GLTrace_glVertexAttrib1fv(GLuint indx, const GLfloat* values) { 4875 GLMessage glmsg; 4876 GLTraceContext *glContext = getGLTraceContext(); 4877 4878 glmsg.set_function(GLMessage::glVertexAttrib1fv); 4879 4880 // copy argument indx 4881 GLMessage_DataType *arg_indx = glmsg.add_args(); 4882 arg_indx->set_isarray(false); 4883 arg_indx->set_type(GLMessage::DataType::INT); 4884 arg_indx->add_intvalue(indx); 4885 4886 // copy argument values 4887 GLMessage_DataType *arg_values = glmsg.add_args(); 4888 arg_values->set_isarray(false); 4889 arg_values->set_type(GLMessage::DataType::INT); 4890 arg_values->add_intvalue((int)values); 4891 4892 // call function 4893 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4894 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4895 glContext->hooks->gl.glVertexAttrib1fv(indx, values); 4896 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4897 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4898 4899 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4900 threadStartTime, threadEndTime, 4901 &glmsg); 4902 glContext->traceGLMessage(&glmsg); 4903} 4904 4905void GLTrace_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) { 4906 GLMessage glmsg; 4907 GLTraceContext *glContext = getGLTraceContext(); 4908 4909 glmsg.set_function(GLMessage::glVertexAttrib2f); 4910 4911 // copy argument indx 4912 GLMessage_DataType *arg_indx = glmsg.add_args(); 4913 arg_indx->set_isarray(false); 4914 arg_indx->set_type(GLMessage::DataType::INT); 4915 arg_indx->add_intvalue(indx); 4916 4917 // copy argument x 4918 GLMessage_DataType *arg_x = glmsg.add_args(); 4919 arg_x->set_isarray(false); 4920 arg_x->set_type(GLMessage::DataType::FLOAT); 4921 arg_x->add_floatvalue(x); 4922 4923 // copy argument y 4924 GLMessage_DataType *arg_y = glmsg.add_args(); 4925 arg_y->set_isarray(false); 4926 arg_y->set_type(GLMessage::DataType::FLOAT); 4927 arg_y->add_floatvalue(y); 4928 4929 // call function 4930 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4931 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4932 glContext->hooks->gl.glVertexAttrib2f(indx, x, y); 4933 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4934 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4935 4936 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4937 threadStartTime, threadEndTime, 4938 &glmsg); 4939 glContext->traceGLMessage(&glmsg); 4940} 4941 4942void GLTrace_glVertexAttrib2fv(GLuint indx, const GLfloat* values) { 4943 GLMessage glmsg; 4944 GLTraceContext *glContext = getGLTraceContext(); 4945 4946 glmsg.set_function(GLMessage::glVertexAttrib2fv); 4947 4948 // copy argument indx 4949 GLMessage_DataType *arg_indx = glmsg.add_args(); 4950 arg_indx->set_isarray(false); 4951 arg_indx->set_type(GLMessage::DataType::INT); 4952 arg_indx->add_intvalue(indx); 4953 4954 // copy argument values 4955 GLMessage_DataType *arg_values = glmsg.add_args(); 4956 arg_values->set_isarray(false); 4957 arg_values->set_type(GLMessage::DataType::INT); 4958 arg_values->add_intvalue((int)values); 4959 4960 // call function 4961 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 4962 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 4963 glContext->hooks->gl.glVertexAttrib2fv(indx, values); 4964 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 4965 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 4966 4967 fixupGLMessage(glContext, wallStartTime, wallEndTime, 4968 threadStartTime, threadEndTime, 4969 &glmsg); 4970 glContext->traceGLMessage(&glmsg); 4971} 4972 4973void GLTrace_glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) { 4974 GLMessage glmsg; 4975 GLTraceContext *glContext = getGLTraceContext(); 4976 4977 glmsg.set_function(GLMessage::glVertexAttrib3f); 4978 4979 // copy argument indx 4980 GLMessage_DataType *arg_indx = glmsg.add_args(); 4981 arg_indx->set_isarray(false); 4982 arg_indx->set_type(GLMessage::DataType::INT); 4983 arg_indx->add_intvalue(indx); 4984 4985 // copy argument x 4986 GLMessage_DataType *arg_x = glmsg.add_args(); 4987 arg_x->set_isarray(false); 4988 arg_x->set_type(GLMessage::DataType::FLOAT); 4989 arg_x->add_floatvalue(x); 4990 4991 // copy argument y 4992 GLMessage_DataType *arg_y = glmsg.add_args(); 4993 arg_y->set_isarray(false); 4994 arg_y->set_type(GLMessage::DataType::FLOAT); 4995 arg_y->add_floatvalue(y); 4996 4997 // copy argument z 4998 GLMessage_DataType *arg_z = glmsg.add_args(); 4999 arg_z->set_isarray(false); 5000 arg_z->set_type(GLMessage::DataType::FLOAT); 5001 arg_z->add_floatvalue(z); 5002 5003 // call function 5004 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5005 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5006 glContext->hooks->gl.glVertexAttrib3f(indx, x, y, z); 5007 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5008 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5009 5010 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5011 threadStartTime, threadEndTime, 5012 &glmsg); 5013 glContext->traceGLMessage(&glmsg); 5014} 5015 5016void GLTrace_glVertexAttrib3fv(GLuint indx, const GLfloat* values) { 5017 GLMessage glmsg; 5018 GLTraceContext *glContext = getGLTraceContext(); 5019 5020 glmsg.set_function(GLMessage::glVertexAttrib3fv); 5021 5022 // copy argument indx 5023 GLMessage_DataType *arg_indx = glmsg.add_args(); 5024 arg_indx->set_isarray(false); 5025 arg_indx->set_type(GLMessage::DataType::INT); 5026 arg_indx->add_intvalue(indx); 5027 5028 // copy argument values 5029 GLMessage_DataType *arg_values = glmsg.add_args(); 5030 arg_values->set_isarray(false); 5031 arg_values->set_type(GLMessage::DataType::INT); 5032 arg_values->add_intvalue((int)values); 5033 5034 // call function 5035 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5036 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5037 glContext->hooks->gl.glVertexAttrib3fv(indx, values); 5038 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5039 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5040 5041 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5042 threadStartTime, threadEndTime, 5043 &glmsg); 5044 glContext->traceGLMessage(&glmsg); 5045} 5046 5047void GLTrace_glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { 5048 GLMessage glmsg; 5049 GLTraceContext *glContext = getGLTraceContext(); 5050 5051 glmsg.set_function(GLMessage::glVertexAttrib4f); 5052 5053 // copy argument indx 5054 GLMessage_DataType *arg_indx = glmsg.add_args(); 5055 arg_indx->set_isarray(false); 5056 arg_indx->set_type(GLMessage::DataType::INT); 5057 arg_indx->add_intvalue(indx); 5058 5059 // copy argument x 5060 GLMessage_DataType *arg_x = glmsg.add_args(); 5061 arg_x->set_isarray(false); 5062 arg_x->set_type(GLMessage::DataType::FLOAT); 5063 arg_x->add_floatvalue(x); 5064 5065 // copy argument y 5066 GLMessage_DataType *arg_y = glmsg.add_args(); 5067 arg_y->set_isarray(false); 5068 arg_y->set_type(GLMessage::DataType::FLOAT); 5069 arg_y->add_floatvalue(y); 5070 5071 // copy argument z 5072 GLMessage_DataType *arg_z = glmsg.add_args(); 5073 arg_z->set_isarray(false); 5074 arg_z->set_type(GLMessage::DataType::FLOAT); 5075 arg_z->add_floatvalue(z); 5076 5077 // copy argument w 5078 GLMessage_DataType *arg_w = glmsg.add_args(); 5079 arg_w->set_isarray(false); 5080 arg_w->set_type(GLMessage::DataType::FLOAT); 5081 arg_w->add_floatvalue(w); 5082 5083 // call function 5084 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5085 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5086 glContext->hooks->gl.glVertexAttrib4f(indx, x, y, z, w); 5087 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5088 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5089 5090 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5091 threadStartTime, threadEndTime, 5092 &glmsg); 5093 glContext->traceGLMessage(&glmsg); 5094} 5095 5096void GLTrace_glVertexAttrib4fv(GLuint indx, const GLfloat* values) { 5097 GLMessage glmsg; 5098 GLTraceContext *glContext = getGLTraceContext(); 5099 5100 glmsg.set_function(GLMessage::glVertexAttrib4fv); 5101 5102 // copy argument indx 5103 GLMessage_DataType *arg_indx = glmsg.add_args(); 5104 arg_indx->set_isarray(false); 5105 arg_indx->set_type(GLMessage::DataType::INT); 5106 arg_indx->add_intvalue(indx); 5107 5108 // copy argument values 5109 GLMessage_DataType *arg_values = glmsg.add_args(); 5110 arg_values->set_isarray(false); 5111 arg_values->set_type(GLMessage::DataType::INT); 5112 arg_values->add_intvalue((int)values); 5113 5114 // call function 5115 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5116 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5117 glContext->hooks->gl.glVertexAttrib4fv(indx, values); 5118 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5119 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5120 5121 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5122 threadStartTime, threadEndTime, 5123 &glmsg); 5124 glContext->traceGLMessage(&glmsg); 5125} 5126 5127void GLTrace_glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr) { 5128 GLMessage glmsg; 5129 GLTraceContext *glContext = getGLTraceContext(); 5130 5131 glmsg.set_function(GLMessage::glVertexAttribPointer); 5132 5133 // copy argument indx 5134 GLMessage_DataType *arg_indx = glmsg.add_args(); 5135 arg_indx->set_isarray(false); 5136 arg_indx->set_type(GLMessage::DataType::INT); 5137 arg_indx->add_intvalue(indx); 5138 5139 // copy argument size 5140 GLMessage_DataType *arg_size = glmsg.add_args(); 5141 arg_size->set_isarray(false); 5142 arg_size->set_type(GLMessage::DataType::INT); 5143 arg_size->add_intvalue(size); 5144 5145 // copy argument type 5146 GLMessage_DataType *arg_type = glmsg.add_args(); 5147 arg_type->set_isarray(false); 5148 arg_type->set_type(GLMessage::DataType::ENUM); 5149 arg_type->add_intvalue((int)type); 5150 5151 // copy argument normalized 5152 GLMessage_DataType *arg_normalized = glmsg.add_args(); 5153 arg_normalized->set_isarray(false); 5154 arg_normalized->set_type(GLMessage::DataType::BOOL); 5155 arg_normalized->add_boolvalue(normalized); 5156 5157 // copy argument stride 5158 GLMessage_DataType *arg_stride = glmsg.add_args(); 5159 arg_stride->set_isarray(false); 5160 arg_stride->set_type(GLMessage::DataType::INT); 5161 arg_stride->add_intvalue(stride); 5162 5163 // copy argument ptr 5164 GLMessage_DataType *arg_ptr = glmsg.add_args(); 5165 arg_ptr->set_isarray(false); 5166 arg_ptr->set_type(GLMessage::DataType::INT); 5167 arg_ptr->add_intvalue((int)ptr); 5168 5169 // call function 5170 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5171 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5172 glContext->hooks->gl.glVertexAttribPointer(indx, size, type, normalized, stride, ptr); 5173 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5174 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5175 5176 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5177 threadStartTime, threadEndTime, 5178 &glmsg); 5179 glContext->traceGLMessage(&glmsg); 5180} 5181 5182void GLTrace_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { 5183 GLMessage glmsg; 5184 GLTraceContext *glContext = getGLTraceContext(); 5185 5186 glmsg.set_function(GLMessage::glViewport); 5187 5188 // copy argument x 5189 GLMessage_DataType *arg_x = glmsg.add_args(); 5190 arg_x->set_isarray(false); 5191 arg_x->set_type(GLMessage::DataType::INT); 5192 arg_x->add_intvalue(x); 5193 5194 // copy argument y 5195 GLMessage_DataType *arg_y = glmsg.add_args(); 5196 arg_y->set_isarray(false); 5197 arg_y->set_type(GLMessage::DataType::INT); 5198 arg_y->add_intvalue(y); 5199 5200 // copy argument width 5201 GLMessage_DataType *arg_width = glmsg.add_args(); 5202 arg_width->set_isarray(false); 5203 arg_width->set_type(GLMessage::DataType::INT); 5204 arg_width->add_intvalue(width); 5205 5206 // copy argument height 5207 GLMessage_DataType *arg_height = glmsg.add_args(); 5208 arg_height->set_isarray(false); 5209 arg_height->set_type(GLMessage::DataType::INT); 5210 arg_height->add_intvalue(height); 5211 5212 // call function 5213 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5214 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5215 glContext->hooks->gl.glViewport(x, y, width, height); 5216 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5217 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5218 5219 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5220 threadStartTime, threadEndTime, 5221 &glmsg); 5222 glContext->traceGLMessage(&glmsg); 5223} 5224 5225 5226// Definitions for GL2Ext APIs 5227 5228void GLTrace_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) { 5229 GLMessage glmsg; 5230 GLTraceContext *glContext = getGLTraceContext(); 5231 5232 glmsg.set_function(GLMessage::glEGLImageTargetTexture2DOES); 5233 5234 // copy argument target 5235 GLMessage_DataType *arg_target = glmsg.add_args(); 5236 arg_target->set_isarray(false); 5237 arg_target->set_type(GLMessage::DataType::ENUM); 5238 arg_target->add_intvalue((int)target); 5239 5240 // copy argument image 5241 GLMessage_DataType *arg_image = glmsg.add_args(); 5242 arg_image->set_isarray(false); 5243 arg_image->set_type(GLMessage::DataType::INT); 5244 arg_image->add_intvalue((int)image); 5245 5246 // call function 5247 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5248 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5249 glContext->hooks->gl.glEGLImageTargetTexture2DOES(target, image); 5250 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5251 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5252 5253 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5254 threadStartTime, threadEndTime, 5255 &glmsg); 5256 glContext->traceGLMessage(&glmsg); 5257} 5258 5259void GLTrace_glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) { 5260 GLMessage glmsg; 5261 GLTraceContext *glContext = getGLTraceContext(); 5262 5263 glmsg.set_function(GLMessage::glEGLImageTargetRenderbufferStorageOES); 5264 5265 // copy argument target 5266 GLMessage_DataType *arg_target = glmsg.add_args(); 5267 arg_target->set_isarray(false); 5268 arg_target->set_type(GLMessage::DataType::ENUM); 5269 arg_target->add_intvalue((int)target); 5270 5271 // copy argument image 5272 GLMessage_DataType *arg_image = glmsg.add_args(); 5273 arg_image->set_isarray(false); 5274 arg_image->set_type(GLMessage::DataType::INT); 5275 arg_image->add_intvalue((int)image); 5276 5277 // call function 5278 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5279 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5280 glContext->hooks->gl.glEGLImageTargetRenderbufferStorageOES(target, image); 5281 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5282 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5283 5284 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5285 threadStartTime, threadEndTime, 5286 &glmsg); 5287 glContext->traceGLMessage(&glmsg); 5288} 5289 5290void GLTrace_glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary) { 5291 GLMessage glmsg; 5292 GLTraceContext *glContext = getGLTraceContext(); 5293 5294 glmsg.set_function(GLMessage::glGetProgramBinaryOES); 5295 5296 // copy argument program 5297 GLMessage_DataType *arg_program = glmsg.add_args(); 5298 arg_program->set_isarray(false); 5299 arg_program->set_type(GLMessage::DataType::INT); 5300 arg_program->add_intvalue(program); 5301 5302 // copy argument bufSize 5303 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 5304 arg_bufSize->set_isarray(false); 5305 arg_bufSize->set_type(GLMessage::DataType::INT); 5306 arg_bufSize->add_intvalue(bufSize); 5307 5308 // copy argument length 5309 GLMessage_DataType *arg_length = glmsg.add_args(); 5310 arg_length->set_isarray(false); 5311 arg_length->set_type(GLMessage::DataType::INT); 5312 arg_length->add_intvalue((int)length); 5313 5314 // copy argument binaryFormat 5315 GLMessage_DataType *arg_binaryFormat = glmsg.add_args(); 5316 arg_binaryFormat->set_isarray(false); 5317 arg_binaryFormat->set_type(GLMessage::DataType::INT); 5318 arg_binaryFormat->add_intvalue((int)binaryFormat); 5319 5320 // copy argument binary 5321 GLMessage_DataType *arg_binary = glmsg.add_args(); 5322 arg_binary->set_isarray(false); 5323 arg_binary->set_type(GLMessage::DataType::INT); 5324 arg_binary->add_intvalue((int)binary); 5325 5326 // call function 5327 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5328 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5329 glContext->hooks->gl.glGetProgramBinaryOES(program, bufSize, length, binaryFormat, binary); 5330 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5331 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5332 5333 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5334 threadStartTime, threadEndTime, 5335 &glmsg); 5336 glContext->traceGLMessage(&glmsg); 5337} 5338 5339void GLTrace_glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLint length) { 5340 GLMessage glmsg; 5341 GLTraceContext *glContext = getGLTraceContext(); 5342 5343 glmsg.set_function(GLMessage::glProgramBinaryOES); 5344 5345 // copy argument program 5346 GLMessage_DataType *arg_program = glmsg.add_args(); 5347 arg_program->set_isarray(false); 5348 arg_program->set_type(GLMessage::DataType::INT); 5349 arg_program->add_intvalue(program); 5350 5351 // copy argument binaryFormat 5352 GLMessage_DataType *arg_binaryFormat = glmsg.add_args(); 5353 arg_binaryFormat->set_isarray(false); 5354 arg_binaryFormat->set_type(GLMessage::DataType::ENUM); 5355 arg_binaryFormat->add_intvalue((int)binaryFormat); 5356 5357 // copy argument binary 5358 GLMessage_DataType *arg_binary = glmsg.add_args(); 5359 arg_binary->set_isarray(false); 5360 arg_binary->set_type(GLMessage::DataType::INT); 5361 arg_binary->add_intvalue((int)binary); 5362 5363 // copy argument length 5364 GLMessage_DataType *arg_length = glmsg.add_args(); 5365 arg_length->set_isarray(false); 5366 arg_length->set_type(GLMessage::DataType::INT); 5367 arg_length->add_intvalue(length); 5368 5369 // call function 5370 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5371 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5372 glContext->hooks->gl.glProgramBinaryOES(program, binaryFormat, binary, length); 5373 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5374 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5375 5376 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5377 threadStartTime, threadEndTime, 5378 &glmsg); 5379 glContext->traceGLMessage(&glmsg); 5380} 5381 5382void* GLTrace_glMapBufferOES(GLenum target, GLenum access) { 5383 GLMessage glmsg; 5384 GLTraceContext *glContext = getGLTraceContext(); 5385 5386 glmsg.set_function(GLMessage::glMapBufferOES); 5387 5388 // copy argument target 5389 GLMessage_DataType *arg_target = glmsg.add_args(); 5390 arg_target->set_isarray(false); 5391 arg_target->set_type(GLMessage::DataType::ENUM); 5392 arg_target->add_intvalue((int)target); 5393 5394 // copy argument access 5395 GLMessage_DataType *arg_access = glmsg.add_args(); 5396 arg_access->set_isarray(false); 5397 arg_access->set_type(GLMessage::DataType::ENUM); 5398 arg_access->add_intvalue((int)access); 5399 5400 // call function 5401 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5402 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5403 void* retValue = glContext->hooks->gl.glMapBufferOES(target, access); 5404 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5405 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5406 5407 // set return value 5408 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 5409 rt->set_isarray(false); 5410 rt->set_type(GLMessage::DataType::INT); 5411 rt->add_intvalue((int)retValue); 5412 5413 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5414 threadStartTime, threadEndTime, 5415 &glmsg); 5416 glContext->traceGLMessage(&glmsg); 5417 5418 return retValue; 5419} 5420 5421GLboolean GLTrace_glUnmapBufferOES(GLenum target) { 5422 GLMessage glmsg; 5423 GLTraceContext *glContext = getGLTraceContext(); 5424 5425 glmsg.set_function(GLMessage::glUnmapBufferOES); 5426 5427 // copy argument target 5428 GLMessage_DataType *arg_target = glmsg.add_args(); 5429 arg_target->set_isarray(false); 5430 arg_target->set_type(GLMessage::DataType::ENUM); 5431 arg_target->add_intvalue((int)target); 5432 5433 // call function 5434 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5435 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5436 GLboolean retValue = glContext->hooks->gl.glUnmapBufferOES(target); 5437 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5438 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5439 5440 // set return value 5441 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 5442 rt->set_isarray(false); 5443 rt->set_type(GLMessage::DataType::BOOL); 5444 rt->add_boolvalue(retValue); 5445 5446 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5447 threadStartTime, threadEndTime, 5448 &glmsg); 5449 glContext->traceGLMessage(&glmsg); 5450 5451 return retValue; 5452} 5453 5454void GLTrace_glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params) { 5455 GLMessage glmsg; 5456 GLTraceContext *glContext = getGLTraceContext(); 5457 5458 glmsg.set_function(GLMessage::glGetBufferPointervOES); 5459 5460 // copy argument target 5461 GLMessage_DataType *arg_target = glmsg.add_args(); 5462 arg_target->set_isarray(false); 5463 arg_target->set_type(GLMessage::DataType::ENUM); 5464 arg_target->add_intvalue((int)target); 5465 5466 // copy argument pname 5467 GLMessage_DataType *arg_pname = glmsg.add_args(); 5468 arg_pname->set_isarray(false); 5469 arg_pname->set_type(GLMessage::DataType::ENUM); 5470 arg_pname->add_intvalue((int)pname); 5471 5472 // copy argument params 5473 GLMessage_DataType *arg_params = glmsg.add_args(); 5474 arg_params->set_isarray(false); 5475 arg_params->set_type(GLMessage::DataType::INT); 5476 arg_params->add_intvalue((int)params); 5477 5478 // call function 5479 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5480 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5481 glContext->hooks->gl.glGetBufferPointervOES(target, pname, params); 5482 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5483 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5484 5485 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5486 threadStartTime, threadEndTime, 5487 &glmsg); 5488 glContext->traceGLMessage(&glmsg); 5489} 5490 5491void GLTrace_glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { 5492 GLMessage glmsg; 5493 GLTraceContext *glContext = getGLTraceContext(); 5494 5495 glmsg.set_function(GLMessage::glTexImage3DOES); 5496 5497 // copy argument target 5498 GLMessage_DataType *arg_target = glmsg.add_args(); 5499 arg_target->set_isarray(false); 5500 arg_target->set_type(GLMessage::DataType::ENUM); 5501 arg_target->add_intvalue((int)target); 5502 5503 // copy argument level 5504 GLMessage_DataType *arg_level = glmsg.add_args(); 5505 arg_level->set_isarray(false); 5506 arg_level->set_type(GLMessage::DataType::INT); 5507 arg_level->add_intvalue(level); 5508 5509 // copy argument internalformat 5510 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 5511 arg_internalformat->set_isarray(false); 5512 arg_internalformat->set_type(GLMessage::DataType::ENUM); 5513 arg_internalformat->add_intvalue((int)internalformat); 5514 5515 // copy argument width 5516 GLMessage_DataType *arg_width = glmsg.add_args(); 5517 arg_width->set_isarray(false); 5518 arg_width->set_type(GLMessage::DataType::INT); 5519 arg_width->add_intvalue(width); 5520 5521 // copy argument height 5522 GLMessage_DataType *arg_height = glmsg.add_args(); 5523 arg_height->set_isarray(false); 5524 arg_height->set_type(GLMessage::DataType::INT); 5525 arg_height->add_intvalue(height); 5526 5527 // copy argument depth 5528 GLMessage_DataType *arg_depth = glmsg.add_args(); 5529 arg_depth->set_isarray(false); 5530 arg_depth->set_type(GLMessage::DataType::INT); 5531 arg_depth->add_intvalue(depth); 5532 5533 // copy argument border 5534 GLMessage_DataType *arg_border = glmsg.add_args(); 5535 arg_border->set_isarray(false); 5536 arg_border->set_type(GLMessage::DataType::INT); 5537 arg_border->add_intvalue(border); 5538 5539 // copy argument format 5540 GLMessage_DataType *arg_format = glmsg.add_args(); 5541 arg_format->set_isarray(false); 5542 arg_format->set_type(GLMessage::DataType::ENUM); 5543 arg_format->add_intvalue((int)format); 5544 5545 // copy argument type 5546 GLMessage_DataType *arg_type = glmsg.add_args(); 5547 arg_type->set_isarray(false); 5548 arg_type->set_type(GLMessage::DataType::ENUM); 5549 arg_type->add_intvalue((int)type); 5550 5551 // copy argument pixels 5552 GLMessage_DataType *arg_pixels = glmsg.add_args(); 5553 arg_pixels->set_isarray(false); 5554 arg_pixels->set_type(GLMessage::DataType::INT); 5555 arg_pixels->add_intvalue((int)pixels); 5556 5557 // call function 5558 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5559 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5560 glContext->hooks->gl.glTexImage3DOES(target, level, internalformat, width, height, depth, border, format, type, pixels); 5561 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5562 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5563 5564 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5565 threadStartTime, threadEndTime, 5566 &glmsg); 5567 glContext->traceGLMessage(&glmsg); 5568} 5569 5570void 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) { 5571 GLMessage glmsg; 5572 GLTraceContext *glContext = getGLTraceContext(); 5573 5574 glmsg.set_function(GLMessage::glTexSubImage3DOES); 5575 5576 // copy argument target 5577 GLMessage_DataType *arg_target = glmsg.add_args(); 5578 arg_target->set_isarray(false); 5579 arg_target->set_type(GLMessage::DataType::ENUM); 5580 arg_target->add_intvalue((int)target); 5581 5582 // copy argument level 5583 GLMessage_DataType *arg_level = glmsg.add_args(); 5584 arg_level->set_isarray(false); 5585 arg_level->set_type(GLMessage::DataType::INT); 5586 arg_level->add_intvalue(level); 5587 5588 // copy argument xoffset 5589 GLMessage_DataType *arg_xoffset = glmsg.add_args(); 5590 arg_xoffset->set_isarray(false); 5591 arg_xoffset->set_type(GLMessage::DataType::INT); 5592 arg_xoffset->add_intvalue(xoffset); 5593 5594 // copy argument yoffset 5595 GLMessage_DataType *arg_yoffset = glmsg.add_args(); 5596 arg_yoffset->set_isarray(false); 5597 arg_yoffset->set_type(GLMessage::DataType::INT); 5598 arg_yoffset->add_intvalue(yoffset); 5599 5600 // copy argument zoffset 5601 GLMessage_DataType *arg_zoffset = glmsg.add_args(); 5602 arg_zoffset->set_isarray(false); 5603 arg_zoffset->set_type(GLMessage::DataType::INT); 5604 arg_zoffset->add_intvalue(zoffset); 5605 5606 // copy argument width 5607 GLMessage_DataType *arg_width = glmsg.add_args(); 5608 arg_width->set_isarray(false); 5609 arg_width->set_type(GLMessage::DataType::INT); 5610 arg_width->add_intvalue(width); 5611 5612 // copy argument height 5613 GLMessage_DataType *arg_height = glmsg.add_args(); 5614 arg_height->set_isarray(false); 5615 arg_height->set_type(GLMessage::DataType::INT); 5616 arg_height->add_intvalue(height); 5617 5618 // copy argument depth 5619 GLMessage_DataType *arg_depth = glmsg.add_args(); 5620 arg_depth->set_isarray(false); 5621 arg_depth->set_type(GLMessage::DataType::INT); 5622 arg_depth->add_intvalue(depth); 5623 5624 // copy argument format 5625 GLMessage_DataType *arg_format = glmsg.add_args(); 5626 arg_format->set_isarray(false); 5627 arg_format->set_type(GLMessage::DataType::ENUM); 5628 arg_format->add_intvalue((int)format); 5629 5630 // copy argument type 5631 GLMessage_DataType *arg_type = glmsg.add_args(); 5632 arg_type->set_isarray(false); 5633 arg_type->set_type(GLMessage::DataType::ENUM); 5634 arg_type->add_intvalue((int)type); 5635 5636 // copy argument pixels 5637 GLMessage_DataType *arg_pixels = glmsg.add_args(); 5638 arg_pixels->set_isarray(false); 5639 arg_pixels->set_type(GLMessage::DataType::INT); 5640 arg_pixels->add_intvalue((int)pixels); 5641 5642 // call function 5643 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5644 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5645 glContext->hooks->gl.glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); 5646 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5647 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5648 5649 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5650 threadStartTime, threadEndTime, 5651 &glmsg); 5652 glContext->traceGLMessage(&glmsg); 5653} 5654 5655void GLTrace_glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { 5656 GLMessage glmsg; 5657 GLTraceContext *glContext = getGLTraceContext(); 5658 5659 glmsg.set_function(GLMessage::glCopyTexSubImage3DOES); 5660 5661 // copy argument target 5662 GLMessage_DataType *arg_target = glmsg.add_args(); 5663 arg_target->set_isarray(false); 5664 arg_target->set_type(GLMessage::DataType::ENUM); 5665 arg_target->add_intvalue((int)target); 5666 5667 // copy argument level 5668 GLMessage_DataType *arg_level = glmsg.add_args(); 5669 arg_level->set_isarray(false); 5670 arg_level->set_type(GLMessage::DataType::INT); 5671 arg_level->add_intvalue(level); 5672 5673 // copy argument xoffset 5674 GLMessage_DataType *arg_xoffset = glmsg.add_args(); 5675 arg_xoffset->set_isarray(false); 5676 arg_xoffset->set_type(GLMessage::DataType::INT); 5677 arg_xoffset->add_intvalue(xoffset); 5678 5679 // copy argument yoffset 5680 GLMessage_DataType *arg_yoffset = glmsg.add_args(); 5681 arg_yoffset->set_isarray(false); 5682 arg_yoffset->set_type(GLMessage::DataType::INT); 5683 arg_yoffset->add_intvalue(yoffset); 5684 5685 // copy argument zoffset 5686 GLMessage_DataType *arg_zoffset = glmsg.add_args(); 5687 arg_zoffset->set_isarray(false); 5688 arg_zoffset->set_type(GLMessage::DataType::INT); 5689 arg_zoffset->add_intvalue(zoffset); 5690 5691 // copy argument x 5692 GLMessage_DataType *arg_x = glmsg.add_args(); 5693 arg_x->set_isarray(false); 5694 arg_x->set_type(GLMessage::DataType::INT); 5695 arg_x->add_intvalue(x); 5696 5697 // copy argument y 5698 GLMessage_DataType *arg_y = glmsg.add_args(); 5699 arg_y->set_isarray(false); 5700 arg_y->set_type(GLMessage::DataType::INT); 5701 arg_y->add_intvalue(y); 5702 5703 // copy argument width 5704 GLMessage_DataType *arg_width = glmsg.add_args(); 5705 arg_width->set_isarray(false); 5706 arg_width->set_type(GLMessage::DataType::INT); 5707 arg_width->add_intvalue(width); 5708 5709 // copy argument height 5710 GLMessage_DataType *arg_height = glmsg.add_args(); 5711 arg_height->set_isarray(false); 5712 arg_height->set_type(GLMessage::DataType::INT); 5713 arg_height->add_intvalue(height); 5714 5715 // call function 5716 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5717 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5718 glContext->hooks->gl.glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height); 5719 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5720 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5721 5722 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5723 threadStartTime, threadEndTime, 5724 &glmsg); 5725 glContext->traceGLMessage(&glmsg); 5726} 5727 5728void GLTrace_glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) { 5729 GLMessage glmsg; 5730 GLTraceContext *glContext = getGLTraceContext(); 5731 5732 glmsg.set_function(GLMessage::glCompressedTexImage3DOES); 5733 5734 // copy argument target 5735 GLMessage_DataType *arg_target = glmsg.add_args(); 5736 arg_target->set_isarray(false); 5737 arg_target->set_type(GLMessage::DataType::ENUM); 5738 arg_target->add_intvalue((int)target); 5739 5740 // copy argument level 5741 GLMessage_DataType *arg_level = glmsg.add_args(); 5742 arg_level->set_isarray(false); 5743 arg_level->set_type(GLMessage::DataType::INT); 5744 arg_level->add_intvalue(level); 5745 5746 // copy argument internalformat 5747 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 5748 arg_internalformat->set_isarray(false); 5749 arg_internalformat->set_type(GLMessage::DataType::ENUM); 5750 arg_internalformat->add_intvalue((int)internalformat); 5751 5752 // copy argument width 5753 GLMessage_DataType *arg_width = glmsg.add_args(); 5754 arg_width->set_isarray(false); 5755 arg_width->set_type(GLMessage::DataType::INT); 5756 arg_width->add_intvalue(width); 5757 5758 // copy argument height 5759 GLMessage_DataType *arg_height = glmsg.add_args(); 5760 arg_height->set_isarray(false); 5761 arg_height->set_type(GLMessage::DataType::INT); 5762 arg_height->add_intvalue(height); 5763 5764 // copy argument depth 5765 GLMessage_DataType *arg_depth = glmsg.add_args(); 5766 arg_depth->set_isarray(false); 5767 arg_depth->set_type(GLMessage::DataType::INT); 5768 arg_depth->add_intvalue(depth); 5769 5770 // copy argument border 5771 GLMessage_DataType *arg_border = glmsg.add_args(); 5772 arg_border->set_isarray(false); 5773 arg_border->set_type(GLMessage::DataType::INT); 5774 arg_border->add_intvalue(border); 5775 5776 // copy argument imageSize 5777 GLMessage_DataType *arg_imageSize = glmsg.add_args(); 5778 arg_imageSize->set_isarray(false); 5779 arg_imageSize->set_type(GLMessage::DataType::INT); 5780 arg_imageSize->add_intvalue(imageSize); 5781 5782 // copy argument data 5783 GLMessage_DataType *arg_data = glmsg.add_args(); 5784 arg_data->set_isarray(false); 5785 arg_data->set_type(GLMessage::DataType::INT); 5786 arg_data->add_intvalue((int)data); 5787 5788 // call function 5789 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5790 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5791 glContext->hooks->gl.glCompressedTexImage3DOES(target, level, internalformat, width, height, depth, border, imageSize, data); 5792 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5793 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5794 5795 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5796 threadStartTime, threadEndTime, 5797 &glmsg); 5798 glContext->traceGLMessage(&glmsg); 5799} 5800 5801void 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) { 5802 GLMessage glmsg; 5803 GLTraceContext *glContext = getGLTraceContext(); 5804 5805 glmsg.set_function(GLMessage::glCompressedTexSubImage3DOES); 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 level 5814 GLMessage_DataType *arg_level = glmsg.add_args(); 5815 arg_level->set_isarray(false); 5816 arg_level->set_type(GLMessage::DataType::INT); 5817 arg_level->add_intvalue(level); 5818 5819 // copy argument xoffset 5820 GLMessage_DataType *arg_xoffset = glmsg.add_args(); 5821 arg_xoffset->set_isarray(false); 5822 arg_xoffset->set_type(GLMessage::DataType::INT); 5823 arg_xoffset->add_intvalue(xoffset); 5824 5825 // copy argument yoffset 5826 GLMessage_DataType *arg_yoffset = glmsg.add_args(); 5827 arg_yoffset->set_isarray(false); 5828 arg_yoffset->set_type(GLMessage::DataType::INT); 5829 arg_yoffset->add_intvalue(yoffset); 5830 5831 // copy argument zoffset 5832 GLMessage_DataType *arg_zoffset = glmsg.add_args(); 5833 arg_zoffset->set_isarray(false); 5834 arg_zoffset->set_type(GLMessage::DataType::INT); 5835 arg_zoffset->add_intvalue(zoffset); 5836 5837 // copy argument width 5838 GLMessage_DataType *arg_width = glmsg.add_args(); 5839 arg_width->set_isarray(false); 5840 arg_width->set_type(GLMessage::DataType::INT); 5841 arg_width->add_intvalue(width); 5842 5843 // copy argument height 5844 GLMessage_DataType *arg_height = glmsg.add_args(); 5845 arg_height->set_isarray(false); 5846 arg_height->set_type(GLMessage::DataType::INT); 5847 arg_height->add_intvalue(height); 5848 5849 // copy argument depth 5850 GLMessage_DataType *arg_depth = glmsg.add_args(); 5851 arg_depth->set_isarray(false); 5852 arg_depth->set_type(GLMessage::DataType::INT); 5853 arg_depth->add_intvalue(depth); 5854 5855 // copy argument format 5856 GLMessage_DataType *arg_format = glmsg.add_args(); 5857 arg_format->set_isarray(false); 5858 arg_format->set_type(GLMessage::DataType::ENUM); 5859 arg_format->add_intvalue((int)format); 5860 5861 // copy argument imageSize 5862 GLMessage_DataType *arg_imageSize = glmsg.add_args(); 5863 arg_imageSize->set_isarray(false); 5864 arg_imageSize->set_type(GLMessage::DataType::INT); 5865 arg_imageSize->add_intvalue(imageSize); 5866 5867 // copy argument data 5868 GLMessage_DataType *arg_data = glmsg.add_args(); 5869 arg_data->set_isarray(false); 5870 arg_data->set_type(GLMessage::DataType::INT); 5871 arg_data->add_intvalue((int)data); 5872 5873 // call function 5874 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5875 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5876 glContext->hooks->gl.glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); 5877 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5878 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5879 5880 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5881 threadStartTime, threadEndTime, 5882 &glmsg); 5883 glContext->traceGLMessage(&glmsg); 5884} 5885 5886void GLTrace_glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { 5887 GLMessage glmsg; 5888 GLTraceContext *glContext = getGLTraceContext(); 5889 5890 glmsg.set_function(GLMessage::glFramebufferTexture3DOES); 5891 5892 // copy argument target 5893 GLMessage_DataType *arg_target = glmsg.add_args(); 5894 arg_target->set_isarray(false); 5895 arg_target->set_type(GLMessage::DataType::ENUM); 5896 arg_target->add_intvalue((int)target); 5897 5898 // copy argument attachment 5899 GLMessage_DataType *arg_attachment = glmsg.add_args(); 5900 arg_attachment->set_isarray(false); 5901 arg_attachment->set_type(GLMessage::DataType::ENUM); 5902 arg_attachment->add_intvalue((int)attachment); 5903 5904 // copy argument textarget 5905 GLMessage_DataType *arg_textarget = glmsg.add_args(); 5906 arg_textarget->set_isarray(false); 5907 arg_textarget->set_type(GLMessage::DataType::ENUM); 5908 arg_textarget->add_intvalue((int)textarget); 5909 5910 // copy argument texture 5911 GLMessage_DataType *arg_texture = glmsg.add_args(); 5912 arg_texture->set_isarray(false); 5913 arg_texture->set_type(GLMessage::DataType::INT); 5914 arg_texture->add_intvalue(texture); 5915 5916 // copy argument level 5917 GLMessage_DataType *arg_level = glmsg.add_args(); 5918 arg_level->set_isarray(false); 5919 arg_level->set_type(GLMessage::DataType::INT); 5920 arg_level->add_intvalue(level); 5921 5922 // copy argument zoffset 5923 GLMessage_DataType *arg_zoffset = glmsg.add_args(); 5924 arg_zoffset->set_isarray(false); 5925 arg_zoffset->set_type(GLMessage::DataType::INT); 5926 arg_zoffset->add_intvalue(zoffset); 5927 5928 // call function 5929 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5930 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5931 glContext->hooks->gl.glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset); 5932 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5933 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5934 5935 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5936 threadStartTime, threadEndTime, 5937 &glmsg); 5938 glContext->traceGLMessage(&glmsg); 5939} 5940 5941void GLTrace_glBindVertexArrayOES(GLuint array) { 5942 GLMessage glmsg; 5943 GLTraceContext *glContext = getGLTraceContext(); 5944 5945 glmsg.set_function(GLMessage::glBindVertexArrayOES); 5946 5947 // copy argument array 5948 GLMessage_DataType *arg_array = glmsg.add_args(); 5949 arg_array->set_isarray(false); 5950 arg_array->set_type(GLMessage::DataType::INT); 5951 arg_array->add_intvalue(array); 5952 5953 // call function 5954 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5955 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5956 glContext->hooks->gl.glBindVertexArrayOES(array); 5957 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5958 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5959 5960 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5961 threadStartTime, threadEndTime, 5962 &glmsg); 5963 glContext->traceGLMessage(&glmsg); 5964} 5965 5966void GLTrace_glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays) { 5967 GLMessage glmsg; 5968 GLTraceContext *glContext = getGLTraceContext(); 5969 5970 glmsg.set_function(GLMessage::glDeleteVertexArraysOES); 5971 5972 // copy argument n 5973 GLMessage_DataType *arg_n = glmsg.add_args(); 5974 arg_n->set_isarray(false); 5975 arg_n->set_type(GLMessage::DataType::INT); 5976 arg_n->add_intvalue(n); 5977 5978 // copy argument arrays 5979 GLMessage_DataType *arg_arrays = glmsg.add_args(); 5980 arg_arrays->set_isarray(false); 5981 arg_arrays->set_type(GLMessage::DataType::INT); 5982 arg_arrays->add_intvalue((int)arrays); 5983 5984 // call function 5985 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 5986 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 5987 glContext->hooks->gl.glDeleteVertexArraysOES(n, arrays); 5988 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 5989 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 5990 5991 fixupGLMessage(glContext, wallStartTime, wallEndTime, 5992 threadStartTime, threadEndTime, 5993 &glmsg); 5994 glContext->traceGLMessage(&glmsg); 5995} 5996 5997void GLTrace_glGenVertexArraysOES(GLsizei n, GLuint *arrays) { 5998 GLMessage glmsg; 5999 GLTraceContext *glContext = getGLTraceContext(); 6000 6001 glmsg.set_function(GLMessage::glGenVertexArraysOES); 6002 6003 // copy argument n 6004 GLMessage_DataType *arg_n = glmsg.add_args(); 6005 arg_n->set_isarray(false); 6006 arg_n->set_type(GLMessage::DataType::INT); 6007 arg_n->add_intvalue(n); 6008 6009 // copy argument arrays 6010 GLMessage_DataType *arg_arrays = glmsg.add_args(); 6011 arg_arrays->set_isarray(false); 6012 arg_arrays->set_type(GLMessage::DataType::INT); 6013 arg_arrays->add_intvalue((int)arrays); 6014 6015 // call function 6016 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6017 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6018 glContext->hooks->gl.glGenVertexArraysOES(n, arrays); 6019 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6020 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6021 6022 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6023 threadStartTime, threadEndTime, 6024 &glmsg); 6025 glContext->traceGLMessage(&glmsg); 6026} 6027 6028GLboolean GLTrace_glIsVertexArrayOES(GLuint array) { 6029 GLMessage glmsg; 6030 GLTraceContext *glContext = getGLTraceContext(); 6031 6032 glmsg.set_function(GLMessage::glIsVertexArrayOES); 6033 6034 // copy argument array 6035 GLMessage_DataType *arg_array = glmsg.add_args(); 6036 arg_array->set_isarray(false); 6037 arg_array->set_type(GLMessage::DataType::INT); 6038 arg_array->add_intvalue(array); 6039 6040 // call function 6041 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6042 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6043 GLboolean retValue = glContext->hooks->gl.glIsVertexArrayOES(array); 6044 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6045 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6046 6047 // set return value 6048 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 6049 rt->set_isarray(false); 6050 rt->set_type(GLMessage::DataType::BOOL); 6051 rt->add_boolvalue(retValue); 6052 6053 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6054 threadStartTime, threadEndTime, 6055 &glmsg); 6056 glContext->traceGLMessage(&glmsg); 6057 6058 return retValue; 6059} 6060 6061void GLTrace_glGetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups) { 6062 GLMessage glmsg; 6063 GLTraceContext *glContext = getGLTraceContext(); 6064 6065 glmsg.set_function(GLMessage::glGetPerfMonitorGroupsAMD); 6066 6067 // copy argument numGroups 6068 GLMessage_DataType *arg_numGroups = glmsg.add_args(); 6069 arg_numGroups->set_isarray(false); 6070 arg_numGroups->set_type(GLMessage::DataType::INT); 6071 arg_numGroups->add_intvalue((int)numGroups); 6072 6073 // copy argument groupsSize 6074 GLMessage_DataType *arg_groupsSize = glmsg.add_args(); 6075 arg_groupsSize->set_isarray(false); 6076 arg_groupsSize->set_type(GLMessage::DataType::INT); 6077 arg_groupsSize->add_intvalue(groupsSize); 6078 6079 // copy argument groups 6080 GLMessage_DataType *arg_groups = glmsg.add_args(); 6081 arg_groups->set_isarray(false); 6082 arg_groups->set_type(GLMessage::DataType::INT); 6083 arg_groups->add_intvalue((int)groups); 6084 6085 // call function 6086 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6087 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6088 glContext->hooks->gl.glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups); 6089 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6090 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6091 6092 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6093 threadStartTime, threadEndTime, 6094 &glmsg); 6095 glContext->traceGLMessage(&glmsg); 6096} 6097 6098void GLTrace_glGetPerfMonitorCountersAMD(GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters) { 6099 GLMessage glmsg; 6100 GLTraceContext *glContext = getGLTraceContext(); 6101 6102 glmsg.set_function(GLMessage::glGetPerfMonitorCountersAMD); 6103 6104 // copy argument group 6105 GLMessage_DataType *arg_group = glmsg.add_args(); 6106 arg_group->set_isarray(false); 6107 arg_group->set_type(GLMessage::DataType::INT); 6108 arg_group->add_intvalue(group); 6109 6110 // copy argument numCounters 6111 GLMessage_DataType *arg_numCounters = glmsg.add_args(); 6112 arg_numCounters->set_isarray(false); 6113 arg_numCounters->set_type(GLMessage::DataType::INT); 6114 arg_numCounters->add_intvalue((int)numCounters); 6115 6116 // copy argument maxActiveCounters 6117 GLMessage_DataType *arg_maxActiveCounters = glmsg.add_args(); 6118 arg_maxActiveCounters->set_isarray(false); 6119 arg_maxActiveCounters->set_type(GLMessage::DataType::INT); 6120 arg_maxActiveCounters->add_intvalue((int)maxActiveCounters); 6121 6122 // copy argument counterSize 6123 GLMessage_DataType *arg_counterSize = glmsg.add_args(); 6124 arg_counterSize->set_isarray(false); 6125 arg_counterSize->set_type(GLMessage::DataType::INT); 6126 arg_counterSize->add_intvalue(counterSize); 6127 6128 // copy argument counters 6129 GLMessage_DataType *arg_counters = glmsg.add_args(); 6130 arg_counters->set_isarray(false); 6131 arg_counters->set_type(GLMessage::DataType::INT); 6132 arg_counters->add_intvalue((int)counters); 6133 6134 // call function 6135 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6136 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6137 glContext->hooks->gl.glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters); 6138 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6139 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6140 6141 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6142 threadStartTime, threadEndTime, 6143 &glmsg); 6144 glContext->traceGLMessage(&glmsg); 6145} 6146 6147void GLTrace_glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString) { 6148 GLMessage glmsg; 6149 GLTraceContext *glContext = getGLTraceContext(); 6150 6151 glmsg.set_function(GLMessage::glGetPerfMonitorGroupStringAMD); 6152 6153 // copy argument group 6154 GLMessage_DataType *arg_group = glmsg.add_args(); 6155 arg_group->set_isarray(false); 6156 arg_group->set_type(GLMessage::DataType::INT); 6157 arg_group->add_intvalue(group); 6158 6159 // copy argument bufSize 6160 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 6161 arg_bufSize->set_isarray(false); 6162 arg_bufSize->set_type(GLMessage::DataType::INT); 6163 arg_bufSize->add_intvalue(bufSize); 6164 6165 // copy argument length 6166 GLMessage_DataType *arg_length = glmsg.add_args(); 6167 arg_length->set_isarray(false); 6168 arg_length->set_type(GLMessage::DataType::INT); 6169 arg_length->add_intvalue((int)length); 6170 6171 // copy argument groupString 6172 GLMessage_DataType *arg_groupString = glmsg.add_args(); 6173 arg_groupString->set_isarray(false); 6174 arg_groupString->set_type(GLMessage::DataType::INT); 6175 arg_groupString->add_intvalue((int)groupString); 6176 6177 // call function 6178 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6179 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6180 glContext->hooks->gl.glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString); 6181 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6182 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6183 6184 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6185 threadStartTime, threadEndTime, 6186 &glmsg); 6187 glContext->traceGLMessage(&glmsg); 6188} 6189 6190void GLTrace_glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString) { 6191 GLMessage glmsg; 6192 GLTraceContext *glContext = getGLTraceContext(); 6193 6194 glmsg.set_function(GLMessage::glGetPerfMonitorCounterStringAMD); 6195 6196 // copy argument group 6197 GLMessage_DataType *arg_group = glmsg.add_args(); 6198 arg_group->set_isarray(false); 6199 arg_group->set_type(GLMessage::DataType::INT); 6200 arg_group->add_intvalue(group); 6201 6202 // copy argument counter 6203 GLMessage_DataType *arg_counter = glmsg.add_args(); 6204 arg_counter->set_isarray(false); 6205 arg_counter->set_type(GLMessage::DataType::INT); 6206 arg_counter->add_intvalue(counter); 6207 6208 // copy argument bufSize 6209 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 6210 arg_bufSize->set_isarray(false); 6211 arg_bufSize->set_type(GLMessage::DataType::INT); 6212 arg_bufSize->add_intvalue(bufSize); 6213 6214 // copy argument length 6215 GLMessage_DataType *arg_length = glmsg.add_args(); 6216 arg_length->set_isarray(false); 6217 arg_length->set_type(GLMessage::DataType::INT); 6218 arg_length->add_intvalue((int)length); 6219 6220 // copy argument counterString 6221 GLMessage_DataType *arg_counterString = glmsg.add_args(); 6222 arg_counterString->set_isarray(false); 6223 arg_counterString->set_type(GLMessage::DataType::INT); 6224 arg_counterString->add_intvalue((int)counterString); 6225 6226 // call function 6227 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6228 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6229 glContext->hooks->gl.glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString); 6230 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6231 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6232 6233 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6234 threadStartTime, threadEndTime, 6235 &glmsg); 6236 glContext->traceGLMessage(&glmsg); 6237} 6238 6239void GLTrace_glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid *data) { 6240 GLMessage glmsg; 6241 GLTraceContext *glContext = getGLTraceContext(); 6242 6243 glmsg.set_function(GLMessage::glGetPerfMonitorCounterInfoAMD); 6244 6245 // copy argument group 6246 GLMessage_DataType *arg_group = glmsg.add_args(); 6247 arg_group->set_isarray(false); 6248 arg_group->set_type(GLMessage::DataType::INT); 6249 arg_group->add_intvalue(group); 6250 6251 // copy argument counter 6252 GLMessage_DataType *arg_counter = glmsg.add_args(); 6253 arg_counter->set_isarray(false); 6254 arg_counter->set_type(GLMessage::DataType::INT); 6255 arg_counter->add_intvalue(counter); 6256 6257 // copy argument pname 6258 GLMessage_DataType *arg_pname = glmsg.add_args(); 6259 arg_pname->set_isarray(false); 6260 arg_pname->set_type(GLMessage::DataType::ENUM); 6261 arg_pname->add_intvalue((int)pname); 6262 6263 // copy argument data 6264 GLMessage_DataType *arg_data = glmsg.add_args(); 6265 arg_data->set_isarray(false); 6266 arg_data->set_type(GLMessage::DataType::INT); 6267 arg_data->add_intvalue((int)data); 6268 6269 // call function 6270 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6271 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6272 glContext->hooks->gl.glGetPerfMonitorCounterInfoAMD(group, counter, pname, data); 6273 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6274 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6275 6276 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6277 threadStartTime, threadEndTime, 6278 &glmsg); 6279 glContext->traceGLMessage(&glmsg); 6280} 6281 6282void GLTrace_glGenPerfMonitorsAMD(GLsizei n, GLuint *monitors) { 6283 GLMessage glmsg; 6284 GLTraceContext *glContext = getGLTraceContext(); 6285 6286 glmsg.set_function(GLMessage::glGenPerfMonitorsAMD); 6287 6288 // copy argument n 6289 GLMessage_DataType *arg_n = glmsg.add_args(); 6290 arg_n->set_isarray(false); 6291 arg_n->set_type(GLMessage::DataType::INT); 6292 arg_n->add_intvalue(n); 6293 6294 // copy argument monitors 6295 GLMessage_DataType *arg_monitors = glmsg.add_args(); 6296 arg_monitors->set_isarray(false); 6297 arg_monitors->set_type(GLMessage::DataType::INT); 6298 arg_monitors->add_intvalue((int)monitors); 6299 6300 // call function 6301 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6302 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6303 glContext->hooks->gl.glGenPerfMonitorsAMD(n, monitors); 6304 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6305 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6306 6307 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6308 threadStartTime, threadEndTime, 6309 &glmsg); 6310 glContext->traceGLMessage(&glmsg); 6311} 6312 6313void GLTrace_glDeletePerfMonitorsAMD(GLsizei n, GLuint *monitors) { 6314 GLMessage glmsg; 6315 GLTraceContext *glContext = getGLTraceContext(); 6316 6317 glmsg.set_function(GLMessage::glDeletePerfMonitorsAMD); 6318 6319 // copy argument n 6320 GLMessage_DataType *arg_n = glmsg.add_args(); 6321 arg_n->set_isarray(false); 6322 arg_n->set_type(GLMessage::DataType::INT); 6323 arg_n->add_intvalue(n); 6324 6325 // copy argument monitors 6326 GLMessage_DataType *arg_monitors = glmsg.add_args(); 6327 arg_monitors->set_isarray(false); 6328 arg_monitors->set_type(GLMessage::DataType::INT); 6329 arg_monitors->add_intvalue((int)monitors); 6330 6331 // call function 6332 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6333 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6334 glContext->hooks->gl.glDeletePerfMonitorsAMD(n, monitors); 6335 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6336 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6337 6338 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6339 threadStartTime, threadEndTime, 6340 &glmsg); 6341 glContext->traceGLMessage(&glmsg); 6342} 6343 6344void GLTrace_glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *countersList) { 6345 GLMessage glmsg; 6346 GLTraceContext *glContext = getGLTraceContext(); 6347 6348 glmsg.set_function(GLMessage::glSelectPerfMonitorCountersAMD); 6349 6350 // copy argument monitor 6351 GLMessage_DataType *arg_monitor = glmsg.add_args(); 6352 arg_monitor->set_isarray(false); 6353 arg_monitor->set_type(GLMessage::DataType::INT); 6354 arg_monitor->add_intvalue(monitor); 6355 6356 // copy argument enable 6357 GLMessage_DataType *arg_enable = glmsg.add_args(); 6358 arg_enable->set_isarray(false); 6359 arg_enable->set_type(GLMessage::DataType::BOOL); 6360 arg_enable->add_boolvalue(enable); 6361 6362 // copy argument group 6363 GLMessage_DataType *arg_group = glmsg.add_args(); 6364 arg_group->set_isarray(false); 6365 arg_group->set_type(GLMessage::DataType::INT); 6366 arg_group->add_intvalue(group); 6367 6368 // copy argument numCounters 6369 GLMessage_DataType *arg_numCounters = glmsg.add_args(); 6370 arg_numCounters->set_isarray(false); 6371 arg_numCounters->set_type(GLMessage::DataType::INT); 6372 arg_numCounters->add_intvalue(numCounters); 6373 6374 // copy argument countersList 6375 GLMessage_DataType *arg_countersList = glmsg.add_args(); 6376 arg_countersList->set_isarray(false); 6377 arg_countersList->set_type(GLMessage::DataType::INT); 6378 arg_countersList->add_intvalue((int)countersList); 6379 6380 // call function 6381 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6382 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6383 glContext->hooks->gl.glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, countersList); 6384 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6385 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6386 6387 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6388 threadStartTime, threadEndTime, 6389 &glmsg); 6390 glContext->traceGLMessage(&glmsg); 6391} 6392 6393void GLTrace_glBeginPerfMonitorAMD(GLuint monitor) { 6394 GLMessage glmsg; 6395 GLTraceContext *glContext = getGLTraceContext(); 6396 6397 glmsg.set_function(GLMessage::glBeginPerfMonitorAMD); 6398 6399 // copy argument monitor 6400 GLMessage_DataType *arg_monitor = glmsg.add_args(); 6401 arg_monitor->set_isarray(false); 6402 arg_monitor->set_type(GLMessage::DataType::INT); 6403 arg_monitor->add_intvalue(monitor); 6404 6405 // call function 6406 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6407 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6408 glContext->hooks->gl.glBeginPerfMonitorAMD(monitor); 6409 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6410 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6411 6412 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6413 threadStartTime, threadEndTime, 6414 &glmsg); 6415 glContext->traceGLMessage(&glmsg); 6416} 6417 6418void GLTrace_glEndPerfMonitorAMD(GLuint monitor) { 6419 GLMessage glmsg; 6420 GLTraceContext *glContext = getGLTraceContext(); 6421 6422 glmsg.set_function(GLMessage::glEndPerfMonitorAMD); 6423 6424 // copy argument monitor 6425 GLMessage_DataType *arg_monitor = glmsg.add_args(); 6426 arg_monitor->set_isarray(false); 6427 arg_monitor->set_type(GLMessage::DataType::INT); 6428 arg_monitor->add_intvalue(monitor); 6429 6430 // call function 6431 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6432 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6433 glContext->hooks->gl.glEndPerfMonitorAMD(monitor); 6434 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6435 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6436 6437 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6438 threadStartTime, threadEndTime, 6439 &glmsg); 6440 glContext->traceGLMessage(&glmsg); 6441} 6442 6443void GLTrace_glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten) { 6444 GLMessage glmsg; 6445 GLTraceContext *glContext = getGLTraceContext(); 6446 6447 glmsg.set_function(GLMessage::glGetPerfMonitorCounterDataAMD); 6448 6449 // copy argument monitor 6450 GLMessage_DataType *arg_monitor = glmsg.add_args(); 6451 arg_monitor->set_isarray(false); 6452 arg_monitor->set_type(GLMessage::DataType::INT); 6453 arg_monitor->add_intvalue(monitor); 6454 6455 // copy argument pname 6456 GLMessage_DataType *arg_pname = glmsg.add_args(); 6457 arg_pname->set_isarray(false); 6458 arg_pname->set_type(GLMessage::DataType::ENUM); 6459 arg_pname->add_intvalue((int)pname); 6460 6461 // copy argument dataSize 6462 GLMessage_DataType *arg_dataSize = glmsg.add_args(); 6463 arg_dataSize->set_isarray(false); 6464 arg_dataSize->set_type(GLMessage::DataType::INT); 6465 arg_dataSize->add_intvalue(dataSize); 6466 6467 // copy argument data 6468 GLMessage_DataType *arg_data = glmsg.add_args(); 6469 arg_data->set_isarray(false); 6470 arg_data->set_type(GLMessage::DataType::INT); 6471 arg_data->add_intvalue((int)data); 6472 6473 // copy argument bytesWritten 6474 GLMessage_DataType *arg_bytesWritten = glmsg.add_args(); 6475 arg_bytesWritten->set_isarray(false); 6476 arg_bytesWritten->set_type(GLMessage::DataType::INT); 6477 arg_bytesWritten->add_intvalue((int)bytesWritten); 6478 6479 // call function 6480 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6481 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6482 glContext->hooks->gl.glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten); 6483 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6484 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6485 6486 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6487 threadStartTime, threadEndTime, 6488 &glmsg); 6489 glContext->traceGLMessage(&glmsg); 6490} 6491 6492void GLTrace_glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { 6493 GLMessage glmsg; 6494 GLTraceContext *glContext = getGLTraceContext(); 6495 6496 glmsg.set_function(GLMessage::glBlitFramebufferANGLE); 6497 6498 // copy argument srcX0 6499 GLMessage_DataType *arg_srcX0 = glmsg.add_args(); 6500 arg_srcX0->set_isarray(false); 6501 arg_srcX0->set_type(GLMessage::DataType::INT); 6502 arg_srcX0->add_intvalue(srcX0); 6503 6504 // copy argument srcY0 6505 GLMessage_DataType *arg_srcY0 = glmsg.add_args(); 6506 arg_srcY0->set_isarray(false); 6507 arg_srcY0->set_type(GLMessage::DataType::INT); 6508 arg_srcY0->add_intvalue(srcY0); 6509 6510 // copy argument srcX1 6511 GLMessage_DataType *arg_srcX1 = glmsg.add_args(); 6512 arg_srcX1->set_isarray(false); 6513 arg_srcX1->set_type(GLMessage::DataType::INT); 6514 arg_srcX1->add_intvalue(srcX1); 6515 6516 // copy argument srcY1 6517 GLMessage_DataType *arg_srcY1 = glmsg.add_args(); 6518 arg_srcY1->set_isarray(false); 6519 arg_srcY1->set_type(GLMessage::DataType::INT); 6520 arg_srcY1->add_intvalue(srcY1); 6521 6522 // copy argument dstX0 6523 GLMessage_DataType *arg_dstX0 = glmsg.add_args(); 6524 arg_dstX0->set_isarray(false); 6525 arg_dstX0->set_type(GLMessage::DataType::INT); 6526 arg_dstX0->add_intvalue(dstX0); 6527 6528 // copy argument dstY0 6529 GLMessage_DataType *arg_dstY0 = glmsg.add_args(); 6530 arg_dstY0->set_isarray(false); 6531 arg_dstY0->set_type(GLMessage::DataType::INT); 6532 arg_dstY0->add_intvalue(dstY0); 6533 6534 // copy argument dstX1 6535 GLMessage_DataType *arg_dstX1 = glmsg.add_args(); 6536 arg_dstX1->set_isarray(false); 6537 arg_dstX1->set_type(GLMessage::DataType::INT); 6538 arg_dstX1->add_intvalue(dstX1); 6539 6540 // copy argument dstY1 6541 GLMessage_DataType *arg_dstY1 = glmsg.add_args(); 6542 arg_dstY1->set_isarray(false); 6543 arg_dstY1->set_type(GLMessage::DataType::INT); 6544 arg_dstY1->add_intvalue(dstY1); 6545 6546 // copy argument mask 6547 GLMessage_DataType *arg_mask = glmsg.add_args(); 6548 arg_mask->set_isarray(false); 6549 arg_mask->set_type(GLMessage::DataType::INT); 6550 arg_mask->add_intvalue(mask); 6551 6552 // copy argument filter 6553 GLMessage_DataType *arg_filter = glmsg.add_args(); 6554 arg_filter->set_isarray(false); 6555 arg_filter->set_type(GLMessage::DataType::ENUM); 6556 arg_filter->add_intvalue((int)filter); 6557 6558 // call function 6559 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6560 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6561 glContext->hooks->gl.glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); 6562 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6563 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6564 6565 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6566 threadStartTime, threadEndTime, 6567 &glmsg); 6568 glContext->traceGLMessage(&glmsg); 6569} 6570 6571void GLTrace_glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { 6572 GLMessage glmsg; 6573 GLTraceContext *glContext = getGLTraceContext(); 6574 6575 glmsg.set_function(GLMessage::glRenderbufferStorageMultisampleANGLE); 6576 6577 // copy argument target 6578 GLMessage_DataType *arg_target = glmsg.add_args(); 6579 arg_target->set_isarray(false); 6580 arg_target->set_type(GLMessage::DataType::ENUM); 6581 arg_target->add_intvalue((int)target); 6582 6583 // copy argument samples 6584 GLMessage_DataType *arg_samples = glmsg.add_args(); 6585 arg_samples->set_isarray(false); 6586 arg_samples->set_type(GLMessage::DataType::INT); 6587 arg_samples->add_intvalue(samples); 6588 6589 // copy argument internalformat 6590 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 6591 arg_internalformat->set_isarray(false); 6592 arg_internalformat->set_type(GLMessage::DataType::ENUM); 6593 arg_internalformat->add_intvalue((int)internalformat); 6594 6595 // copy argument width 6596 GLMessage_DataType *arg_width = glmsg.add_args(); 6597 arg_width->set_isarray(false); 6598 arg_width->set_type(GLMessage::DataType::INT); 6599 arg_width->add_intvalue(width); 6600 6601 // copy argument height 6602 GLMessage_DataType *arg_height = glmsg.add_args(); 6603 arg_height->set_isarray(false); 6604 arg_height->set_type(GLMessage::DataType::INT); 6605 arg_height->add_intvalue(height); 6606 6607 // call function 6608 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6609 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6610 glContext->hooks->gl.glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height); 6611 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6612 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6613 6614 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6615 threadStartTime, threadEndTime, 6616 &glmsg); 6617 glContext->traceGLMessage(&glmsg); 6618} 6619 6620void GLTrace_glRenderbufferStorageMultisampleAPPLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { 6621 GLMessage glmsg; 6622 GLTraceContext *glContext = getGLTraceContext(); 6623 6624 glmsg.set_function(GLMessage::glRenderbufferStorageMultisampleAPPLE); 6625 6626 // copy argument target 6627 GLMessage_DataType *arg_target = glmsg.add_args(); 6628 arg_target->set_isarray(false); 6629 arg_target->set_type(GLMessage::DataType::ENUM); 6630 arg_target->add_intvalue((int)target); 6631 6632 // copy argument samples 6633 GLMessage_DataType *arg_samples = glmsg.add_args(); 6634 arg_samples->set_isarray(false); 6635 arg_samples->set_type(GLMessage::DataType::INT); 6636 arg_samples->add_intvalue(samples); 6637 6638 // copy argument internalformat 6639 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 6640 arg_internalformat->set_isarray(false); 6641 arg_internalformat->set_type(GLMessage::DataType::ENUM); 6642 arg_internalformat->add_intvalue((int)internalformat); 6643 6644 // copy argument width 6645 GLMessage_DataType *arg_width = glmsg.add_args(); 6646 arg_width->set_isarray(false); 6647 arg_width->set_type(GLMessage::DataType::INT); 6648 arg_width->add_intvalue(width); 6649 6650 // copy argument height 6651 GLMessage_DataType *arg_height = glmsg.add_args(); 6652 arg_height->set_isarray(false); 6653 arg_height->set_type(GLMessage::DataType::INT); 6654 arg_height->add_intvalue(height); 6655 6656 // call function 6657 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6658 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6659 glContext->hooks->gl.glRenderbufferStorageMultisampleAPPLE(target, samples, internalformat, width, height); 6660 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6661 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6662 6663 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6664 threadStartTime, threadEndTime, 6665 &glmsg); 6666 glContext->traceGLMessage(&glmsg); 6667} 6668 6669void GLTrace_glResolveMultisampleFramebufferAPPLE(void) { 6670 GLMessage glmsg; 6671 GLTraceContext *glContext = getGLTraceContext(); 6672 6673 glmsg.set_function(GLMessage::glResolveMultisampleFramebufferAPPLE); 6674 6675 // call function 6676 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6677 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6678 glContext->hooks->gl.glResolveMultisampleFramebufferAPPLE(); 6679 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6680 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6681 6682 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6683 threadStartTime, threadEndTime, 6684 &glmsg); 6685 glContext->traceGLMessage(&glmsg); 6686} 6687 6688void GLTrace_glLabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label) { 6689 GLMessage glmsg; 6690 GLTraceContext *glContext = getGLTraceContext(); 6691 6692 glmsg.set_function(GLMessage::glLabelObjectEXT); 6693 6694 // copy argument type 6695 GLMessage_DataType *arg_type = glmsg.add_args(); 6696 arg_type->set_isarray(false); 6697 arg_type->set_type(GLMessage::DataType::ENUM); 6698 arg_type->add_intvalue((int)type); 6699 6700 // copy argument object 6701 GLMessage_DataType *arg_object = glmsg.add_args(); 6702 arg_object->set_isarray(false); 6703 arg_object->set_type(GLMessage::DataType::INT); 6704 arg_object->add_intvalue(object); 6705 6706 // copy argument length 6707 GLMessage_DataType *arg_length = glmsg.add_args(); 6708 arg_length->set_isarray(false); 6709 arg_length->set_type(GLMessage::DataType::INT); 6710 arg_length->add_intvalue(length); 6711 6712 // copy argument label 6713 GLMessage_DataType *arg_label = glmsg.add_args(); 6714 arg_label->set_isarray(false); 6715 arg_label->set_type(GLMessage::DataType::INT); 6716 arg_label->add_intvalue((int)label); 6717 6718 // call function 6719 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6720 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6721 glContext->hooks->gl.glLabelObjectEXT(type, object, length, label); 6722 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6723 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6724 6725 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6726 threadStartTime, threadEndTime, 6727 &glmsg); 6728 glContext->traceGLMessage(&glmsg); 6729} 6730 6731void GLTrace_glGetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label) { 6732 GLMessage glmsg; 6733 GLTraceContext *glContext = getGLTraceContext(); 6734 6735 glmsg.set_function(GLMessage::glGetObjectLabelEXT); 6736 6737 // copy argument type 6738 GLMessage_DataType *arg_type = glmsg.add_args(); 6739 arg_type->set_isarray(false); 6740 arg_type->set_type(GLMessage::DataType::ENUM); 6741 arg_type->add_intvalue((int)type); 6742 6743 // copy argument object 6744 GLMessage_DataType *arg_object = glmsg.add_args(); 6745 arg_object->set_isarray(false); 6746 arg_object->set_type(GLMessage::DataType::INT); 6747 arg_object->add_intvalue(object); 6748 6749 // copy argument bufSize 6750 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 6751 arg_bufSize->set_isarray(false); 6752 arg_bufSize->set_type(GLMessage::DataType::INT); 6753 arg_bufSize->add_intvalue(bufSize); 6754 6755 // copy argument length 6756 GLMessage_DataType *arg_length = glmsg.add_args(); 6757 arg_length->set_isarray(false); 6758 arg_length->set_type(GLMessage::DataType::INT); 6759 arg_length->add_intvalue((int)length); 6760 6761 // copy argument label 6762 GLMessage_DataType *arg_label = glmsg.add_args(); 6763 arg_label->set_isarray(false); 6764 arg_label->set_type(GLMessage::DataType::INT); 6765 arg_label->add_intvalue((int)label); 6766 6767 // call function 6768 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6769 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6770 glContext->hooks->gl.glGetObjectLabelEXT(type, object, bufSize, length, label); 6771 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6772 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6773 6774 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6775 threadStartTime, threadEndTime, 6776 &glmsg); 6777 glContext->traceGLMessage(&glmsg); 6778} 6779 6780void GLTrace_glInsertEventMarkerEXT(GLsizei length, const GLchar *marker) { 6781 GLMessage glmsg; 6782 GLTraceContext *glContext = getGLTraceContext(); 6783 6784 glmsg.set_function(GLMessage::glInsertEventMarkerEXT); 6785 6786 // copy argument length 6787 GLMessage_DataType *arg_length = glmsg.add_args(); 6788 arg_length->set_isarray(false); 6789 arg_length->set_type(GLMessage::DataType::INT); 6790 arg_length->add_intvalue(length); 6791 6792 // copy argument marker 6793 GLMessage_DataType *arg_marker = glmsg.add_args(); 6794 arg_marker->set_isarray(false); 6795 arg_marker->set_type(GLMessage::DataType::INT); 6796 arg_marker->add_intvalue((int)marker); 6797 6798 // call function 6799 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6800 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6801 glContext->hooks->gl.glInsertEventMarkerEXT(length, marker); 6802 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6803 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6804 6805 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6806 threadStartTime, threadEndTime, 6807 &glmsg); 6808 glContext->traceGLMessage(&glmsg); 6809} 6810 6811void GLTrace_glPushGroupMarkerEXT(GLsizei length, const GLchar *marker) { 6812 GLMessage glmsg; 6813 GLTraceContext *glContext = getGLTraceContext(); 6814 6815 glmsg.set_function(GLMessage::glPushGroupMarkerEXT); 6816 6817 // copy argument length 6818 GLMessage_DataType *arg_length = glmsg.add_args(); 6819 arg_length->set_isarray(false); 6820 arg_length->set_type(GLMessage::DataType::INT); 6821 arg_length->add_intvalue(length); 6822 6823 // copy argument marker 6824 GLMessage_DataType *arg_marker = glmsg.add_args(); 6825 arg_marker->set_isarray(false); 6826 arg_marker->set_type(GLMessage::DataType::INT); 6827 arg_marker->add_intvalue((int)marker); 6828 6829 // call function 6830 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6831 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6832 glContext->hooks->gl.glPushGroupMarkerEXT(length, marker); 6833 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6834 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6835 6836 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6837 threadStartTime, threadEndTime, 6838 &glmsg); 6839 glContext->traceGLMessage(&glmsg); 6840} 6841 6842void GLTrace_glPopGroupMarkerEXT(void) { 6843 GLMessage glmsg; 6844 GLTraceContext *glContext = getGLTraceContext(); 6845 6846 glmsg.set_function(GLMessage::glPopGroupMarkerEXT); 6847 6848 // call function 6849 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6850 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6851 glContext->hooks->gl.glPopGroupMarkerEXT(); 6852 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6853 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6854 6855 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6856 threadStartTime, threadEndTime, 6857 &glmsg); 6858 glContext->traceGLMessage(&glmsg); 6859} 6860 6861void GLTrace_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) { 6862 GLMessage glmsg; 6863 GLTraceContext *glContext = getGLTraceContext(); 6864 6865 glmsg.set_function(GLMessage::glDiscardFramebufferEXT); 6866 6867 // copy argument target 6868 GLMessage_DataType *arg_target = glmsg.add_args(); 6869 arg_target->set_isarray(false); 6870 arg_target->set_type(GLMessage::DataType::ENUM); 6871 arg_target->add_intvalue((int)target); 6872 6873 // copy argument numAttachments 6874 GLMessage_DataType *arg_numAttachments = glmsg.add_args(); 6875 arg_numAttachments->set_isarray(false); 6876 arg_numAttachments->set_type(GLMessage::DataType::INT); 6877 arg_numAttachments->add_intvalue(numAttachments); 6878 6879 // copy argument attachments 6880 GLMessage_DataType *arg_attachments = glmsg.add_args(); 6881 arg_attachments->set_isarray(false); 6882 arg_attachments->set_type(GLMessage::DataType::INT); 6883 arg_attachments->add_intvalue((int)attachments); 6884 6885 // call function 6886 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6887 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6888 glContext->hooks->gl.glDiscardFramebufferEXT(target, numAttachments, attachments); 6889 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6890 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6891 6892 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6893 threadStartTime, threadEndTime, 6894 &glmsg); 6895 glContext->traceGLMessage(&glmsg); 6896} 6897 6898void GLTrace_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { 6899 GLMessage glmsg; 6900 GLTraceContext *glContext = getGLTraceContext(); 6901 6902 glmsg.set_function(GLMessage::glRenderbufferStorageMultisampleEXT); 6903 6904 // copy argument target 6905 GLMessage_DataType *arg_target = glmsg.add_args(); 6906 arg_target->set_isarray(false); 6907 arg_target->set_type(GLMessage::DataType::ENUM); 6908 arg_target->add_intvalue((int)target); 6909 6910 // copy argument samples 6911 GLMessage_DataType *arg_samples = glmsg.add_args(); 6912 arg_samples->set_isarray(false); 6913 arg_samples->set_type(GLMessage::DataType::INT); 6914 arg_samples->add_intvalue(samples); 6915 6916 // copy argument internalformat 6917 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 6918 arg_internalformat->set_isarray(false); 6919 arg_internalformat->set_type(GLMessage::DataType::ENUM); 6920 arg_internalformat->add_intvalue((int)internalformat); 6921 6922 // copy argument width 6923 GLMessage_DataType *arg_width = glmsg.add_args(); 6924 arg_width->set_isarray(false); 6925 arg_width->set_type(GLMessage::DataType::INT); 6926 arg_width->add_intvalue(width); 6927 6928 // copy argument height 6929 GLMessage_DataType *arg_height = glmsg.add_args(); 6930 arg_height->set_isarray(false); 6931 arg_height->set_type(GLMessage::DataType::INT); 6932 arg_height->add_intvalue(height); 6933 6934 // call function 6935 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6936 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6937 glContext->hooks->gl.glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height); 6938 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6939 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6940 6941 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6942 threadStartTime, threadEndTime, 6943 &glmsg); 6944 glContext->traceGLMessage(&glmsg); 6945} 6946 6947void GLTrace_glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) { 6948 GLMessage glmsg; 6949 GLTraceContext *glContext = getGLTraceContext(); 6950 6951 glmsg.set_function(GLMessage::glFramebufferTexture2DMultisampleEXT); 6952 6953 // copy argument target 6954 GLMessage_DataType *arg_target = glmsg.add_args(); 6955 arg_target->set_isarray(false); 6956 arg_target->set_type(GLMessage::DataType::ENUM); 6957 arg_target->add_intvalue((int)target); 6958 6959 // copy argument attachment 6960 GLMessage_DataType *arg_attachment = glmsg.add_args(); 6961 arg_attachment->set_isarray(false); 6962 arg_attachment->set_type(GLMessage::DataType::ENUM); 6963 arg_attachment->add_intvalue((int)attachment); 6964 6965 // copy argument textarget 6966 GLMessage_DataType *arg_textarget = glmsg.add_args(); 6967 arg_textarget->set_isarray(false); 6968 arg_textarget->set_type(GLMessage::DataType::ENUM); 6969 arg_textarget->add_intvalue((int)textarget); 6970 6971 // copy argument texture 6972 GLMessage_DataType *arg_texture = glmsg.add_args(); 6973 arg_texture->set_isarray(false); 6974 arg_texture->set_type(GLMessage::DataType::INT); 6975 arg_texture->add_intvalue(texture); 6976 6977 // copy argument level 6978 GLMessage_DataType *arg_level = glmsg.add_args(); 6979 arg_level->set_isarray(false); 6980 arg_level->set_type(GLMessage::DataType::INT); 6981 arg_level->add_intvalue(level); 6982 6983 // copy argument samples 6984 GLMessage_DataType *arg_samples = glmsg.add_args(); 6985 arg_samples->set_isarray(false); 6986 arg_samples->set_type(GLMessage::DataType::INT); 6987 arg_samples->add_intvalue(samples); 6988 6989 // call function 6990 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 6991 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 6992 glContext->hooks->gl.glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples); 6993 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 6994 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 6995 6996 fixupGLMessage(glContext, wallStartTime, wallEndTime, 6997 threadStartTime, threadEndTime, 6998 &glmsg); 6999 glContext->traceGLMessage(&glmsg); 7000} 7001 7002void GLTrace_glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount) { 7003 GLMessage glmsg; 7004 GLTraceContext *glContext = getGLTraceContext(); 7005 7006 glmsg.set_function(GLMessage::glMultiDrawArraysEXT); 7007 7008 // copy argument mode 7009 GLMessage_DataType *arg_mode = glmsg.add_args(); 7010 arg_mode->set_isarray(false); 7011 arg_mode->set_type(GLMessage::DataType::ENUM); 7012 arg_mode->add_intvalue((int)mode); 7013 7014 // copy argument first 7015 GLMessage_DataType *arg_first = glmsg.add_args(); 7016 arg_first->set_isarray(false); 7017 arg_first->set_type(GLMessage::DataType::INT); 7018 arg_first->add_intvalue((int)first); 7019 7020 // copy argument count 7021 GLMessage_DataType *arg_count = glmsg.add_args(); 7022 arg_count->set_isarray(false); 7023 arg_count->set_type(GLMessage::DataType::INT); 7024 arg_count->add_intvalue((int)count); 7025 7026 // copy argument primcount 7027 GLMessage_DataType *arg_primcount = glmsg.add_args(); 7028 arg_primcount->set_isarray(false); 7029 arg_primcount->set_type(GLMessage::DataType::INT); 7030 arg_primcount->add_intvalue(primcount); 7031 7032 // call function 7033 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7034 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7035 glContext->hooks->gl.glMultiDrawArraysEXT(mode, first, count, primcount); 7036 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7037 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7038 7039 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7040 threadStartTime, threadEndTime, 7041 &glmsg); 7042 glContext->traceGLMessage(&glmsg); 7043} 7044 7045void GLTrace_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) { 7046 GLMessage glmsg; 7047 GLTraceContext *glContext = getGLTraceContext(); 7048 7049 glmsg.set_function(GLMessage::glMultiDrawElementsEXT); 7050 7051 // copy argument mode 7052 GLMessage_DataType *arg_mode = glmsg.add_args(); 7053 arg_mode->set_isarray(false); 7054 arg_mode->set_type(GLMessage::DataType::ENUM); 7055 arg_mode->add_intvalue((int)mode); 7056 7057 // copy argument count 7058 GLMessage_DataType *arg_count = glmsg.add_args(); 7059 arg_count->set_isarray(false); 7060 arg_count->set_type(GLMessage::DataType::INT); 7061 arg_count->add_intvalue((int)count); 7062 7063 // copy argument type 7064 GLMessage_DataType *arg_type = glmsg.add_args(); 7065 arg_type->set_isarray(false); 7066 arg_type->set_type(GLMessage::DataType::ENUM); 7067 arg_type->add_intvalue((int)type); 7068 7069 // copy argument indices 7070 GLMessage_DataType *arg_indices = glmsg.add_args(); 7071 arg_indices->set_isarray(false); 7072 arg_indices->set_type(GLMessage::DataType::INT); 7073 arg_indices->add_intvalue((int)indices); 7074 7075 // copy argument primcount 7076 GLMessage_DataType *arg_primcount = glmsg.add_args(); 7077 arg_primcount->set_isarray(false); 7078 arg_primcount->set_type(GLMessage::DataType::INT); 7079 arg_primcount->add_intvalue(primcount); 7080 7081 // call function 7082 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7083 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7084 glContext->hooks->gl.glMultiDrawElementsEXT(mode, count, type, indices, primcount); 7085 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7086 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7087 7088 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7089 threadStartTime, threadEndTime, 7090 &glmsg); 7091 glContext->traceGLMessage(&glmsg); 7092} 7093 7094void GLTrace_glGenQueriesEXT(GLsizei n, GLuint *ids) { 7095 GLMessage glmsg; 7096 GLTraceContext *glContext = getGLTraceContext(); 7097 7098 glmsg.set_function(GLMessage::glGenQueriesEXT); 7099 7100 // copy argument n 7101 GLMessage_DataType *arg_n = glmsg.add_args(); 7102 arg_n->set_isarray(false); 7103 arg_n->set_type(GLMessage::DataType::INT); 7104 arg_n->add_intvalue(n); 7105 7106 // copy argument ids 7107 GLMessage_DataType *arg_ids = glmsg.add_args(); 7108 arg_ids->set_isarray(false); 7109 arg_ids->set_type(GLMessage::DataType::INT); 7110 arg_ids->add_intvalue((int)ids); 7111 7112 // call function 7113 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7114 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7115 glContext->hooks->gl.glGenQueriesEXT(n, ids); 7116 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7117 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7118 7119 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7120 threadStartTime, threadEndTime, 7121 &glmsg); 7122 glContext->traceGLMessage(&glmsg); 7123} 7124 7125void GLTrace_glDeleteQueriesEXT(GLsizei n, const GLuint *ids) { 7126 GLMessage glmsg; 7127 GLTraceContext *glContext = getGLTraceContext(); 7128 7129 glmsg.set_function(GLMessage::glDeleteQueriesEXT); 7130 7131 // copy argument n 7132 GLMessage_DataType *arg_n = glmsg.add_args(); 7133 arg_n->set_isarray(false); 7134 arg_n->set_type(GLMessage::DataType::INT); 7135 arg_n->add_intvalue(n); 7136 7137 // copy argument ids 7138 GLMessage_DataType *arg_ids = glmsg.add_args(); 7139 arg_ids->set_isarray(false); 7140 arg_ids->set_type(GLMessage::DataType::INT); 7141 arg_ids->add_intvalue((int)ids); 7142 7143 // call function 7144 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7145 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7146 glContext->hooks->gl.glDeleteQueriesEXT(n, ids); 7147 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7148 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7149 7150 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7151 threadStartTime, threadEndTime, 7152 &glmsg); 7153 glContext->traceGLMessage(&glmsg); 7154} 7155 7156GLboolean GLTrace_glIsQueryEXT(GLuint id) { 7157 GLMessage glmsg; 7158 GLTraceContext *glContext = getGLTraceContext(); 7159 7160 glmsg.set_function(GLMessage::glIsQueryEXT); 7161 7162 // copy argument id 7163 GLMessage_DataType *arg_id = glmsg.add_args(); 7164 arg_id->set_isarray(false); 7165 arg_id->set_type(GLMessage::DataType::INT); 7166 arg_id->add_intvalue(id); 7167 7168 // call function 7169 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7170 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7171 GLboolean retValue = glContext->hooks->gl.glIsQueryEXT(id); 7172 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7173 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7174 7175 // set return value 7176 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 7177 rt->set_isarray(false); 7178 rt->set_type(GLMessage::DataType::BOOL); 7179 rt->add_boolvalue(retValue); 7180 7181 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7182 threadStartTime, threadEndTime, 7183 &glmsg); 7184 glContext->traceGLMessage(&glmsg); 7185 7186 return retValue; 7187} 7188 7189void GLTrace_glBeginQueryEXT(GLenum target, GLuint id) { 7190 GLMessage glmsg; 7191 GLTraceContext *glContext = getGLTraceContext(); 7192 7193 glmsg.set_function(GLMessage::glBeginQueryEXT); 7194 7195 // copy argument target 7196 GLMessage_DataType *arg_target = glmsg.add_args(); 7197 arg_target->set_isarray(false); 7198 arg_target->set_type(GLMessage::DataType::ENUM); 7199 arg_target->add_intvalue((int)target); 7200 7201 // copy argument id 7202 GLMessage_DataType *arg_id = glmsg.add_args(); 7203 arg_id->set_isarray(false); 7204 arg_id->set_type(GLMessage::DataType::INT); 7205 arg_id->add_intvalue(id); 7206 7207 // call function 7208 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7209 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7210 glContext->hooks->gl.glBeginQueryEXT(target, id); 7211 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7212 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7213 7214 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7215 threadStartTime, threadEndTime, 7216 &glmsg); 7217 glContext->traceGLMessage(&glmsg); 7218} 7219 7220void GLTrace_glEndQueryEXT(GLenum target) { 7221 GLMessage glmsg; 7222 GLTraceContext *glContext = getGLTraceContext(); 7223 7224 glmsg.set_function(GLMessage::glEndQueryEXT); 7225 7226 // copy argument target 7227 GLMessage_DataType *arg_target = glmsg.add_args(); 7228 arg_target->set_isarray(false); 7229 arg_target->set_type(GLMessage::DataType::ENUM); 7230 arg_target->add_intvalue((int)target); 7231 7232 // call function 7233 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7234 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7235 glContext->hooks->gl.glEndQueryEXT(target); 7236 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7237 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7238 7239 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7240 threadStartTime, threadEndTime, 7241 &glmsg); 7242 glContext->traceGLMessage(&glmsg); 7243} 7244 7245void GLTrace_glGetQueryivEXT(GLenum target, GLenum pname, GLint *params) { 7246 GLMessage glmsg; 7247 GLTraceContext *glContext = getGLTraceContext(); 7248 7249 glmsg.set_function(GLMessage::glGetQueryivEXT); 7250 7251 // copy argument target 7252 GLMessage_DataType *arg_target = glmsg.add_args(); 7253 arg_target->set_isarray(false); 7254 arg_target->set_type(GLMessage::DataType::ENUM); 7255 arg_target->add_intvalue((int)target); 7256 7257 // copy argument pname 7258 GLMessage_DataType *arg_pname = glmsg.add_args(); 7259 arg_pname->set_isarray(false); 7260 arg_pname->set_type(GLMessage::DataType::ENUM); 7261 arg_pname->add_intvalue((int)pname); 7262 7263 // copy argument params 7264 GLMessage_DataType *arg_params = glmsg.add_args(); 7265 arg_params->set_isarray(false); 7266 arg_params->set_type(GLMessage::DataType::INT); 7267 arg_params->add_intvalue((int)params); 7268 7269 // call function 7270 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7271 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7272 glContext->hooks->gl.glGetQueryivEXT(target, pname, params); 7273 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7274 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7275 7276 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7277 threadStartTime, threadEndTime, 7278 &glmsg); 7279 glContext->traceGLMessage(&glmsg); 7280} 7281 7282void GLTrace_glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params) { 7283 GLMessage glmsg; 7284 GLTraceContext *glContext = getGLTraceContext(); 7285 7286 glmsg.set_function(GLMessage::glGetQueryObjectuivEXT); 7287 7288 // copy argument id 7289 GLMessage_DataType *arg_id = glmsg.add_args(); 7290 arg_id->set_isarray(false); 7291 arg_id->set_type(GLMessage::DataType::INT); 7292 arg_id->add_intvalue(id); 7293 7294 // copy argument pname 7295 GLMessage_DataType *arg_pname = glmsg.add_args(); 7296 arg_pname->set_isarray(false); 7297 arg_pname->set_type(GLMessage::DataType::ENUM); 7298 arg_pname->add_intvalue((int)pname); 7299 7300 // copy argument params 7301 GLMessage_DataType *arg_params = glmsg.add_args(); 7302 arg_params->set_isarray(false); 7303 arg_params->set_type(GLMessage::DataType::INT); 7304 arg_params->add_intvalue((int)params); 7305 7306 // call function 7307 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7308 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7309 glContext->hooks->gl.glGetQueryObjectuivEXT(id, pname, params); 7310 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7311 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7312 7313 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7314 threadStartTime, threadEndTime, 7315 &glmsg); 7316 glContext->traceGLMessage(&glmsg); 7317} 7318 7319GLenum GLTrace_glGetGraphicsResetStatusEXT(void) { 7320 GLMessage glmsg; 7321 GLTraceContext *glContext = getGLTraceContext(); 7322 7323 glmsg.set_function(GLMessage::glGetGraphicsResetStatusEXT); 7324 7325 // call function 7326 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7327 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7328 GLenum retValue = glContext->hooks->gl.glGetGraphicsResetStatusEXT(); 7329 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7330 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7331 7332 // set return value 7333 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 7334 rt->set_isarray(false); 7335 rt->set_type(GLMessage::DataType::ENUM); 7336 rt->add_intvalue((int)retValue); 7337 7338 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7339 threadStartTime, threadEndTime, 7340 &glmsg); 7341 glContext->traceGLMessage(&glmsg); 7342 7343 return retValue; 7344} 7345 7346void GLTrace_glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data) { 7347 GLMessage glmsg; 7348 GLTraceContext *glContext = getGLTraceContext(); 7349 7350 glmsg.set_function(GLMessage::glReadnPixelsEXT); 7351 7352 // copy argument x 7353 GLMessage_DataType *arg_x = glmsg.add_args(); 7354 arg_x->set_isarray(false); 7355 arg_x->set_type(GLMessage::DataType::INT); 7356 arg_x->add_intvalue(x); 7357 7358 // copy argument y 7359 GLMessage_DataType *arg_y = glmsg.add_args(); 7360 arg_y->set_isarray(false); 7361 arg_y->set_type(GLMessage::DataType::INT); 7362 arg_y->add_intvalue(y); 7363 7364 // copy argument width 7365 GLMessage_DataType *arg_width = glmsg.add_args(); 7366 arg_width->set_isarray(false); 7367 arg_width->set_type(GLMessage::DataType::INT); 7368 arg_width->add_intvalue(width); 7369 7370 // copy argument height 7371 GLMessage_DataType *arg_height = glmsg.add_args(); 7372 arg_height->set_isarray(false); 7373 arg_height->set_type(GLMessage::DataType::INT); 7374 arg_height->add_intvalue(height); 7375 7376 // copy argument format 7377 GLMessage_DataType *arg_format = glmsg.add_args(); 7378 arg_format->set_isarray(false); 7379 arg_format->set_type(GLMessage::DataType::ENUM); 7380 arg_format->add_intvalue((int)format); 7381 7382 // copy argument type 7383 GLMessage_DataType *arg_type = glmsg.add_args(); 7384 arg_type->set_isarray(false); 7385 arg_type->set_type(GLMessage::DataType::ENUM); 7386 arg_type->add_intvalue((int)type); 7387 7388 // copy argument bufSize 7389 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 7390 arg_bufSize->set_isarray(false); 7391 arg_bufSize->set_type(GLMessage::DataType::INT); 7392 arg_bufSize->add_intvalue(bufSize); 7393 7394 // copy argument data 7395 GLMessage_DataType *arg_data = glmsg.add_args(); 7396 arg_data->set_isarray(false); 7397 arg_data->set_type(GLMessage::DataType::INT); 7398 arg_data->add_intvalue((int)data); 7399 7400 // call function 7401 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7402 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7403 glContext->hooks->gl.glReadnPixelsEXT(x, y, width, height, format, type, bufSize, data); 7404 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7405 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7406 7407 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7408 threadStartTime, threadEndTime, 7409 &glmsg); 7410 glContext->traceGLMessage(&glmsg); 7411} 7412 7413void GLTrace_glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, float *params) { 7414 GLMessage glmsg; 7415 GLTraceContext *glContext = getGLTraceContext(); 7416 7417 glmsg.set_function(GLMessage::glGetnUniformfvEXT); 7418 7419 // copy argument program 7420 GLMessage_DataType *arg_program = glmsg.add_args(); 7421 arg_program->set_isarray(false); 7422 arg_program->set_type(GLMessage::DataType::INT); 7423 arg_program->add_intvalue(program); 7424 7425 // copy argument location 7426 GLMessage_DataType *arg_location = glmsg.add_args(); 7427 arg_location->set_isarray(false); 7428 arg_location->set_type(GLMessage::DataType::INT); 7429 arg_location->add_intvalue(location); 7430 7431 // copy argument bufSize 7432 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 7433 arg_bufSize->set_isarray(false); 7434 arg_bufSize->set_type(GLMessage::DataType::INT); 7435 arg_bufSize->add_intvalue(bufSize); 7436 7437 // copy argument params 7438 GLMessage_DataType *arg_params = glmsg.add_args(); 7439 arg_params->set_isarray(false); 7440 arg_params->set_type(GLMessage::DataType::INT); 7441 arg_params->add_intvalue((int)params); 7442 7443 // call function 7444 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7445 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7446 glContext->hooks->gl.glGetnUniformfvEXT(program, location, bufSize, params); 7447 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7448 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7449 7450 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7451 threadStartTime, threadEndTime, 7452 &glmsg); 7453 glContext->traceGLMessage(&glmsg); 7454} 7455 7456void GLTrace_glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params) { 7457 GLMessage glmsg; 7458 GLTraceContext *glContext = getGLTraceContext(); 7459 7460 glmsg.set_function(GLMessage::glGetnUniformivEXT); 7461 7462 // copy argument program 7463 GLMessage_DataType *arg_program = glmsg.add_args(); 7464 arg_program->set_isarray(false); 7465 arg_program->set_type(GLMessage::DataType::INT); 7466 arg_program->add_intvalue(program); 7467 7468 // copy argument location 7469 GLMessage_DataType *arg_location = glmsg.add_args(); 7470 arg_location->set_isarray(false); 7471 arg_location->set_type(GLMessage::DataType::INT); 7472 arg_location->add_intvalue(location); 7473 7474 // copy argument bufSize 7475 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 7476 arg_bufSize->set_isarray(false); 7477 arg_bufSize->set_type(GLMessage::DataType::INT); 7478 arg_bufSize->add_intvalue(bufSize); 7479 7480 // copy argument params 7481 GLMessage_DataType *arg_params = glmsg.add_args(); 7482 arg_params->set_isarray(false); 7483 arg_params->set_type(GLMessage::DataType::INT); 7484 arg_params->add_intvalue((int)params); 7485 7486 // call function 7487 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7488 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7489 glContext->hooks->gl.glGetnUniformivEXT(program, location, bufSize, params); 7490 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7491 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7492 7493 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7494 threadStartTime, threadEndTime, 7495 &glmsg); 7496 glContext->traceGLMessage(&glmsg); 7497} 7498 7499void GLTrace_glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program) { 7500 GLMessage glmsg; 7501 GLTraceContext *glContext = getGLTraceContext(); 7502 7503 glmsg.set_function(GLMessage::glUseProgramStagesEXT); 7504 7505 // copy argument pipeline 7506 GLMessage_DataType *arg_pipeline = glmsg.add_args(); 7507 arg_pipeline->set_isarray(false); 7508 arg_pipeline->set_type(GLMessage::DataType::INT); 7509 arg_pipeline->add_intvalue(pipeline); 7510 7511 // copy argument stages 7512 GLMessage_DataType *arg_stages = glmsg.add_args(); 7513 arg_stages->set_isarray(false); 7514 arg_stages->set_type(GLMessage::DataType::INT); 7515 arg_stages->add_intvalue(stages); 7516 7517 // copy argument program 7518 GLMessage_DataType *arg_program = glmsg.add_args(); 7519 arg_program->set_isarray(false); 7520 arg_program->set_type(GLMessage::DataType::INT); 7521 arg_program->add_intvalue(program); 7522 7523 // call function 7524 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7525 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7526 glContext->hooks->gl.glUseProgramStagesEXT(pipeline, stages, program); 7527 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7528 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7529 7530 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7531 threadStartTime, threadEndTime, 7532 &glmsg); 7533 glContext->traceGLMessage(&glmsg); 7534} 7535 7536void GLTrace_glActiveShaderProgramEXT(GLuint pipeline, GLuint program) { 7537 GLMessage glmsg; 7538 GLTraceContext *glContext = getGLTraceContext(); 7539 7540 glmsg.set_function(GLMessage::glActiveShaderProgramEXT); 7541 7542 // copy argument pipeline 7543 GLMessage_DataType *arg_pipeline = glmsg.add_args(); 7544 arg_pipeline->set_isarray(false); 7545 arg_pipeline->set_type(GLMessage::DataType::INT); 7546 arg_pipeline->add_intvalue(pipeline); 7547 7548 // copy argument program 7549 GLMessage_DataType *arg_program = glmsg.add_args(); 7550 arg_program->set_isarray(false); 7551 arg_program->set_type(GLMessage::DataType::INT); 7552 arg_program->add_intvalue(program); 7553 7554 // call function 7555 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7556 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7557 glContext->hooks->gl.glActiveShaderProgramEXT(pipeline, program); 7558 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7559 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7560 7561 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7562 threadStartTime, threadEndTime, 7563 &glmsg); 7564 glContext->traceGLMessage(&glmsg); 7565} 7566 7567GLuint GLTrace_glCreateShaderProgramvEXT(GLenum type, GLsizei count, const GLchar **strings) { 7568 GLMessage glmsg; 7569 GLTraceContext *glContext = getGLTraceContext(); 7570 7571 glmsg.set_function(GLMessage::glCreateShaderProgramvEXT); 7572 7573 // copy argument type 7574 GLMessage_DataType *arg_type = glmsg.add_args(); 7575 arg_type->set_isarray(false); 7576 arg_type->set_type(GLMessage::DataType::ENUM); 7577 arg_type->add_intvalue((int)type); 7578 7579 // copy argument count 7580 GLMessage_DataType *arg_count = glmsg.add_args(); 7581 arg_count->set_isarray(false); 7582 arg_count->set_type(GLMessage::DataType::INT); 7583 arg_count->add_intvalue(count); 7584 7585 // copy argument strings 7586 GLMessage_DataType *arg_strings = glmsg.add_args(); 7587 arg_strings->set_isarray(false); 7588 arg_strings->set_type(GLMessage::DataType::INT); 7589 arg_strings->add_intvalue((int)strings); 7590 7591 // call function 7592 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7593 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7594 GLuint retValue = glContext->hooks->gl.glCreateShaderProgramvEXT(type, count, strings); 7595 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7596 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7597 7598 // set return value 7599 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 7600 rt->set_isarray(false); 7601 rt->set_type(GLMessage::DataType::INT); 7602 rt->add_intvalue(retValue); 7603 7604 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7605 threadStartTime, threadEndTime, 7606 &glmsg); 7607 glContext->traceGLMessage(&glmsg); 7608 7609 return retValue; 7610} 7611 7612void GLTrace_glBindProgramPipelineEXT(GLuint pipeline) { 7613 GLMessage glmsg; 7614 GLTraceContext *glContext = getGLTraceContext(); 7615 7616 glmsg.set_function(GLMessage::glBindProgramPipelineEXT); 7617 7618 // copy argument pipeline 7619 GLMessage_DataType *arg_pipeline = glmsg.add_args(); 7620 arg_pipeline->set_isarray(false); 7621 arg_pipeline->set_type(GLMessage::DataType::INT); 7622 arg_pipeline->add_intvalue(pipeline); 7623 7624 // call function 7625 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7626 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7627 glContext->hooks->gl.glBindProgramPipelineEXT(pipeline); 7628 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7629 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7630 7631 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7632 threadStartTime, threadEndTime, 7633 &glmsg); 7634 glContext->traceGLMessage(&glmsg); 7635} 7636 7637void GLTrace_glDeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines) { 7638 GLMessage glmsg; 7639 GLTraceContext *glContext = getGLTraceContext(); 7640 7641 glmsg.set_function(GLMessage::glDeleteProgramPipelinesEXT); 7642 7643 // copy argument n 7644 GLMessage_DataType *arg_n = glmsg.add_args(); 7645 arg_n->set_isarray(false); 7646 arg_n->set_type(GLMessage::DataType::INT); 7647 arg_n->add_intvalue(n); 7648 7649 // copy argument pipelines 7650 GLMessage_DataType *arg_pipelines = glmsg.add_args(); 7651 arg_pipelines->set_isarray(false); 7652 arg_pipelines->set_type(GLMessage::DataType::INT); 7653 arg_pipelines->add_intvalue((int)pipelines); 7654 7655 // call function 7656 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7657 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7658 glContext->hooks->gl.glDeleteProgramPipelinesEXT(n, pipelines); 7659 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7660 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7661 7662 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7663 threadStartTime, threadEndTime, 7664 &glmsg); 7665 glContext->traceGLMessage(&glmsg); 7666} 7667 7668void GLTrace_glGenProgramPipelinesEXT(GLsizei n, GLuint *pipelines) { 7669 GLMessage glmsg; 7670 GLTraceContext *glContext = getGLTraceContext(); 7671 7672 glmsg.set_function(GLMessage::glGenProgramPipelinesEXT); 7673 7674 // copy argument n 7675 GLMessage_DataType *arg_n = glmsg.add_args(); 7676 arg_n->set_isarray(false); 7677 arg_n->set_type(GLMessage::DataType::INT); 7678 arg_n->add_intvalue(n); 7679 7680 // copy argument pipelines 7681 GLMessage_DataType *arg_pipelines = glmsg.add_args(); 7682 arg_pipelines->set_isarray(false); 7683 arg_pipelines->set_type(GLMessage::DataType::INT); 7684 arg_pipelines->add_intvalue((int)pipelines); 7685 7686 // call function 7687 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7688 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7689 glContext->hooks->gl.glGenProgramPipelinesEXT(n, pipelines); 7690 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7691 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7692 7693 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7694 threadStartTime, threadEndTime, 7695 &glmsg); 7696 glContext->traceGLMessage(&glmsg); 7697} 7698 7699GLboolean GLTrace_glIsProgramPipelineEXT(GLuint pipeline) { 7700 GLMessage glmsg; 7701 GLTraceContext *glContext = getGLTraceContext(); 7702 7703 glmsg.set_function(GLMessage::glIsProgramPipelineEXT); 7704 7705 // copy argument pipeline 7706 GLMessage_DataType *arg_pipeline = glmsg.add_args(); 7707 arg_pipeline->set_isarray(false); 7708 arg_pipeline->set_type(GLMessage::DataType::INT); 7709 arg_pipeline->add_intvalue(pipeline); 7710 7711 // call function 7712 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7713 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7714 GLboolean retValue = glContext->hooks->gl.glIsProgramPipelineEXT(pipeline); 7715 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7716 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7717 7718 // set return value 7719 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 7720 rt->set_isarray(false); 7721 rt->set_type(GLMessage::DataType::BOOL); 7722 rt->add_boolvalue(retValue); 7723 7724 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7725 threadStartTime, threadEndTime, 7726 &glmsg); 7727 glContext->traceGLMessage(&glmsg); 7728 7729 return retValue; 7730} 7731 7732void GLTrace_glProgramParameteriEXT(GLuint program, GLenum pname, GLint value) { 7733 GLMessage glmsg; 7734 GLTraceContext *glContext = getGLTraceContext(); 7735 7736 glmsg.set_function(GLMessage::glProgramParameteriEXT); 7737 7738 // copy argument program 7739 GLMessage_DataType *arg_program = glmsg.add_args(); 7740 arg_program->set_isarray(false); 7741 arg_program->set_type(GLMessage::DataType::INT); 7742 arg_program->add_intvalue(program); 7743 7744 // copy argument pname 7745 GLMessage_DataType *arg_pname = glmsg.add_args(); 7746 arg_pname->set_isarray(false); 7747 arg_pname->set_type(GLMessage::DataType::ENUM); 7748 arg_pname->add_intvalue((int)pname); 7749 7750 // copy argument value 7751 GLMessage_DataType *arg_value = glmsg.add_args(); 7752 arg_value->set_isarray(false); 7753 arg_value->set_type(GLMessage::DataType::INT); 7754 arg_value->add_intvalue(value); 7755 7756 // call function 7757 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7758 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7759 glContext->hooks->gl.glProgramParameteriEXT(program, pname, value); 7760 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7761 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7762 7763 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7764 threadStartTime, threadEndTime, 7765 &glmsg); 7766 glContext->traceGLMessage(&glmsg); 7767} 7768 7769void GLTrace_glGetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params) { 7770 GLMessage glmsg; 7771 GLTraceContext *glContext = getGLTraceContext(); 7772 7773 glmsg.set_function(GLMessage::glGetProgramPipelineivEXT); 7774 7775 // copy argument pipeline 7776 GLMessage_DataType *arg_pipeline = glmsg.add_args(); 7777 arg_pipeline->set_isarray(false); 7778 arg_pipeline->set_type(GLMessage::DataType::INT); 7779 arg_pipeline->add_intvalue(pipeline); 7780 7781 // copy argument pname 7782 GLMessage_DataType *arg_pname = glmsg.add_args(); 7783 arg_pname->set_isarray(false); 7784 arg_pname->set_type(GLMessage::DataType::ENUM); 7785 arg_pname->add_intvalue((int)pname); 7786 7787 // copy argument params 7788 GLMessage_DataType *arg_params = glmsg.add_args(); 7789 arg_params->set_isarray(false); 7790 arg_params->set_type(GLMessage::DataType::INT); 7791 arg_params->add_intvalue((int)params); 7792 7793 // call function 7794 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7795 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7796 glContext->hooks->gl.glGetProgramPipelineivEXT(pipeline, pname, params); 7797 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7798 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7799 7800 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7801 threadStartTime, threadEndTime, 7802 &glmsg); 7803 glContext->traceGLMessage(&glmsg); 7804} 7805 7806void GLTrace_glProgramUniform1iEXT(GLuint program, GLint location, GLint x) { 7807 GLMessage glmsg; 7808 GLTraceContext *glContext = getGLTraceContext(); 7809 7810 glmsg.set_function(GLMessage::glProgramUniform1iEXT); 7811 7812 // copy argument program 7813 GLMessage_DataType *arg_program = glmsg.add_args(); 7814 arg_program->set_isarray(false); 7815 arg_program->set_type(GLMessage::DataType::INT); 7816 arg_program->add_intvalue(program); 7817 7818 // copy argument location 7819 GLMessage_DataType *arg_location = glmsg.add_args(); 7820 arg_location->set_isarray(false); 7821 arg_location->set_type(GLMessage::DataType::INT); 7822 arg_location->add_intvalue(location); 7823 7824 // copy argument x 7825 GLMessage_DataType *arg_x = glmsg.add_args(); 7826 arg_x->set_isarray(false); 7827 arg_x->set_type(GLMessage::DataType::INT); 7828 arg_x->add_intvalue(x); 7829 7830 // call function 7831 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7832 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7833 glContext->hooks->gl.glProgramUniform1iEXT(program, location, x); 7834 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7835 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7836 7837 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7838 threadStartTime, threadEndTime, 7839 &glmsg); 7840 glContext->traceGLMessage(&glmsg); 7841} 7842 7843void GLTrace_glProgramUniform2iEXT(GLuint program, GLint location, GLint x, GLint y) { 7844 GLMessage glmsg; 7845 GLTraceContext *glContext = getGLTraceContext(); 7846 7847 glmsg.set_function(GLMessage::glProgramUniform2iEXT); 7848 7849 // copy argument program 7850 GLMessage_DataType *arg_program = glmsg.add_args(); 7851 arg_program->set_isarray(false); 7852 arg_program->set_type(GLMessage::DataType::INT); 7853 arg_program->add_intvalue(program); 7854 7855 // copy argument location 7856 GLMessage_DataType *arg_location = glmsg.add_args(); 7857 arg_location->set_isarray(false); 7858 arg_location->set_type(GLMessage::DataType::INT); 7859 arg_location->add_intvalue(location); 7860 7861 // copy argument x 7862 GLMessage_DataType *arg_x = glmsg.add_args(); 7863 arg_x->set_isarray(false); 7864 arg_x->set_type(GLMessage::DataType::INT); 7865 arg_x->add_intvalue(x); 7866 7867 // copy argument y 7868 GLMessage_DataType *arg_y = glmsg.add_args(); 7869 arg_y->set_isarray(false); 7870 arg_y->set_type(GLMessage::DataType::INT); 7871 arg_y->add_intvalue(y); 7872 7873 // call function 7874 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7875 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7876 glContext->hooks->gl.glProgramUniform2iEXT(program, location, x, y); 7877 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7878 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7879 7880 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7881 threadStartTime, threadEndTime, 7882 &glmsg); 7883 glContext->traceGLMessage(&glmsg); 7884} 7885 7886void GLTrace_glProgramUniform3iEXT(GLuint program, GLint location, GLint x, GLint y, GLint z) { 7887 GLMessage glmsg; 7888 GLTraceContext *glContext = getGLTraceContext(); 7889 7890 glmsg.set_function(GLMessage::glProgramUniform3iEXT); 7891 7892 // copy argument program 7893 GLMessage_DataType *arg_program = glmsg.add_args(); 7894 arg_program->set_isarray(false); 7895 arg_program->set_type(GLMessage::DataType::INT); 7896 arg_program->add_intvalue(program); 7897 7898 // copy argument location 7899 GLMessage_DataType *arg_location = glmsg.add_args(); 7900 arg_location->set_isarray(false); 7901 arg_location->set_type(GLMessage::DataType::INT); 7902 arg_location->add_intvalue(location); 7903 7904 // copy argument x 7905 GLMessage_DataType *arg_x = glmsg.add_args(); 7906 arg_x->set_isarray(false); 7907 arg_x->set_type(GLMessage::DataType::INT); 7908 arg_x->add_intvalue(x); 7909 7910 // copy argument y 7911 GLMessage_DataType *arg_y = glmsg.add_args(); 7912 arg_y->set_isarray(false); 7913 arg_y->set_type(GLMessage::DataType::INT); 7914 arg_y->add_intvalue(y); 7915 7916 // copy argument z 7917 GLMessage_DataType *arg_z = glmsg.add_args(); 7918 arg_z->set_isarray(false); 7919 arg_z->set_type(GLMessage::DataType::INT); 7920 arg_z->add_intvalue(z); 7921 7922 // call function 7923 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7924 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7925 glContext->hooks->gl.glProgramUniform3iEXT(program, location, x, y, z); 7926 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7927 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7928 7929 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7930 threadStartTime, threadEndTime, 7931 &glmsg); 7932 glContext->traceGLMessage(&glmsg); 7933} 7934 7935void GLTrace_glProgramUniform4iEXT(GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w) { 7936 GLMessage glmsg; 7937 GLTraceContext *glContext = getGLTraceContext(); 7938 7939 glmsg.set_function(GLMessage::glProgramUniform4iEXT); 7940 7941 // copy argument program 7942 GLMessage_DataType *arg_program = glmsg.add_args(); 7943 arg_program->set_isarray(false); 7944 arg_program->set_type(GLMessage::DataType::INT); 7945 arg_program->add_intvalue(program); 7946 7947 // copy argument location 7948 GLMessage_DataType *arg_location = glmsg.add_args(); 7949 arg_location->set_isarray(false); 7950 arg_location->set_type(GLMessage::DataType::INT); 7951 arg_location->add_intvalue(location); 7952 7953 // copy argument x 7954 GLMessage_DataType *arg_x = glmsg.add_args(); 7955 arg_x->set_isarray(false); 7956 arg_x->set_type(GLMessage::DataType::INT); 7957 arg_x->add_intvalue(x); 7958 7959 // copy argument y 7960 GLMessage_DataType *arg_y = glmsg.add_args(); 7961 arg_y->set_isarray(false); 7962 arg_y->set_type(GLMessage::DataType::INT); 7963 arg_y->add_intvalue(y); 7964 7965 // copy argument z 7966 GLMessage_DataType *arg_z = glmsg.add_args(); 7967 arg_z->set_isarray(false); 7968 arg_z->set_type(GLMessage::DataType::INT); 7969 arg_z->add_intvalue(z); 7970 7971 // copy argument w 7972 GLMessage_DataType *arg_w = glmsg.add_args(); 7973 arg_w->set_isarray(false); 7974 arg_w->set_type(GLMessage::DataType::INT); 7975 arg_w->add_intvalue(w); 7976 7977 // call function 7978 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 7979 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 7980 glContext->hooks->gl.glProgramUniform4iEXT(program, location, x, y, z, w); 7981 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 7982 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 7983 7984 fixupGLMessage(glContext, wallStartTime, wallEndTime, 7985 threadStartTime, threadEndTime, 7986 &glmsg); 7987 glContext->traceGLMessage(&glmsg); 7988} 7989 7990void GLTrace_glProgramUniform1fEXT(GLuint program, GLint location, GLfloat x) { 7991 GLMessage glmsg; 7992 GLTraceContext *glContext = getGLTraceContext(); 7993 7994 glmsg.set_function(GLMessage::glProgramUniform1fEXT); 7995 7996 // copy argument program 7997 GLMessage_DataType *arg_program = glmsg.add_args(); 7998 arg_program->set_isarray(false); 7999 arg_program->set_type(GLMessage::DataType::INT); 8000 arg_program->add_intvalue(program); 8001 8002 // copy argument location 8003 GLMessage_DataType *arg_location = glmsg.add_args(); 8004 arg_location->set_isarray(false); 8005 arg_location->set_type(GLMessage::DataType::INT); 8006 arg_location->add_intvalue(location); 8007 8008 // copy argument x 8009 GLMessage_DataType *arg_x = glmsg.add_args(); 8010 arg_x->set_isarray(false); 8011 arg_x->set_type(GLMessage::DataType::FLOAT); 8012 arg_x->add_floatvalue(x); 8013 8014 // call function 8015 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8016 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8017 glContext->hooks->gl.glProgramUniform1fEXT(program, location, x); 8018 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8019 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8020 8021 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8022 threadStartTime, threadEndTime, 8023 &glmsg); 8024 glContext->traceGLMessage(&glmsg); 8025} 8026 8027void GLTrace_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat x, GLfloat y) { 8028 GLMessage glmsg; 8029 GLTraceContext *glContext = getGLTraceContext(); 8030 8031 glmsg.set_function(GLMessage::glProgramUniform2fEXT); 8032 8033 // copy argument program 8034 GLMessage_DataType *arg_program = glmsg.add_args(); 8035 arg_program->set_isarray(false); 8036 arg_program->set_type(GLMessage::DataType::INT); 8037 arg_program->add_intvalue(program); 8038 8039 // copy argument location 8040 GLMessage_DataType *arg_location = glmsg.add_args(); 8041 arg_location->set_isarray(false); 8042 arg_location->set_type(GLMessage::DataType::INT); 8043 arg_location->add_intvalue(location); 8044 8045 // copy argument x 8046 GLMessage_DataType *arg_x = glmsg.add_args(); 8047 arg_x->set_isarray(false); 8048 arg_x->set_type(GLMessage::DataType::FLOAT); 8049 arg_x->add_floatvalue(x); 8050 8051 // copy argument y 8052 GLMessage_DataType *arg_y = glmsg.add_args(); 8053 arg_y->set_isarray(false); 8054 arg_y->set_type(GLMessage::DataType::FLOAT); 8055 arg_y->add_floatvalue(y); 8056 8057 // call function 8058 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8059 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8060 glContext->hooks->gl.glProgramUniform2fEXT(program, location, x, y); 8061 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8062 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8063 8064 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8065 threadStartTime, threadEndTime, 8066 &glmsg); 8067 glContext->traceGLMessage(&glmsg); 8068} 8069 8070void GLTrace_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z) { 8071 GLMessage glmsg; 8072 GLTraceContext *glContext = getGLTraceContext(); 8073 8074 glmsg.set_function(GLMessage::glProgramUniform3fEXT); 8075 8076 // copy argument program 8077 GLMessage_DataType *arg_program = glmsg.add_args(); 8078 arg_program->set_isarray(false); 8079 arg_program->set_type(GLMessage::DataType::INT); 8080 arg_program->add_intvalue(program); 8081 8082 // copy argument location 8083 GLMessage_DataType *arg_location = glmsg.add_args(); 8084 arg_location->set_isarray(false); 8085 arg_location->set_type(GLMessage::DataType::INT); 8086 arg_location->add_intvalue(location); 8087 8088 // copy argument x 8089 GLMessage_DataType *arg_x = glmsg.add_args(); 8090 arg_x->set_isarray(false); 8091 arg_x->set_type(GLMessage::DataType::FLOAT); 8092 arg_x->add_floatvalue(x); 8093 8094 // copy argument y 8095 GLMessage_DataType *arg_y = glmsg.add_args(); 8096 arg_y->set_isarray(false); 8097 arg_y->set_type(GLMessage::DataType::FLOAT); 8098 arg_y->add_floatvalue(y); 8099 8100 // copy argument z 8101 GLMessage_DataType *arg_z = glmsg.add_args(); 8102 arg_z->set_isarray(false); 8103 arg_z->set_type(GLMessage::DataType::FLOAT); 8104 arg_z->add_floatvalue(z); 8105 8106 // call function 8107 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8108 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8109 glContext->hooks->gl.glProgramUniform3fEXT(program, location, x, y, z); 8110 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8111 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8112 8113 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8114 threadStartTime, threadEndTime, 8115 &glmsg); 8116 glContext->traceGLMessage(&glmsg); 8117} 8118 8119void GLTrace_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { 8120 GLMessage glmsg; 8121 GLTraceContext *glContext = getGLTraceContext(); 8122 8123 glmsg.set_function(GLMessage::glProgramUniform4fEXT); 8124 8125 // copy argument program 8126 GLMessage_DataType *arg_program = glmsg.add_args(); 8127 arg_program->set_isarray(false); 8128 arg_program->set_type(GLMessage::DataType::INT); 8129 arg_program->add_intvalue(program); 8130 8131 // copy argument location 8132 GLMessage_DataType *arg_location = glmsg.add_args(); 8133 arg_location->set_isarray(false); 8134 arg_location->set_type(GLMessage::DataType::INT); 8135 arg_location->add_intvalue(location); 8136 8137 // copy argument x 8138 GLMessage_DataType *arg_x = glmsg.add_args(); 8139 arg_x->set_isarray(false); 8140 arg_x->set_type(GLMessage::DataType::FLOAT); 8141 arg_x->add_floatvalue(x); 8142 8143 // copy argument y 8144 GLMessage_DataType *arg_y = glmsg.add_args(); 8145 arg_y->set_isarray(false); 8146 arg_y->set_type(GLMessage::DataType::FLOAT); 8147 arg_y->add_floatvalue(y); 8148 8149 // copy argument z 8150 GLMessage_DataType *arg_z = glmsg.add_args(); 8151 arg_z->set_isarray(false); 8152 arg_z->set_type(GLMessage::DataType::FLOAT); 8153 arg_z->add_floatvalue(z); 8154 8155 // copy argument w 8156 GLMessage_DataType *arg_w = glmsg.add_args(); 8157 arg_w->set_isarray(false); 8158 arg_w->set_type(GLMessage::DataType::FLOAT); 8159 arg_w->add_floatvalue(w); 8160 8161 // call function 8162 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8163 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8164 glContext->hooks->gl.glProgramUniform4fEXT(program, location, x, y, z, w); 8165 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8166 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8167 8168 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8169 threadStartTime, threadEndTime, 8170 &glmsg); 8171 glContext->traceGLMessage(&glmsg); 8172} 8173 8174void GLTrace_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value) { 8175 GLMessage glmsg; 8176 GLTraceContext *glContext = getGLTraceContext(); 8177 8178 glmsg.set_function(GLMessage::glProgramUniform1ivEXT); 8179 8180 // copy argument program 8181 GLMessage_DataType *arg_program = glmsg.add_args(); 8182 arg_program->set_isarray(false); 8183 arg_program->set_type(GLMessage::DataType::INT); 8184 arg_program->add_intvalue(program); 8185 8186 // copy argument location 8187 GLMessage_DataType *arg_location = glmsg.add_args(); 8188 arg_location->set_isarray(false); 8189 arg_location->set_type(GLMessage::DataType::INT); 8190 arg_location->add_intvalue(location); 8191 8192 // copy argument count 8193 GLMessage_DataType *arg_count = glmsg.add_args(); 8194 arg_count->set_isarray(false); 8195 arg_count->set_type(GLMessage::DataType::INT); 8196 arg_count->add_intvalue(count); 8197 8198 // copy argument value 8199 GLMessage_DataType *arg_value = glmsg.add_args(); 8200 arg_value->set_isarray(false); 8201 arg_value->set_type(GLMessage::DataType::INT); 8202 arg_value->add_intvalue((int)value); 8203 8204 // call function 8205 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8206 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8207 glContext->hooks->gl.glProgramUniform1ivEXT(program, location, count, value); 8208 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8209 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8210 8211 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8212 threadStartTime, threadEndTime, 8213 &glmsg); 8214 glContext->traceGLMessage(&glmsg); 8215} 8216 8217void GLTrace_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value) { 8218 GLMessage glmsg; 8219 GLTraceContext *glContext = getGLTraceContext(); 8220 8221 glmsg.set_function(GLMessage::glProgramUniform2ivEXT); 8222 8223 // copy argument program 8224 GLMessage_DataType *arg_program = glmsg.add_args(); 8225 arg_program->set_isarray(false); 8226 arg_program->set_type(GLMessage::DataType::INT); 8227 arg_program->add_intvalue(program); 8228 8229 // copy argument location 8230 GLMessage_DataType *arg_location = glmsg.add_args(); 8231 arg_location->set_isarray(false); 8232 arg_location->set_type(GLMessage::DataType::INT); 8233 arg_location->add_intvalue(location); 8234 8235 // copy argument count 8236 GLMessage_DataType *arg_count = glmsg.add_args(); 8237 arg_count->set_isarray(false); 8238 arg_count->set_type(GLMessage::DataType::INT); 8239 arg_count->add_intvalue(count); 8240 8241 // copy argument value 8242 GLMessage_DataType *arg_value = glmsg.add_args(); 8243 arg_value->set_isarray(false); 8244 arg_value->set_type(GLMessage::DataType::INT); 8245 arg_value->add_intvalue((int)value); 8246 8247 // call function 8248 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8249 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8250 glContext->hooks->gl.glProgramUniform2ivEXT(program, location, count, value); 8251 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8252 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8253 8254 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8255 threadStartTime, threadEndTime, 8256 &glmsg); 8257 glContext->traceGLMessage(&glmsg); 8258} 8259 8260void GLTrace_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value) { 8261 GLMessage glmsg; 8262 GLTraceContext *glContext = getGLTraceContext(); 8263 8264 glmsg.set_function(GLMessage::glProgramUniform3ivEXT); 8265 8266 // copy argument program 8267 GLMessage_DataType *arg_program = glmsg.add_args(); 8268 arg_program->set_isarray(false); 8269 arg_program->set_type(GLMessage::DataType::INT); 8270 arg_program->add_intvalue(program); 8271 8272 // copy argument location 8273 GLMessage_DataType *arg_location = glmsg.add_args(); 8274 arg_location->set_isarray(false); 8275 arg_location->set_type(GLMessage::DataType::INT); 8276 arg_location->add_intvalue(location); 8277 8278 // copy argument count 8279 GLMessage_DataType *arg_count = glmsg.add_args(); 8280 arg_count->set_isarray(false); 8281 arg_count->set_type(GLMessage::DataType::INT); 8282 arg_count->add_intvalue(count); 8283 8284 // copy argument value 8285 GLMessage_DataType *arg_value = glmsg.add_args(); 8286 arg_value->set_isarray(false); 8287 arg_value->set_type(GLMessage::DataType::INT); 8288 arg_value->add_intvalue((int)value); 8289 8290 // call function 8291 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8292 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8293 glContext->hooks->gl.glProgramUniform3ivEXT(program, location, count, value); 8294 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8295 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8296 8297 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8298 threadStartTime, threadEndTime, 8299 &glmsg); 8300 glContext->traceGLMessage(&glmsg); 8301} 8302 8303void GLTrace_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value) { 8304 GLMessage glmsg; 8305 GLTraceContext *glContext = getGLTraceContext(); 8306 8307 glmsg.set_function(GLMessage::glProgramUniform4ivEXT); 8308 8309 // copy argument program 8310 GLMessage_DataType *arg_program = glmsg.add_args(); 8311 arg_program->set_isarray(false); 8312 arg_program->set_type(GLMessage::DataType::INT); 8313 arg_program->add_intvalue(program); 8314 8315 // copy argument location 8316 GLMessage_DataType *arg_location = glmsg.add_args(); 8317 arg_location->set_isarray(false); 8318 arg_location->set_type(GLMessage::DataType::INT); 8319 arg_location->add_intvalue(location); 8320 8321 // copy argument count 8322 GLMessage_DataType *arg_count = glmsg.add_args(); 8323 arg_count->set_isarray(false); 8324 arg_count->set_type(GLMessage::DataType::INT); 8325 arg_count->add_intvalue(count); 8326 8327 // copy argument value 8328 GLMessage_DataType *arg_value = glmsg.add_args(); 8329 arg_value->set_isarray(false); 8330 arg_value->set_type(GLMessage::DataType::INT); 8331 arg_value->add_intvalue((int)value); 8332 8333 // call function 8334 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8335 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8336 glContext->hooks->gl.glProgramUniform4ivEXT(program, location, count, value); 8337 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8338 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8339 8340 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8341 threadStartTime, threadEndTime, 8342 &glmsg); 8343 glContext->traceGLMessage(&glmsg); 8344} 8345 8346void GLTrace_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value) { 8347 GLMessage glmsg; 8348 GLTraceContext *glContext = getGLTraceContext(); 8349 8350 glmsg.set_function(GLMessage::glProgramUniform1fvEXT); 8351 8352 // copy argument program 8353 GLMessage_DataType *arg_program = glmsg.add_args(); 8354 arg_program->set_isarray(false); 8355 arg_program->set_type(GLMessage::DataType::INT); 8356 arg_program->add_intvalue(program); 8357 8358 // copy argument location 8359 GLMessage_DataType *arg_location = glmsg.add_args(); 8360 arg_location->set_isarray(false); 8361 arg_location->set_type(GLMessage::DataType::INT); 8362 arg_location->add_intvalue(location); 8363 8364 // copy argument count 8365 GLMessage_DataType *arg_count = glmsg.add_args(); 8366 arg_count->set_isarray(false); 8367 arg_count->set_type(GLMessage::DataType::INT); 8368 arg_count->add_intvalue(count); 8369 8370 // copy argument value 8371 GLMessage_DataType *arg_value = glmsg.add_args(); 8372 arg_value->set_isarray(false); 8373 arg_value->set_type(GLMessage::DataType::INT); 8374 arg_value->add_intvalue((int)value); 8375 8376 // call function 8377 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8378 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8379 glContext->hooks->gl.glProgramUniform1fvEXT(program, location, count, value); 8380 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8381 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8382 8383 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8384 threadStartTime, threadEndTime, 8385 &glmsg); 8386 glContext->traceGLMessage(&glmsg); 8387} 8388 8389void GLTrace_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value) { 8390 GLMessage glmsg; 8391 GLTraceContext *glContext = getGLTraceContext(); 8392 8393 glmsg.set_function(GLMessage::glProgramUniform2fvEXT); 8394 8395 // copy argument program 8396 GLMessage_DataType *arg_program = glmsg.add_args(); 8397 arg_program->set_isarray(false); 8398 arg_program->set_type(GLMessage::DataType::INT); 8399 arg_program->add_intvalue(program); 8400 8401 // copy argument location 8402 GLMessage_DataType *arg_location = glmsg.add_args(); 8403 arg_location->set_isarray(false); 8404 arg_location->set_type(GLMessage::DataType::INT); 8405 arg_location->add_intvalue(location); 8406 8407 // copy argument count 8408 GLMessage_DataType *arg_count = glmsg.add_args(); 8409 arg_count->set_isarray(false); 8410 arg_count->set_type(GLMessage::DataType::INT); 8411 arg_count->add_intvalue(count); 8412 8413 // copy argument value 8414 GLMessage_DataType *arg_value = glmsg.add_args(); 8415 arg_value->set_isarray(false); 8416 arg_value->set_type(GLMessage::DataType::INT); 8417 arg_value->add_intvalue((int)value); 8418 8419 // call function 8420 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8421 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8422 glContext->hooks->gl.glProgramUniform2fvEXT(program, location, count, value); 8423 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8424 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8425 8426 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8427 threadStartTime, threadEndTime, 8428 &glmsg); 8429 glContext->traceGLMessage(&glmsg); 8430} 8431 8432void GLTrace_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value) { 8433 GLMessage glmsg; 8434 GLTraceContext *glContext = getGLTraceContext(); 8435 8436 glmsg.set_function(GLMessage::glProgramUniform3fvEXT); 8437 8438 // copy argument program 8439 GLMessage_DataType *arg_program = glmsg.add_args(); 8440 arg_program->set_isarray(false); 8441 arg_program->set_type(GLMessage::DataType::INT); 8442 arg_program->add_intvalue(program); 8443 8444 // copy argument location 8445 GLMessage_DataType *arg_location = glmsg.add_args(); 8446 arg_location->set_isarray(false); 8447 arg_location->set_type(GLMessage::DataType::INT); 8448 arg_location->add_intvalue(location); 8449 8450 // copy argument count 8451 GLMessage_DataType *arg_count = glmsg.add_args(); 8452 arg_count->set_isarray(false); 8453 arg_count->set_type(GLMessage::DataType::INT); 8454 arg_count->add_intvalue(count); 8455 8456 // copy argument value 8457 GLMessage_DataType *arg_value = glmsg.add_args(); 8458 arg_value->set_isarray(false); 8459 arg_value->set_type(GLMessage::DataType::INT); 8460 arg_value->add_intvalue((int)value); 8461 8462 // call function 8463 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8464 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8465 glContext->hooks->gl.glProgramUniform3fvEXT(program, location, count, value); 8466 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8467 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8468 8469 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8470 threadStartTime, threadEndTime, 8471 &glmsg); 8472 glContext->traceGLMessage(&glmsg); 8473} 8474 8475void GLTrace_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value) { 8476 GLMessage glmsg; 8477 GLTraceContext *glContext = getGLTraceContext(); 8478 8479 glmsg.set_function(GLMessage::glProgramUniform4fvEXT); 8480 8481 // copy argument program 8482 GLMessage_DataType *arg_program = glmsg.add_args(); 8483 arg_program->set_isarray(false); 8484 arg_program->set_type(GLMessage::DataType::INT); 8485 arg_program->add_intvalue(program); 8486 8487 // copy argument location 8488 GLMessage_DataType *arg_location = glmsg.add_args(); 8489 arg_location->set_isarray(false); 8490 arg_location->set_type(GLMessage::DataType::INT); 8491 arg_location->add_intvalue(location); 8492 8493 // copy argument count 8494 GLMessage_DataType *arg_count = glmsg.add_args(); 8495 arg_count->set_isarray(false); 8496 arg_count->set_type(GLMessage::DataType::INT); 8497 arg_count->add_intvalue(count); 8498 8499 // copy argument value 8500 GLMessage_DataType *arg_value = glmsg.add_args(); 8501 arg_value->set_isarray(false); 8502 arg_value->set_type(GLMessage::DataType::INT); 8503 arg_value->add_intvalue((int)value); 8504 8505 // call function 8506 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8507 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8508 glContext->hooks->gl.glProgramUniform4fvEXT(program, location, count, value); 8509 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8510 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8511 8512 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8513 threadStartTime, threadEndTime, 8514 &glmsg); 8515 glContext->traceGLMessage(&glmsg); 8516} 8517 8518void GLTrace_glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { 8519 GLMessage glmsg; 8520 GLTraceContext *glContext = getGLTraceContext(); 8521 8522 glmsg.set_function(GLMessage::glProgramUniformMatrix2fvEXT); 8523 8524 // copy argument program 8525 GLMessage_DataType *arg_program = glmsg.add_args(); 8526 arg_program->set_isarray(false); 8527 arg_program->set_type(GLMessage::DataType::INT); 8528 arg_program->add_intvalue(program); 8529 8530 // copy argument location 8531 GLMessage_DataType *arg_location = glmsg.add_args(); 8532 arg_location->set_isarray(false); 8533 arg_location->set_type(GLMessage::DataType::INT); 8534 arg_location->add_intvalue(location); 8535 8536 // copy argument count 8537 GLMessage_DataType *arg_count = glmsg.add_args(); 8538 arg_count->set_isarray(false); 8539 arg_count->set_type(GLMessage::DataType::INT); 8540 arg_count->add_intvalue(count); 8541 8542 // copy argument transpose 8543 GLMessage_DataType *arg_transpose = glmsg.add_args(); 8544 arg_transpose->set_isarray(false); 8545 arg_transpose->set_type(GLMessage::DataType::BOOL); 8546 arg_transpose->add_boolvalue(transpose); 8547 8548 // copy argument value 8549 GLMessage_DataType *arg_value = glmsg.add_args(); 8550 arg_value->set_isarray(false); 8551 arg_value->set_type(GLMessage::DataType::INT); 8552 arg_value->add_intvalue((int)value); 8553 8554 // call function 8555 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8556 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8557 glContext->hooks->gl.glProgramUniformMatrix2fvEXT(program, location, count, transpose, value); 8558 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8559 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8560 8561 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8562 threadStartTime, threadEndTime, 8563 &glmsg); 8564 glContext->traceGLMessage(&glmsg); 8565} 8566 8567void GLTrace_glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { 8568 GLMessage glmsg; 8569 GLTraceContext *glContext = getGLTraceContext(); 8570 8571 glmsg.set_function(GLMessage::glProgramUniformMatrix3fvEXT); 8572 8573 // copy argument program 8574 GLMessage_DataType *arg_program = glmsg.add_args(); 8575 arg_program->set_isarray(false); 8576 arg_program->set_type(GLMessage::DataType::INT); 8577 arg_program->add_intvalue(program); 8578 8579 // copy argument location 8580 GLMessage_DataType *arg_location = glmsg.add_args(); 8581 arg_location->set_isarray(false); 8582 arg_location->set_type(GLMessage::DataType::INT); 8583 arg_location->add_intvalue(location); 8584 8585 // copy argument count 8586 GLMessage_DataType *arg_count = glmsg.add_args(); 8587 arg_count->set_isarray(false); 8588 arg_count->set_type(GLMessage::DataType::INT); 8589 arg_count->add_intvalue(count); 8590 8591 // copy argument transpose 8592 GLMessage_DataType *arg_transpose = glmsg.add_args(); 8593 arg_transpose->set_isarray(false); 8594 arg_transpose->set_type(GLMessage::DataType::BOOL); 8595 arg_transpose->add_boolvalue(transpose); 8596 8597 // copy argument value 8598 GLMessage_DataType *arg_value = glmsg.add_args(); 8599 arg_value->set_isarray(false); 8600 arg_value->set_type(GLMessage::DataType::INT); 8601 arg_value->add_intvalue((int)value); 8602 8603 // call function 8604 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8605 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8606 glContext->hooks->gl.glProgramUniformMatrix3fvEXT(program, location, count, transpose, value); 8607 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8608 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8609 8610 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8611 threadStartTime, threadEndTime, 8612 &glmsg); 8613 glContext->traceGLMessage(&glmsg); 8614} 8615 8616void GLTrace_glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { 8617 GLMessage glmsg; 8618 GLTraceContext *glContext = getGLTraceContext(); 8619 8620 glmsg.set_function(GLMessage::glProgramUniformMatrix4fvEXT); 8621 8622 // copy argument program 8623 GLMessage_DataType *arg_program = glmsg.add_args(); 8624 arg_program->set_isarray(false); 8625 arg_program->set_type(GLMessage::DataType::INT); 8626 arg_program->add_intvalue(program); 8627 8628 // copy argument location 8629 GLMessage_DataType *arg_location = glmsg.add_args(); 8630 arg_location->set_isarray(false); 8631 arg_location->set_type(GLMessage::DataType::INT); 8632 arg_location->add_intvalue(location); 8633 8634 // copy argument count 8635 GLMessage_DataType *arg_count = glmsg.add_args(); 8636 arg_count->set_isarray(false); 8637 arg_count->set_type(GLMessage::DataType::INT); 8638 arg_count->add_intvalue(count); 8639 8640 // copy argument transpose 8641 GLMessage_DataType *arg_transpose = glmsg.add_args(); 8642 arg_transpose->set_isarray(false); 8643 arg_transpose->set_type(GLMessage::DataType::BOOL); 8644 arg_transpose->add_boolvalue(transpose); 8645 8646 // copy argument value 8647 GLMessage_DataType *arg_value = glmsg.add_args(); 8648 arg_value->set_isarray(false); 8649 arg_value->set_type(GLMessage::DataType::INT); 8650 arg_value->add_intvalue((int)value); 8651 8652 // call function 8653 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8654 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8655 glContext->hooks->gl.glProgramUniformMatrix4fvEXT(program, location, count, transpose, value); 8656 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8657 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8658 8659 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8660 threadStartTime, threadEndTime, 8661 &glmsg); 8662 glContext->traceGLMessage(&glmsg); 8663} 8664 8665void GLTrace_glValidateProgramPipelineEXT(GLuint pipeline) { 8666 GLMessage glmsg; 8667 GLTraceContext *glContext = getGLTraceContext(); 8668 8669 glmsg.set_function(GLMessage::glValidateProgramPipelineEXT); 8670 8671 // copy argument pipeline 8672 GLMessage_DataType *arg_pipeline = glmsg.add_args(); 8673 arg_pipeline->set_isarray(false); 8674 arg_pipeline->set_type(GLMessage::DataType::INT); 8675 arg_pipeline->add_intvalue(pipeline); 8676 8677 // call function 8678 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8679 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8680 glContext->hooks->gl.glValidateProgramPipelineEXT(pipeline); 8681 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8682 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8683 8684 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8685 threadStartTime, threadEndTime, 8686 &glmsg); 8687 glContext->traceGLMessage(&glmsg); 8688} 8689 8690void GLTrace_glGetProgramPipelineInfoLogEXT(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog) { 8691 GLMessage glmsg; 8692 GLTraceContext *glContext = getGLTraceContext(); 8693 8694 glmsg.set_function(GLMessage::glGetProgramPipelineInfoLogEXT); 8695 8696 // copy argument pipeline 8697 GLMessage_DataType *arg_pipeline = glmsg.add_args(); 8698 arg_pipeline->set_isarray(false); 8699 arg_pipeline->set_type(GLMessage::DataType::INT); 8700 arg_pipeline->add_intvalue(pipeline); 8701 8702 // copy argument bufSize 8703 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 8704 arg_bufSize->set_isarray(false); 8705 arg_bufSize->set_type(GLMessage::DataType::INT); 8706 arg_bufSize->add_intvalue(bufSize); 8707 8708 // copy argument length 8709 GLMessage_DataType *arg_length = glmsg.add_args(); 8710 arg_length->set_isarray(false); 8711 arg_length->set_type(GLMessage::DataType::INT); 8712 arg_length->add_intvalue((int)length); 8713 8714 // copy argument infoLog 8715 GLMessage_DataType *arg_infoLog = glmsg.add_args(); 8716 arg_infoLog->set_isarray(false); 8717 arg_infoLog->set_type(GLMessage::DataType::INT); 8718 arg_infoLog->add_intvalue((int)infoLog); 8719 8720 // call function 8721 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8722 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8723 glContext->hooks->gl.glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog); 8724 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8725 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8726 8727 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8728 threadStartTime, threadEndTime, 8729 &glmsg); 8730 glContext->traceGLMessage(&glmsg); 8731} 8732 8733void GLTrace_glTexStorage1DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { 8734 GLMessage glmsg; 8735 GLTraceContext *glContext = getGLTraceContext(); 8736 8737 glmsg.set_function(GLMessage::glTexStorage1DEXT); 8738 8739 // copy argument target 8740 GLMessage_DataType *arg_target = glmsg.add_args(); 8741 arg_target->set_isarray(false); 8742 arg_target->set_type(GLMessage::DataType::ENUM); 8743 arg_target->add_intvalue((int)target); 8744 8745 // copy argument levels 8746 GLMessage_DataType *arg_levels = glmsg.add_args(); 8747 arg_levels->set_isarray(false); 8748 arg_levels->set_type(GLMessage::DataType::INT); 8749 arg_levels->add_intvalue(levels); 8750 8751 // copy argument internalformat 8752 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 8753 arg_internalformat->set_isarray(false); 8754 arg_internalformat->set_type(GLMessage::DataType::ENUM); 8755 arg_internalformat->add_intvalue((int)internalformat); 8756 8757 // copy argument width 8758 GLMessage_DataType *arg_width = glmsg.add_args(); 8759 arg_width->set_isarray(false); 8760 arg_width->set_type(GLMessage::DataType::INT); 8761 arg_width->add_intvalue(width); 8762 8763 // call function 8764 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8765 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8766 glContext->hooks->gl.glTexStorage1DEXT(target, levels, internalformat, width); 8767 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8768 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8769 8770 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8771 threadStartTime, threadEndTime, 8772 &glmsg); 8773 glContext->traceGLMessage(&glmsg); 8774} 8775 8776void GLTrace_glTexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { 8777 GLMessage glmsg; 8778 GLTraceContext *glContext = getGLTraceContext(); 8779 8780 glmsg.set_function(GLMessage::glTexStorage2DEXT); 8781 8782 // copy argument target 8783 GLMessage_DataType *arg_target = glmsg.add_args(); 8784 arg_target->set_isarray(false); 8785 arg_target->set_type(GLMessage::DataType::ENUM); 8786 arg_target->add_intvalue((int)target); 8787 8788 // copy argument levels 8789 GLMessage_DataType *arg_levels = glmsg.add_args(); 8790 arg_levels->set_isarray(false); 8791 arg_levels->set_type(GLMessage::DataType::INT); 8792 arg_levels->add_intvalue(levels); 8793 8794 // copy argument internalformat 8795 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 8796 arg_internalformat->set_isarray(false); 8797 arg_internalformat->set_type(GLMessage::DataType::ENUM); 8798 arg_internalformat->add_intvalue((int)internalformat); 8799 8800 // copy argument width 8801 GLMessage_DataType *arg_width = glmsg.add_args(); 8802 arg_width->set_isarray(false); 8803 arg_width->set_type(GLMessage::DataType::INT); 8804 arg_width->add_intvalue(width); 8805 8806 // copy argument height 8807 GLMessage_DataType *arg_height = glmsg.add_args(); 8808 arg_height->set_isarray(false); 8809 arg_height->set_type(GLMessage::DataType::INT); 8810 arg_height->add_intvalue(height); 8811 8812 // call function 8813 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8814 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8815 glContext->hooks->gl.glTexStorage2DEXT(target, levels, internalformat, width, height); 8816 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8817 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8818 8819 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8820 threadStartTime, threadEndTime, 8821 &glmsg); 8822 glContext->traceGLMessage(&glmsg); 8823} 8824 8825void GLTrace_glTexStorage3DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { 8826 GLMessage glmsg; 8827 GLTraceContext *glContext = getGLTraceContext(); 8828 8829 glmsg.set_function(GLMessage::glTexStorage3DEXT); 8830 8831 // copy argument target 8832 GLMessage_DataType *arg_target = glmsg.add_args(); 8833 arg_target->set_isarray(false); 8834 arg_target->set_type(GLMessage::DataType::ENUM); 8835 arg_target->add_intvalue((int)target); 8836 8837 // copy argument levels 8838 GLMessage_DataType *arg_levels = glmsg.add_args(); 8839 arg_levels->set_isarray(false); 8840 arg_levels->set_type(GLMessage::DataType::INT); 8841 arg_levels->add_intvalue(levels); 8842 8843 // copy argument internalformat 8844 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 8845 arg_internalformat->set_isarray(false); 8846 arg_internalformat->set_type(GLMessage::DataType::ENUM); 8847 arg_internalformat->add_intvalue((int)internalformat); 8848 8849 // copy argument width 8850 GLMessage_DataType *arg_width = glmsg.add_args(); 8851 arg_width->set_isarray(false); 8852 arg_width->set_type(GLMessage::DataType::INT); 8853 arg_width->add_intvalue(width); 8854 8855 // copy argument height 8856 GLMessage_DataType *arg_height = glmsg.add_args(); 8857 arg_height->set_isarray(false); 8858 arg_height->set_type(GLMessage::DataType::INT); 8859 arg_height->add_intvalue(height); 8860 8861 // copy argument depth 8862 GLMessage_DataType *arg_depth = glmsg.add_args(); 8863 arg_depth->set_isarray(false); 8864 arg_depth->set_type(GLMessage::DataType::INT); 8865 arg_depth->add_intvalue(depth); 8866 8867 // call function 8868 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8869 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8870 glContext->hooks->gl.glTexStorage3DEXT(target, levels, internalformat, width, height, depth); 8871 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8872 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8873 8874 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8875 threadStartTime, threadEndTime, 8876 &glmsg); 8877 glContext->traceGLMessage(&glmsg); 8878} 8879 8880void GLTrace_glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { 8881 GLMessage glmsg; 8882 GLTraceContext *glContext = getGLTraceContext(); 8883 8884 glmsg.set_function(GLMessage::glTextureStorage1DEXT); 8885 8886 // copy argument texture 8887 GLMessage_DataType *arg_texture = glmsg.add_args(); 8888 arg_texture->set_isarray(false); 8889 arg_texture->set_type(GLMessage::DataType::INT); 8890 arg_texture->add_intvalue(texture); 8891 8892 // copy argument target 8893 GLMessage_DataType *arg_target = glmsg.add_args(); 8894 arg_target->set_isarray(false); 8895 arg_target->set_type(GLMessage::DataType::ENUM); 8896 arg_target->add_intvalue((int)target); 8897 8898 // copy argument levels 8899 GLMessage_DataType *arg_levels = glmsg.add_args(); 8900 arg_levels->set_isarray(false); 8901 arg_levels->set_type(GLMessage::DataType::INT); 8902 arg_levels->add_intvalue(levels); 8903 8904 // copy argument internalformat 8905 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 8906 arg_internalformat->set_isarray(false); 8907 arg_internalformat->set_type(GLMessage::DataType::ENUM); 8908 arg_internalformat->add_intvalue((int)internalformat); 8909 8910 // copy argument width 8911 GLMessage_DataType *arg_width = glmsg.add_args(); 8912 arg_width->set_isarray(false); 8913 arg_width->set_type(GLMessage::DataType::INT); 8914 arg_width->add_intvalue(width); 8915 8916 // call function 8917 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8918 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8919 glContext->hooks->gl.glTextureStorage1DEXT(texture, target, levels, internalformat, width); 8920 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8921 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8922 8923 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8924 threadStartTime, threadEndTime, 8925 &glmsg); 8926 glContext->traceGLMessage(&glmsg); 8927} 8928 8929void GLTrace_glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { 8930 GLMessage glmsg; 8931 GLTraceContext *glContext = getGLTraceContext(); 8932 8933 glmsg.set_function(GLMessage::glTextureStorage2DEXT); 8934 8935 // copy argument texture 8936 GLMessage_DataType *arg_texture = glmsg.add_args(); 8937 arg_texture->set_isarray(false); 8938 arg_texture->set_type(GLMessage::DataType::INT); 8939 arg_texture->add_intvalue(texture); 8940 8941 // copy argument target 8942 GLMessage_DataType *arg_target = glmsg.add_args(); 8943 arg_target->set_isarray(false); 8944 arg_target->set_type(GLMessage::DataType::ENUM); 8945 arg_target->add_intvalue((int)target); 8946 8947 // copy argument levels 8948 GLMessage_DataType *arg_levels = glmsg.add_args(); 8949 arg_levels->set_isarray(false); 8950 arg_levels->set_type(GLMessage::DataType::INT); 8951 arg_levels->add_intvalue(levels); 8952 8953 // copy argument internalformat 8954 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 8955 arg_internalformat->set_isarray(false); 8956 arg_internalformat->set_type(GLMessage::DataType::ENUM); 8957 arg_internalformat->add_intvalue((int)internalformat); 8958 8959 // copy argument width 8960 GLMessage_DataType *arg_width = glmsg.add_args(); 8961 arg_width->set_isarray(false); 8962 arg_width->set_type(GLMessage::DataType::INT); 8963 arg_width->add_intvalue(width); 8964 8965 // copy argument height 8966 GLMessage_DataType *arg_height = glmsg.add_args(); 8967 arg_height->set_isarray(false); 8968 arg_height->set_type(GLMessage::DataType::INT); 8969 arg_height->add_intvalue(height); 8970 8971 // call function 8972 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 8973 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 8974 glContext->hooks->gl.glTextureStorage2DEXT(texture, target, levels, internalformat, width, height); 8975 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 8976 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 8977 8978 fixupGLMessage(glContext, wallStartTime, wallEndTime, 8979 threadStartTime, threadEndTime, 8980 &glmsg); 8981 glContext->traceGLMessage(&glmsg); 8982} 8983 8984void GLTrace_glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { 8985 GLMessage glmsg; 8986 GLTraceContext *glContext = getGLTraceContext(); 8987 8988 glmsg.set_function(GLMessage::glTextureStorage3DEXT); 8989 8990 // copy argument texture 8991 GLMessage_DataType *arg_texture = glmsg.add_args(); 8992 arg_texture->set_isarray(false); 8993 arg_texture->set_type(GLMessage::DataType::INT); 8994 arg_texture->add_intvalue(texture); 8995 8996 // copy argument target 8997 GLMessage_DataType *arg_target = glmsg.add_args(); 8998 arg_target->set_isarray(false); 8999 arg_target->set_type(GLMessage::DataType::ENUM); 9000 arg_target->add_intvalue((int)target); 9001 9002 // copy argument levels 9003 GLMessage_DataType *arg_levels = glmsg.add_args(); 9004 arg_levels->set_isarray(false); 9005 arg_levels->set_type(GLMessage::DataType::INT); 9006 arg_levels->add_intvalue(levels); 9007 9008 // copy argument internalformat 9009 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 9010 arg_internalformat->set_isarray(false); 9011 arg_internalformat->set_type(GLMessage::DataType::ENUM); 9012 arg_internalformat->add_intvalue((int)internalformat); 9013 9014 // copy argument width 9015 GLMessage_DataType *arg_width = glmsg.add_args(); 9016 arg_width->set_isarray(false); 9017 arg_width->set_type(GLMessage::DataType::INT); 9018 arg_width->add_intvalue(width); 9019 9020 // copy argument height 9021 GLMessage_DataType *arg_height = glmsg.add_args(); 9022 arg_height->set_isarray(false); 9023 arg_height->set_type(GLMessage::DataType::INT); 9024 arg_height->add_intvalue(height); 9025 9026 // copy argument depth 9027 GLMessage_DataType *arg_depth = glmsg.add_args(); 9028 arg_depth->set_isarray(false); 9029 arg_depth->set_type(GLMessage::DataType::INT); 9030 arg_depth->add_intvalue(depth); 9031 9032 // call function 9033 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9034 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9035 glContext->hooks->gl.glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth); 9036 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9037 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9038 9039 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9040 threadStartTime, threadEndTime, 9041 &glmsg); 9042 glContext->traceGLMessage(&glmsg); 9043} 9044 9045void GLTrace_glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { 9046 GLMessage glmsg; 9047 GLTraceContext *glContext = getGLTraceContext(); 9048 9049 glmsg.set_function(GLMessage::glRenderbufferStorageMultisampleIMG); 9050 9051 // copy argument target 9052 GLMessage_DataType *arg_target = glmsg.add_args(); 9053 arg_target->set_isarray(false); 9054 arg_target->set_type(GLMessage::DataType::ENUM); 9055 arg_target->add_intvalue((int)target); 9056 9057 // copy argument samples 9058 GLMessage_DataType *arg_samples = glmsg.add_args(); 9059 arg_samples->set_isarray(false); 9060 arg_samples->set_type(GLMessage::DataType::INT); 9061 arg_samples->add_intvalue(samples); 9062 9063 // copy argument internalformat 9064 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 9065 arg_internalformat->set_isarray(false); 9066 arg_internalformat->set_type(GLMessage::DataType::ENUM); 9067 arg_internalformat->add_intvalue((int)internalformat); 9068 9069 // copy argument width 9070 GLMessage_DataType *arg_width = glmsg.add_args(); 9071 arg_width->set_isarray(false); 9072 arg_width->set_type(GLMessage::DataType::INT); 9073 arg_width->add_intvalue(width); 9074 9075 // copy argument height 9076 GLMessage_DataType *arg_height = glmsg.add_args(); 9077 arg_height->set_isarray(false); 9078 arg_height->set_type(GLMessage::DataType::INT); 9079 arg_height->add_intvalue(height); 9080 9081 // call function 9082 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9083 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9084 glContext->hooks->gl.glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height); 9085 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9086 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9087 9088 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9089 threadStartTime, threadEndTime, 9090 &glmsg); 9091 glContext->traceGLMessage(&glmsg); 9092} 9093 9094void GLTrace_glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) { 9095 GLMessage glmsg; 9096 GLTraceContext *glContext = getGLTraceContext(); 9097 9098 glmsg.set_function(GLMessage::glFramebufferTexture2DMultisampleIMG); 9099 9100 // copy argument target 9101 GLMessage_DataType *arg_target = glmsg.add_args(); 9102 arg_target->set_isarray(false); 9103 arg_target->set_type(GLMessage::DataType::ENUM); 9104 arg_target->add_intvalue((int)target); 9105 9106 // copy argument attachment 9107 GLMessage_DataType *arg_attachment = glmsg.add_args(); 9108 arg_attachment->set_isarray(false); 9109 arg_attachment->set_type(GLMessage::DataType::ENUM); 9110 arg_attachment->add_intvalue((int)attachment); 9111 9112 // copy argument textarget 9113 GLMessage_DataType *arg_textarget = glmsg.add_args(); 9114 arg_textarget->set_isarray(false); 9115 arg_textarget->set_type(GLMessage::DataType::ENUM); 9116 arg_textarget->add_intvalue((int)textarget); 9117 9118 // copy argument texture 9119 GLMessage_DataType *arg_texture = glmsg.add_args(); 9120 arg_texture->set_isarray(false); 9121 arg_texture->set_type(GLMessage::DataType::INT); 9122 arg_texture->add_intvalue(texture); 9123 9124 // copy argument level 9125 GLMessage_DataType *arg_level = glmsg.add_args(); 9126 arg_level->set_isarray(false); 9127 arg_level->set_type(GLMessage::DataType::INT); 9128 arg_level->add_intvalue(level); 9129 9130 // copy argument samples 9131 GLMessage_DataType *arg_samples = glmsg.add_args(); 9132 arg_samples->set_isarray(false); 9133 arg_samples->set_type(GLMessage::DataType::INT); 9134 arg_samples->add_intvalue(samples); 9135 9136 // call function 9137 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9138 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9139 glContext->hooks->gl.glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples); 9140 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9141 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9142 9143 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9144 threadStartTime, threadEndTime, 9145 &glmsg); 9146 glContext->traceGLMessage(&glmsg); 9147} 9148 9149void GLTrace_glCoverageMaskNV(GLboolean mask) { 9150 GLMessage glmsg; 9151 GLTraceContext *glContext = getGLTraceContext(); 9152 9153 glmsg.set_function(GLMessage::glCoverageMaskNV); 9154 9155 // copy argument mask 9156 GLMessage_DataType *arg_mask = glmsg.add_args(); 9157 arg_mask->set_isarray(false); 9158 arg_mask->set_type(GLMessage::DataType::BOOL); 9159 arg_mask->add_boolvalue(mask); 9160 9161 // call function 9162 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9163 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9164 glContext->hooks->gl.glCoverageMaskNV(mask); 9165 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9166 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9167 9168 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9169 threadStartTime, threadEndTime, 9170 &glmsg); 9171 glContext->traceGLMessage(&glmsg); 9172} 9173 9174void GLTrace_glCoverageOperationNV(GLenum operation) { 9175 GLMessage glmsg; 9176 GLTraceContext *glContext = getGLTraceContext(); 9177 9178 glmsg.set_function(GLMessage::glCoverageOperationNV); 9179 9180 // copy argument operation 9181 GLMessage_DataType *arg_operation = glmsg.add_args(); 9182 arg_operation->set_isarray(false); 9183 arg_operation->set_type(GLMessage::DataType::ENUM); 9184 arg_operation->add_intvalue((int)operation); 9185 9186 // call function 9187 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9188 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9189 glContext->hooks->gl.glCoverageOperationNV(operation); 9190 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9191 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9192 9193 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9194 threadStartTime, threadEndTime, 9195 &glmsg); 9196 glContext->traceGLMessage(&glmsg); 9197} 9198 9199void GLTrace_glDrawBuffersNV(GLsizei n, const GLenum *bufs) { 9200 GLMessage glmsg; 9201 GLTraceContext *glContext = getGLTraceContext(); 9202 9203 glmsg.set_function(GLMessage::glDrawBuffersNV); 9204 9205 // copy argument n 9206 GLMessage_DataType *arg_n = glmsg.add_args(); 9207 arg_n->set_isarray(false); 9208 arg_n->set_type(GLMessage::DataType::INT); 9209 arg_n->add_intvalue(n); 9210 9211 // copy argument bufs 9212 GLMessage_DataType *arg_bufs = glmsg.add_args(); 9213 arg_bufs->set_isarray(false); 9214 arg_bufs->set_type(GLMessage::DataType::INT); 9215 arg_bufs->add_intvalue((int)bufs); 9216 9217 // call function 9218 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9219 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9220 glContext->hooks->gl.glDrawBuffersNV(n, bufs); 9221 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9222 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9223 9224 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9225 threadStartTime, threadEndTime, 9226 &glmsg); 9227 glContext->traceGLMessage(&glmsg); 9228} 9229 9230void GLTrace_glDeleteFencesNV(GLsizei n, const GLuint *fences) { 9231 GLMessage glmsg; 9232 GLTraceContext *glContext = getGLTraceContext(); 9233 9234 glmsg.set_function(GLMessage::glDeleteFencesNV); 9235 9236 // copy argument n 9237 GLMessage_DataType *arg_n = glmsg.add_args(); 9238 arg_n->set_isarray(false); 9239 arg_n->set_type(GLMessage::DataType::INT); 9240 arg_n->add_intvalue(n); 9241 9242 // copy argument fences 9243 GLMessage_DataType *arg_fences = glmsg.add_args(); 9244 arg_fences->set_isarray(false); 9245 arg_fences->set_type(GLMessage::DataType::INT); 9246 arg_fences->add_intvalue((int)fences); 9247 9248 // call function 9249 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9250 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9251 glContext->hooks->gl.glDeleteFencesNV(n, fences); 9252 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9253 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9254 9255 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9256 threadStartTime, threadEndTime, 9257 &glmsg); 9258 glContext->traceGLMessage(&glmsg); 9259} 9260 9261void GLTrace_glGenFencesNV(GLsizei n, GLuint *fences) { 9262 GLMessage glmsg; 9263 GLTraceContext *glContext = getGLTraceContext(); 9264 9265 glmsg.set_function(GLMessage::glGenFencesNV); 9266 9267 // copy argument n 9268 GLMessage_DataType *arg_n = glmsg.add_args(); 9269 arg_n->set_isarray(false); 9270 arg_n->set_type(GLMessage::DataType::INT); 9271 arg_n->add_intvalue(n); 9272 9273 // copy argument fences 9274 GLMessage_DataType *arg_fences = glmsg.add_args(); 9275 arg_fences->set_isarray(false); 9276 arg_fences->set_type(GLMessage::DataType::INT); 9277 arg_fences->add_intvalue((int)fences); 9278 9279 // call function 9280 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9281 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9282 glContext->hooks->gl.glGenFencesNV(n, fences); 9283 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9284 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9285 9286 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9287 threadStartTime, threadEndTime, 9288 &glmsg); 9289 glContext->traceGLMessage(&glmsg); 9290} 9291 9292GLboolean GLTrace_glIsFenceNV(GLuint fence) { 9293 GLMessage glmsg; 9294 GLTraceContext *glContext = getGLTraceContext(); 9295 9296 glmsg.set_function(GLMessage::glIsFenceNV); 9297 9298 // copy argument fence 9299 GLMessage_DataType *arg_fence = glmsg.add_args(); 9300 arg_fence->set_isarray(false); 9301 arg_fence->set_type(GLMessage::DataType::INT); 9302 arg_fence->add_intvalue(fence); 9303 9304 // call function 9305 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9306 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9307 GLboolean retValue = glContext->hooks->gl.glIsFenceNV(fence); 9308 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9309 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9310 9311 // set return value 9312 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 9313 rt->set_isarray(false); 9314 rt->set_type(GLMessage::DataType::BOOL); 9315 rt->add_boolvalue(retValue); 9316 9317 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9318 threadStartTime, threadEndTime, 9319 &glmsg); 9320 glContext->traceGLMessage(&glmsg); 9321 9322 return retValue; 9323} 9324 9325GLboolean GLTrace_glTestFenceNV(GLuint fence) { 9326 GLMessage glmsg; 9327 GLTraceContext *glContext = getGLTraceContext(); 9328 9329 glmsg.set_function(GLMessage::glTestFenceNV); 9330 9331 // copy argument fence 9332 GLMessage_DataType *arg_fence = glmsg.add_args(); 9333 arg_fence->set_isarray(false); 9334 arg_fence->set_type(GLMessage::DataType::INT); 9335 arg_fence->add_intvalue(fence); 9336 9337 // call function 9338 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9339 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9340 GLboolean retValue = glContext->hooks->gl.glTestFenceNV(fence); 9341 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9342 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9343 9344 // set return value 9345 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 9346 rt->set_isarray(false); 9347 rt->set_type(GLMessage::DataType::BOOL); 9348 rt->add_boolvalue(retValue); 9349 9350 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9351 threadStartTime, threadEndTime, 9352 &glmsg); 9353 glContext->traceGLMessage(&glmsg); 9354 9355 return retValue; 9356} 9357 9358void GLTrace_glGetFenceivNV(GLuint fence, GLenum pname, GLint *params) { 9359 GLMessage glmsg; 9360 GLTraceContext *glContext = getGLTraceContext(); 9361 9362 glmsg.set_function(GLMessage::glGetFenceivNV); 9363 9364 // copy argument fence 9365 GLMessage_DataType *arg_fence = glmsg.add_args(); 9366 arg_fence->set_isarray(false); 9367 arg_fence->set_type(GLMessage::DataType::INT); 9368 arg_fence->add_intvalue(fence); 9369 9370 // copy argument pname 9371 GLMessage_DataType *arg_pname = glmsg.add_args(); 9372 arg_pname->set_isarray(false); 9373 arg_pname->set_type(GLMessage::DataType::ENUM); 9374 arg_pname->add_intvalue((int)pname); 9375 9376 // copy argument params 9377 GLMessage_DataType *arg_params = glmsg.add_args(); 9378 arg_params->set_isarray(false); 9379 arg_params->set_type(GLMessage::DataType::INT); 9380 arg_params->add_intvalue((int)params); 9381 9382 // call function 9383 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9384 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9385 glContext->hooks->gl.glGetFenceivNV(fence, pname, params); 9386 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9387 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9388 9389 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9390 threadStartTime, threadEndTime, 9391 &glmsg); 9392 glContext->traceGLMessage(&glmsg); 9393} 9394 9395void GLTrace_glFinishFenceNV(GLuint fence) { 9396 GLMessage glmsg; 9397 GLTraceContext *glContext = getGLTraceContext(); 9398 9399 glmsg.set_function(GLMessage::glFinishFenceNV); 9400 9401 // copy argument fence 9402 GLMessage_DataType *arg_fence = glmsg.add_args(); 9403 arg_fence->set_isarray(false); 9404 arg_fence->set_type(GLMessage::DataType::INT); 9405 arg_fence->add_intvalue(fence); 9406 9407 // call function 9408 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9409 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9410 glContext->hooks->gl.glFinishFenceNV(fence); 9411 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9412 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9413 9414 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9415 threadStartTime, threadEndTime, 9416 &glmsg); 9417 glContext->traceGLMessage(&glmsg); 9418} 9419 9420void GLTrace_glSetFenceNV(GLuint fence, GLenum condition) { 9421 GLMessage glmsg; 9422 GLTraceContext *glContext = getGLTraceContext(); 9423 9424 glmsg.set_function(GLMessage::glSetFenceNV); 9425 9426 // copy argument fence 9427 GLMessage_DataType *arg_fence = glmsg.add_args(); 9428 arg_fence->set_isarray(false); 9429 arg_fence->set_type(GLMessage::DataType::INT); 9430 arg_fence->add_intvalue(fence); 9431 9432 // copy argument condition 9433 GLMessage_DataType *arg_condition = glmsg.add_args(); 9434 arg_condition->set_isarray(false); 9435 arg_condition->set_type(GLMessage::DataType::ENUM); 9436 arg_condition->add_intvalue((int)condition); 9437 9438 // call function 9439 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9440 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9441 glContext->hooks->gl.glSetFenceNV(fence, condition); 9442 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9443 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9444 9445 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9446 threadStartTime, threadEndTime, 9447 &glmsg); 9448 glContext->traceGLMessage(&glmsg); 9449} 9450 9451void GLTrace_glReadBufferNV(GLenum mode) { 9452 GLMessage glmsg; 9453 GLTraceContext *glContext = getGLTraceContext(); 9454 9455 glmsg.set_function(GLMessage::glReadBufferNV); 9456 9457 // copy argument mode 9458 GLMessage_DataType *arg_mode = glmsg.add_args(); 9459 arg_mode->set_isarray(false); 9460 arg_mode->set_type(GLMessage::DataType::ENUM); 9461 arg_mode->add_intvalue((int)mode); 9462 9463 // call function 9464 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9465 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9466 glContext->hooks->gl.glReadBufferNV(mode); 9467 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9468 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9469 9470 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9471 threadStartTime, threadEndTime, 9472 &glmsg); 9473 glContext->traceGLMessage(&glmsg); 9474} 9475 9476void GLTrace_glAlphaFuncQCOM(GLenum func, GLclampf ref) { 9477 GLMessage glmsg; 9478 GLTraceContext *glContext = getGLTraceContext(); 9479 9480 glmsg.set_function(GLMessage::glAlphaFuncQCOM); 9481 9482 // copy argument func 9483 GLMessage_DataType *arg_func = glmsg.add_args(); 9484 arg_func->set_isarray(false); 9485 arg_func->set_type(GLMessage::DataType::ENUM); 9486 arg_func->add_intvalue((int)func); 9487 9488 // copy argument ref 9489 GLMessage_DataType *arg_ref = glmsg.add_args(); 9490 arg_ref->set_isarray(false); 9491 arg_ref->set_type(GLMessage::DataType::FLOAT); 9492 arg_ref->add_floatvalue(ref); 9493 9494 // call function 9495 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9496 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9497 glContext->hooks->gl.glAlphaFuncQCOM(func, ref); 9498 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9499 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9500 9501 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9502 threadStartTime, threadEndTime, 9503 &glmsg); 9504 glContext->traceGLMessage(&glmsg); 9505} 9506 9507void GLTrace_glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls) { 9508 GLMessage glmsg; 9509 GLTraceContext *glContext = getGLTraceContext(); 9510 9511 glmsg.set_function(GLMessage::glGetDriverControlsQCOM); 9512 9513 // copy argument num 9514 GLMessage_DataType *arg_num = glmsg.add_args(); 9515 arg_num->set_isarray(false); 9516 arg_num->set_type(GLMessage::DataType::INT); 9517 arg_num->add_intvalue((int)num); 9518 9519 // copy argument size 9520 GLMessage_DataType *arg_size = glmsg.add_args(); 9521 arg_size->set_isarray(false); 9522 arg_size->set_type(GLMessage::DataType::INT); 9523 arg_size->add_intvalue(size); 9524 9525 // copy argument driverControls 9526 GLMessage_DataType *arg_driverControls = glmsg.add_args(); 9527 arg_driverControls->set_isarray(false); 9528 arg_driverControls->set_type(GLMessage::DataType::INT); 9529 arg_driverControls->add_intvalue((int)driverControls); 9530 9531 // call function 9532 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9533 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9534 glContext->hooks->gl.glGetDriverControlsQCOM(num, size, driverControls); 9535 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9536 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9537 9538 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9539 threadStartTime, threadEndTime, 9540 &glmsg); 9541 glContext->traceGLMessage(&glmsg); 9542} 9543 9544void GLTrace_glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString) { 9545 GLMessage glmsg; 9546 GLTraceContext *glContext = getGLTraceContext(); 9547 9548 glmsg.set_function(GLMessage::glGetDriverControlStringQCOM); 9549 9550 // copy argument driverControl 9551 GLMessage_DataType *arg_driverControl = glmsg.add_args(); 9552 arg_driverControl->set_isarray(false); 9553 arg_driverControl->set_type(GLMessage::DataType::INT); 9554 arg_driverControl->add_intvalue(driverControl); 9555 9556 // copy argument bufSize 9557 GLMessage_DataType *arg_bufSize = glmsg.add_args(); 9558 arg_bufSize->set_isarray(false); 9559 arg_bufSize->set_type(GLMessage::DataType::INT); 9560 arg_bufSize->add_intvalue(bufSize); 9561 9562 // copy argument length 9563 GLMessage_DataType *arg_length = glmsg.add_args(); 9564 arg_length->set_isarray(false); 9565 arg_length->set_type(GLMessage::DataType::INT); 9566 arg_length->add_intvalue((int)length); 9567 9568 // copy argument driverControlString 9569 GLMessage_DataType *arg_driverControlString = glmsg.add_args(); 9570 arg_driverControlString->set_isarray(false); 9571 arg_driverControlString->set_type(GLMessage::DataType::INT); 9572 arg_driverControlString->add_intvalue((int)driverControlString); 9573 9574 // call function 9575 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9576 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9577 glContext->hooks->gl.glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString); 9578 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9579 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9580 9581 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9582 threadStartTime, threadEndTime, 9583 &glmsg); 9584 glContext->traceGLMessage(&glmsg); 9585} 9586 9587void GLTrace_glEnableDriverControlQCOM(GLuint driverControl) { 9588 GLMessage glmsg; 9589 GLTraceContext *glContext = getGLTraceContext(); 9590 9591 glmsg.set_function(GLMessage::glEnableDriverControlQCOM); 9592 9593 // copy argument driverControl 9594 GLMessage_DataType *arg_driverControl = glmsg.add_args(); 9595 arg_driverControl->set_isarray(false); 9596 arg_driverControl->set_type(GLMessage::DataType::INT); 9597 arg_driverControl->add_intvalue(driverControl); 9598 9599 // call function 9600 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9601 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9602 glContext->hooks->gl.glEnableDriverControlQCOM(driverControl); 9603 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9604 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9605 9606 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9607 threadStartTime, threadEndTime, 9608 &glmsg); 9609 glContext->traceGLMessage(&glmsg); 9610} 9611 9612void GLTrace_glDisableDriverControlQCOM(GLuint driverControl) { 9613 GLMessage glmsg; 9614 GLTraceContext *glContext = getGLTraceContext(); 9615 9616 glmsg.set_function(GLMessage::glDisableDriverControlQCOM); 9617 9618 // copy argument driverControl 9619 GLMessage_DataType *arg_driverControl = glmsg.add_args(); 9620 arg_driverControl->set_isarray(false); 9621 arg_driverControl->set_type(GLMessage::DataType::INT); 9622 arg_driverControl->add_intvalue(driverControl); 9623 9624 // call function 9625 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9626 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9627 glContext->hooks->gl.glDisableDriverControlQCOM(driverControl); 9628 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9629 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9630 9631 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9632 threadStartTime, threadEndTime, 9633 &glmsg); 9634 glContext->traceGLMessage(&glmsg); 9635} 9636 9637void GLTrace_glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures) { 9638 GLMessage glmsg; 9639 GLTraceContext *glContext = getGLTraceContext(); 9640 9641 glmsg.set_function(GLMessage::glExtGetTexturesQCOM); 9642 9643 // copy argument textures 9644 GLMessage_DataType *arg_textures = glmsg.add_args(); 9645 arg_textures->set_isarray(false); 9646 arg_textures->set_type(GLMessage::DataType::INT); 9647 arg_textures->add_intvalue((int)textures); 9648 9649 // copy argument maxTextures 9650 GLMessage_DataType *arg_maxTextures = glmsg.add_args(); 9651 arg_maxTextures->set_isarray(false); 9652 arg_maxTextures->set_type(GLMessage::DataType::INT); 9653 arg_maxTextures->add_intvalue(maxTextures); 9654 9655 // copy argument numTextures 9656 GLMessage_DataType *arg_numTextures = glmsg.add_args(); 9657 arg_numTextures->set_isarray(false); 9658 arg_numTextures->set_type(GLMessage::DataType::INT); 9659 arg_numTextures->add_intvalue((int)numTextures); 9660 9661 // call function 9662 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9663 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9664 glContext->hooks->gl.glExtGetTexturesQCOM(textures, maxTextures, numTextures); 9665 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9666 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9667 9668 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9669 threadStartTime, threadEndTime, 9670 &glmsg); 9671 glContext->traceGLMessage(&glmsg); 9672} 9673 9674void GLTrace_glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers) { 9675 GLMessage glmsg; 9676 GLTraceContext *glContext = getGLTraceContext(); 9677 9678 glmsg.set_function(GLMessage::glExtGetBuffersQCOM); 9679 9680 // copy argument buffers 9681 GLMessage_DataType *arg_buffers = glmsg.add_args(); 9682 arg_buffers->set_isarray(false); 9683 arg_buffers->set_type(GLMessage::DataType::INT); 9684 arg_buffers->add_intvalue((int)buffers); 9685 9686 // copy argument maxBuffers 9687 GLMessage_DataType *arg_maxBuffers = glmsg.add_args(); 9688 arg_maxBuffers->set_isarray(false); 9689 arg_maxBuffers->set_type(GLMessage::DataType::INT); 9690 arg_maxBuffers->add_intvalue(maxBuffers); 9691 9692 // copy argument numBuffers 9693 GLMessage_DataType *arg_numBuffers = glmsg.add_args(); 9694 arg_numBuffers->set_isarray(false); 9695 arg_numBuffers->set_type(GLMessage::DataType::INT); 9696 arg_numBuffers->add_intvalue((int)numBuffers); 9697 9698 // call function 9699 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9700 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9701 glContext->hooks->gl.glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers); 9702 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9703 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9704 9705 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9706 threadStartTime, threadEndTime, 9707 &glmsg); 9708 glContext->traceGLMessage(&glmsg); 9709} 9710 9711void GLTrace_glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers) { 9712 GLMessage glmsg; 9713 GLTraceContext *glContext = getGLTraceContext(); 9714 9715 glmsg.set_function(GLMessage::glExtGetRenderbuffersQCOM); 9716 9717 // copy argument renderbuffers 9718 GLMessage_DataType *arg_renderbuffers = glmsg.add_args(); 9719 arg_renderbuffers->set_isarray(false); 9720 arg_renderbuffers->set_type(GLMessage::DataType::INT); 9721 arg_renderbuffers->add_intvalue((int)renderbuffers); 9722 9723 // copy argument maxRenderbuffers 9724 GLMessage_DataType *arg_maxRenderbuffers = glmsg.add_args(); 9725 arg_maxRenderbuffers->set_isarray(false); 9726 arg_maxRenderbuffers->set_type(GLMessage::DataType::INT); 9727 arg_maxRenderbuffers->add_intvalue(maxRenderbuffers); 9728 9729 // copy argument numRenderbuffers 9730 GLMessage_DataType *arg_numRenderbuffers = glmsg.add_args(); 9731 arg_numRenderbuffers->set_isarray(false); 9732 arg_numRenderbuffers->set_type(GLMessage::DataType::INT); 9733 arg_numRenderbuffers->add_intvalue((int)numRenderbuffers); 9734 9735 // call function 9736 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9737 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9738 glContext->hooks->gl.glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers); 9739 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9740 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9741 9742 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9743 threadStartTime, threadEndTime, 9744 &glmsg); 9745 glContext->traceGLMessage(&glmsg); 9746} 9747 9748void GLTrace_glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers) { 9749 GLMessage glmsg; 9750 GLTraceContext *glContext = getGLTraceContext(); 9751 9752 glmsg.set_function(GLMessage::glExtGetFramebuffersQCOM); 9753 9754 // copy argument framebuffers 9755 GLMessage_DataType *arg_framebuffers = glmsg.add_args(); 9756 arg_framebuffers->set_isarray(false); 9757 arg_framebuffers->set_type(GLMessage::DataType::INT); 9758 arg_framebuffers->add_intvalue((int)framebuffers); 9759 9760 // copy argument maxFramebuffers 9761 GLMessage_DataType *arg_maxFramebuffers = glmsg.add_args(); 9762 arg_maxFramebuffers->set_isarray(false); 9763 arg_maxFramebuffers->set_type(GLMessage::DataType::INT); 9764 arg_maxFramebuffers->add_intvalue(maxFramebuffers); 9765 9766 // copy argument numFramebuffers 9767 GLMessage_DataType *arg_numFramebuffers = glmsg.add_args(); 9768 arg_numFramebuffers->set_isarray(false); 9769 arg_numFramebuffers->set_type(GLMessage::DataType::INT); 9770 arg_numFramebuffers->add_intvalue((int)numFramebuffers); 9771 9772 // call function 9773 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9774 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9775 glContext->hooks->gl.glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers); 9776 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9777 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9778 9779 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9780 threadStartTime, threadEndTime, 9781 &glmsg); 9782 glContext->traceGLMessage(&glmsg); 9783} 9784 9785void GLTrace_glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params) { 9786 GLMessage glmsg; 9787 GLTraceContext *glContext = getGLTraceContext(); 9788 9789 glmsg.set_function(GLMessage::glExtGetTexLevelParameterivQCOM); 9790 9791 // copy argument texture 9792 GLMessage_DataType *arg_texture = glmsg.add_args(); 9793 arg_texture->set_isarray(false); 9794 arg_texture->set_type(GLMessage::DataType::INT); 9795 arg_texture->add_intvalue(texture); 9796 9797 // copy argument face 9798 GLMessage_DataType *arg_face = glmsg.add_args(); 9799 arg_face->set_isarray(false); 9800 arg_face->set_type(GLMessage::DataType::ENUM); 9801 arg_face->add_intvalue((int)face); 9802 9803 // copy argument level 9804 GLMessage_DataType *arg_level = glmsg.add_args(); 9805 arg_level->set_isarray(false); 9806 arg_level->set_type(GLMessage::DataType::INT); 9807 arg_level->add_intvalue(level); 9808 9809 // copy argument pname 9810 GLMessage_DataType *arg_pname = glmsg.add_args(); 9811 arg_pname->set_isarray(false); 9812 arg_pname->set_type(GLMessage::DataType::ENUM); 9813 arg_pname->add_intvalue((int)pname); 9814 9815 // copy argument params 9816 GLMessage_DataType *arg_params = glmsg.add_args(); 9817 arg_params->set_isarray(false); 9818 arg_params->set_type(GLMessage::DataType::INT); 9819 arg_params->add_intvalue((int)params); 9820 9821 // call function 9822 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9823 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9824 glContext->hooks->gl.glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params); 9825 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9826 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9827 9828 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9829 threadStartTime, threadEndTime, 9830 &glmsg); 9831 glContext->traceGLMessage(&glmsg); 9832} 9833 9834void GLTrace_glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param) { 9835 GLMessage glmsg; 9836 GLTraceContext *glContext = getGLTraceContext(); 9837 9838 glmsg.set_function(GLMessage::glExtTexObjectStateOverrideiQCOM); 9839 9840 // copy argument target 9841 GLMessage_DataType *arg_target = glmsg.add_args(); 9842 arg_target->set_isarray(false); 9843 arg_target->set_type(GLMessage::DataType::ENUM); 9844 arg_target->add_intvalue((int)target); 9845 9846 // copy argument pname 9847 GLMessage_DataType *arg_pname = glmsg.add_args(); 9848 arg_pname->set_isarray(false); 9849 arg_pname->set_type(GLMessage::DataType::ENUM); 9850 arg_pname->add_intvalue((int)pname); 9851 9852 // copy argument param 9853 GLMessage_DataType *arg_param = glmsg.add_args(); 9854 arg_param->set_isarray(false); 9855 arg_param->set_type(GLMessage::DataType::INT); 9856 arg_param->add_intvalue(param); 9857 9858 // call function 9859 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9860 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9861 glContext->hooks->gl.glExtTexObjectStateOverrideiQCOM(target, pname, param); 9862 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9863 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9864 9865 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9866 threadStartTime, threadEndTime, 9867 &glmsg); 9868 glContext->traceGLMessage(&glmsg); 9869} 9870 9871void GLTrace_glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels) { 9872 GLMessage glmsg; 9873 GLTraceContext *glContext = getGLTraceContext(); 9874 9875 glmsg.set_function(GLMessage::glExtGetTexSubImageQCOM); 9876 9877 // copy argument target 9878 GLMessage_DataType *arg_target = glmsg.add_args(); 9879 arg_target->set_isarray(false); 9880 arg_target->set_type(GLMessage::DataType::ENUM); 9881 arg_target->add_intvalue((int)target); 9882 9883 // copy argument level 9884 GLMessage_DataType *arg_level = glmsg.add_args(); 9885 arg_level->set_isarray(false); 9886 arg_level->set_type(GLMessage::DataType::INT); 9887 arg_level->add_intvalue(level); 9888 9889 // copy argument xoffset 9890 GLMessage_DataType *arg_xoffset = glmsg.add_args(); 9891 arg_xoffset->set_isarray(false); 9892 arg_xoffset->set_type(GLMessage::DataType::INT); 9893 arg_xoffset->add_intvalue(xoffset); 9894 9895 // copy argument yoffset 9896 GLMessage_DataType *arg_yoffset = glmsg.add_args(); 9897 arg_yoffset->set_isarray(false); 9898 arg_yoffset->set_type(GLMessage::DataType::INT); 9899 arg_yoffset->add_intvalue(yoffset); 9900 9901 // copy argument zoffset 9902 GLMessage_DataType *arg_zoffset = glmsg.add_args(); 9903 arg_zoffset->set_isarray(false); 9904 arg_zoffset->set_type(GLMessage::DataType::INT); 9905 arg_zoffset->add_intvalue(zoffset); 9906 9907 // copy argument width 9908 GLMessage_DataType *arg_width = glmsg.add_args(); 9909 arg_width->set_isarray(false); 9910 arg_width->set_type(GLMessage::DataType::INT); 9911 arg_width->add_intvalue(width); 9912 9913 // copy argument height 9914 GLMessage_DataType *arg_height = glmsg.add_args(); 9915 arg_height->set_isarray(false); 9916 arg_height->set_type(GLMessage::DataType::INT); 9917 arg_height->add_intvalue(height); 9918 9919 // copy argument depth 9920 GLMessage_DataType *arg_depth = glmsg.add_args(); 9921 arg_depth->set_isarray(false); 9922 arg_depth->set_type(GLMessage::DataType::INT); 9923 arg_depth->add_intvalue(depth); 9924 9925 // copy argument format 9926 GLMessage_DataType *arg_format = glmsg.add_args(); 9927 arg_format->set_isarray(false); 9928 arg_format->set_type(GLMessage::DataType::ENUM); 9929 arg_format->add_intvalue((int)format); 9930 9931 // copy argument type 9932 GLMessage_DataType *arg_type = glmsg.add_args(); 9933 arg_type->set_isarray(false); 9934 arg_type->set_type(GLMessage::DataType::ENUM); 9935 arg_type->add_intvalue((int)type); 9936 9937 // copy argument texels 9938 GLMessage_DataType *arg_texels = glmsg.add_args(); 9939 arg_texels->set_isarray(false); 9940 arg_texels->set_type(GLMessage::DataType::INT); 9941 arg_texels->add_intvalue((int)texels); 9942 9943 // call function 9944 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9945 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9946 glContext->hooks->gl.glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels); 9947 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9948 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9949 9950 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9951 threadStartTime, threadEndTime, 9952 &glmsg); 9953 glContext->traceGLMessage(&glmsg); 9954} 9955 9956void GLTrace_glExtGetBufferPointervQCOM(GLenum target, GLvoid **params) { 9957 GLMessage glmsg; 9958 GLTraceContext *glContext = getGLTraceContext(); 9959 9960 glmsg.set_function(GLMessage::glExtGetBufferPointervQCOM); 9961 9962 // copy argument target 9963 GLMessage_DataType *arg_target = glmsg.add_args(); 9964 arg_target->set_isarray(false); 9965 arg_target->set_type(GLMessage::DataType::ENUM); 9966 arg_target->add_intvalue((int)target); 9967 9968 // copy argument params 9969 GLMessage_DataType *arg_params = glmsg.add_args(); 9970 arg_params->set_isarray(false); 9971 arg_params->set_type(GLMessage::DataType::INT); 9972 arg_params->add_intvalue((int)params); 9973 9974 // call function 9975 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 9976 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 9977 glContext->hooks->gl.glExtGetBufferPointervQCOM(target, params); 9978 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 9979 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 9980 9981 fixupGLMessage(glContext, wallStartTime, wallEndTime, 9982 threadStartTime, threadEndTime, 9983 &glmsg); 9984 glContext->traceGLMessage(&glmsg); 9985} 9986 9987void GLTrace_glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders) { 9988 GLMessage glmsg; 9989 GLTraceContext *glContext = getGLTraceContext(); 9990 9991 glmsg.set_function(GLMessage::glExtGetShadersQCOM); 9992 9993 // copy argument shaders 9994 GLMessage_DataType *arg_shaders = glmsg.add_args(); 9995 arg_shaders->set_isarray(false); 9996 arg_shaders->set_type(GLMessage::DataType::INT); 9997 arg_shaders->add_intvalue((int)shaders); 9998 9999 // copy argument maxShaders 10000 GLMessage_DataType *arg_maxShaders = glmsg.add_args(); 10001 arg_maxShaders->set_isarray(false); 10002 arg_maxShaders->set_type(GLMessage::DataType::INT); 10003 arg_maxShaders->add_intvalue(maxShaders); 10004 10005 // copy argument numShaders 10006 GLMessage_DataType *arg_numShaders = glmsg.add_args(); 10007 arg_numShaders->set_isarray(false); 10008 arg_numShaders->set_type(GLMessage::DataType::INT); 10009 arg_numShaders->add_intvalue((int)numShaders); 10010 10011 // call function 10012 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10013 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10014 glContext->hooks->gl.glExtGetShadersQCOM(shaders, maxShaders, numShaders); 10015 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10016 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10017 10018 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10019 threadStartTime, threadEndTime, 10020 &glmsg); 10021 glContext->traceGLMessage(&glmsg); 10022} 10023 10024void GLTrace_glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms) { 10025 GLMessage glmsg; 10026 GLTraceContext *glContext = getGLTraceContext(); 10027 10028 glmsg.set_function(GLMessage::glExtGetProgramsQCOM); 10029 10030 // copy argument programs 10031 GLMessage_DataType *arg_programs = glmsg.add_args(); 10032 arg_programs->set_isarray(false); 10033 arg_programs->set_type(GLMessage::DataType::INT); 10034 arg_programs->add_intvalue((int)programs); 10035 10036 // copy argument maxPrograms 10037 GLMessage_DataType *arg_maxPrograms = glmsg.add_args(); 10038 arg_maxPrograms->set_isarray(false); 10039 arg_maxPrograms->set_type(GLMessage::DataType::INT); 10040 arg_maxPrograms->add_intvalue(maxPrograms); 10041 10042 // copy argument numPrograms 10043 GLMessage_DataType *arg_numPrograms = glmsg.add_args(); 10044 arg_numPrograms->set_isarray(false); 10045 arg_numPrograms->set_type(GLMessage::DataType::INT); 10046 arg_numPrograms->add_intvalue((int)numPrograms); 10047 10048 // call function 10049 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10050 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10051 glContext->hooks->gl.glExtGetProgramsQCOM(programs, maxPrograms, numPrograms); 10052 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10053 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10054 10055 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10056 threadStartTime, threadEndTime, 10057 &glmsg); 10058 glContext->traceGLMessage(&glmsg); 10059} 10060 10061GLboolean GLTrace_glExtIsProgramBinaryQCOM(GLuint program) { 10062 GLMessage glmsg; 10063 GLTraceContext *glContext = getGLTraceContext(); 10064 10065 glmsg.set_function(GLMessage::glExtIsProgramBinaryQCOM); 10066 10067 // copy argument program 10068 GLMessage_DataType *arg_program = glmsg.add_args(); 10069 arg_program->set_isarray(false); 10070 arg_program->set_type(GLMessage::DataType::INT); 10071 arg_program->add_intvalue(program); 10072 10073 // call function 10074 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10075 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10076 GLboolean retValue = glContext->hooks->gl.glExtIsProgramBinaryQCOM(program); 10077 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10078 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10079 10080 // set return value 10081 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 10082 rt->set_isarray(false); 10083 rt->set_type(GLMessage::DataType::BOOL); 10084 rt->add_boolvalue(retValue); 10085 10086 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10087 threadStartTime, threadEndTime, 10088 &glmsg); 10089 glContext->traceGLMessage(&glmsg); 10090 10091 return retValue; 10092} 10093 10094void GLTrace_glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length) { 10095 GLMessage glmsg; 10096 GLTraceContext *glContext = getGLTraceContext(); 10097 10098 glmsg.set_function(GLMessage::glExtGetProgramBinarySourceQCOM); 10099 10100 // copy argument program 10101 GLMessage_DataType *arg_program = glmsg.add_args(); 10102 arg_program->set_isarray(false); 10103 arg_program->set_type(GLMessage::DataType::INT); 10104 arg_program->add_intvalue(program); 10105 10106 // copy argument shadertype 10107 GLMessage_DataType *arg_shadertype = glmsg.add_args(); 10108 arg_shadertype->set_isarray(false); 10109 arg_shadertype->set_type(GLMessage::DataType::ENUM); 10110 arg_shadertype->add_intvalue((int)shadertype); 10111 10112 // copy argument source 10113 GLMessage_DataType *arg_source = glmsg.add_args(); 10114 arg_source->set_isarray(false); 10115 arg_source->set_type(GLMessage::DataType::INT); 10116 arg_source->add_intvalue((int)source); 10117 10118 // copy argument length 10119 GLMessage_DataType *arg_length = glmsg.add_args(); 10120 arg_length->set_isarray(false); 10121 arg_length->set_type(GLMessage::DataType::INT); 10122 arg_length->add_intvalue((int)length); 10123 10124 // call function 10125 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10126 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10127 glContext->hooks->gl.glExtGetProgramBinarySourceQCOM(program, shadertype, source, length); 10128 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10129 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10130 10131 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10132 threadStartTime, threadEndTime, 10133 &glmsg); 10134 glContext->traceGLMessage(&glmsg); 10135} 10136 10137void GLTrace_glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) { 10138 GLMessage glmsg; 10139 GLTraceContext *glContext = getGLTraceContext(); 10140 10141 glmsg.set_function(GLMessage::glStartTilingQCOM); 10142 10143 // copy argument x 10144 GLMessage_DataType *arg_x = glmsg.add_args(); 10145 arg_x->set_isarray(false); 10146 arg_x->set_type(GLMessage::DataType::INT); 10147 arg_x->add_intvalue(x); 10148 10149 // copy argument y 10150 GLMessage_DataType *arg_y = glmsg.add_args(); 10151 arg_y->set_isarray(false); 10152 arg_y->set_type(GLMessage::DataType::INT); 10153 arg_y->add_intvalue(y); 10154 10155 // copy argument width 10156 GLMessage_DataType *arg_width = glmsg.add_args(); 10157 arg_width->set_isarray(false); 10158 arg_width->set_type(GLMessage::DataType::INT); 10159 arg_width->add_intvalue(width); 10160 10161 // copy argument height 10162 GLMessage_DataType *arg_height = glmsg.add_args(); 10163 arg_height->set_isarray(false); 10164 arg_height->set_type(GLMessage::DataType::INT); 10165 arg_height->add_intvalue(height); 10166 10167 // copy argument preserveMask 10168 GLMessage_DataType *arg_preserveMask = glmsg.add_args(); 10169 arg_preserveMask->set_isarray(false); 10170 arg_preserveMask->set_type(GLMessage::DataType::INT); 10171 arg_preserveMask->add_intvalue(preserveMask); 10172 10173 // call function 10174 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10175 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10176 glContext->hooks->gl.glStartTilingQCOM(x, y, width, height, preserveMask); 10177 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10178 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10179 10180 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10181 threadStartTime, threadEndTime, 10182 &glmsg); 10183 glContext->traceGLMessage(&glmsg); 10184} 10185 10186void GLTrace_glEndTilingQCOM(GLbitfield preserveMask) { 10187 GLMessage glmsg; 10188 GLTraceContext *glContext = getGLTraceContext(); 10189 10190 glmsg.set_function(GLMessage::glEndTilingQCOM); 10191 10192 // copy argument preserveMask 10193 GLMessage_DataType *arg_preserveMask = glmsg.add_args(); 10194 arg_preserveMask->set_isarray(false); 10195 arg_preserveMask->set_type(GLMessage::DataType::INT); 10196 arg_preserveMask->add_intvalue(preserveMask); 10197 10198 // call function 10199 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10200 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10201 glContext->hooks->gl.glEndTilingQCOM(preserveMask); 10202 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10203 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10204 10205 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10206 threadStartTime, threadEndTime, 10207 &glmsg); 10208 glContext->traceGLMessage(&glmsg); 10209} 10210 10211 10212// Definitions for GL1 APIs 10213 10214void GLTrace_glAlphaFunc(GLenum func, GLclampf ref) { 10215 GLMessage glmsg; 10216 GLTraceContext *glContext = getGLTraceContext(); 10217 10218 glmsg.set_function(GLMessage::glAlphaFunc); 10219 10220 // copy argument func 10221 GLMessage_DataType *arg_func = glmsg.add_args(); 10222 arg_func->set_isarray(false); 10223 arg_func->set_type(GLMessage::DataType::ENUM); 10224 arg_func->add_intvalue((int)func); 10225 10226 // copy argument ref 10227 GLMessage_DataType *arg_ref = glmsg.add_args(); 10228 arg_ref->set_isarray(false); 10229 arg_ref->set_type(GLMessage::DataType::FLOAT); 10230 arg_ref->add_floatvalue(ref); 10231 10232 // call function 10233 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10234 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10235 glContext->hooks->gl.glAlphaFunc(func, ref); 10236 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10237 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10238 10239 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10240 threadStartTime, threadEndTime, 10241 &glmsg); 10242 glContext->traceGLMessage(&glmsg); 10243} 10244 10245void GLTrace_glClipPlanef(GLenum plane, const GLfloat *equation) { 10246 GLMessage glmsg; 10247 GLTraceContext *glContext = getGLTraceContext(); 10248 10249 glmsg.set_function(GLMessage::glClipPlanef); 10250 10251 // copy argument plane 10252 GLMessage_DataType *arg_plane = glmsg.add_args(); 10253 arg_plane->set_isarray(false); 10254 arg_plane->set_type(GLMessage::DataType::ENUM); 10255 arg_plane->add_intvalue((int)plane); 10256 10257 // copy argument equation 10258 GLMessage_DataType *arg_equation = glmsg.add_args(); 10259 arg_equation->set_isarray(false); 10260 arg_equation->set_type(GLMessage::DataType::INT); 10261 arg_equation->add_intvalue((int)equation); 10262 10263 // call function 10264 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10265 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10266 glContext->hooks->gl.glClipPlanef(plane, equation); 10267 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10268 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10269 10270 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10271 threadStartTime, threadEndTime, 10272 &glmsg); 10273 glContext->traceGLMessage(&glmsg); 10274} 10275 10276void GLTrace_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { 10277 GLMessage glmsg; 10278 GLTraceContext *glContext = getGLTraceContext(); 10279 10280 glmsg.set_function(GLMessage::glColor4f); 10281 10282 // copy argument red 10283 GLMessage_DataType *arg_red = glmsg.add_args(); 10284 arg_red->set_isarray(false); 10285 arg_red->set_type(GLMessage::DataType::FLOAT); 10286 arg_red->add_floatvalue(red); 10287 10288 // copy argument green 10289 GLMessage_DataType *arg_green = glmsg.add_args(); 10290 arg_green->set_isarray(false); 10291 arg_green->set_type(GLMessage::DataType::FLOAT); 10292 arg_green->add_floatvalue(green); 10293 10294 // copy argument blue 10295 GLMessage_DataType *arg_blue = glmsg.add_args(); 10296 arg_blue->set_isarray(false); 10297 arg_blue->set_type(GLMessage::DataType::FLOAT); 10298 arg_blue->add_floatvalue(blue); 10299 10300 // copy argument alpha 10301 GLMessage_DataType *arg_alpha = glmsg.add_args(); 10302 arg_alpha->set_isarray(false); 10303 arg_alpha->set_type(GLMessage::DataType::FLOAT); 10304 arg_alpha->add_floatvalue(alpha); 10305 10306 // call function 10307 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10308 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10309 glContext->hooks->gl.glColor4f(red, green, blue, alpha); 10310 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10311 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10312 10313 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10314 threadStartTime, threadEndTime, 10315 &glmsg); 10316 glContext->traceGLMessage(&glmsg); 10317} 10318 10319void GLTrace_glFogf(GLenum pname, GLfloat param) { 10320 GLMessage glmsg; 10321 GLTraceContext *glContext = getGLTraceContext(); 10322 10323 glmsg.set_function(GLMessage::glFogf); 10324 10325 // copy argument pname 10326 GLMessage_DataType *arg_pname = glmsg.add_args(); 10327 arg_pname->set_isarray(false); 10328 arg_pname->set_type(GLMessage::DataType::ENUM); 10329 arg_pname->add_intvalue((int)pname); 10330 10331 // copy argument param 10332 GLMessage_DataType *arg_param = glmsg.add_args(); 10333 arg_param->set_isarray(false); 10334 arg_param->set_type(GLMessage::DataType::FLOAT); 10335 arg_param->add_floatvalue(param); 10336 10337 // call function 10338 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10339 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10340 glContext->hooks->gl.glFogf(pname, param); 10341 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10342 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10343 10344 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10345 threadStartTime, threadEndTime, 10346 &glmsg); 10347 glContext->traceGLMessage(&glmsg); 10348} 10349 10350void GLTrace_glFogfv(GLenum pname, const GLfloat *params) { 10351 GLMessage glmsg; 10352 GLTraceContext *glContext = getGLTraceContext(); 10353 10354 glmsg.set_function(GLMessage::glFogfv); 10355 10356 // copy argument pname 10357 GLMessage_DataType *arg_pname = glmsg.add_args(); 10358 arg_pname->set_isarray(false); 10359 arg_pname->set_type(GLMessage::DataType::ENUM); 10360 arg_pname->add_intvalue((int)pname); 10361 10362 // copy argument params 10363 GLMessage_DataType *arg_params = glmsg.add_args(); 10364 arg_params->set_isarray(false); 10365 arg_params->set_type(GLMessage::DataType::INT); 10366 arg_params->add_intvalue((int)params); 10367 10368 // call function 10369 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10370 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10371 glContext->hooks->gl.glFogfv(pname, params); 10372 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10373 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10374 10375 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10376 threadStartTime, threadEndTime, 10377 &glmsg); 10378 glContext->traceGLMessage(&glmsg); 10379} 10380 10381void GLTrace_glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { 10382 GLMessage glmsg; 10383 GLTraceContext *glContext = getGLTraceContext(); 10384 10385 glmsg.set_function(GLMessage::glFrustumf); 10386 10387 // copy argument left 10388 GLMessage_DataType *arg_left = glmsg.add_args(); 10389 arg_left->set_isarray(false); 10390 arg_left->set_type(GLMessage::DataType::FLOAT); 10391 arg_left->add_floatvalue(left); 10392 10393 // copy argument right 10394 GLMessage_DataType *arg_right = glmsg.add_args(); 10395 arg_right->set_isarray(false); 10396 arg_right->set_type(GLMessage::DataType::FLOAT); 10397 arg_right->add_floatvalue(right); 10398 10399 // copy argument bottom 10400 GLMessage_DataType *arg_bottom = glmsg.add_args(); 10401 arg_bottom->set_isarray(false); 10402 arg_bottom->set_type(GLMessage::DataType::FLOAT); 10403 arg_bottom->add_floatvalue(bottom); 10404 10405 // copy argument top 10406 GLMessage_DataType *arg_top = glmsg.add_args(); 10407 arg_top->set_isarray(false); 10408 arg_top->set_type(GLMessage::DataType::FLOAT); 10409 arg_top->add_floatvalue(top); 10410 10411 // copy argument zNear 10412 GLMessage_DataType *arg_zNear = glmsg.add_args(); 10413 arg_zNear->set_isarray(false); 10414 arg_zNear->set_type(GLMessage::DataType::FLOAT); 10415 arg_zNear->add_floatvalue(zNear); 10416 10417 // copy argument zFar 10418 GLMessage_DataType *arg_zFar = glmsg.add_args(); 10419 arg_zFar->set_isarray(false); 10420 arg_zFar->set_type(GLMessage::DataType::FLOAT); 10421 arg_zFar->add_floatvalue(zFar); 10422 10423 // call function 10424 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10425 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10426 glContext->hooks->gl.glFrustumf(left, right, bottom, top, zNear, zFar); 10427 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10428 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10429 10430 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10431 threadStartTime, threadEndTime, 10432 &glmsg); 10433 glContext->traceGLMessage(&glmsg); 10434} 10435 10436void GLTrace_glGetClipPlanef(GLenum pname, GLfloat eqn[4]) { 10437 GLMessage glmsg; 10438 GLTraceContext *glContext = getGLTraceContext(); 10439 10440 glmsg.set_function(GLMessage::glGetClipPlanef); 10441 10442 // copy argument pname 10443 GLMessage_DataType *arg_pname = glmsg.add_args(); 10444 arg_pname->set_isarray(false); 10445 arg_pname->set_type(GLMessage::DataType::ENUM); 10446 arg_pname->add_intvalue((int)pname); 10447 10448 // copy argument eqn 10449 GLMessage_DataType *arg_eqn = glmsg.add_args(); 10450 arg_eqn->set_isarray(false); 10451 arg_eqn->set_type(GLMessage::DataType::INT); 10452 arg_eqn->add_intvalue((int)eqn); 10453 10454 // call function 10455 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10456 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10457 glContext->hooks->gl.glGetClipPlanef(pname, eqn); 10458 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10459 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10460 10461 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10462 threadStartTime, threadEndTime, 10463 &glmsg); 10464 glContext->traceGLMessage(&glmsg); 10465} 10466 10467void GLTrace_glGetLightfv(GLenum light, GLenum pname, GLfloat *params) { 10468 GLMessage glmsg; 10469 GLTraceContext *glContext = getGLTraceContext(); 10470 10471 glmsg.set_function(GLMessage::glGetLightfv); 10472 10473 // copy argument light 10474 GLMessage_DataType *arg_light = glmsg.add_args(); 10475 arg_light->set_isarray(false); 10476 arg_light->set_type(GLMessage::DataType::ENUM); 10477 arg_light->add_intvalue((int)light); 10478 10479 // copy argument pname 10480 GLMessage_DataType *arg_pname = glmsg.add_args(); 10481 arg_pname->set_isarray(false); 10482 arg_pname->set_type(GLMessage::DataType::ENUM); 10483 arg_pname->add_intvalue((int)pname); 10484 10485 // copy argument params 10486 GLMessage_DataType *arg_params = glmsg.add_args(); 10487 arg_params->set_isarray(false); 10488 arg_params->set_type(GLMessage::DataType::INT); 10489 arg_params->add_intvalue((int)params); 10490 10491 // call function 10492 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10493 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10494 glContext->hooks->gl.glGetLightfv(light, pname, params); 10495 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10496 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10497 10498 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10499 threadStartTime, threadEndTime, 10500 &glmsg); 10501 glContext->traceGLMessage(&glmsg); 10502} 10503 10504void GLTrace_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) { 10505 GLMessage glmsg; 10506 GLTraceContext *glContext = getGLTraceContext(); 10507 10508 glmsg.set_function(GLMessage::glGetMaterialfv); 10509 10510 // copy argument face 10511 GLMessage_DataType *arg_face = glmsg.add_args(); 10512 arg_face->set_isarray(false); 10513 arg_face->set_type(GLMessage::DataType::ENUM); 10514 arg_face->add_intvalue((int)face); 10515 10516 // copy argument pname 10517 GLMessage_DataType *arg_pname = glmsg.add_args(); 10518 arg_pname->set_isarray(false); 10519 arg_pname->set_type(GLMessage::DataType::ENUM); 10520 arg_pname->add_intvalue((int)pname); 10521 10522 // copy argument params 10523 GLMessage_DataType *arg_params = glmsg.add_args(); 10524 arg_params->set_isarray(false); 10525 arg_params->set_type(GLMessage::DataType::INT); 10526 arg_params->add_intvalue((int)params); 10527 10528 // call function 10529 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10530 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10531 glContext->hooks->gl.glGetMaterialfv(face, pname, params); 10532 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10533 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10534 10535 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10536 threadStartTime, threadEndTime, 10537 &glmsg); 10538 glContext->traceGLMessage(&glmsg); 10539} 10540 10541void GLTrace_glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params) { 10542 GLMessage glmsg; 10543 GLTraceContext *glContext = getGLTraceContext(); 10544 10545 glmsg.set_function(GLMessage::glGetTexEnvfv); 10546 10547 // copy argument env 10548 GLMessage_DataType *arg_env = glmsg.add_args(); 10549 arg_env->set_isarray(false); 10550 arg_env->set_type(GLMessage::DataType::ENUM); 10551 arg_env->add_intvalue((int)env); 10552 10553 // copy argument pname 10554 GLMessage_DataType *arg_pname = glmsg.add_args(); 10555 arg_pname->set_isarray(false); 10556 arg_pname->set_type(GLMessage::DataType::ENUM); 10557 arg_pname->add_intvalue((int)pname); 10558 10559 // copy argument params 10560 GLMessage_DataType *arg_params = glmsg.add_args(); 10561 arg_params->set_isarray(false); 10562 arg_params->set_type(GLMessage::DataType::INT); 10563 arg_params->add_intvalue((int)params); 10564 10565 // call function 10566 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10567 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10568 glContext->hooks->gl.glGetTexEnvfv(env, pname, params); 10569 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10570 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10571 10572 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10573 threadStartTime, threadEndTime, 10574 &glmsg); 10575 glContext->traceGLMessage(&glmsg); 10576} 10577 10578void GLTrace_glLightModelf(GLenum pname, GLfloat param) { 10579 GLMessage glmsg; 10580 GLTraceContext *glContext = getGLTraceContext(); 10581 10582 glmsg.set_function(GLMessage::glLightModelf); 10583 10584 // copy argument pname 10585 GLMessage_DataType *arg_pname = glmsg.add_args(); 10586 arg_pname->set_isarray(false); 10587 arg_pname->set_type(GLMessage::DataType::ENUM); 10588 arg_pname->add_intvalue((int)pname); 10589 10590 // copy argument param 10591 GLMessage_DataType *arg_param = glmsg.add_args(); 10592 arg_param->set_isarray(false); 10593 arg_param->set_type(GLMessage::DataType::FLOAT); 10594 arg_param->add_floatvalue(param); 10595 10596 // call function 10597 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10598 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10599 glContext->hooks->gl.glLightModelf(pname, param); 10600 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10601 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10602 10603 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10604 threadStartTime, threadEndTime, 10605 &glmsg); 10606 glContext->traceGLMessage(&glmsg); 10607} 10608 10609void GLTrace_glLightModelfv(GLenum pname, const GLfloat *params) { 10610 GLMessage glmsg; 10611 GLTraceContext *glContext = getGLTraceContext(); 10612 10613 glmsg.set_function(GLMessage::glLightModelfv); 10614 10615 // copy argument pname 10616 GLMessage_DataType *arg_pname = glmsg.add_args(); 10617 arg_pname->set_isarray(false); 10618 arg_pname->set_type(GLMessage::DataType::ENUM); 10619 arg_pname->add_intvalue((int)pname); 10620 10621 // copy argument params 10622 GLMessage_DataType *arg_params = glmsg.add_args(); 10623 arg_params->set_isarray(false); 10624 arg_params->set_type(GLMessage::DataType::INT); 10625 arg_params->add_intvalue((int)params); 10626 10627 // call function 10628 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10629 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10630 glContext->hooks->gl.glLightModelfv(pname, params); 10631 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10632 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10633 10634 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10635 threadStartTime, threadEndTime, 10636 &glmsg); 10637 glContext->traceGLMessage(&glmsg); 10638} 10639 10640void GLTrace_glLightf(GLenum light, GLenum pname, GLfloat param) { 10641 GLMessage glmsg; 10642 GLTraceContext *glContext = getGLTraceContext(); 10643 10644 glmsg.set_function(GLMessage::glLightf); 10645 10646 // copy argument light 10647 GLMessage_DataType *arg_light = glmsg.add_args(); 10648 arg_light->set_isarray(false); 10649 arg_light->set_type(GLMessage::DataType::ENUM); 10650 arg_light->add_intvalue((int)light); 10651 10652 // copy argument pname 10653 GLMessage_DataType *arg_pname = glmsg.add_args(); 10654 arg_pname->set_isarray(false); 10655 arg_pname->set_type(GLMessage::DataType::ENUM); 10656 arg_pname->add_intvalue((int)pname); 10657 10658 // copy argument param 10659 GLMessage_DataType *arg_param = glmsg.add_args(); 10660 arg_param->set_isarray(false); 10661 arg_param->set_type(GLMessage::DataType::FLOAT); 10662 arg_param->add_floatvalue(param); 10663 10664 // call function 10665 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10666 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10667 glContext->hooks->gl.glLightf(light, pname, param); 10668 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10669 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10670 10671 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10672 threadStartTime, threadEndTime, 10673 &glmsg); 10674 glContext->traceGLMessage(&glmsg); 10675} 10676 10677void GLTrace_glLightfv(GLenum light, GLenum pname, const GLfloat *params) { 10678 GLMessage glmsg; 10679 GLTraceContext *glContext = getGLTraceContext(); 10680 10681 glmsg.set_function(GLMessage::glLightfv); 10682 10683 // copy argument light 10684 GLMessage_DataType *arg_light = glmsg.add_args(); 10685 arg_light->set_isarray(false); 10686 arg_light->set_type(GLMessage::DataType::ENUM); 10687 arg_light->add_intvalue((int)light); 10688 10689 // copy argument pname 10690 GLMessage_DataType *arg_pname = glmsg.add_args(); 10691 arg_pname->set_isarray(false); 10692 arg_pname->set_type(GLMessage::DataType::ENUM); 10693 arg_pname->add_intvalue((int)pname); 10694 10695 // copy argument params 10696 GLMessage_DataType *arg_params = glmsg.add_args(); 10697 arg_params->set_isarray(false); 10698 arg_params->set_type(GLMessage::DataType::INT); 10699 arg_params->add_intvalue((int)params); 10700 10701 // call function 10702 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10703 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10704 glContext->hooks->gl.glLightfv(light, pname, params); 10705 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10706 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10707 10708 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10709 threadStartTime, threadEndTime, 10710 &glmsg); 10711 glContext->traceGLMessage(&glmsg); 10712} 10713 10714void GLTrace_glLoadMatrixf(const GLfloat *m) { 10715 GLMessage glmsg; 10716 GLTraceContext *glContext = getGLTraceContext(); 10717 10718 glmsg.set_function(GLMessage::glLoadMatrixf); 10719 10720 // copy argument m 10721 GLMessage_DataType *arg_m = glmsg.add_args(); 10722 arg_m->set_isarray(false); 10723 arg_m->set_type(GLMessage::DataType::INT); 10724 arg_m->add_intvalue((int)m); 10725 10726 // call function 10727 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10728 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10729 glContext->hooks->gl.glLoadMatrixf(m); 10730 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10731 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10732 10733 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10734 threadStartTime, threadEndTime, 10735 &glmsg); 10736 glContext->traceGLMessage(&glmsg); 10737} 10738 10739void GLTrace_glMaterialf(GLenum face, GLenum pname, GLfloat param) { 10740 GLMessage glmsg; 10741 GLTraceContext *glContext = getGLTraceContext(); 10742 10743 glmsg.set_function(GLMessage::glMaterialf); 10744 10745 // copy argument face 10746 GLMessage_DataType *arg_face = glmsg.add_args(); 10747 arg_face->set_isarray(false); 10748 arg_face->set_type(GLMessage::DataType::ENUM); 10749 arg_face->add_intvalue((int)face); 10750 10751 // copy argument pname 10752 GLMessage_DataType *arg_pname = glmsg.add_args(); 10753 arg_pname->set_isarray(false); 10754 arg_pname->set_type(GLMessage::DataType::ENUM); 10755 arg_pname->add_intvalue((int)pname); 10756 10757 // copy argument param 10758 GLMessage_DataType *arg_param = glmsg.add_args(); 10759 arg_param->set_isarray(false); 10760 arg_param->set_type(GLMessage::DataType::FLOAT); 10761 arg_param->add_floatvalue(param); 10762 10763 // call function 10764 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10765 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10766 glContext->hooks->gl.glMaterialf(face, pname, param); 10767 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10768 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10769 10770 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10771 threadStartTime, threadEndTime, 10772 &glmsg); 10773 glContext->traceGLMessage(&glmsg); 10774} 10775 10776void GLTrace_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) { 10777 GLMessage glmsg; 10778 GLTraceContext *glContext = getGLTraceContext(); 10779 10780 glmsg.set_function(GLMessage::glMaterialfv); 10781 10782 // copy argument face 10783 GLMessage_DataType *arg_face = glmsg.add_args(); 10784 arg_face->set_isarray(false); 10785 arg_face->set_type(GLMessage::DataType::ENUM); 10786 arg_face->add_intvalue((int)face); 10787 10788 // copy argument pname 10789 GLMessage_DataType *arg_pname = glmsg.add_args(); 10790 arg_pname->set_isarray(false); 10791 arg_pname->set_type(GLMessage::DataType::ENUM); 10792 arg_pname->add_intvalue((int)pname); 10793 10794 // copy argument params 10795 GLMessage_DataType *arg_params = glmsg.add_args(); 10796 arg_params->set_isarray(false); 10797 arg_params->set_type(GLMessage::DataType::INT); 10798 arg_params->add_intvalue((int)params); 10799 10800 // call function 10801 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10802 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10803 glContext->hooks->gl.glMaterialfv(face, pname, params); 10804 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10805 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10806 10807 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10808 threadStartTime, threadEndTime, 10809 &glmsg); 10810 glContext->traceGLMessage(&glmsg); 10811} 10812 10813void GLTrace_glMultMatrixf(const GLfloat *m) { 10814 GLMessage glmsg; 10815 GLTraceContext *glContext = getGLTraceContext(); 10816 10817 glmsg.set_function(GLMessage::glMultMatrixf); 10818 10819 // copy argument m 10820 GLMessage_DataType *arg_m = glmsg.add_args(); 10821 arg_m->set_isarray(false); 10822 arg_m->set_type(GLMessage::DataType::INT); 10823 arg_m->add_intvalue((int)m); 10824 10825 // call function 10826 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10827 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10828 glContext->hooks->gl.glMultMatrixf(m); 10829 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10830 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10831 10832 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10833 threadStartTime, threadEndTime, 10834 &glmsg); 10835 glContext->traceGLMessage(&glmsg); 10836} 10837 10838void GLTrace_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { 10839 GLMessage glmsg; 10840 GLTraceContext *glContext = getGLTraceContext(); 10841 10842 glmsg.set_function(GLMessage::glMultiTexCoord4f); 10843 10844 // copy argument target 10845 GLMessage_DataType *arg_target = glmsg.add_args(); 10846 arg_target->set_isarray(false); 10847 arg_target->set_type(GLMessage::DataType::ENUM); 10848 arg_target->add_intvalue((int)target); 10849 10850 // copy argument s 10851 GLMessage_DataType *arg_s = glmsg.add_args(); 10852 arg_s->set_isarray(false); 10853 arg_s->set_type(GLMessage::DataType::FLOAT); 10854 arg_s->add_floatvalue(s); 10855 10856 // copy argument t 10857 GLMessage_DataType *arg_t = glmsg.add_args(); 10858 arg_t->set_isarray(false); 10859 arg_t->set_type(GLMessage::DataType::FLOAT); 10860 arg_t->add_floatvalue(t); 10861 10862 // copy argument r 10863 GLMessage_DataType *arg_r = glmsg.add_args(); 10864 arg_r->set_isarray(false); 10865 arg_r->set_type(GLMessage::DataType::FLOAT); 10866 arg_r->add_floatvalue(r); 10867 10868 // copy argument q 10869 GLMessage_DataType *arg_q = glmsg.add_args(); 10870 arg_q->set_isarray(false); 10871 arg_q->set_type(GLMessage::DataType::FLOAT); 10872 arg_q->add_floatvalue(q); 10873 10874 // call function 10875 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10876 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10877 glContext->hooks->gl.glMultiTexCoord4f(target, s, t, r, q); 10878 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10879 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10880 10881 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10882 threadStartTime, threadEndTime, 10883 &glmsg); 10884 glContext->traceGLMessage(&glmsg); 10885} 10886 10887void GLTrace_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) { 10888 GLMessage glmsg; 10889 GLTraceContext *glContext = getGLTraceContext(); 10890 10891 glmsg.set_function(GLMessage::glNormal3f); 10892 10893 // copy argument nx 10894 GLMessage_DataType *arg_nx = glmsg.add_args(); 10895 arg_nx->set_isarray(false); 10896 arg_nx->set_type(GLMessage::DataType::FLOAT); 10897 arg_nx->add_floatvalue(nx); 10898 10899 // copy argument ny 10900 GLMessage_DataType *arg_ny = glmsg.add_args(); 10901 arg_ny->set_isarray(false); 10902 arg_ny->set_type(GLMessage::DataType::FLOAT); 10903 arg_ny->add_floatvalue(ny); 10904 10905 // copy argument nz 10906 GLMessage_DataType *arg_nz = glmsg.add_args(); 10907 arg_nz->set_isarray(false); 10908 arg_nz->set_type(GLMessage::DataType::FLOAT); 10909 arg_nz->add_floatvalue(nz); 10910 10911 // call function 10912 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10913 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10914 glContext->hooks->gl.glNormal3f(nx, ny, nz); 10915 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10916 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10917 10918 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10919 threadStartTime, threadEndTime, 10920 &glmsg); 10921 glContext->traceGLMessage(&glmsg); 10922} 10923 10924void GLTrace_glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { 10925 GLMessage glmsg; 10926 GLTraceContext *glContext = getGLTraceContext(); 10927 10928 glmsg.set_function(GLMessage::glOrthof); 10929 10930 // copy argument left 10931 GLMessage_DataType *arg_left = glmsg.add_args(); 10932 arg_left->set_isarray(false); 10933 arg_left->set_type(GLMessage::DataType::FLOAT); 10934 arg_left->add_floatvalue(left); 10935 10936 // copy argument right 10937 GLMessage_DataType *arg_right = glmsg.add_args(); 10938 arg_right->set_isarray(false); 10939 arg_right->set_type(GLMessage::DataType::FLOAT); 10940 arg_right->add_floatvalue(right); 10941 10942 // copy argument bottom 10943 GLMessage_DataType *arg_bottom = glmsg.add_args(); 10944 arg_bottom->set_isarray(false); 10945 arg_bottom->set_type(GLMessage::DataType::FLOAT); 10946 arg_bottom->add_floatvalue(bottom); 10947 10948 // copy argument top 10949 GLMessage_DataType *arg_top = glmsg.add_args(); 10950 arg_top->set_isarray(false); 10951 arg_top->set_type(GLMessage::DataType::FLOAT); 10952 arg_top->add_floatvalue(top); 10953 10954 // copy argument zNear 10955 GLMessage_DataType *arg_zNear = glmsg.add_args(); 10956 arg_zNear->set_isarray(false); 10957 arg_zNear->set_type(GLMessage::DataType::FLOAT); 10958 arg_zNear->add_floatvalue(zNear); 10959 10960 // copy argument zFar 10961 GLMessage_DataType *arg_zFar = glmsg.add_args(); 10962 arg_zFar->set_isarray(false); 10963 arg_zFar->set_type(GLMessage::DataType::FLOAT); 10964 arg_zFar->add_floatvalue(zFar); 10965 10966 // call function 10967 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10968 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 10969 glContext->hooks->gl.glOrthof(left, right, bottom, top, zNear, zFar); 10970 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 10971 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 10972 10973 fixupGLMessage(glContext, wallStartTime, wallEndTime, 10974 threadStartTime, threadEndTime, 10975 &glmsg); 10976 glContext->traceGLMessage(&glmsg); 10977} 10978 10979void GLTrace_glPointParameterf(GLenum pname, GLfloat param) { 10980 GLMessage glmsg; 10981 GLTraceContext *glContext = getGLTraceContext(); 10982 10983 glmsg.set_function(GLMessage::glPointParameterf); 10984 10985 // copy argument pname 10986 GLMessage_DataType *arg_pname = glmsg.add_args(); 10987 arg_pname->set_isarray(false); 10988 arg_pname->set_type(GLMessage::DataType::ENUM); 10989 arg_pname->add_intvalue((int)pname); 10990 10991 // copy argument param 10992 GLMessage_DataType *arg_param = glmsg.add_args(); 10993 arg_param->set_isarray(false); 10994 arg_param->set_type(GLMessage::DataType::FLOAT); 10995 arg_param->add_floatvalue(param); 10996 10997 // call function 10998 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 10999 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11000 glContext->hooks->gl.glPointParameterf(pname, param); 11001 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11002 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11003 11004 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11005 threadStartTime, threadEndTime, 11006 &glmsg); 11007 glContext->traceGLMessage(&glmsg); 11008} 11009 11010void GLTrace_glPointParameterfv(GLenum pname, const GLfloat *params) { 11011 GLMessage glmsg; 11012 GLTraceContext *glContext = getGLTraceContext(); 11013 11014 glmsg.set_function(GLMessage::glPointParameterfv); 11015 11016 // copy argument pname 11017 GLMessage_DataType *arg_pname = glmsg.add_args(); 11018 arg_pname->set_isarray(false); 11019 arg_pname->set_type(GLMessage::DataType::ENUM); 11020 arg_pname->add_intvalue((int)pname); 11021 11022 // copy argument params 11023 GLMessage_DataType *arg_params = glmsg.add_args(); 11024 arg_params->set_isarray(false); 11025 arg_params->set_type(GLMessage::DataType::INT); 11026 arg_params->add_intvalue((int)params); 11027 11028 // call function 11029 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11030 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11031 glContext->hooks->gl.glPointParameterfv(pname, params); 11032 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11033 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11034 11035 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11036 threadStartTime, threadEndTime, 11037 &glmsg); 11038 glContext->traceGLMessage(&glmsg); 11039} 11040 11041void GLTrace_glPointSize(GLfloat size) { 11042 GLMessage glmsg; 11043 GLTraceContext *glContext = getGLTraceContext(); 11044 11045 glmsg.set_function(GLMessage::glPointSize); 11046 11047 // copy argument size 11048 GLMessage_DataType *arg_size = glmsg.add_args(); 11049 arg_size->set_isarray(false); 11050 arg_size->set_type(GLMessage::DataType::FLOAT); 11051 arg_size->add_floatvalue(size); 11052 11053 // call function 11054 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11055 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11056 glContext->hooks->gl.glPointSize(size); 11057 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11058 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11059 11060 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11061 threadStartTime, threadEndTime, 11062 &glmsg); 11063 glContext->traceGLMessage(&glmsg); 11064} 11065 11066void GLTrace_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { 11067 GLMessage glmsg; 11068 GLTraceContext *glContext = getGLTraceContext(); 11069 11070 glmsg.set_function(GLMessage::glRotatef); 11071 11072 // copy argument angle 11073 GLMessage_DataType *arg_angle = glmsg.add_args(); 11074 arg_angle->set_isarray(false); 11075 arg_angle->set_type(GLMessage::DataType::FLOAT); 11076 arg_angle->add_floatvalue(angle); 11077 11078 // copy argument x 11079 GLMessage_DataType *arg_x = glmsg.add_args(); 11080 arg_x->set_isarray(false); 11081 arg_x->set_type(GLMessage::DataType::FLOAT); 11082 arg_x->add_floatvalue(x); 11083 11084 // copy argument y 11085 GLMessage_DataType *arg_y = glmsg.add_args(); 11086 arg_y->set_isarray(false); 11087 arg_y->set_type(GLMessage::DataType::FLOAT); 11088 arg_y->add_floatvalue(y); 11089 11090 // copy argument z 11091 GLMessage_DataType *arg_z = glmsg.add_args(); 11092 arg_z->set_isarray(false); 11093 arg_z->set_type(GLMessage::DataType::FLOAT); 11094 arg_z->add_floatvalue(z); 11095 11096 // call function 11097 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11098 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11099 glContext->hooks->gl.glRotatef(angle, x, y, z); 11100 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11101 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11102 11103 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11104 threadStartTime, threadEndTime, 11105 &glmsg); 11106 glContext->traceGLMessage(&glmsg); 11107} 11108 11109void GLTrace_glScalef(GLfloat x, GLfloat y, GLfloat z) { 11110 GLMessage glmsg; 11111 GLTraceContext *glContext = getGLTraceContext(); 11112 11113 glmsg.set_function(GLMessage::glScalef); 11114 11115 // copy argument x 11116 GLMessage_DataType *arg_x = glmsg.add_args(); 11117 arg_x->set_isarray(false); 11118 arg_x->set_type(GLMessage::DataType::FLOAT); 11119 arg_x->add_floatvalue(x); 11120 11121 // copy argument y 11122 GLMessage_DataType *arg_y = glmsg.add_args(); 11123 arg_y->set_isarray(false); 11124 arg_y->set_type(GLMessage::DataType::FLOAT); 11125 arg_y->add_floatvalue(y); 11126 11127 // copy argument z 11128 GLMessage_DataType *arg_z = glmsg.add_args(); 11129 arg_z->set_isarray(false); 11130 arg_z->set_type(GLMessage::DataType::FLOAT); 11131 arg_z->add_floatvalue(z); 11132 11133 // call function 11134 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11135 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11136 glContext->hooks->gl.glScalef(x, y, z); 11137 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11138 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11139 11140 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11141 threadStartTime, threadEndTime, 11142 &glmsg); 11143 glContext->traceGLMessage(&glmsg); 11144} 11145 11146void GLTrace_glTexEnvf(GLenum target, GLenum pname, GLfloat param) { 11147 GLMessage glmsg; 11148 GLTraceContext *glContext = getGLTraceContext(); 11149 11150 glmsg.set_function(GLMessage::glTexEnvf); 11151 11152 // copy argument target 11153 GLMessage_DataType *arg_target = glmsg.add_args(); 11154 arg_target->set_isarray(false); 11155 arg_target->set_type(GLMessage::DataType::ENUM); 11156 arg_target->add_intvalue((int)target); 11157 11158 // copy argument pname 11159 GLMessage_DataType *arg_pname = glmsg.add_args(); 11160 arg_pname->set_isarray(false); 11161 arg_pname->set_type(GLMessage::DataType::ENUM); 11162 arg_pname->add_intvalue((int)pname); 11163 11164 // copy argument param 11165 GLMessage_DataType *arg_param = glmsg.add_args(); 11166 arg_param->set_isarray(false); 11167 arg_param->set_type(GLMessage::DataType::FLOAT); 11168 arg_param->add_floatvalue(param); 11169 11170 // call function 11171 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11172 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11173 glContext->hooks->gl.glTexEnvf(target, pname, param); 11174 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11175 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11176 11177 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11178 threadStartTime, threadEndTime, 11179 &glmsg); 11180 glContext->traceGLMessage(&glmsg); 11181} 11182 11183void GLTrace_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) { 11184 GLMessage glmsg; 11185 GLTraceContext *glContext = getGLTraceContext(); 11186 11187 glmsg.set_function(GLMessage::glTexEnvfv); 11188 11189 // copy argument target 11190 GLMessage_DataType *arg_target = glmsg.add_args(); 11191 arg_target->set_isarray(false); 11192 arg_target->set_type(GLMessage::DataType::ENUM); 11193 arg_target->add_intvalue((int)target); 11194 11195 // copy argument pname 11196 GLMessage_DataType *arg_pname = glmsg.add_args(); 11197 arg_pname->set_isarray(false); 11198 arg_pname->set_type(GLMessage::DataType::ENUM); 11199 arg_pname->add_intvalue((int)pname); 11200 11201 // copy argument params 11202 GLMessage_DataType *arg_params = glmsg.add_args(); 11203 arg_params->set_isarray(false); 11204 arg_params->set_type(GLMessage::DataType::INT); 11205 arg_params->add_intvalue((int)params); 11206 11207 // call function 11208 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11209 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11210 glContext->hooks->gl.glTexEnvfv(target, pname, params); 11211 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11212 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11213 11214 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11215 threadStartTime, threadEndTime, 11216 &glmsg); 11217 glContext->traceGLMessage(&glmsg); 11218} 11219 11220void GLTrace_glTranslatef(GLfloat x, GLfloat y, GLfloat z) { 11221 GLMessage glmsg; 11222 GLTraceContext *glContext = getGLTraceContext(); 11223 11224 glmsg.set_function(GLMessage::glTranslatef); 11225 11226 // copy argument x 11227 GLMessage_DataType *arg_x = glmsg.add_args(); 11228 arg_x->set_isarray(false); 11229 arg_x->set_type(GLMessage::DataType::FLOAT); 11230 arg_x->add_floatvalue(x); 11231 11232 // copy argument y 11233 GLMessage_DataType *arg_y = glmsg.add_args(); 11234 arg_y->set_isarray(false); 11235 arg_y->set_type(GLMessage::DataType::FLOAT); 11236 arg_y->add_floatvalue(y); 11237 11238 // copy argument z 11239 GLMessage_DataType *arg_z = glmsg.add_args(); 11240 arg_z->set_isarray(false); 11241 arg_z->set_type(GLMessage::DataType::FLOAT); 11242 arg_z->add_floatvalue(z); 11243 11244 // call function 11245 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11246 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11247 glContext->hooks->gl.glTranslatef(x, y, z); 11248 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11249 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11250 11251 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11252 threadStartTime, threadEndTime, 11253 &glmsg); 11254 glContext->traceGLMessage(&glmsg); 11255} 11256 11257void GLTrace_glAlphaFuncx(GLenum func, GLclampx ref) { 11258 GLMessage glmsg; 11259 GLTraceContext *glContext = getGLTraceContext(); 11260 11261 glmsg.set_function(GLMessage::glAlphaFuncx); 11262 11263 // copy argument func 11264 GLMessage_DataType *arg_func = glmsg.add_args(); 11265 arg_func->set_isarray(false); 11266 arg_func->set_type(GLMessage::DataType::ENUM); 11267 arg_func->add_intvalue((int)func); 11268 11269 // copy argument ref 11270 GLMessage_DataType *arg_ref = glmsg.add_args(); 11271 arg_ref->set_isarray(false); 11272 arg_ref->set_type(GLMessage::DataType::INT); 11273 arg_ref->add_intvalue(ref); 11274 11275 // call function 11276 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11277 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11278 glContext->hooks->gl.glAlphaFuncx(func, ref); 11279 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11280 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11281 11282 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11283 threadStartTime, threadEndTime, 11284 &glmsg); 11285 glContext->traceGLMessage(&glmsg); 11286} 11287 11288void GLTrace_glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) { 11289 GLMessage glmsg; 11290 GLTraceContext *glContext = getGLTraceContext(); 11291 11292 glmsg.set_function(GLMessage::glClearColorx); 11293 11294 // copy argument red 11295 GLMessage_DataType *arg_red = glmsg.add_args(); 11296 arg_red->set_isarray(false); 11297 arg_red->set_type(GLMessage::DataType::INT); 11298 arg_red->add_intvalue(red); 11299 11300 // copy argument green 11301 GLMessage_DataType *arg_green = glmsg.add_args(); 11302 arg_green->set_isarray(false); 11303 arg_green->set_type(GLMessage::DataType::INT); 11304 arg_green->add_intvalue(green); 11305 11306 // copy argument blue 11307 GLMessage_DataType *arg_blue = glmsg.add_args(); 11308 arg_blue->set_isarray(false); 11309 arg_blue->set_type(GLMessage::DataType::INT); 11310 arg_blue->add_intvalue(blue); 11311 11312 // copy argument alpha 11313 GLMessage_DataType *arg_alpha = glmsg.add_args(); 11314 arg_alpha->set_isarray(false); 11315 arg_alpha->set_type(GLMessage::DataType::INT); 11316 arg_alpha->add_intvalue(alpha); 11317 11318 // call function 11319 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11320 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11321 glContext->hooks->gl.glClearColorx(red, green, blue, alpha); 11322 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11323 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11324 11325 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11326 threadStartTime, threadEndTime, 11327 &glmsg); 11328 glContext->traceGLMessage(&glmsg); 11329} 11330 11331void GLTrace_glClearDepthx(GLclampx depth) { 11332 GLMessage glmsg; 11333 GLTraceContext *glContext = getGLTraceContext(); 11334 11335 glmsg.set_function(GLMessage::glClearDepthx); 11336 11337 // copy argument depth 11338 GLMessage_DataType *arg_depth = glmsg.add_args(); 11339 arg_depth->set_isarray(false); 11340 arg_depth->set_type(GLMessage::DataType::INT); 11341 arg_depth->add_intvalue(depth); 11342 11343 // call function 11344 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11345 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11346 glContext->hooks->gl.glClearDepthx(depth); 11347 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11348 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11349 11350 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11351 threadStartTime, threadEndTime, 11352 &glmsg); 11353 glContext->traceGLMessage(&glmsg); 11354} 11355 11356void GLTrace_glClientActiveTexture(GLenum texture) { 11357 GLMessage glmsg; 11358 GLTraceContext *glContext = getGLTraceContext(); 11359 11360 glmsg.set_function(GLMessage::glClientActiveTexture); 11361 11362 // copy argument texture 11363 GLMessage_DataType *arg_texture = glmsg.add_args(); 11364 arg_texture->set_isarray(false); 11365 arg_texture->set_type(GLMessage::DataType::ENUM); 11366 arg_texture->add_intvalue((int)texture); 11367 11368 // call function 11369 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11370 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11371 glContext->hooks->gl.glClientActiveTexture(texture); 11372 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11373 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11374 11375 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11376 threadStartTime, threadEndTime, 11377 &glmsg); 11378 glContext->traceGLMessage(&glmsg); 11379} 11380 11381void GLTrace_glClipPlanex(GLenum plane, const GLfixed *equation) { 11382 GLMessage glmsg; 11383 GLTraceContext *glContext = getGLTraceContext(); 11384 11385 glmsg.set_function(GLMessage::glClipPlanex); 11386 11387 // copy argument plane 11388 GLMessage_DataType *arg_plane = glmsg.add_args(); 11389 arg_plane->set_isarray(false); 11390 arg_plane->set_type(GLMessage::DataType::ENUM); 11391 arg_plane->add_intvalue((int)plane); 11392 11393 // copy argument equation 11394 GLMessage_DataType *arg_equation = glmsg.add_args(); 11395 arg_equation->set_isarray(false); 11396 arg_equation->set_type(GLMessage::DataType::INT); 11397 arg_equation->add_intvalue((int)equation); 11398 11399 // call function 11400 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11401 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11402 glContext->hooks->gl.glClipPlanex(plane, equation); 11403 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11404 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11405 11406 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11407 threadStartTime, threadEndTime, 11408 &glmsg); 11409 glContext->traceGLMessage(&glmsg); 11410} 11411 11412void GLTrace_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { 11413 GLMessage glmsg; 11414 GLTraceContext *glContext = getGLTraceContext(); 11415 11416 glmsg.set_function(GLMessage::glColor4ub); 11417 11418 // copy argument red 11419 GLMessage_DataType *arg_red = glmsg.add_args(); 11420 arg_red->set_isarray(false); 11421 arg_red->set_type(GLMessage::DataType::BYTE); 11422 arg_red->add_intvalue((int)red); 11423 11424 // copy argument green 11425 GLMessage_DataType *arg_green = glmsg.add_args(); 11426 arg_green->set_isarray(false); 11427 arg_green->set_type(GLMessage::DataType::BYTE); 11428 arg_green->add_intvalue((int)green); 11429 11430 // copy argument blue 11431 GLMessage_DataType *arg_blue = glmsg.add_args(); 11432 arg_blue->set_isarray(false); 11433 arg_blue->set_type(GLMessage::DataType::BYTE); 11434 arg_blue->add_intvalue((int)blue); 11435 11436 // copy argument alpha 11437 GLMessage_DataType *arg_alpha = glmsg.add_args(); 11438 arg_alpha->set_isarray(false); 11439 arg_alpha->set_type(GLMessage::DataType::BYTE); 11440 arg_alpha->add_intvalue((int)alpha); 11441 11442 // call function 11443 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11444 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11445 glContext->hooks->gl.glColor4ub(red, green, blue, alpha); 11446 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11447 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11448 11449 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11450 threadStartTime, threadEndTime, 11451 &glmsg); 11452 glContext->traceGLMessage(&glmsg); 11453} 11454 11455void GLTrace_glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { 11456 GLMessage glmsg; 11457 GLTraceContext *glContext = getGLTraceContext(); 11458 11459 glmsg.set_function(GLMessage::glColor4x); 11460 11461 // copy argument red 11462 GLMessage_DataType *arg_red = glmsg.add_args(); 11463 arg_red->set_isarray(false); 11464 arg_red->set_type(GLMessage::DataType::INT); 11465 arg_red->add_intvalue(red); 11466 11467 // copy argument green 11468 GLMessage_DataType *arg_green = glmsg.add_args(); 11469 arg_green->set_isarray(false); 11470 arg_green->set_type(GLMessage::DataType::INT); 11471 arg_green->add_intvalue(green); 11472 11473 // copy argument blue 11474 GLMessage_DataType *arg_blue = glmsg.add_args(); 11475 arg_blue->set_isarray(false); 11476 arg_blue->set_type(GLMessage::DataType::INT); 11477 arg_blue->add_intvalue(blue); 11478 11479 // copy argument alpha 11480 GLMessage_DataType *arg_alpha = glmsg.add_args(); 11481 arg_alpha->set_isarray(false); 11482 arg_alpha->set_type(GLMessage::DataType::INT); 11483 arg_alpha->add_intvalue(alpha); 11484 11485 // call function 11486 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11487 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11488 glContext->hooks->gl.glColor4x(red, green, blue, alpha); 11489 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11490 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11491 11492 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11493 threadStartTime, threadEndTime, 11494 &glmsg); 11495 glContext->traceGLMessage(&glmsg); 11496} 11497 11498void GLTrace_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { 11499 GLMessage glmsg; 11500 GLTraceContext *glContext = getGLTraceContext(); 11501 11502 glmsg.set_function(GLMessage::glColorPointer); 11503 11504 // copy argument size 11505 GLMessage_DataType *arg_size = glmsg.add_args(); 11506 arg_size->set_isarray(false); 11507 arg_size->set_type(GLMessage::DataType::INT); 11508 arg_size->add_intvalue(size); 11509 11510 // copy argument type 11511 GLMessage_DataType *arg_type = glmsg.add_args(); 11512 arg_type->set_isarray(false); 11513 arg_type->set_type(GLMessage::DataType::ENUM); 11514 arg_type->add_intvalue((int)type); 11515 11516 // copy argument stride 11517 GLMessage_DataType *arg_stride = glmsg.add_args(); 11518 arg_stride->set_isarray(false); 11519 arg_stride->set_type(GLMessage::DataType::INT); 11520 arg_stride->add_intvalue(stride); 11521 11522 // copy argument pointer 11523 GLMessage_DataType *arg_pointer = glmsg.add_args(); 11524 arg_pointer->set_isarray(false); 11525 arg_pointer->set_type(GLMessage::DataType::INT); 11526 arg_pointer->add_intvalue((int)pointer); 11527 11528 // call function 11529 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11530 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11531 glContext->hooks->gl.glColorPointer(size, type, stride, pointer); 11532 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11533 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11534 11535 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11536 threadStartTime, threadEndTime, 11537 &glmsg); 11538 glContext->traceGLMessage(&glmsg); 11539} 11540 11541void GLTrace_glDepthRangex(GLclampx zNear, GLclampx zFar) { 11542 GLMessage glmsg; 11543 GLTraceContext *glContext = getGLTraceContext(); 11544 11545 glmsg.set_function(GLMessage::glDepthRangex); 11546 11547 // copy argument zNear 11548 GLMessage_DataType *arg_zNear = glmsg.add_args(); 11549 arg_zNear->set_isarray(false); 11550 arg_zNear->set_type(GLMessage::DataType::INT); 11551 arg_zNear->add_intvalue(zNear); 11552 11553 // copy argument zFar 11554 GLMessage_DataType *arg_zFar = glmsg.add_args(); 11555 arg_zFar->set_isarray(false); 11556 arg_zFar->set_type(GLMessage::DataType::INT); 11557 arg_zFar->add_intvalue(zFar); 11558 11559 // call function 11560 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11561 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11562 glContext->hooks->gl.glDepthRangex(zNear, zFar); 11563 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11564 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11565 11566 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11567 threadStartTime, threadEndTime, 11568 &glmsg); 11569 glContext->traceGLMessage(&glmsg); 11570} 11571 11572void GLTrace_glDisableClientState(GLenum array) { 11573 GLMessage glmsg; 11574 GLTraceContext *glContext = getGLTraceContext(); 11575 11576 glmsg.set_function(GLMessage::glDisableClientState); 11577 11578 // copy argument array 11579 GLMessage_DataType *arg_array = glmsg.add_args(); 11580 arg_array->set_isarray(false); 11581 arg_array->set_type(GLMessage::DataType::ENUM); 11582 arg_array->add_intvalue((int)array); 11583 11584 // call function 11585 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11586 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11587 glContext->hooks->gl.glDisableClientState(array); 11588 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11589 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11590 11591 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11592 threadStartTime, threadEndTime, 11593 &glmsg); 11594 glContext->traceGLMessage(&glmsg); 11595} 11596 11597void GLTrace_glEnableClientState(GLenum array) { 11598 GLMessage glmsg; 11599 GLTraceContext *glContext = getGLTraceContext(); 11600 11601 glmsg.set_function(GLMessage::glEnableClientState); 11602 11603 // copy argument array 11604 GLMessage_DataType *arg_array = glmsg.add_args(); 11605 arg_array->set_isarray(false); 11606 arg_array->set_type(GLMessage::DataType::ENUM); 11607 arg_array->add_intvalue((int)array); 11608 11609 // call function 11610 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11611 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11612 glContext->hooks->gl.glEnableClientState(array); 11613 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11614 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11615 11616 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11617 threadStartTime, threadEndTime, 11618 &glmsg); 11619 glContext->traceGLMessage(&glmsg); 11620} 11621 11622void GLTrace_glFogx(GLenum pname, GLfixed param) { 11623 GLMessage glmsg; 11624 GLTraceContext *glContext = getGLTraceContext(); 11625 11626 glmsg.set_function(GLMessage::glFogx); 11627 11628 // copy argument pname 11629 GLMessage_DataType *arg_pname = glmsg.add_args(); 11630 arg_pname->set_isarray(false); 11631 arg_pname->set_type(GLMessage::DataType::ENUM); 11632 arg_pname->add_intvalue((int)pname); 11633 11634 // copy argument param 11635 GLMessage_DataType *arg_param = glmsg.add_args(); 11636 arg_param->set_isarray(false); 11637 arg_param->set_type(GLMessage::DataType::INT); 11638 arg_param->add_intvalue(param); 11639 11640 // call function 11641 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11642 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11643 glContext->hooks->gl.glFogx(pname, param); 11644 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11645 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11646 11647 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11648 threadStartTime, threadEndTime, 11649 &glmsg); 11650 glContext->traceGLMessage(&glmsg); 11651} 11652 11653void GLTrace_glFogxv(GLenum pname, const GLfixed *params) { 11654 GLMessage glmsg; 11655 GLTraceContext *glContext = getGLTraceContext(); 11656 11657 glmsg.set_function(GLMessage::glFogxv); 11658 11659 // copy argument pname 11660 GLMessage_DataType *arg_pname = glmsg.add_args(); 11661 arg_pname->set_isarray(false); 11662 arg_pname->set_type(GLMessage::DataType::ENUM); 11663 arg_pname->add_intvalue((int)pname); 11664 11665 // copy argument params 11666 GLMessage_DataType *arg_params = glmsg.add_args(); 11667 arg_params->set_isarray(false); 11668 arg_params->set_type(GLMessage::DataType::INT); 11669 arg_params->add_intvalue((int)params); 11670 11671 // call function 11672 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11673 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11674 glContext->hooks->gl.glFogxv(pname, params); 11675 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11676 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11677 11678 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11679 threadStartTime, threadEndTime, 11680 &glmsg); 11681 glContext->traceGLMessage(&glmsg); 11682} 11683 11684void GLTrace_glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { 11685 GLMessage glmsg; 11686 GLTraceContext *glContext = getGLTraceContext(); 11687 11688 glmsg.set_function(GLMessage::glFrustumx); 11689 11690 // copy argument left 11691 GLMessage_DataType *arg_left = glmsg.add_args(); 11692 arg_left->set_isarray(false); 11693 arg_left->set_type(GLMessage::DataType::INT); 11694 arg_left->add_intvalue(left); 11695 11696 // copy argument right 11697 GLMessage_DataType *arg_right = glmsg.add_args(); 11698 arg_right->set_isarray(false); 11699 arg_right->set_type(GLMessage::DataType::INT); 11700 arg_right->add_intvalue(right); 11701 11702 // copy argument bottom 11703 GLMessage_DataType *arg_bottom = glmsg.add_args(); 11704 arg_bottom->set_isarray(false); 11705 arg_bottom->set_type(GLMessage::DataType::INT); 11706 arg_bottom->add_intvalue(bottom); 11707 11708 // copy argument top 11709 GLMessage_DataType *arg_top = glmsg.add_args(); 11710 arg_top->set_isarray(false); 11711 arg_top->set_type(GLMessage::DataType::INT); 11712 arg_top->add_intvalue(top); 11713 11714 // copy argument zNear 11715 GLMessage_DataType *arg_zNear = glmsg.add_args(); 11716 arg_zNear->set_isarray(false); 11717 arg_zNear->set_type(GLMessage::DataType::INT); 11718 arg_zNear->add_intvalue(zNear); 11719 11720 // copy argument zFar 11721 GLMessage_DataType *arg_zFar = glmsg.add_args(); 11722 arg_zFar->set_isarray(false); 11723 arg_zFar->set_type(GLMessage::DataType::INT); 11724 arg_zFar->add_intvalue(zFar); 11725 11726 // call function 11727 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11728 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11729 glContext->hooks->gl.glFrustumx(left, right, bottom, top, zNear, zFar); 11730 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11731 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11732 11733 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11734 threadStartTime, threadEndTime, 11735 &glmsg); 11736 glContext->traceGLMessage(&glmsg); 11737} 11738 11739void GLTrace_glGetClipPlanex(GLenum pname, GLfixed eqn[4]) { 11740 GLMessage glmsg; 11741 GLTraceContext *glContext = getGLTraceContext(); 11742 11743 glmsg.set_function(GLMessage::glGetClipPlanex); 11744 11745 // copy argument pname 11746 GLMessage_DataType *arg_pname = glmsg.add_args(); 11747 arg_pname->set_isarray(false); 11748 arg_pname->set_type(GLMessage::DataType::ENUM); 11749 arg_pname->add_intvalue((int)pname); 11750 11751 // copy argument eqn 11752 GLMessage_DataType *arg_eqn = glmsg.add_args(); 11753 arg_eqn->set_isarray(false); 11754 arg_eqn->set_type(GLMessage::DataType::INT); 11755 arg_eqn->add_intvalue((int)eqn); 11756 11757 // call function 11758 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11759 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11760 glContext->hooks->gl.glGetClipPlanex(pname, eqn); 11761 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11762 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11763 11764 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11765 threadStartTime, threadEndTime, 11766 &glmsg); 11767 glContext->traceGLMessage(&glmsg); 11768} 11769 11770void GLTrace_glGetFixedv(GLenum pname, GLfixed *params) { 11771 GLMessage glmsg; 11772 GLTraceContext *glContext = getGLTraceContext(); 11773 11774 glmsg.set_function(GLMessage::glGetFixedv); 11775 11776 // copy argument pname 11777 GLMessage_DataType *arg_pname = glmsg.add_args(); 11778 arg_pname->set_isarray(false); 11779 arg_pname->set_type(GLMessage::DataType::ENUM); 11780 arg_pname->add_intvalue((int)pname); 11781 11782 // copy argument params 11783 GLMessage_DataType *arg_params = glmsg.add_args(); 11784 arg_params->set_isarray(false); 11785 arg_params->set_type(GLMessage::DataType::INT); 11786 arg_params->add_intvalue((int)params); 11787 11788 // call function 11789 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11790 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11791 glContext->hooks->gl.glGetFixedv(pname, params); 11792 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11793 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11794 11795 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11796 threadStartTime, threadEndTime, 11797 &glmsg); 11798 glContext->traceGLMessage(&glmsg); 11799} 11800 11801void GLTrace_glGetLightxv(GLenum light, GLenum pname, GLfixed *params) { 11802 GLMessage glmsg; 11803 GLTraceContext *glContext = getGLTraceContext(); 11804 11805 glmsg.set_function(GLMessage::glGetLightxv); 11806 11807 // copy argument light 11808 GLMessage_DataType *arg_light = glmsg.add_args(); 11809 arg_light->set_isarray(false); 11810 arg_light->set_type(GLMessage::DataType::ENUM); 11811 arg_light->add_intvalue((int)light); 11812 11813 // copy argument pname 11814 GLMessage_DataType *arg_pname = glmsg.add_args(); 11815 arg_pname->set_isarray(false); 11816 arg_pname->set_type(GLMessage::DataType::ENUM); 11817 arg_pname->add_intvalue((int)pname); 11818 11819 // copy argument params 11820 GLMessage_DataType *arg_params = glmsg.add_args(); 11821 arg_params->set_isarray(false); 11822 arg_params->set_type(GLMessage::DataType::INT); 11823 arg_params->add_intvalue((int)params); 11824 11825 // call function 11826 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11827 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11828 glContext->hooks->gl.glGetLightxv(light, pname, params); 11829 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11830 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11831 11832 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11833 threadStartTime, threadEndTime, 11834 &glmsg); 11835 glContext->traceGLMessage(&glmsg); 11836} 11837 11838void GLTrace_glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params) { 11839 GLMessage glmsg; 11840 GLTraceContext *glContext = getGLTraceContext(); 11841 11842 glmsg.set_function(GLMessage::glGetMaterialxv); 11843 11844 // copy argument face 11845 GLMessage_DataType *arg_face = glmsg.add_args(); 11846 arg_face->set_isarray(false); 11847 arg_face->set_type(GLMessage::DataType::ENUM); 11848 arg_face->add_intvalue((int)face); 11849 11850 // copy argument pname 11851 GLMessage_DataType *arg_pname = glmsg.add_args(); 11852 arg_pname->set_isarray(false); 11853 arg_pname->set_type(GLMessage::DataType::ENUM); 11854 arg_pname->add_intvalue((int)pname); 11855 11856 // copy argument params 11857 GLMessage_DataType *arg_params = glmsg.add_args(); 11858 arg_params->set_isarray(false); 11859 arg_params->set_type(GLMessage::DataType::INT); 11860 arg_params->add_intvalue((int)params); 11861 11862 // call function 11863 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11864 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11865 glContext->hooks->gl.glGetMaterialxv(face, pname, params); 11866 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11867 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11868 11869 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11870 threadStartTime, threadEndTime, 11871 &glmsg); 11872 glContext->traceGLMessage(&glmsg); 11873} 11874 11875void GLTrace_glGetPointerv(GLenum pname, GLvoid **params) { 11876 GLMessage glmsg; 11877 GLTraceContext *glContext = getGLTraceContext(); 11878 11879 glmsg.set_function(GLMessage::glGetPointerv); 11880 11881 // copy argument pname 11882 GLMessage_DataType *arg_pname = glmsg.add_args(); 11883 arg_pname->set_isarray(false); 11884 arg_pname->set_type(GLMessage::DataType::ENUM); 11885 arg_pname->add_intvalue((int)pname); 11886 11887 // copy argument params 11888 GLMessage_DataType *arg_params = glmsg.add_args(); 11889 arg_params->set_isarray(false); 11890 arg_params->set_type(GLMessage::DataType::INT); 11891 arg_params->add_intvalue((int)params); 11892 11893 // call function 11894 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11895 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11896 glContext->hooks->gl.glGetPointerv(pname, params); 11897 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11898 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11899 11900 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11901 threadStartTime, threadEndTime, 11902 &glmsg); 11903 glContext->traceGLMessage(&glmsg); 11904} 11905 11906void GLTrace_glGetTexEnviv(GLenum env, GLenum pname, GLint *params) { 11907 GLMessage glmsg; 11908 GLTraceContext *glContext = getGLTraceContext(); 11909 11910 glmsg.set_function(GLMessage::glGetTexEnviv); 11911 11912 // copy argument env 11913 GLMessage_DataType *arg_env = glmsg.add_args(); 11914 arg_env->set_isarray(false); 11915 arg_env->set_type(GLMessage::DataType::ENUM); 11916 arg_env->add_intvalue((int)env); 11917 11918 // copy argument pname 11919 GLMessage_DataType *arg_pname = glmsg.add_args(); 11920 arg_pname->set_isarray(false); 11921 arg_pname->set_type(GLMessage::DataType::ENUM); 11922 arg_pname->add_intvalue((int)pname); 11923 11924 // copy argument params 11925 GLMessage_DataType *arg_params = glmsg.add_args(); 11926 arg_params->set_isarray(false); 11927 arg_params->set_type(GLMessage::DataType::INT); 11928 arg_params->add_intvalue((int)params); 11929 11930 // call function 11931 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11932 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11933 glContext->hooks->gl.glGetTexEnviv(env, pname, params); 11934 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11935 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11936 11937 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11938 threadStartTime, threadEndTime, 11939 &glmsg); 11940 glContext->traceGLMessage(&glmsg); 11941} 11942 11943void GLTrace_glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params) { 11944 GLMessage glmsg; 11945 GLTraceContext *glContext = getGLTraceContext(); 11946 11947 glmsg.set_function(GLMessage::glGetTexEnvxv); 11948 11949 // copy argument env 11950 GLMessage_DataType *arg_env = glmsg.add_args(); 11951 arg_env->set_isarray(false); 11952 arg_env->set_type(GLMessage::DataType::ENUM); 11953 arg_env->add_intvalue((int)env); 11954 11955 // copy argument pname 11956 GLMessage_DataType *arg_pname = glmsg.add_args(); 11957 arg_pname->set_isarray(false); 11958 arg_pname->set_type(GLMessage::DataType::ENUM); 11959 arg_pname->add_intvalue((int)pname); 11960 11961 // copy argument params 11962 GLMessage_DataType *arg_params = glmsg.add_args(); 11963 arg_params->set_isarray(false); 11964 arg_params->set_type(GLMessage::DataType::INT); 11965 arg_params->add_intvalue((int)params); 11966 11967 // call function 11968 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 11969 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 11970 glContext->hooks->gl.glGetTexEnvxv(env, pname, params); 11971 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 11972 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 11973 11974 fixupGLMessage(glContext, wallStartTime, wallEndTime, 11975 threadStartTime, threadEndTime, 11976 &glmsg); 11977 glContext->traceGLMessage(&glmsg); 11978} 11979 11980void GLTrace_glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) { 11981 GLMessage glmsg; 11982 GLTraceContext *glContext = getGLTraceContext(); 11983 11984 glmsg.set_function(GLMessage::glGetTexParameterxv); 11985 11986 // copy argument target 11987 GLMessage_DataType *arg_target = glmsg.add_args(); 11988 arg_target->set_isarray(false); 11989 arg_target->set_type(GLMessage::DataType::ENUM); 11990 arg_target->add_intvalue((int)target); 11991 11992 // copy argument pname 11993 GLMessage_DataType *arg_pname = glmsg.add_args(); 11994 arg_pname->set_isarray(false); 11995 arg_pname->set_type(GLMessage::DataType::ENUM); 11996 arg_pname->add_intvalue((int)pname); 11997 11998 // copy argument params 11999 GLMessage_DataType *arg_params = glmsg.add_args(); 12000 arg_params->set_isarray(false); 12001 arg_params->set_type(GLMessage::DataType::INT); 12002 arg_params->add_intvalue((int)params); 12003 12004 // call function 12005 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12006 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12007 glContext->hooks->gl.glGetTexParameterxv(target, pname, params); 12008 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12009 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12010 12011 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12012 threadStartTime, threadEndTime, 12013 &glmsg); 12014 glContext->traceGLMessage(&glmsg); 12015} 12016 12017void GLTrace_glLightModelx(GLenum pname, GLfixed param) { 12018 GLMessage glmsg; 12019 GLTraceContext *glContext = getGLTraceContext(); 12020 12021 glmsg.set_function(GLMessage::glLightModelx); 12022 12023 // copy argument pname 12024 GLMessage_DataType *arg_pname = glmsg.add_args(); 12025 arg_pname->set_isarray(false); 12026 arg_pname->set_type(GLMessage::DataType::ENUM); 12027 arg_pname->add_intvalue((int)pname); 12028 12029 // copy argument param 12030 GLMessage_DataType *arg_param = glmsg.add_args(); 12031 arg_param->set_isarray(false); 12032 arg_param->set_type(GLMessage::DataType::INT); 12033 arg_param->add_intvalue(param); 12034 12035 // call function 12036 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12037 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12038 glContext->hooks->gl.glLightModelx(pname, param); 12039 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12040 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12041 12042 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12043 threadStartTime, threadEndTime, 12044 &glmsg); 12045 glContext->traceGLMessage(&glmsg); 12046} 12047 12048void GLTrace_glLightModelxv(GLenum pname, const GLfixed *params) { 12049 GLMessage glmsg; 12050 GLTraceContext *glContext = getGLTraceContext(); 12051 12052 glmsg.set_function(GLMessage::glLightModelxv); 12053 12054 // copy argument pname 12055 GLMessage_DataType *arg_pname = glmsg.add_args(); 12056 arg_pname->set_isarray(false); 12057 arg_pname->set_type(GLMessage::DataType::ENUM); 12058 arg_pname->add_intvalue((int)pname); 12059 12060 // copy argument params 12061 GLMessage_DataType *arg_params = glmsg.add_args(); 12062 arg_params->set_isarray(false); 12063 arg_params->set_type(GLMessage::DataType::INT); 12064 arg_params->add_intvalue((int)params); 12065 12066 // call function 12067 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12068 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12069 glContext->hooks->gl.glLightModelxv(pname, params); 12070 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12071 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12072 12073 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12074 threadStartTime, threadEndTime, 12075 &glmsg); 12076 glContext->traceGLMessage(&glmsg); 12077} 12078 12079void GLTrace_glLightx(GLenum light, GLenum pname, GLfixed param) { 12080 GLMessage glmsg; 12081 GLTraceContext *glContext = getGLTraceContext(); 12082 12083 glmsg.set_function(GLMessage::glLightx); 12084 12085 // copy argument light 12086 GLMessage_DataType *arg_light = glmsg.add_args(); 12087 arg_light->set_isarray(false); 12088 arg_light->set_type(GLMessage::DataType::ENUM); 12089 arg_light->add_intvalue((int)light); 12090 12091 // copy argument pname 12092 GLMessage_DataType *arg_pname = glmsg.add_args(); 12093 arg_pname->set_isarray(false); 12094 arg_pname->set_type(GLMessage::DataType::ENUM); 12095 arg_pname->add_intvalue((int)pname); 12096 12097 // copy argument param 12098 GLMessage_DataType *arg_param = glmsg.add_args(); 12099 arg_param->set_isarray(false); 12100 arg_param->set_type(GLMessage::DataType::INT); 12101 arg_param->add_intvalue(param); 12102 12103 // call function 12104 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12105 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12106 glContext->hooks->gl.glLightx(light, pname, param); 12107 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12108 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12109 12110 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12111 threadStartTime, threadEndTime, 12112 &glmsg); 12113 glContext->traceGLMessage(&glmsg); 12114} 12115 12116void GLTrace_glLightxv(GLenum light, GLenum pname, const GLfixed *params) { 12117 GLMessage glmsg; 12118 GLTraceContext *glContext = getGLTraceContext(); 12119 12120 glmsg.set_function(GLMessage::glLightxv); 12121 12122 // copy argument light 12123 GLMessage_DataType *arg_light = glmsg.add_args(); 12124 arg_light->set_isarray(false); 12125 arg_light->set_type(GLMessage::DataType::ENUM); 12126 arg_light->add_intvalue((int)light); 12127 12128 // copy argument pname 12129 GLMessage_DataType *arg_pname = glmsg.add_args(); 12130 arg_pname->set_isarray(false); 12131 arg_pname->set_type(GLMessage::DataType::ENUM); 12132 arg_pname->add_intvalue((int)pname); 12133 12134 // copy argument params 12135 GLMessage_DataType *arg_params = glmsg.add_args(); 12136 arg_params->set_isarray(false); 12137 arg_params->set_type(GLMessage::DataType::INT); 12138 arg_params->add_intvalue((int)params); 12139 12140 // call function 12141 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12142 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12143 glContext->hooks->gl.glLightxv(light, pname, params); 12144 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12145 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12146 12147 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12148 threadStartTime, threadEndTime, 12149 &glmsg); 12150 glContext->traceGLMessage(&glmsg); 12151} 12152 12153void GLTrace_glLineWidthx(GLfixed width) { 12154 GLMessage glmsg; 12155 GLTraceContext *glContext = getGLTraceContext(); 12156 12157 glmsg.set_function(GLMessage::glLineWidthx); 12158 12159 // copy argument width 12160 GLMessage_DataType *arg_width = glmsg.add_args(); 12161 arg_width->set_isarray(false); 12162 arg_width->set_type(GLMessage::DataType::INT); 12163 arg_width->add_intvalue(width); 12164 12165 // call function 12166 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12167 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12168 glContext->hooks->gl.glLineWidthx(width); 12169 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12170 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12171 12172 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12173 threadStartTime, threadEndTime, 12174 &glmsg); 12175 glContext->traceGLMessage(&glmsg); 12176} 12177 12178void GLTrace_glLoadIdentity(void) { 12179 GLMessage glmsg; 12180 GLTraceContext *glContext = getGLTraceContext(); 12181 12182 glmsg.set_function(GLMessage::glLoadIdentity); 12183 12184 // call function 12185 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12186 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12187 glContext->hooks->gl.glLoadIdentity(); 12188 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12189 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12190 12191 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12192 threadStartTime, threadEndTime, 12193 &glmsg); 12194 glContext->traceGLMessage(&glmsg); 12195} 12196 12197void GLTrace_glLoadMatrixx(const GLfixed *m) { 12198 GLMessage glmsg; 12199 GLTraceContext *glContext = getGLTraceContext(); 12200 12201 glmsg.set_function(GLMessage::glLoadMatrixx); 12202 12203 // copy argument m 12204 GLMessage_DataType *arg_m = glmsg.add_args(); 12205 arg_m->set_isarray(false); 12206 arg_m->set_type(GLMessage::DataType::INT); 12207 arg_m->add_intvalue((int)m); 12208 12209 // call function 12210 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12211 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12212 glContext->hooks->gl.glLoadMatrixx(m); 12213 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12214 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12215 12216 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12217 threadStartTime, threadEndTime, 12218 &glmsg); 12219 glContext->traceGLMessage(&glmsg); 12220} 12221 12222void GLTrace_glLogicOp(GLenum opcode) { 12223 GLMessage glmsg; 12224 GLTraceContext *glContext = getGLTraceContext(); 12225 12226 glmsg.set_function(GLMessage::glLogicOp); 12227 12228 // copy argument opcode 12229 GLMessage_DataType *arg_opcode = glmsg.add_args(); 12230 arg_opcode->set_isarray(false); 12231 arg_opcode->set_type(GLMessage::DataType::ENUM); 12232 arg_opcode->add_intvalue((int)opcode); 12233 12234 // call function 12235 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12236 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12237 glContext->hooks->gl.glLogicOp(opcode); 12238 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12239 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12240 12241 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12242 threadStartTime, threadEndTime, 12243 &glmsg); 12244 glContext->traceGLMessage(&glmsg); 12245} 12246 12247void GLTrace_glMaterialx(GLenum face, GLenum pname, GLfixed param) { 12248 GLMessage glmsg; 12249 GLTraceContext *glContext = getGLTraceContext(); 12250 12251 glmsg.set_function(GLMessage::glMaterialx); 12252 12253 // copy argument face 12254 GLMessage_DataType *arg_face = glmsg.add_args(); 12255 arg_face->set_isarray(false); 12256 arg_face->set_type(GLMessage::DataType::ENUM); 12257 arg_face->add_intvalue((int)face); 12258 12259 // copy argument pname 12260 GLMessage_DataType *arg_pname = glmsg.add_args(); 12261 arg_pname->set_isarray(false); 12262 arg_pname->set_type(GLMessage::DataType::ENUM); 12263 arg_pname->add_intvalue((int)pname); 12264 12265 // copy argument param 12266 GLMessage_DataType *arg_param = glmsg.add_args(); 12267 arg_param->set_isarray(false); 12268 arg_param->set_type(GLMessage::DataType::INT); 12269 arg_param->add_intvalue(param); 12270 12271 // call function 12272 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12273 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12274 glContext->hooks->gl.glMaterialx(face, pname, param); 12275 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12276 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12277 12278 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12279 threadStartTime, threadEndTime, 12280 &glmsg); 12281 glContext->traceGLMessage(&glmsg); 12282} 12283 12284void GLTrace_glMaterialxv(GLenum face, GLenum pname, const GLfixed *params) { 12285 GLMessage glmsg; 12286 GLTraceContext *glContext = getGLTraceContext(); 12287 12288 glmsg.set_function(GLMessage::glMaterialxv); 12289 12290 // copy argument face 12291 GLMessage_DataType *arg_face = glmsg.add_args(); 12292 arg_face->set_isarray(false); 12293 arg_face->set_type(GLMessage::DataType::ENUM); 12294 arg_face->add_intvalue((int)face); 12295 12296 // copy argument pname 12297 GLMessage_DataType *arg_pname = glmsg.add_args(); 12298 arg_pname->set_isarray(false); 12299 arg_pname->set_type(GLMessage::DataType::ENUM); 12300 arg_pname->add_intvalue((int)pname); 12301 12302 // copy argument params 12303 GLMessage_DataType *arg_params = glmsg.add_args(); 12304 arg_params->set_isarray(false); 12305 arg_params->set_type(GLMessage::DataType::INT); 12306 arg_params->add_intvalue((int)params); 12307 12308 // call function 12309 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12310 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12311 glContext->hooks->gl.glMaterialxv(face, pname, params); 12312 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12313 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12314 12315 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12316 threadStartTime, threadEndTime, 12317 &glmsg); 12318 glContext->traceGLMessage(&glmsg); 12319} 12320 12321void GLTrace_glMatrixMode(GLenum mode) { 12322 GLMessage glmsg; 12323 GLTraceContext *glContext = getGLTraceContext(); 12324 12325 glmsg.set_function(GLMessage::glMatrixMode); 12326 12327 // copy argument mode 12328 GLMessage_DataType *arg_mode = glmsg.add_args(); 12329 arg_mode->set_isarray(false); 12330 arg_mode->set_type(GLMessage::DataType::ENUM); 12331 arg_mode->add_intvalue((int)mode); 12332 12333 // call function 12334 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12335 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12336 glContext->hooks->gl.glMatrixMode(mode); 12337 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12338 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12339 12340 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12341 threadStartTime, threadEndTime, 12342 &glmsg); 12343 glContext->traceGLMessage(&glmsg); 12344} 12345 12346void GLTrace_glMultMatrixx(const GLfixed *m) { 12347 GLMessage glmsg; 12348 GLTraceContext *glContext = getGLTraceContext(); 12349 12350 glmsg.set_function(GLMessage::glMultMatrixx); 12351 12352 // copy argument m 12353 GLMessage_DataType *arg_m = glmsg.add_args(); 12354 arg_m->set_isarray(false); 12355 arg_m->set_type(GLMessage::DataType::INT); 12356 arg_m->add_intvalue((int)m); 12357 12358 // call function 12359 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12360 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12361 glContext->hooks->gl.glMultMatrixx(m); 12362 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12363 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12364 12365 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12366 threadStartTime, threadEndTime, 12367 &glmsg); 12368 glContext->traceGLMessage(&glmsg); 12369} 12370 12371void GLTrace_glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { 12372 GLMessage glmsg; 12373 GLTraceContext *glContext = getGLTraceContext(); 12374 12375 glmsg.set_function(GLMessage::glMultiTexCoord4x); 12376 12377 // copy argument target 12378 GLMessage_DataType *arg_target = glmsg.add_args(); 12379 arg_target->set_isarray(false); 12380 arg_target->set_type(GLMessage::DataType::ENUM); 12381 arg_target->add_intvalue((int)target); 12382 12383 // copy argument s 12384 GLMessage_DataType *arg_s = glmsg.add_args(); 12385 arg_s->set_isarray(false); 12386 arg_s->set_type(GLMessage::DataType::INT); 12387 arg_s->add_intvalue(s); 12388 12389 // copy argument t 12390 GLMessage_DataType *arg_t = glmsg.add_args(); 12391 arg_t->set_isarray(false); 12392 arg_t->set_type(GLMessage::DataType::INT); 12393 arg_t->add_intvalue(t); 12394 12395 // copy argument r 12396 GLMessage_DataType *arg_r = glmsg.add_args(); 12397 arg_r->set_isarray(false); 12398 arg_r->set_type(GLMessage::DataType::INT); 12399 arg_r->add_intvalue(r); 12400 12401 // copy argument q 12402 GLMessage_DataType *arg_q = glmsg.add_args(); 12403 arg_q->set_isarray(false); 12404 arg_q->set_type(GLMessage::DataType::INT); 12405 arg_q->add_intvalue(q); 12406 12407 // call function 12408 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12409 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12410 glContext->hooks->gl.glMultiTexCoord4x(target, s, t, r, q); 12411 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12412 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12413 12414 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12415 threadStartTime, threadEndTime, 12416 &glmsg); 12417 glContext->traceGLMessage(&glmsg); 12418} 12419 12420void GLTrace_glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz) { 12421 GLMessage glmsg; 12422 GLTraceContext *glContext = getGLTraceContext(); 12423 12424 glmsg.set_function(GLMessage::glNormal3x); 12425 12426 // copy argument nx 12427 GLMessage_DataType *arg_nx = glmsg.add_args(); 12428 arg_nx->set_isarray(false); 12429 arg_nx->set_type(GLMessage::DataType::INT); 12430 arg_nx->add_intvalue(nx); 12431 12432 // copy argument ny 12433 GLMessage_DataType *arg_ny = glmsg.add_args(); 12434 arg_ny->set_isarray(false); 12435 arg_ny->set_type(GLMessage::DataType::INT); 12436 arg_ny->add_intvalue(ny); 12437 12438 // copy argument nz 12439 GLMessage_DataType *arg_nz = glmsg.add_args(); 12440 arg_nz->set_isarray(false); 12441 arg_nz->set_type(GLMessage::DataType::INT); 12442 arg_nz->add_intvalue(nz); 12443 12444 // call function 12445 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12446 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12447 glContext->hooks->gl.glNormal3x(nx, ny, nz); 12448 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12449 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12450 12451 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12452 threadStartTime, threadEndTime, 12453 &glmsg); 12454 glContext->traceGLMessage(&glmsg); 12455} 12456 12457void GLTrace_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) { 12458 GLMessage glmsg; 12459 GLTraceContext *glContext = getGLTraceContext(); 12460 12461 glmsg.set_function(GLMessage::glNormalPointer); 12462 12463 // copy argument type 12464 GLMessage_DataType *arg_type = glmsg.add_args(); 12465 arg_type->set_isarray(false); 12466 arg_type->set_type(GLMessage::DataType::ENUM); 12467 arg_type->add_intvalue((int)type); 12468 12469 // copy argument stride 12470 GLMessage_DataType *arg_stride = glmsg.add_args(); 12471 arg_stride->set_isarray(false); 12472 arg_stride->set_type(GLMessage::DataType::INT); 12473 arg_stride->add_intvalue(stride); 12474 12475 // copy argument pointer 12476 GLMessage_DataType *arg_pointer = glmsg.add_args(); 12477 arg_pointer->set_isarray(false); 12478 arg_pointer->set_type(GLMessage::DataType::INT); 12479 arg_pointer->add_intvalue((int)pointer); 12480 12481 // call function 12482 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12483 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12484 glContext->hooks->gl.glNormalPointer(type, stride, pointer); 12485 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12486 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12487 12488 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12489 threadStartTime, threadEndTime, 12490 &glmsg); 12491 glContext->traceGLMessage(&glmsg); 12492} 12493 12494void GLTrace_glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { 12495 GLMessage glmsg; 12496 GLTraceContext *glContext = getGLTraceContext(); 12497 12498 glmsg.set_function(GLMessage::glOrthox); 12499 12500 // copy argument left 12501 GLMessage_DataType *arg_left = glmsg.add_args(); 12502 arg_left->set_isarray(false); 12503 arg_left->set_type(GLMessage::DataType::INT); 12504 arg_left->add_intvalue(left); 12505 12506 // copy argument right 12507 GLMessage_DataType *arg_right = glmsg.add_args(); 12508 arg_right->set_isarray(false); 12509 arg_right->set_type(GLMessage::DataType::INT); 12510 arg_right->add_intvalue(right); 12511 12512 // copy argument bottom 12513 GLMessage_DataType *arg_bottom = glmsg.add_args(); 12514 arg_bottom->set_isarray(false); 12515 arg_bottom->set_type(GLMessage::DataType::INT); 12516 arg_bottom->add_intvalue(bottom); 12517 12518 // copy argument top 12519 GLMessage_DataType *arg_top = glmsg.add_args(); 12520 arg_top->set_isarray(false); 12521 arg_top->set_type(GLMessage::DataType::INT); 12522 arg_top->add_intvalue(top); 12523 12524 // copy argument zNear 12525 GLMessage_DataType *arg_zNear = glmsg.add_args(); 12526 arg_zNear->set_isarray(false); 12527 arg_zNear->set_type(GLMessage::DataType::INT); 12528 arg_zNear->add_intvalue(zNear); 12529 12530 // copy argument zFar 12531 GLMessage_DataType *arg_zFar = glmsg.add_args(); 12532 arg_zFar->set_isarray(false); 12533 arg_zFar->set_type(GLMessage::DataType::INT); 12534 arg_zFar->add_intvalue(zFar); 12535 12536 // call function 12537 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12538 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12539 glContext->hooks->gl.glOrthox(left, right, bottom, top, zNear, zFar); 12540 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12541 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12542 12543 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12544 threadStartTime, threadEndTime, 12545 &glmsg); 12546 glContext->traceGLMessage(&glmsg); 12547} 12548 12549void GLTrace_glPointParameterx(GLenum pname, GLfixed param) { 12550 GLMessage glmsg; 12551 GLTraceContext *glContext = getGLTraceContext(); 12552 12553 glmsg.set_function(GLMessage::glPointParameterx); 12554 12555 // copy argument pname 12556 GLMessage_DataType *arg_pname = glmsg.add_args(); 12557 arg_pname->set_isarray(false); 12558 arg_pname->set_type(GLMessage::DataType::ENUM); 12559 arg_pname->add_intvalue((int)pname); 12560 12561 // copy argument param 12562 GLMessage_DataType *arg_param = glmsg.add_args(); 12563 arg_param->set_isarray(false); 12564 arg_param->set_type(GLMessage::DataType::INT); 12565 arg_param->add_intvalue(param); 12566 12567 // call function 12568 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12569 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12570 glContext->hooks->gl.glPointParameterx(pname, param); 12571 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12572 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12573 12574 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12575 threadStartTime, threadEndTime, 12576 &glmsg); 12577 glContext->traceGLMessage(&glmsg); 12578} 12579 12580void GLTrace_glPointParameterxv(GLenum pname, const GLfixed *params) { 12581 GLMessage glmsg; 12582 GLTraceContext *glContext = getGLTraceContext(); 12583 12584 glmsg.set_function(GLMessage::glPointParameterxv); 12585 12586 // copy argument pname 12587 GLMessage_DataType *arg_pname = glmsg.add_args(); 12588 arg_pname->set_isarray(false); 12589 arg_pname->set_type(GLMessage::DataType::ENUM); 12590 arg_pname->add_intvalue((int)pname); 12591 12592 // copy argument params 12593 GLMessage_DataType *arg_params = glmsg.add_args(); 12594 arg_params->set_isarray(false); 12595 arg_params->set_type(GLMessage::DataType::INT); 12596 arg_params->add_intvalue((int)params); 12597 12598 // call function 12599 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12600 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12601 glContext->hooks->gl.glPointParameterxv(pname, params); 12602 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12603 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12604 12605 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12606 threadStartTime, threadEndTime, 12607 &glmsg); 12608 glContext->traceGLMessage(&glmsg); 12609} 12610 12611void GLTrace_glPointSizex(GLfixed size) { 12612 GLMessage glmsg; 12613 GLTraceContext *glContext = getGLTraceContext(); 12614 12615 glmsg.set_function(GLMessage::glPointSizex); 12616 12617 // copy argument size 12618 GLMessage_DataType *arg_size = glmsg.add_args(); 12619 arg_size->set_isarray(false); 12620 arg_size->set_type(GLMessage::DataType::INT); 12621 arg_size->add_intvalue(size); 12622 12623 // call function 12624 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12625 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12626 glContext->hooks->gl.glPointSizex(size); 12627 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12628 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12629 12630 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12631 threadStartTime, threadEndTime, 12632 &glmsg); 12633 glContext->traceGLMessage(&glmsg); 12634} 12635 12636void GLTrace_glPolygonOffsetx(GLfixed factor, GLfixed units) { 12637 GLMessage glmsg; 12638 GLTraceContext *glContext = getGLTraceContext(); 12639 12640 glmsg.set_function(GLMessage::glPolygonOffsetx); 12641 12642 // copy argument factor 12643 GLMessage_DataType *arg_factor = glmsg.add_args(); 12644 arg_factor->set_isarray(false); 12645 arg_factor->set_type(GLMessage::DataType::INT); 12646 arg_factor->add_intvalue(factor); 12647 12648 // copy argument units 12649 GLMessage_DataType *arg_units = glmsg.add_args(); 12650 arg_units->set_isarray(false); 12651 arg_units->set_type(GLMessage::DataType::INT); 12652 arg_units->add_intvalue(units); 12653 12654 // call function 12655 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12656 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12657 glContext->hooks->gl.glPolygonOffsetx(factor, units); 12658 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12659 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12660 12661 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12662 threadStartTime, threadEndTime, 12663 &glmsg); 12664 glContext->traceGLMessage(&glmsg); 12665} 12666 12667void GLTrace_glPopMatrix(void) { 12668 GLMessage glmsg; 12669 GLTraceContext *glContext = getGLTraceContext(); 12670 12671 glmsg.set_function(GLMessage::glPopMatrix); 12672 12673 // call function 12674 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12675 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12676 glContext->hooks->gl.glPopMatrix(); 12677 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12678 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12679 12680 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12681 threadStartTime, threadEndTime, 12682 &glmsg); 12683 glContext->traceGLMessage(&glmsg); 12684} 12685 12686void GLTrace_glPushMatrix(void) { 12687 GLMessage glmsg; 12688 GLTraceContext *glContext = getGLTraceContext(); 12689 12690 glmsg.set_function(GLMessage::glPushMatrix); 12691 12692 // call function 12693 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12694 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12695 glContext->hooks->gl.glPushMatrix(); 12696 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12697 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12698 12699 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12700 threadStartTime, threadEndTime, 12701 &glmsg); 12702 glContext->traceGLMessage(&glmsg); 12703} 12704 12705void GLTrace_glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { 12706 GLMessage glmsg; 12707 GLTraceContext *glContext = getGLTraceContext(); 12708 12709 glmsg.set_function(GLMessage::glRotatex); 12710 12711 // copy argument angle 12712 GLMessage_DataType *arg_angle = glmsg.add_args(); 12713 arg_angle->set_isarray(false); 12714 arg_angle->set_type(GLMessage::DataType::INT); 12715 arg_angle->add_intvalue(angle); 12716 12717 // copy argument x 12718 GLMessage_DataType *arg_x = glmsg.add_args(); 12719 arg_x->set_isarray(false); 12720 arg_x->set_type(GLMessage::DataType::INT); 12721 arg_x->add_intvalue(x); 12722 12723 // copy argument y 12724 GLMessage_DataType *arg_y = glmsg.add_args(); 12725 arg_y->set_isarray(false); 12726 arg_y->set_type(GLMessage::DataType::INT); 12727 arg_y->add_intvalue(y); 12728 12729 // copy argument z 12730 GLMessage_DataType *arg_z = glmsg.add_args(); 12731 arg_z->set_isarray(false); 12732 arg_z->set_type(GLMessage::DataType::INT); 12733 arg_z->add_intvalue(z); 12734 12735 // call function 12736 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12737 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12738 glContext->hooks->gl.glRotatex(angle, x, y, z); 12739 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12740 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12741 12742 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12743 threadStartTime, threadEndTime, 12744 &glmsg); 12745 glContext->traceGLMessage(&glmsg); 12746} 12747 12748void GLTrace_glSampleCoveragex(GLclampx value, GLboolean invert) { 12749 GLMessage glmsg; 12750 GLTraceContext *glContext = getGLTraceContext(); 12751 12752 glmsg.set_function(GLMessage::glSampleCoveragex); 12753 12754 // copy argument value 12755 GLMessage_DataType *arg_value = glmsg.add_args(); 12756 arg_value->set_isarray(false); 12757 arg_value->set_type(GLMessage::DataType::INT); 12758 arg_value->add_intvalue(value); 12759 12760 // copy argument invert 12761 GLMessage_DataType *arg_invert = glmsg.add_args(); 12762 arg_invert->set_isarray(false); 12763 arg_invert->set_type(GLMessage::DataType::BOOL); 12764 arg_invert->add_boolvalue(invert); 12765 12766 // call function 12767 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12768 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12769 glContext->hooks->gl.glSampleCoveragex(value, invert); 12770 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12771 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12772 12773 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12774 threadStartTime, threadEndTime, 12775 &glmsg); 12776 glContext->traceGLMessage(&glmsg); 12777} 12778 12779void GLTrace_glScalex(GLfixed x, GLfixed y, GLfixed z) { 12780 GLMessage glmsg; 12781 GLTraceContext *glContext = getGLTraceContext(); 12782 12783 glmsg.set_function(GLMessage::glScalex); 12784 12785 // copy argument x 12786 GLMessage_DataType *arg_x = glmsg.add_args(); 12787 arg_x->set_isarray(false); 12788 arg_x->set_type(GLMessage::DataType::INT); 12789 arg_x->add_intvalue(x); 12790 12791 // copy argument y 12792 GLMessage_DataType *arg_y = glmsg.add_args(); 12793 arg_y->set_isarray(false); 12794 arg_y->set_type(GLMessage::DataType::INT); 12795 arg_y->add_intvalue(y); 12796 12797 // copy argument z 12798 GLMessage_DataType *arg_z = glmsg.add_args(); 12799 arg_z->set_isarray(false); 12800 arg_z->set_type(GLMessage::DataType::INT); 12801 arg_z->add_intvalue(z); 12802 12803 // call function 12804 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12805 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12806 glContext->hooks->gl.glScalex(x, y, z); 12807 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12808 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12809 12810 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12811 threadStartTime, threadEndTime, 12812 &glmsg); 12813 glContext->traceGLMessage(&glmsg); 12814} 12815 12816void GLTrace_glShadeModel(GLenum mode) { 12817 GLMessage glmsg; 12818 GLTraceContext *glContext = getGLTraceContext(); 12819 12820 glmsg.set_function(GLMessage::glShadeModel); 12821 12822 // copy argument mode 12823 GLMessage_DataType *arg_mode = glmsg.add_args(); 12824 arg_mode->set_isarray(false); 12825 arg_mode->set_type(GLMessage::DataType::ENUM); 12826 arg_mode->add_intvalue((int)mode); 12827 12828 // call function 12829 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12830 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12831 glContext->hooks->gl.glShadeModel(mode); 12832 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12833 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12834 12835 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12836 threadStartTime, threadEndTime, 12837 &glmsg); 12838 glContext->traceGLMessage(&glmsg); 12839} 12840 12841void GLTrace_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { 12842 GLMessage glmsg; 12843 GLTraceContext *glContext = getGLTraceContext(); 12844 12845 glmsg.set_function(GLMessage::glTexCoordPointer); 12846 12847 // copy argument size 12848 GLMessage_DataType *arg_size = glmsg.add_args(); 12849 arg_size->set_isarray(false); 12850 arg_size->set_type(GLMessage::DataType::INT); 12851 arg_size->add_intvalue(size); 12852 12853 // copy argument type 12854 GLMessage_DataType *arg_type = glmsg.add_args(); 12855 arg_type->set_isarray(false); 12856 arg_type->set_type(GLMessage::DataType::ENUM); 12857 arg_type->add_intvalue((int)type); 12858 12859 // copy argument stride 12860 GLMessage_DataType *arg_stride = glmsg.add_args(); 12861 arg_stride->set_isarray(false); 12862 arg_stride->set_type(GLMessage::DataType::INT); 12863 arg_stride->add_intvalue(stride); 12864 12865 // copy argument pointer 12866 GLMessage_DataType *arg_pointer = glmsg.add_args(); 12867 arg_pointer->set_isarray(false); 12868 arg_pointer->set_type(GLMessage::DataType::INT); 12869 arg_pointer->add_intvalue((int)pointer); 12870 12871 // call function 12872 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12873 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12874 glContext->hooks->gl.glTexCoordPointer(size, type, stride, pointer); 12875 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12876 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12877 12878 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12879 threadStartTime, threadEndTime, 12880 &glmsg); 12881 glContext->traceGLMessage(&glmsg); 12882} 12883 12884void GLTrace_glTexEnvi(GLenum target, GLenum pname, GLint param) { 12885 GLMessage glmsg; 12886 GLTraceContext *glContext = getGLTraceContext(); 12887 12888 glmsg.set_function(GLMessage::glTexEnvi); 12889 12890 // copy argument target 12891 GLMessage_DataType *arg_target = glmsg.add_args(); 12892 arg_target->set_isarray(false); 12893 arg_target->set_type(GLMessage::DataType::ENUM); 12894 arg_target->add_intvalue((int)target); 12895 12896 // copy argument pname 12897 GLMessage_DataType *arg_pname = glmsg.add_args(); 12898 arg_pname->set_isarray(false); 12899 arg_pname->set_type(GLMessage::DataType::ENUM); 12900 arg_pname->add_intvalue((int)pname); 12901 12902 // copy argument param 12903 GLMessage_DataType *arg_param = glmsg.add_args(); 12904 arg_param->set_isarray(false); 12905 arg_param->set_type(GLMessage::DataType::INT); 12906 arg_param->add_intvalue(param); 12907 12908 // call function 12909 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12910 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12911 glContext->hooks->gl.glTexEnvi(target, pname, param); 12912 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12913 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12914 12915 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12916 threadStartTime, threadEndTime, 12917 &glmsg); 12918 glContext->traceGLMessage(&glmsg); 12919} 12920 12921void GLTrace_glTexEnvx(GLenum target, GLenum pname, GLfixed param) { 12922 GLMessage glmsg; 12923 GLTraceContext *glContext = getGLTraceContext(); 12924 12925 glmsg.set_function(GLMessage::glTexEnvx); 12926 12927 // copy argument target 12928 GLMessage_DataType *arg_target = glmsg.add_args(); 12929 arg_target->set_isarray(false); 12930 arg_target->set_type(GLMessage::DataType::ENUM); 12931 arg_target->add_intvalue((int)target); 12932 12933 // copy argument pname 12934 GLMessage_DataType *arg_pname = glmsg.add_args(); 12935 arg_pname->set_isarray(false); 12936 arg_pname->set_type(GLMessage::DataType::ENUM); 12937 arg_pname->add_intvalue((int)pname); 12938 12939 // copy argument param 12940 GLMessage_DataType *arg_param = glmsg.add_args(); 12941 arg_param->set_isarray(false); 12942 arg_param->set_type(GLMessage::DataType::INT); 12943 arg_param->add_intvalue(param); 12944 12945 // call function 12946 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12947 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12948 glContext->hooks->gl.glTexEnvx(target, pname, param); 12949 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12950 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12951 12952 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12953 threadStartTime, threadEndTime, 12954 &glmsg); 12955 glContext->traceGLMessage(&glmsg); 12956} 12957 12958void GLTrace_glTexEnviv(GLenum target, GLenum pname, const GLint *params) { 12959 GLMessage glmsg; 12960 GLTraceContext *glContext = getGLTraceContext(); 12961 12962 glmsg.set_function(GLMessage::glTexEnviv); 12963 12964 // copy argument target 12965 GLMessage_DataType *arg_target = glmsg.add_args(); 12966 arg_target->set_isarray(false); 12967 arg_target->set_type(GLMessage::DataType::ENUM); 12968 arg_target->add_intvalue((int)target); 12969 12970 // copy argument pname 12971 GLMessage_DataType *arg_pname = glmsg.add_args(); 12972 arg_pname->set_isarray(false); 12973 arg_pname->set_type(GLMessage::DataType::ENUM); 12974 arg_pname->add_intvalue((int)pname); 12975 12976 // copy argument params 12977 GLMessage_DataType *arg_params = glmsg.add_args(); 12978 arg_params->set_isarray(false); 12979 arg_params->set_type(GLMessage::DataType::INT); 12980 arg_params->add_intvalue((int)params); 12981 12982 // call function 12983 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 12984 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 12985 glContext->hooks->gl.glTexEnviv(target, pname, params); 12986 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 12987 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 12988 12989 fixupGLMessage(glContext, wallStartTime, wallEndTime, 12990 threadStartTime, threadEndTime, 12991 &glmsg); 12992 glContext->traceGLMessage(&glmsg); 12993} 12994 12995void GLTrace_glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params) { 12996 GLMessage glmsg; 12997 GLTraceContext *glContext = getGLTraceContext(); 12998 12999 glmsg.set_function(GLMessage::glTexEnvxv); 13000 13001 // copy argument target 13002 GLMessage_DataType *arg_target = glmsg.add_args(); 13003 arg_target->set_isarray(false); 13004 arg_target->set_type(GLMessage::DataType::ENUM); 13005 arg_target->add_intvalue((int)target); 13006 13007 // copy argument pname 13008 GLMessage_DataType *arg_pname = glmsg.add_args(); 13009 arg_pname->set_isarray(false); 13010 arg_pname->set_type(GLMessage::DataType::ENUM); 13011 arg_pname->add_intvalue((int)pname); 13012 13013 // copy argument params 13014 GLMessage_DataType *arg_params = glmsg.add_args(); 13015 arg_params->set_isarray(false); 13016 arg_params->set_type(GLMessage::DataType::INT); 13017 arg_params->add_intvalue((int)params); 13018 13019 // call function 13020 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13021 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13022 glContext->hooks->gl.glTexEnvxv(target, pname, params); 13023 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13024 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13025 13026 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13027 threadStartTime, threadEndTime, 13028 &glmsg); 13029 glContext->traceGLMessage(&glmsg); 13030} 13031 13032void GLTrace_glTexParameterx(GLenum target, GLenum pname, GLfixed param) { 13033 GLMessage glmsg; 13034 GLTraceContext *glContext = getGLTraceContext(); 13035 13036 glmsg.set_function(GLMessage::glTexParameterx); 13037 13038 // copy argument target 13039 GLMessage_DataType *arg_target = glmsg.add_args(); 13040 arg_target->set_isarray(false); 13041 arg_target->set_type(GLMessage::DataType::ENUM); 13042 arg_target->add_intvalue((int)target); 13043 13044 // copy argument pname 13045 GLMessage_DataType *arg_pname = glmsg.add_args(); 13046 arg_pname->set_isarray(false); 13047 arg_pname->set_type(GLMessage::DataType::ENUM); 13048 arg_pname->add_intvalue((int)pname); 13049 13050 // copy argument param 13051 GLMessage_DataType *arg_param = glmsg.add_args(); 13052 arg_param->set_isarray(false); 13053 arg_param->set_type(GLMessage::DataType::INT); 13054 arg_param->add_intvalue(param); 13055 13056 // call function 13057 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13058 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13059 glContext->hooks->gl.glTexParameterx(target, pname, param); 13060 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13061 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13062 13063 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13064 threadStartTime, threadEndTime, 13065 &glmsg); 13066 glContext->traceGLMessage(&glmsg); 13067} 13068 13069void GLTrace_glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params) { 13070 GLMessage glmsg; 13071 GLTraceContext *glContext = getGLTraceContext(); 13072 13073 glmsg.set_function(GLMessage::glTexParameterxv); 13074 13075 // copy argument target 13076 GLMessage_DataType *arg_target = glmsg.add_args(); 13077 arg_target->set_isarray(false); 13078 arg_target->set_type(GLMessage::DataType::ENUM); 13079 arg_target->add_intvalue((int)target); 13080 13081 // copy argument pname 13082 GLMessage_DataType *arg_pname = glmsg.add_args(); 13083 arg_pname->set_isarray(false); 13084 arg_pname->set_type(GLMessage::DataType::ENUM); 13085 arg_pname->add_intvalue((int)pname); 13086 13087 // copy argument params 13088 GLMessage_DataType *arg_params = glmsg.add_args(); 13089 arg_params->set_isarray(false); 13090 arg_params->set_type(GLMessage::DataType::INT); 13091 arg_params->add_intvalue((int)params); 13092 13093 // call function 13094 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13095 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13096 glContext->hooks->gl.glTexParameterxv(target, pname, params); 13097 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13098 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13099 13100 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13101 threadStartTime, threadEndTime, 13102 &glmsg); 13103 glContext->traceGLMessage(&glmsg); 13104} 13105 13106void GLTrace_glTranslatex(GLfixed x, GLfixed y, GLfixed z) { 13107 GLMessage glmsg; 13108 GLTraceContext *glContext = getGLTraceContext(); 13109 13110 glmsg.set_function(GLMessage::glTranslatex); 13111 13112 // copy argument x 13113 GLMessage_DataType *arg_x = glmsg.add_args(); 13114 arg_x->set_isarray(false); 13115 arg_x->set_type(GLMessage::DataType::INT); 13116 arg_x->add_intvalue(x); 13117 13118 // copy argument y 13119 GLMessage_DataType *arg_y = glmsg.add_args(); 13120 arg_y->set_isarray(false); 13121 arg_y->set_type(GLMessage::DataType::INT); 13122 arg_y->add_intvalue(y); 13123 13124 // copy argument z 13125 GLMessage_DataType *arg_z = glmsg.add_args(); 13126 arg_z->set_isarray(false); 13127 arg_z->set_type(GLMessage::DataType::INT); 13128 arg_z->add_intvalue(z); 13129 13130 // call function 13131 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13132 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13133 glContext->hooks->gl.glTranslatex(x, y, z); 13134 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13135 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13136 13137 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13138 threadStartTime, threadEndTime, 13139 &glmsg); 13140 glContext->traceGLMessage(&glmsg); 13141} 13142 13143void GLTrace_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { 13144 GLMessage glmsg; 13145 GLTraceContext *glContext = getGLTraceContext(); 13146 13147 glmsg.set_function(GLMessage::glVertexPointer); 13148 13149 // copy argument size 13150 GLMessage_DataType *arg_size = glmsg.add_args(); 13151 arg_size->set_isarray(false); 13152 arg_size->set_type(GLMessage::DataType::INT); 13153 arg_size->add_intvalue(size); 13154 13155 // copy argument type 13156 GLMessage_DataType *arg_type = glmsg.add_args(); 13157 arg_type->set_isarray(false); 13158 arg_type->set_type(GLMessage::DataType::ENUM); 13159 arg_type->add_intvalue((int)type); 13160 13161 // copy argument stride 13162 GLMessage_DataType *arg_stride = glmsg.add_args(); 13163 arg_stride->set_isarray(false); 13164 arg_stride->set_type(GLMessage::DataType::INT); 13165 arg_stride->add_intvalue(stride); 13166 13167 // copy argument pointer 13168 GLMessage_DataType *arg_pointer = glmsg.add_args(); 13169 arg_pointer->set_isarray(false); 13170 arg_pointer->set_type(GLMessage::DataType::INT); 13171 arg_pointer->add_intvalue((int)pointer); 13172 13173 // call function 13174 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13175 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13176 glContext->hooks->gl.glVertexPointer(size, type, stride, pointer); 13177 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13178 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13179 13180 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13181 threadStartTime, threadEndTime, 13182 &glmsg); 13183 glContext->traceGLMessage(&glmsg); 13184} 13185 13186void GLTrace_glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer) { 13187 GLMessage glmsg; 13188 GLTraceContext *glContext = getGLTraceContext(); 13189 13190 glmsg.set_function(GLMessage::glPointSizePointerOES); 13191 13192 // copy argument type 13193 GLMessage_DataType *arg_type = glmsg.add_args(); 13194 arg_type->set_isarray(false); 13195 arg_type->set_type(GLMessage::DataType::ENUM); 13196 arg_type->add_intvalue((int)type); 13197 13198 // copy argument stride 13199 GLMessage_DataType *arg_stride = glmsg.add_args(); 13200 arg_stride->set_isarray(false); 13201 arg_stride->set_type(GLMessage::DataType::INT); 13202 arg_stride->add_intvalue(stride); 13203 13204 // copy argument pointer 13205 GLMessage_DataType *arg_pointer = glmsg.add_args(); 13206 arg_pointer->set_isarray(false); 13207 arg_pointer->set_type(GLMessage::DataType::INT); 13208 arg_pointer->add_intvalue((int)pointer); 13209 13210 // call function 13211 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13212 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13213 glContext->hooks->gl.glPointSizePointerOES(type, stride, pointer); 13214 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13215 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13216 13217 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13218 threadStartTime, threadEndTime, 13219 &glmsg); 13220 glContext->traceGLMessage(&glmsg); 13221} 13222 13223 13224// Definitions for GL1Ext APIs 13225 13226void GLTrace_glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha) { 13227 GLMessage glmsg; 13228 GLTraceContext *glContext = getGLTraceContext(); 13229 13230 glmsg.set_function(GLMessage::glBlendEquationSeparateOES); 13231 13232 // copy argument modeRGB 13233 GLMessage_DataType *arg_modeRGB = glmsg.add_args(); 13234 arg_modeRGB->set_isarray(false); 13235 arg_modeRGB->set_type(GLMessage::DataType::ENUM); 13236 arg_modeRGB->add_intvalue((int)modeRGB); 13237 13238 // copy argument modeAlpha 13239 GLMessage_DataType *arg_modeAlpha = glmsg.add_args(); 13240 arg_modeAlpha->set_isarray(false); 13241 arg_modeAlpha->set_type(GLMessage::DataType::ENUM); 13242 arg_modeAlpha->add_intvalue((int)modeAlpha); 13243 13244 // call function 13245 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13246 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13247 glContext->hooks->gl.glBlendEquationSeparateOES(modeRGB, modeAlpha); 13248 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13249 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13250 13251 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13252 threadStartTime, threadEndTime, 13253 &glmsg); 13254 glContext->traceGLMessage(&glmsg); 13255} 13256 13257void GLTrace_glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { 13258 GLMessage glmsg; 13259 GLTraceContext *glContext = getGLTraceContext(); 13260 13261 glmsg.set_function(GLMessage::glBlendFuncSeparateOES); 13262 13263 // copy argument srcRGB 13264 GLMessage_DataType *arg_srcRGB = glmsg.add_args(); 13265 arg_srcRGB->set_isarray(false); 13266 arg_srcRGB->set_type(GLMessage::DataType::ENUM); 13267 arg_srcRGB->add_intvalue((int)srcRGB); 13268 13269 // copy argument dstRGB 13270 GLMessage_DataType *arg_dstRGB = glmsg.add_args(); 13271 arg_dstRGB->set_isarray(false); 13272 arg_dstRGB->set_type(GLMessage::DataType::ENUM); 13273 arg_dstRGB->add_intvalue((int)dstRGB); 13274 13275 // copy argument srcAlpha 13276 GLMessage_DataType *arg_srcAlpha = glmsg.add_args(); 13277 arg_srcAlpha->set_isarray(false); 13278 arg_srcAlpha->set_type(GLMessage::DataType::ENUM); 13279 arg_srcAlpha->add_intvalue((int)srcAlpha); 13280 13281 // copy argument dstAlpha 13282 GLMessage_DataType *arg_dstAlpha = glmsg.add_args(); 13283 arg_dstAlpha->set_isarray(false); 13284 arg_dstAlpha->set_type(GLMessage::DataType::ENUM); 13285 arg_dstAlpha->add_intvalue((int)dstAlpha); 13286 13287 // call function 13288 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13289 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13290 glContext->hooks->gl.glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha); 13291 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13292 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13293 13294 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13295 threadStartTime, threadEndTime, 13296 &glmsg); 13297 glContext->traceGLMessage(&glmsg); 13298} 13299 13300void GLTrace_glBlendEquationOES(GLenum mode) { 13301 GLMessage glmsg; 13302 GLTraceContext *glContext = getGLTraceContext(); 13303 13304 glmsg.set_function(GLMessage::glBlendEquationOES); 13305 13306 // copy argument mode 13307 GLMessage_DataType *arg_mode = glmsg.add_args(); 13308 arg_mode->set_isarray(false); 13309 arg_mode->set_type(GLMessage::DataType::ENUM); 13310 arg_mode->add_intvalue((int)mode); 13311 13312 // call function 13313 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13314 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13315 glContext->hooks->gl.glBlendEquationOES(mode); 13316 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13317 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13318 13319 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13320 threadStartTime, threadEndTime, 13321 &glmsg); 13322 glContext->traceGLMessage(&glmsg); 13323} 13324 13325void GLTrace_glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) { 13326 GLMessage glmsg; 13327 GLTraceContext *glContext = getGLTraceContext(); 13328 13329 glmsg.set_function(GLMessage::glDrawTexsOES); 13330 13331 // copy argument x 13332 GLMessage_DataType *arg_x = glmsg.add_args(); 13333 arg_x->set_isarray(false); 13334 arg_x->set_type(GLMessage::DataType::INT); 13335 arg_x->add_intvalue(x); 13336 13337 // copy argument y 13338 GLMessage_DataType *arg_y = glmsg.add_args(); 13339 arg_y->set_isarray(false); 13340 arg_y->set_type(GLMessage::DataType::INT); 13341 arg_y->add_intvalue(y); 13342 13343 // copy argument z 13344 GLMessage_DataType *arg_z = glmsg.add_args(); 13345 arg_z->set_isarray(false); 13346 arg_z->set_type(GLMessage::DataType::INT); 13347 arg_z->add_intvalue(z); 13348 13349 // copy argument width 13350 GLMessage_DataType *arg_width = glmsg.add_args(); 13351 arg_width->set_isarray(false); 13352 arg_width->set_type(GLMessage::DataType::INT); 13353 arg_width->add_intvalue(width); 13354 13355 // copy argument height 13356 GLMessage_DataType *arg_height = glmsg.add_args(); 13357 arg_height->set_isarray(false); 13358 arg_height->set_type(GLMessage::DataType::INT); 13359 arg_height->add_intvalue(height); 13360 13361 // call function 13362 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13363 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13364 glContext->hooks->gl.glDrawTexsOES(x, y, z, width, height); 13365 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13366 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13367 13368 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13369 threadStartTime, threadEndTime, 13370 &glmsg); 13371 glContext->traceGLMessage(&glmsg); 13372} 13373 13374void GLTrace_glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height) { 13375 GLMessage glmsg; 13376 GLTraceContext *glContext = getGLTraceContext(); 13377 13378 glmsg.set_function(GLMessage::glDrawTexiOES); 13379 13380 // copy argument x 13381 GLMessage_DataType *arg_x = glmsg.add_args(); 13382 arg_x->set_isarray(false); 13383 arg_x->set_type(GLMessage::DataType::INT); 13384 arg_x->add_intvalue(x); 13385 13386 // copy argument y 13387 GLMessage_DataType *arg_y = glmsg.add_args(); 13388 arg_y->set_isarray(false); 13389 arg_y->set_type(GLMessage::DataType::INT); 13390 arg_y->add_intvalue(y); 13391 13392 // copy argument z 13393 GLMessage_DataType *arg_z = glmsg.add_args(); 13394 arg_z->set_isarray(false); 13395 arg_z->set_type(GLMessage::DataType::INT); 13396 arg_z->add_intvalue(z); 13397 13398 // copy argument width 13399 GLMessage_DataType *arg_width = glmsg.add_args(); 13400 arg_width->set_isarray(false); 13401 arg_width->set_type(GLMessage::DataType::INT); 13402 arg_width->add_intvalue(width); 13403 13404 // copy argument height 13405 GLMessage_DataType *arg_height = glmsg.add_args(); 13406 arg_height->set_isarray(false); 13407 arg_height->set_type(GLMessage::DataType::INT); 13408 arg_height->add_intvalue(height); 13409 13410 // call function 13411 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13412 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13413 glContext->hooks->gl.glDrawTexiOES(x, y, z, width, height); 13414 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13415 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13416 13417 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13418 threadStartTime, threadEndTime, 13419 &glmsg); 13420 glContext->traceGLMessage(&glmsg); 13421} 13422 13423void GLTrace_glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) { 13424 GLMessage glmsg; 13425 GLTraceContext *glContext = getGLTraceContext(); 13426 13427 glmsg.set_function(GLMessage::glDrawTexxOES); 13428 13429 // copy argument x 13430 GLMessage_DataType *arg_x = glmsg.add_args(); 13431 arg_x->set_isarray(false); 13432 arg_x->set_type(GLMessage::DataType::INT); 13433 arg_x->add_intvalue(x); 13434 13435 // copy argument y 13436 GLMessage_DataType *arg_y = glmsg.add_args(); 13437 arg_y->set_isarray(false); 13438 arg_y->set_type(GLMessage::DataType::INT); 13439 arg_y->add_intvalue(y); 13440 13441 // copy argument z 13442 GLMessage_DataType *arg_z = glmsg.add_args(); 13443 arg_z->set_isarray(false); 13444 arg_z->set_type(GLMessage::DataType::INT); 13445 arg_z->add_intvalue(z); 13446 13447 // copy argument width 13448 GLMessage_DataType *arg_width = glmsg.add_args(); 13449 arg_width->set_isarray(false); 13450 arg_width->set_type(GLMessage::DataType::INT); 13451 arg_width->add_intvalue(width); 13452 13453 // copy argument height 13454 GLMessage_DataType *arg_height = glmsg.add_args(); 13455 arg_height->set_isarray(false); 13456 arg_height->set_type(GLMessage::DataType::INT); 13457 arg_height->add_intvalue(height); 13458 13459 // call function 13460 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13461 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13462 glContext->hooks->gl.glDrawTexxOES(x, y, z, width, height); 13463 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13464 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13465 13466 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13467 threadStartTime, threadEndTime, 13468 &glmsg); 13469 glContext->traceGLMessage(&glmsg); 13470} 13471 13472void GLTrace_glDrawTexsvOES(const GLshort *coords) { 13473 GLMessage glmsg; 13474 GLTraceContext *glContext = getGLTraceContext(); 13475 13476 glmsg.set_function(GLMessage::glDrawTexsvOES); 13477 13478 // copy argument coords 13479 GLMessage_DataType *arg_coords = glmsg.add_args(); 13480 arg_coords->set_isarray(false); 13481 arg_coords->set_type(GLMessage::DataType::INT); 13482 arg_coords->add_intvalue((int)coords); 13483 13484 // call function 13485 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13486 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13487 glContext->hooks->gl.glDrawTexsvOES(coords); 13488 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13489 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13490 13491 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13492 threadStartTime, threadEndTime, 13493 &glmsg); 13494 glContext->traceGLMessage(&glmsg); 13495} 13496 13497void GLTrace_glDrawTexivOES(const GLint *coords) { 13498 GLMessage glmsg; 13499 GLTraceContext *glContext = getGLTraceContext(); 13500 13501 glmsg.set_function(GLMessage::glDrawTexivOES); 13502 13503 // copy argument coords 13504 GLMessage_DataType *arg_coords = glmsg.add_args(); 13505 arg_coords->set_isarray(false); 13506 arg_coords->set_type(GLMessage::DataType::INT); 13507 arg_coords->add_intvalue((int)coords); 13508 13509 // call function 13510 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13511 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13512 glContext->hooks->gl.glDrawTexivOES(coords); 13513 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13514 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13515 13516 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13517 threadStartTime, threadEndTime, 13518 &glmsg); 13519 glContext->traceGLMessage(&glmsg); 13520} 13521 13522void GLTrace_glDrawTexxvOES(const GLfixed *coords) { 13523 GLMessage glmsg; 13524 GLTraceContext *glContext = getGLTraceContext(); 13525 13526 glmsg.set_function(GLMessage::glDrawTexxvOES); 13527 13528 // copy argument coords 13529 GLMessage_DataType *arg_coords = glmsg.add_args(); 13530 arg_coords->set_isarray(false); 13531 arg_coords->set_type(GLMessage::DataType::INT); 13532 arg_coords->add_intvalue((int)coords); 13533 13534 // call function 13535 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13536 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13537 glContext->hooks->gl.glDrawTexxvOES(coords); 13538 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13539 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13540 13541 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13542 threadStartTime, threadEndTime, 13543 &glmsg); 13544 glContext->traceGLMessage(&glmsg); 13545} 13546 13547void GLTrace_glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) { 13548 GLMessage glmsg; 13549 GLTraceContext *glContext = getGLTraceContext(); 13550 13551 glmsg.set_function(GLMessage::glDrawTexfOES); 13552 13553 // copy argument x 13554 GLMessage_DataType *arg_x = glmsg.add_args(); 13555 arg_x->set_isarray(false); 13556 arg_x->set_type(GLMessage::DataType::FLOAT); 13557 arg_x->add_floatvalue(x); 13558 13559 // copy argument y 13560 GLMessage_DataType *arg_y = glmsg.add_args(); 13561 arg_y->set_isarray(false); 13562 arg_y->set_type(GLMessage::DataType::FLOAT); 13563 arg_y->add_floatvalue(y); 13564 13565 // copy argument z 13566 GLMessage_DataType *arg_z = glmsg.add_args(); 13567 arg_z->set_isarray(false); 13568 arg_z->set_type(GLMessage::DataType::FLOAT); 13569 arg_z->add_floatvalue(z); 13570 13571 // copy argument width 13572 GLMessage_DataType *arg_width = glmsg.add_args(); 13573 arg_width->set_isarray(false); 13574 arg_width->set_type(GLMessage::DataType::FLOAT); 13575 arg_width->add_floatvalue(width); 13576 13577 // copy argument height 13578 GLMessage_DataType *arg_height = glmsg.add_args(); 13579 arg_height->set_isarray(false); 13580 arg_height->set_type(GLMessage::DataType::FLOAT); 13581 arg_height->add_floatvalue(height); 13582 13583 // call function 13584 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13585 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13586 glContext->hooks->gl.glDrawTexfOES(x, y, z, width, height); 13587 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13588 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13589 13590 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13591 threadStartTime, threadEndTime, 13592 &glmsg); 13593 glContext->traceGLMessage(&glmsg); 13594} 13595 13596void GLTrace_glDrawTexfvOES(const GLfloat *coords) { 13597 GLMessage glmsg; 13598 GLTraceContext *glContext = getGLTraceContext(); 13599 13600 glmsg.set_function(GLMessage::glDrawTexfvOES); 13601 13602 // copy argument coords 13603 GLMessage_DataType *arg_coords = glmsg.add_args(); 13604 arg_coords->set_isarray(false); 13605 arg_coords->set_type(GLMessage::DataType::INT); 13606 arg_coords->add_intvalue((int)coords); 13607 13608 // call function 13609 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13610 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13611 glContext->hooks->gl.glDrawTexfvOES(coords); 13612 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13613 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13614 13615 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13616 threadStartTime, threadEndTime, 13617 &glmsg); 13618 glContext->traceGLMessage(&glmsg); 13619} 13620 13621void GLTrace_glAlphaFuncxOES(GLenum func, GLclampx ref) { 13622 GLMessage glmsg; 13623 GLTraceContext *glContext = getGLTraceContext(); 13624 13625 glmsg.set_function(GLMessage::glAlphaFuncxOES); 13626 13627 // copy argument func 13628 GLMessage_DataType *arg_func = glmsg.add_args(); 13629 arg_func->set_isarray(false); 13630 arg_func->set_type(GLMessage::DataType::ENUM); 13631 arg_func->add_intvalue((int)func); 13632 13633 // copy argument ref 13634 GLMessage_DataType *arg_ref = glmsg.add_args(); 13635 arg_ref->set_isarray(false); 13636 arg_ref->set_type(GLMessage::DataType::INT); 13637 arg_ref->add_intvalue(ref); 13638 13639 // call function 13640 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13641 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13642 glContext->hooks->gl.glAlphaFuncxOES(func, ref); 13643 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13644 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13645 13646 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13647 threadStartTime, threadEndTime, 13648 &glmsg); 13649 glContext->traceGLMessage(&glmsg); 13650} 13651 13652void GLTrace_glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) { 13653 GLMessage glmsg; 13654 GLTraceContext *glContext = getGLTraceContext(); 13655 13656 glmsg.set_function(GLMessage::glClearColorxOES); 13657 13658 // copy argument red 13659 GLMessage_DataType *arg_red = glmsg.add_args(); 13660 arg_red->set_isarray(false); 13661 arg_red->set_type(GLMessage::DataType::INT); 13662 arg_red->add_intvalue(red); 13663 13664 // copy argument green 13665 GLMessage_DataType *arg_green = glmsg.add_args(); 13666 arg_green->set_isarray(false); 13667 arg_green->set_type(GLMessage::DataType::INT); 13668 arg_green->add_intvalue(green); 13669 13670 // copy argument blue 13671 GLMessage_DataType *arg_blue = glmsg.add_args(); 13672 arg_blue->set_isarray(false); 13673 arg_blue->set_type(GLMessage::DataType::INT); 13674 arg_blue->add_intvalue(blue); 13675 13676 // copy argument alpha 13677 GLMessage_DataType *arg_alpha = glmsg.add_args(); 13678 arg_alpha->set_isarray(false); 13679 arg_alpha->set_type(GLMessage::DataType::INT); 13680 arg_alpha->add_intvalue(alpha); 13681 13682 // call function 13683 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13684 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13685 glContext->hooks->gl.glClearColorxOES(red, green, blue, alpha); 13686 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13687 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13688 13689 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13690 threadStartTime, threadEndTime, 13691 &glmsg); 13692 glContext->traceGLMessage(&glmsg); 13693} 13694 13695void GLTrace_glClearDepthxOES(GLclampx depth) { 13696 GLMessage glmsg; 13697 GLTraceContext *glContext = getGLTraceContext(); 13698 13699 glmsg.set_function(GLMessage::glClearDepthxOES); 13700 13701 // copy argument depth 13702 GLMessage_DataType *arg_depth = glmsg.add_args(); 13703 arg_depth->set_isarray(false); 13704 arg_depth->set_type(GLMessage::DataType::INT); 13705 arg_depth->add_intvalue(depth); 13706 13707 // call function 13708 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13709 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13710 glContext->hooks->gl.glClearDepthxOES(depth); 13711 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13712 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13713 13714 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13715 threadStartTime, threadEndTime, 13716 &glmsg); 13717 glContext->traceGLMessage(&glmsg); 13718} 13719 13720void GLTrace_glClipPlanexOES(GLenum plane, const GLfixed *equation) { 13721 GLMessage glmsg; 13722 GLTraceContext *glContext = getGLTraceContext(); 13723 13724 glmsg.set_function(GLMessage::glClipPlanexOES); 13725 13726 // copy argument plane 13727 GLMessage_DataType *arg_plane = glmsg.add_args(); 13728 arg_plane->set_isarray(false); 13729 arg_plane->set_type(GLMessage::DataType::ENUM); 13730 arg_plane->add_intvalue((int)plane); 13731 13732 // copy argument equation 13733 GLMessage_DataType *arg_equation = glmsg.add_args(); 13734 arg_equation->set_isarray(false); 13735 arg_equation->set_type(GLMessage::DataType::INT); 13736 arg_equation->add_intvalue((int)equation); 13737 13738 // call function 13739 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13740 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13741 glContext->hooks->gl.glClipPlanexOES(plane, equation); 13742 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13743 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13744 13745 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13746 threadStartTime, threadEndTime, 13747 &glmsg); 13748 glContext->traceGLMessage(&glmsg); 13749} 13750 13751void GLTrace_glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { 13752 GLMessage glmsg; 13753 GLTraceContext *glContext = getGLTraceContext(); 13754 13755 glmsg.set_function(GLMessage::glColor4xOES); 13756 13757 // copy argument red 13758 GLMessage_DataType *arg_red = glmsg.add_args(); 13759 arg_red->set_isarray(false); 13760 arg_red->set_type(GLMessage::DataType::INT); 13761 arg_red->add_intvalue(red); 13762 13763 // copy argument green 13764 GLMessage_DataType *arg_green = glmsg.add_args(); 13765 arg_green->set_isarray(false); 13766 arg_green->set_type(GLMessage::DataType::INT); 13767 arg_green->add_intvalue(green); 13768 13769 // copy argument blue 13770 GLMessage_DataType *arg_blue = glmsg.add_args(); 13771 arg_blue->set_isarray(false); 13772 arg_blue->set_type(GLMessage::DataType::INT); 13773 arg_blue->add_intvalue(blue); 13774 13775 // copy argument alpha 13776 GLMessage_DataType *arg_alpha = glmsg.add_args(); 13777 arg_alpha->set_isarray(false); 13778 arg_alpha->set_type(GLMessage::DataType::INT); 13779 arg_alpha->add_intvalue(alpha); 13780 13781 // call function 13782 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13783 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13784 glContext->hooks->gl.glColor4xOES(red, green, blue, alpha); 13785 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13786 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13787 13788 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13789 threadStartTime, threadEndTime, 13790 &glmsg); 13791 glContext->traceGLMessage(&glmsg); 13792} 13793 13794void GLTrace_glDepthRangexOES(GLclampx zNear, GLclampx zFar) { 13795 GLMessage glmsg; 13796 GLTraceContext *glContext = getGLTraceContext(); 13797 13798 glmsg.set_function(GLMessage::glDepthRangexOES); 13799 13800 // copy argument zNear 13801 GLMessage_DataType *arg_zNear = glmsg.add_args(); 13802 arg_zNear->set_isarray(false); 13803 arg_zNear->set_type(GLMessage::DataType::INT); 13804 arg_zNear->add_intvalue(zNear); 13805 13806 // copy argument zFar 13807 GLMessage_DataType *arg_zFar = glmsg.add_args(); 13808 arg_zFar->set_isarray(false); 13809 arg_zFar->set_type(GLMessage::DataType::INT); 13810 arg_zFar->add_intvalue(zFar); 13811 13812 // call function 13813 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13814 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13815 glContext->hooks->gl.glDepthRangexOES(zNear, zFar); 13816 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13817 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13818 13819 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13820 threadStartTime, threadEndTime, 13821 &glmsg); 13822 glContext->traceGLMessage(&glmsg); 13823} 13824 13825void GLTrace_glFogxOES(GLenum pname, GLfixed param) { 13826 GLMessage glmsg; 13827 GLTraceContext *glContext = getGLTraceContext(); 13828 13829 glmsg.set_function(GLMessage::glFogxOES); 13830 13831 // copy argument pname 13832 GLMessage_DataType *arg_pname = glmsg.add_args(); 13833 arg_pname->set_isarray(false); 13834 arg_pname->set_type(GLMessage::DataType::ENUM); 13835 arg_pname->add_intvalue((int)pname); 13836 13837 // copy argument param 13838 GLMessage_DataType *arg_param = glmsg.add_args(); 13839 arg_param->set_isarray(false); 13840 arg_param->set_type(GLMessage::DataType::INT); 13841 arg_param->add_intvalue(param); 13842 13843 // call function 13844 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13845 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13846 glContext->hooks->gl.glFogxOES(pname, param); 13847 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13848 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13849 13850 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13851 threadStartTime, threadEndTime, 13852 &glmsg); 13853 glContext->traceGLMessage(&glmsg); 13854} 13855 13856void GLTrace_glFogxvOES(GLenum pname, const GLfixed *params) { 13857 GLMessage glmsg; 13858 GLTraceContext *glContext = getGLTraceContext(); 13859 13860 glmsg.set_function(GLMessage::glFogxvOES); 13861 13862 // copy argument pname 13863 GLMessage_DataType *arg_pname = glmsg.add_args(); 13864 arg_pname->set_isarray(false); 13865 arg_pname->set_type(GLMessage::DataType::ENUM); 13866 arg_pname->add_intvalue((int)pname); 13867 13868 // copy argument params 13869 GLMessage_DataType *arg_params = glmsg.add_args(); 13870 arg_params->set_isarray(false); 13871 arg_params->set_type(GLMessage::DataType::INT); 13872 arg_params->add_intvalue((int)params); 13873 13874 // call function 13875 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13876 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13877 glContext->hooks->gl.glFogxvOES(pname, params); 13878 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13879 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13880 13881 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13882 threadStartTime, threadEndTime, 13883 &glmsg); 13884 glContext->traceGLMessage(&glmsg); 13885} 13886 13887void GLTrace_glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { 13888 GLMessage glmsg; 13889 GLTraceContext *glContext = getGLTraceContext(); 13890 13891 glmsg.set_function(GLMessage::glFrustumxOES); 13892 13893 // copy argument left 13894 GLMessage_DataType *arg_left = glmsg.add_args(); 13895 arg_left->set_isarray(false); 13896 arg_left->set_type(GLMessage::DataType::INT); 13897 arg_left->add_intvalue(left); 13898 13899 // copy argument right 13900 GLMessage_DataType *arg_right = glmsg.add_args(); 13901 arg_right->set_isarray(false); 13902 arg_right->set_type(GLMessage::DataType::INT); 13903 arg_right->add_intvalue(right); 13904 13905 // copy argument bottom 13906 GLMessage_DataType *arg_bottom = glmsg.add_args(); 13907 arg_bottom->set_isarray(false); 13908 arg_bottom->set_type(GLMessage::DataType::INT); 13909 arg_bottom->add_intvalue(bottom); 13910 13911 // copy argument top 13912 GLMessage_DataType *arg_top = glmsg.add_args(); 13913 arg_top->set_isarray(false); 13914 arg_top->set_type(GLMessage::DataType::INT); 13915 arg_top->add_intvalue(top); 13916 13917 // copy argument zNear 13918 GLMessage_DataType *arg_zNear = glmsg.add_args(); 13919 arg_zNear->set_isarray(false); 13920 arg_zNear->set_type(GLMessage::DataType::INT); 13921 arg_zNear->add_intvalue(zNear); 13922 13923 // copy argument zFar 13924 GLMessage_DataType *arg_zFar = glmsg.add_args(); 13925 arg_zFar->set_isarray(false); 13926 arg_zFar->set_type(GLMessage::DataType::INT); 13927 arg_zFar->add_intvalue(zFar); 13928 13929 // call function 13930 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13931 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13932 glContext->hooks->gl.glFrustumxOES(left, right, bottom, top, zNear, zFar); 13933 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13934 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13935 13936 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13937 threadStartTime, threadEndTime, 13938 &glmsg); 13939 glContext->traceGLMessage(&glmsg); 13940} 13941 13942void GLTrace_glGetClipPlanexOES(GLenum pname, GLfixed eqn[4]) { 13943 GLMessage glmsg; 13944 GLTraceContext *glContext = getGLTraceContext(); 13945 13946 glmsg.set_function(GLMessage::glGetClipPlanexOES); 13947 13948 // copy argument pname 13949 GLMessage_DataType *arg_pname = glmsg.add_args(); 13950 arg_pname->set_isarray(false); 13951 arg_pname->set_type(GLMessage::DataType::ENUM); 13952 arg_pname->add_intvalue((int)pname); 13953 13954 // copy argument eqn 13955 GLMessage_DataType *arg_eqn = glmsg.add_args(); 13956 arg_eqn->set_isarray(false); 13957 arg_eqn->set_type(GLMessage::DataType::INT); 13958 arg_eqn->add_intvalue((int)eqn); 13959 13960 // call function 13961 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13962 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13963 glContext->hooks->gl.glGetClipPlanexOES(pname, eqn); 13964 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13965 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13966 13967 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13968 threadStartTime, threadEndTime, 13969 &glmsg); 13970 glContext->traceGLMessage(&glmsg); 13971} 13972 13973void GLTrace_glGetFixedvOES(GLenum pname, GLfixed *params) { 13974 GLMessage glmsg; 13975 GLTraceContext *glContext = getGLTraceContext(); 13976 13977 glmsg.set_function(GLMessage::glGetFixedvOES); 13978 13979 // copy argument pname 13980 GLMessage_DataType *arg_pname = glmsg.add_args(); 13981 arg_pname->set_isarray(false); 13982 arg_pname->set_type(GLMessage::DataType::ENUM); 13983 arg_pname->add_intvalue((int)pname); 13984 13985 // copy argument params 13986 GLMessage_DataType *arg_params = glmsg.add_args(); 13987 arg_params->set_isarray(false); 13988 arg_params->set_type(GLMessage::DataType::INT); 13989 arg_params->add_intvalue((int)params); 13990 13991 // call function 13992 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 13993 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 13994 glContext->hooks->gl.glGetFixedvOES(pname, params); 13995 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 13996 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 13997 13998 fixupGLMessage(glContext, wallStartTime, wallEndTime, 13999 threadStartTime, threadEndTime, 14000 &glmsg); 14001 glContext->traceGLMessage(&glmsg); 14002} 14003 14004void GLTrace_glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params) { 14005 GLMessage glmsg; 14006 GLTraceContext *glContext = getGLTraceContext(); 14007 14008 glmsg.set_function(GLMessage::glGetLightxvOES); 14009 14010 // copy argument light 14011 GLMessage_DataType *arg_light = glmsg.add_args(); 14012 arg_light->set_isarray(false); 14013 arg_light->set_type(GLMessage::DataType::ENUM); 14014 arg_light->add_intvalue((int)light); 14015 14016 // copy argument pname 14017 GLMessage_DataType *arg_pname = glmsg.add_args(); 14018 arg_pname->set_isarray(false); 14019 arg_pname->set_type(GLMessage::DataType::ENUM); 14020 arg_pname->add_intvalue((int)pname); 14021 14022 // copy argument params 14023 GLMessage_DataType *arg_params = glmsg.add_args(); 14024 arg_params->set_isarray(false); 14025 arg_params->set_type(GLMessage::DataType::INT); 14026 arg_params->add_intvalue((int)params); 14027 14028 // call function 14029 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14030 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14031 glContext->hooks->gl.glGetLightxvOES(light, pname, params); 14032 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14033 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14034 14035 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14036 threadStartTime, threadEndTime, 14037 &glmsg); 14038 glContext->traceGLMessage(&glmsg); 14039} 14040 14041void GLTrace_glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params) { 14042 GLMessage glmsg; 14043 GLTraceContext *glContext = getGLTraceContext(); 14044 14045 glmsg.set_function(GLMessage::glGetMaterialxvOES); 14046 14047 // copy argument face 14048 GLMessage_DataType *arg_face = glmsg.add_args(); 14049 arg_face->set_isarray(false); 14050 arg_face->set_type(GLMessage::DataType::ENUM); 14051 arg_face->add_intvalue((int)face); 14052 14053 // copy argument pname 14054 GLMessage_DataType *arg_pname = glmsg.add_args(); 14055 arg_pname->set_isarray(false); 14056 arg_pname->set_type(GLMessage::DataType::ENUM); 14057 arg_pname->add_intvalue((int)pname); 14058 14059 // copy argument params 14060 GLMessage_DataType *arg_params = glmsg.add_args(); 14061 arg_params->set_isarray(false); 14062 arg_params->set_type(GLMessage::DataType::INT); 14063 arg_params->add_intvalue((int)params); 14064 14065 // call function 14066 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14067 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14068 glContext->hooks->gl.glGetMaterialxvOES(face, pname, params); 14069 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14070 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14071 14072 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14073 threadStartTime, threadEndTime, 14074 &glmsg); 14075 glContext->traceGLMessage(&glmsg); 14076} 14077 14078void GLTrace_glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params) { 14079 GLMessage glmsg; 14080 GLTraceContext *glContext = getGLTraceContext(); 14081 14082 glmsg.set_function(GLMessage::glGetTexEnvxvOES); 14083 14084 // copy argument env 14085 GLMessage_DataType *arg_env = glmsg.add_args(); 14086 arg_env->set_isarray(false); 14087 arg_env->set_type(GLMessage::DataType::ENUM); 14088 arg_env->add_intvalue((int)env); 14089 14090 // copy argument pname 14091 GLMessage_DataType *arg_pname = glmsg.add_args(); 14092 arg_pname->set_isarray(false); 14093 arg_pname->set_type(GLMessage::DataType::ENUM); 14094 arg_pname->add_intvalue((int)pname); 14095 14096 // copy argument params 14097 GLMessage_DataType *arg_params = glmsg.add_args(); 14098 arg_params->set_isarray(false); 14099 arg_params->set_type(GLMessage::DataType::INT); 14100 arg_params->add_intvalue((int)params); 14101 14102 // call function 14103 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14104 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14105 glContext->hooks->gl.glGetTexEnvxvOES(env, pname, params); 14106 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14107 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14108 14109 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14110 threadStartTime, threadEndTime, 14111 &glmsg); 14112 glContext->traceGLMessage(&glmsg); 14113} 14114 14115void GLTrace_glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params) { 14116 GLMessage glmsg; 14117 GLTraceContext *glContext = getGLTraceContext(); 14118 14119 glmsg.set_function(GLMessage::glGetTexParameterxvOES); 14120 14121 // copy argument target 14122 GLMessage_DataType *arg_target = glmsg.add_args(); 14123 arg_target->set_isarray(false); 14124 arg_target->set_type(GLMessage::DataType::ENUM); 14125 arg_target->add_intvalue((int)target); 14126 14127 // copy argument pname 14128 GLMessage_DataType *arg_pname = glmsg.add_args(); 14129 arg_pname->set_isarray(false); 14130 arg_pname->set_type(GLMessage::DataType::ENUM); 14131 arg_pname->add_intvalue((int)pname); 14132 14133 // copy argument params 14134 GLMessage_DataType *arg_params = glmsg.add_args(); 14135 arg_params->set_isarray(false); 14136 arg_params->set_type(GLMessage::DataType::INT); 14137 arg_params->add_intvalue((int)params); 14138 14139 // call function 14140 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14141 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14142 glContext->hooks->gl.glGetTexParameterxvOES(target, pname, params); 14143 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14144 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14145 14146 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14147 threadStartTime, threadEndTime, 14148 &glmsg); 14149 glContext->traceGLMessage(&glmsg); 14150} 14151 14152void GLTrace_glLightModelxOES(GLenum pname, GLfixed param) { 14153 GLMessage glmsg; 14154 GLTraceContext *glContext = getGLTraceContext(); 14155 14156 glmsg.set_function(GLMessage::glLightModelxOES); 14157 14158 // copy argument pname 14159 GLMessage_DataType *arg_pname = glmsg.add_args(); 14160 arg_pname->set_isarray(false); 14161 arg_pname->set_type(GLMessage::DataType::ENUM); 14162 arg_pname->add_intvalue((int)pname); 14163 14164 // copy argument param 14165 GLMessage_DataType *arg_param = glmsg.add_args(); 14166 arg_param->set_isarray(false); 14167 arg_param->set_type(GLMessage::DataType::INT); 14168 arg_param->add_intvalue(param); 14169 14170 // call function 14171 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14172 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14173 glContext->hooks->gl.glLightModelxOES(pname, param); 14174 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14175 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14176 14177 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14178 threadStartTime, threadEndTime, 14179 &glmsg); 14180 glContext->traceGLMessage(&glmsg); 14181} 14182 14183void GLTrace_glLightModelxvOES(GLenum pname, const GLfixed *params) { 14184 GLMessage glmsg; 14185 GLTraceContext *glContext = getGLTraceContext(); 14186 14187 glmsg.set_function(GLMessage::glLightModelxvOES); 14188 14189 // copy argument pname 14190 GLMessage_DataType *arg_pname = glmsg.add_args(); 14191 arg_pname->set_isarray(false); 14192 arg_pname->set_type(GLMessage::DataType::ENUM); 14193 arg_pname->add_intvalue((int)pname); 14194 14195 // copy argument params 14196 GLMessage_DataType *arg_params = glmsg.add_args(); 14197 arg_params->set_isarray(false); 14198 arg_params->set_type(GLMessage::DataType::INT); 14199 arg_params->add_intvalue((int)params); 14200 14201 // call function 14202 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14203 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14204 glContext->hooks->gl.glLightModelxvOES(pname, params); 14205 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14206 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14207 14208 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14209 threadStartTime, threadEndTime, 14210 &glmsg); 14211 glContext->traceGLMessage(&glmsg); 14212} 14213 14214void GLTrace_glLightxOES(GLenum light, GLenum pname, GLfixed param) { 14215 GLMessage glmsg; 14216 GLTraceContext *glContext = getGLTraceContext(); 14217 14218 glmsg.set_function(GLMessage::glLightxOES); 14219 14220 // copy argument light 14221 GLMessage_DataType *arg_light = glmsg.add_args(); 14222 arg_light->set_isarray(false); 14223 arg_light->set_type(GLMessage::DataType::ENUM); 14224 arg_light->add_intvalue((int)light); 14225 14226 // copy argument pname 14227 GLMessage_DataType *arg_pname = glmsg.add_args(); 14228 arg_pname->set_isarray(false); 14229 arg_pname->set_type(GLMessage::DataType::ENUM); 14230 arg_pname->add_intvalue((int)pname); 14231 14232 // copy argument param 14233 GLMessage_DataType *arg_param = glmsg.add_args(); 14234 arg_param->set_isarray(false); 14235 arg_param->set_type(GLMessage::DataType::INT); 14236 arg_param->add_intvalue(param); 14237 14238 // call function 14239 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14240 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14241 glContext->hooks->gl.glLightxOES(light, pname, param); 14242 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14243 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14244 14245 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14246 threadStartTime, threadEndTime, 14247 &glmsg); 14248 glContext->traceGLMessage(&glmsg); 14249} 14250 14251void GLTrace_glLightxvOES(GLenum light, GLenum pname, const GLfixed *params) { 14252 GLMessage glmsg; 14253 GLTraceContext *glContext = getGLTraceContext(); 14254 14255 glmsg.set_function(GLMessage::glLightxvOES); 14256 14257 // copy argument light 14258 GLMessage_DataType *arg_light = glmsg.add_args(); 14259 arg_light->set_isarray(false); 14260 arg_light->set_type(GLMessage::DataType::ENUM); 14261 arg_light->add_intvalue((int)light); 14262 14263 // copy argument pname 14264 GLMessage_DataType *arg_pname = glmsg.add_args(); 14265 arg_pname->set_isarray(false); 14266 arg_pname->set_type(GLMessage::DataType::ENUM); 14267 arg_pname->add_intvalue((int)pname); 14268 14269 // copy argument params 14270 GLMessage_DataType *arg_params = glmsg.add_args(); 14271 arg_params->set_isarray(false); 14272 arg_params->set_type(GLMessage::DataType::INT); 14273 arg_params->add_intvalue((int)params); 14274 14275 // call function 14276 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14277 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14278 glContext->hooks->gl.glLightxvOES(light, pname, params); 14279 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14280 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14281 14282 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14283 threadStartTime, threadEndTime, 14284 &glmsg); 14285 glContext->traceGLMessage(&glmsg); 14286} 14287 14288void GLTrace_glLineWidthxOES(GLfixed width) { 14289 GLMessage glmsg; 14290 GLTraceContext *glContext = getGLTraceContext(); 14291 14292 glmsg.set_function(GLMessage::glLineWidthxOES); 14293 14294 // copy argument width 14295 GLMessage_DataType *arg_width = glmsg.add_args(); 14296 arg_width->set_isarray(false); 14297 arg_width->set_type(GLMessage::DataType::INT); 14298 arg_width->add_intvalue(width); 14299 14300 // call function 14301 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14302 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14303 glContext->hooks->gl.glLineWidthxOES(width); 14304 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14305 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14306 14307 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14308 threadStartTime, threadEndTime, 14309 &glmsg); 14310 glContext->traceGLMessage(&glmsg); 14311} 14312 14313void GLTrace_glLoadMatrixxOES(const GLfixed *m) { 14314 GLMessage glmsg; 14315 GLTraceContext *glContext = getGLTraceContext(); 14316 14317 glmsg.set_function(GLMessage::glLoadMatrixxOES); 14318 14319 // copy argument m 14320 GLMessage_DataType *arg_m = glmsg.add_args(); 14321 arg_m->set_isarray(false); 14322 arg_m->set_type(GLMessage::DataType::INT); 14323 arg_m->add_intvalue((int)m); 14324 14325 // call function 14326 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14327 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14328 glContext->hooks->gl.glLoadMatrixxOES(m); 14329 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14330 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14331 14332 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14333 threadStartTime, threadEndTime, 14334 &glmsg); 14335 glContext->traceGLMessage(&glmsg); 14336} 14337 14338void GLTrace_glMaterialxOES(GLenum face, GLenum pname, GLfixed param) { 14339 GLMessage glmsg; 14340 GLTraceContext *glContext = getGLTraceContext(); 14341 14342 glmsg.set_function(GLMessage::glMaterialxOES); 14343 14344 // copy argument face 14345 GLMessage_DataType *arg_face = glmsg.add_args(); 14346 arg_face->set_isarray(false); 14347 arg_face->set_type(GLMessage::DataType::ENUM); 14348 arg_face->add_intvalue((int)face); 14349 14350 // copy argument pname 14351 GLMessage_DataType *arg_pname = glmsg.add_args(); 14352 arg_pname->set_isarray(false); 14353 arg_pname->set_type(GLMessage::DataType::ENUM); 14354 arg_pname->add_intvalue((int)pname); 14355 14356 // copy argument param 14357 GLMessage_DataType *arg_param = glmsg.add_args(); 14358 arg_param->set_isarray(false); 14359 arg_param->set_type(GLMessage::DataType::INT); 14360 arg_param->add_intvalue(param); 14361 14362 // call function 14363 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14364 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14365 glContext->hooks->gl.glMaterialxOES(face, pname, param); 14366 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14367 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14368 14369 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14370 threadStartTime, threadEndTime, 14371 &glmsg); 14372 glContext->traceGLMessage(&glmsg); 14373} 14374 14375void GLTrace_glMaterialxvOES(GLenum face, GLenum pname, const GLfixed *params) { 14376 GLMessage glmsg; 14377 GLTraceContext *glContext = getGLTraceContext(); 14378 14379 glmsg.set_function(GLMessage::glMaterialxvOES); 14380 14381 // copy argument face 14382 GLMessage_DataType *arg_face = glmsg.add_args(); 14383 arg_face->set_isarray(false); 14384 arg_face->set_type(GLMessage::DataType::ENUM); 14385 arg_face->add_intvalue((int)face); 14386 14387 // copy argument pname 14388 GLMessage_DataType *arg_pname = glmsg.add_args(); 14389 arg_pname->set_isarray(false); 14390 arg_pname->set_type(GLMessage::DataType::ENUM); 14391 arg_pname->add_intvalue((int)pname); 14392 14393 // copy argument params 14394 GLMessage_DataType *arg_params = glmsg.add_args(); 14395 arg_params->set_isarray(false); 14396 arg_params->set_type(GLMessage::DataType::INT); 14397 arg_params->add_intvalue((int)params); 14398 14399 // call function 14400 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14401 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14402 glContext->hooks->gl.glMaterialxvOES(face, pname, params); 14403 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14404 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14405 14406 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14407 threadStartTime, threadEndTime, 14408 &glmsg); 14409 glContext->traceGLMessage(&glmsg); 14410} 14411 14412void GLTrace_glMultMatrixxOES(const GLfixed *m) { 14413 GLMessage glmsg; 14414 GLTraceContext *glContext = getGLTraceContext(); 14415 14416 glmsg.set_function(GLMessage::glMultMatrixxOES); 14417 14418 // copy argument m 14419 GLMessage_DataType *arg_m = glmsg.add_args(); 14420 arg_m->set_isarray(false); 14421 arg_m->set_type(GLMessage::DataType::INT); 14422 arg_m->add_intvalue((int)m); 14423 14424 // call function 14425 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14426 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14427 glContext->hooks->gl.glMultMatrixxOES(m); 14428 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14429 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14430 14431 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14432 threadStartTime, threadEndTime, 14433 &glmsg); 14434 glContext->traceGLMessage(&glmsg); 14435} 14436 14437void GLTrace_glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { 14438 GLMessage glmsg; 14439 GLTraceContext *glContext = getGLTraceContext(); 14440 14441 glmsg.set_function(GLMessage::glMultiTexCoord4xOES); 14442 14443 // copy argument target 14444 GLMessage_DataType *arg_target = glmsg.add_args(); 14445 arg_target->set_isarray(false); 14446 arg_target->set_type(GLMessage::DataType::ENUM); 14447 arg_target->add_intvalue((int)target); 14448 14449 // copy argument s 14450 GLMessage_DataType *arg_s = glmsg.add_args(); 14451 arg_s->set_isarray(false); 14452 arg_s->set_type(GLMessage::DataType::INT); 14453 arg_s->add_intvalue(s); 14454 14455 // copy argument t 14456 GLMessage_DataType *arg_t = glmsg.add_args(); 14457 arg_t->set_isarray(false); 14458 arg_t->set_type(GLMessage::DataType::INT); 14459 arg_t->add_intvalue(t); 14460 14461 // copy argument r 14462 GLMessage_DataType *arg_r = glmsg.add_args(); 14463 arg_r->set_isarray(false); 14464 arg_r->set_type(GLMessage::DataType::INT); 14465 arg_r->add_intvalue(r); 14466 14467 // copy argument q 14468 GLMessage_DataType *arg_q = glmsg.add_args(); 14469 arg_q->set_isarray(false); 14470 arg_q->set_type(GLMessage::DataType::INT); 14471 arg_q->add_intvalue(q); 14472 14473 // call function 14474 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14475 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14476 glContext->hooks->gl.glMultiTexCoord4xOES(target, s, t, r, q); 14477 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14478 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14479 14480 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14481 threadStartTime, threadEndTime, 14482 &glmsg); 14483 glContext->traceGLMessage(&glmsg); 14484} 14485 14486void GLTrace_glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz) { 14487 GLMessage glmsg; 14488 GLTraceContext *glContext = getGLTraceContext(); 14489 14490 glmsg.set_function(GLMessage::glNormal3xOES); 14491 14492 // copy argument nx 14493 GLMessage_DataType *arg_nx = glmsg.add_args(); 14494 arg_nx->set_isarray(false); 14495 arg_nx->set_type(GLMessage::DataType::INT); 14496 arg_nx->add_intvalue(nx); 14497 14498 // copy argument ny 14499 GLMessage_DataType *arg_ny = glmsg.add_args(); 14500 arg_ny->set_isarray(false); 14501 arg_ny->set_type(GLMessage::DataType::INT); 14502 arg_ny->add_intvalue(ny); 14503 14504 // copy argument nz 14505 GLMessage_DataType *arg_nz = glmsg.add_args(); 14506 arg_nz->set_isarray(false); 14507 arg_nz->set_type(GLMessage::DataType::INT); 14508 arg_nz->add_intvalue(nz); 14509 14510 // call function 14511 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14512 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14513 glContext->hooks->gl.glNormal3xOES(nx, ny, nz); 14514 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14515 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14516 14517 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14518 threadStartTime, threadEndTime, 14519 &glmsg); 14520 glContext->traceGLMessage(&glmsg); 14521} 14522 14523void GLTrace_glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { 14524 GLMessage glmsg; 14525 GLTraceContext *glContext = getGLTraceContext(); 14526 14527 glmsg.set_function(GLMessage::glOrthoxOES); 14528 14529 // copy argument left 14530 GLMessage_DataType *arg_left = glmsg.add_args(); 14531 arg_left->set_isarray(false); 14532 arg_left->set_type(GLMessage::DataType::INT); 14533 arg_left->add_intvalue(left); 14534 14535 // copy argument right 14536 GLMessage_DataType *arg_right = glmsg.add_args(); 14537 arg_right->set_isarray(false); 14538 arg_right->set_type(GLMessage::DataType::INT); 14539 arg_right->add_intvalue(right); 14540 14541 // copy argument bottom 14542 GLMessage_DataType *arg_bottom = glmsg.add_args(); 14543 arg_bottom->set_isarray(false); 14544 arg_bottom->set_type(GLMessage::DataType::INT); 14545 arg_bottom->add_intvalue(bottom); 14546 14547 // copy argument top 14548 GLMessage_DataType *arg_top = glmsg.add_args(); 14549 arg_top->set_isarray(false); 14550 arg_top->set_type(GLMessage::DataType::INT); 14551 arg_top->add_intvalue(top); 14552 14553 // copy argument zNear 14554 GLMessage_DataType *arg_zNear = glmsg.add_args(); 14555 arg_zNear->set_isarray(false); 14556 arg_zNear->set_type(GLMessage::DataType::INT); 14557 arg_zNear->add_intvalue(zNear); 14558 14559 // copy argument zFar 14560 GLMessage_DataType *arg_zFar = glmsg.add_args(); 14561 arg_zFar->set_isarray(false); 14562 arg_zFar->set_type(GLMessage::DataType::INT); 14563 arg_zFar->add_intvalue(zFar); 14564 14565 // call function 14566 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14567 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14568 glContext->hooks->gl.glOrthoxOES(left, right, bottom, top, zNear, zFar); 14569 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14570 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14571 14572 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14573 threadStartTime, threadEndTime, 14574 &glmsg); 14575 glContext->traceGLMessage(&glmsg); 14576} 14577 14578void GLTrace_glPointParameterxOES(GLenum pname, GLfixed param) { 14579 GLMessage glmsg; 14580 GLTraceContext *glContext = getGLTraceContext(); 14581 14582 glmsg.set_function(GLMessage::glPointParameterxOES); 14583 14584 // copy argument pname 14585 GLMessage_DataType *arg_pname = glmsg.add_args(); 14586 arg_pname->set_isarray(false); 14587 arg_pname->set_type(GLMessage::DataType::ENUM); 14588 arg_pname->add_intvalue((int)pname); 14589 14590 // copy argument param 14591 GLMessage_DataType *arg_param = glmsg.add_args(); 14592 arg_param->set_isarray(false); 14593 arg_param->set_type(GLMessage::DataType::INT); 14594 arg_param->add_intvalue(param); 14595 14596 // call function 14597 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14598 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14599 glContext->hooks->gl.glPointParameterxOES(pname, param); 14600 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14601 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14602 14603 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14604 threadStartTime, threadEndTime, 14605 &glmsg); 14606 glContext->traceGLMessage(&glmsg); 14607} 14608 14609void GLTrace_glPointParameterxvOES(GLenum pname, const GLfixed *params) { 14610 GLMessage glmsg; 14611 GLTraceContext *glContext = getGLTraceContext(); 14612 14613 glmsg.set_function(GLMessage::glPointParameterxvOES); 14614 14615 // copy argument pname 14616 GLMessage_DataType *arg_pname = glmsg.add_args(); 14617 arg_pname->set_isarray(false); 14618 arg_pname->set_type(GLMessage::DataType::ENUM); 14619 arg_pname->add_intvalue((int)pname); 14620 14621 // copy argument params 14622 GLMessage_DataType *arg_params = glmsg.add_args(); 14623 arg_params->set_isarray(false); 14624 arg_params->set_type(GLMessage::DataType::INT); 14625 arg_params->add_intvalue((int)params); 14626 14627 // call function 14628 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14629 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14630 glContext->hooks->gl.glPointParameterxvOES(pname, params); 14631 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14632 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14633 14634 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14635 threadStartTime, threadEndTime, 14636 &glmsg); 14637 glContext->traceGLMessage(&glmsg); 14638} 14639 14640void GLTrace_glPointSizexOES(GLfixed size) { 14641 GLMessage glmsg; 14642 GLTraceContext *glContext = getGLTraceContext(); 14643 14644 glmsg.set_function(GLMessage::glPointSizexOES); 14645 14646 // copy argument size 14647 GLMessage_DataType *arg_size = glmsg.add_args(); 14648 arg_size->set_isarray(false); 14649 arg_size->set_type(GLMessage::DataType::INT); 14650 arg_size->add_intvalue(size); 14651 14652 // call function 14653 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14654 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14655 glContext->hooks->gl.glPointSizexOES(size); 14656 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14657 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14658 14659 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14660 threadStartTime, threadEndTime, 14661 &glmsg); 14662 glContext->traceGLMessage(&glmsg); 14663} 14664 14665void GLTrace_glPolygonOffsetxOES(GLfixed factor, GLfixed units) { 14666 GLMessage glmsg; 14667 GLTraceContext *glContext = getGLTraceContext(); 14668 14669 glmsg.set_function(GLMessage::glPolygonOffsetxOES); 14670 14671 // copy argument factor 14672 GLMessage_DataType *arg_factor = glmsg.add_args(); 14673 arg_factor->set_isarray(false); 14674 arg_factor->set_type(GLMessage::DataType::INT); 14675 arg_factor->add_intvalue(factor); 14676 14677 // copy argument units 14678 GLMessage_DataType *arg_units = glmsg.add_args(); 14679 arg_units->set_isarray(false); 14680 arg_units->set_type(GLMessage::DataType::INT); 14681 arg_units->add_intvalue(units); 14682 14683 // call function 14684 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14685 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14686 glContext->hooks->gl.glPolygonOffsetxOES(factor, units); 14687 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14688 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14689 14690 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14691 threadStartTime, threadEndTime, 14692 &glmsg); 14693 glContext->traceGLMessage(&glmsg); 14694} 14695 14696void GLTrace_glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { 14697 GLMessage glmsg; 14698 GLTraceContext *glContext = getGLTraceContext(); 14699 14700 glmsg.set_function(GLMessage::glRotatexOES); 14701 14702 // copy argument angle 14703 GLMessage_DataType *arg_angle = glmsg.add_args(); 14704 arg_angle->set_isarray(false); 14705 arg_angle->set_type(GLMessage::DataType::INT); 14706 arg_angle->add_intvalue(angle); 14707 14708 // copy argument x 14709 GLMessage_DataType *arg_x = glmsg.add_args(); 14710 arg_x->set_isarray(false); 14711 arg_x->set_type(GLMessage::DataType::INT); 14712 arg_x->add_intvalue(x); 14713 14714 // copy argument y 14715 GLMessage_DataType *arg_y = glmsg.add_args(); 14716 arg_y->set_isarray(false); 14717 arg_y->set_type(GLMessage::DataType::INT); 14718 arg_y->add_intvalue(y); 14719 14720 // copy argument z 14721 GLMessage_DataType *arg_z = glmsg.add_args(); 14722 arg_z->set_isarray(false); 14723 arg_z->set_type(GLMessage::DataType::INT); 14724 arg_z->add_intvalue(z); 14725 14726 // call function 14727 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14728 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14729 glContext->hooks->gl.glRotatexOES(angle, x, y, z); 14730 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14731 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14732 14733 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14734 threadStartTime, threadEndTime, 14735 &glmsg); 14736 glContext->traceGLMessage(&glmsg); 14737} 14738 14739void GLTrace_glSampleCoveragexOES(GLclampx value, GLboolean invert) { 14740 GLMessage glmsg; 14741 GLTraceContext *glContext = getGLTraceContext(); 14742 14743 glmsg.set_function(GLMessage::glSampleCoveragexOES); 14744 14745 // copy argument value 14746 GLMessage_DataType *arg_value = glmsg.add_args(); 14747 arg_value->set_isarray(false); 14748 arg_value->set_type(GLMessage::DataType::INT); 14749 arg_value->add_intvalue(value); 14750 14751 // copy argument invert 14752 GLMessage_DataType *arg_invert = glmsg.add_args(); 14753 arg_invert->set_isarray(false); 14754 arg_invert->set_type(GLMessage::DataType::BOOL); 14755 arg_invert->add_boolvalue(invert); 14756 14757 // call function 14758 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14759 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14760 glContext->hooks->gl.glSampleCoveragexOES(value, invert); 14761 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14762 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14763 14764 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14765 threadStartTime, threadEndTime, 14766 &glmsg); 14767 glContext->traceGLMessage(&glmsg); 14768} 14769 14770void GLTrace_glScalexOES(GLfixed x, GLfixed y, GLfixed z) { 14771 GLMessage glmsg; 14772 GLTraceContext *glContext = getGLTraceContext(); 14773 14774 glmsg.set_function(GLMessage::glScalexOES); 14775 14776 // copy argument x 14777 GLMessage_DataType *arg_x = glmsg.add_args(); 14778 arg_x->set_isarray(false); 14779 arg_x->set_type(GLMessage::DataType::INT); 14780 arg_x->add_intvalue(x); 14781 14782 // copy argument y 14783 GLMessage_DataType *arg_y = glmsg.add_args(); 14784 arg_y->set_isarray(false); 14785 arg_y->set_type(GLMessage::DataType::INT); 14786 arg_y->add_intvalue(y); 14787 14788 // copy argument z 14789 GLMessage_DataType *arg_z = glmsg.add_args(); 14790 arg_z->set_isarray(false); 14791 arg_z->set_type(GLMessage::DataType::INT); 14792 arg_z->add_intvalue(z); 14793 14794 // call function 14795 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14796 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14797 glContext->hooks->gl.glScalexOES(x, y, z); 14798 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14799 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14800 14801 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14802 threadStartTime, threadEndTime, 14803 &glmsg); 14804 glContext->traceGLMessage(&glmsg); 14805} 14806 14807void GLTrace_glTexEnvxOES(GLenum target, GLenum pname, GLfixed param) { 14808 GLMessage glmsg; 14809 GLTraceContext *glContext = getGLTraceContext(); 14810 14811 glmsg.set_function(GLMessage::glTexEnvxOES); 14812 14813 // copy argument target 14814 GLMessage_DataType *arg_target = glmsg.add_args(); 14815 arg_target->set_isarray(false); 14816 arg_target->set_type(GLMessage::DataType::ENUM); 14817 arg_target->add_intvalue((int)target); 14818 14819 // copy argument pname 14820 GLMessage_DataType *arg_pname = glmsg.add_args(); 14821 arg_pname->set_isarray(false); 14822 arg_pname->set_type(GLMessage::DataType::ENUM); 14823 arg_pname->add_intvalue((int)pname); 14824 14825 // copy argument param 14826 GLMessage_DataType *arg_param = glmsg.add_args(); 14827 arg_param->set_isarray(false); 14828 arg_param->set_type(GLMessage::DataType::INT); 14829 arg_param->add_intvalue(param); 14830 14831 // call function 14832 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14833 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14834 glContext->hooks->gl.glTexEnvxOES(target, pname, param); 14835 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14836 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14837 14838 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14839 threadStartTime, threadEndTime, 14840 &glmsg); 14841 glContext->traceGLMessage(&glmsg); 14842} 14843 14844void GLTrace_glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params) { 14845 GLMessage glmsg; 14846 GLTraceContext *glContext = getGLTraceContext(); 14847 14848 glmsg.set_function(GLMessage::glTexEnvxvOES); 14849 14850 // copy argument target 14851 GLMessage_DataType *arg_target = glmsg.add_args(); 14852 arg_target->set_isarray(false); 14853 arg_target->set_type(GLMessage::DataType::ENUM); 14854 arg_target->add_intvalue((int)target); 14855 14856 // copy argument pname 14857 GLMessage_DataType *arg_pname = glmsg.add_args(); 14858 arg_pname->set_isarray(false); 14859 arg_pname->set_type(GLMessage::DataType::ENUM); 14860 arg_pname->add_intvalue((int)pname); 14861 14862 // copy argument params 14863 GLMessage_DataType *arg_params = glmsg.add_args(); 14864 arg_params->set_isarray(false); 14865 arg_params->set_type(GLMessage::DataType::INT); 14866 arg_params->add_intvalue((int)params); 14867 14868 // call function 14869 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14870 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14871 glContext->hooks->gl.glTexEnvxvOES(target, pname, params); 14872 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14873 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14874 14875 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14876 threadStartTime, threadEndTime, 14877 &glmsg); 14878 glContext->traceGLMessage(&glmsg); 14879} 14880 14881void GLTrace_glTexParameterxOES(GLenum target, GLenum pname, GLfixed param) { 14882 GLMessage glmsg; 14883 GLTraceContext *glContext = getGLTraceContext(); 14884 14885 glmsg.set_function(GLMessage::glTexParameterxOES); 14886 14887 // copy argument target 14888 GLMessage_DataType *arg_target = glmsg.add_args(); 14889 arg_target->set_isarray(false); 14890 arg_target->set_type(GLMessage::DataType::ENUM); 14891 arg_target->add_intvalue((int)target); 14892 14893 // copy argument pname 14894 GLMessage_DataType *arg_pname = glmsg.add_args(); 14895 arg_pname->set_isarray(false); 14896 arg_pname->set_type(GLMessage::DataType::ENUM); 14897 arg_pname->add_intvalue((int)pname); 14898 14899 // copy argument param 14900 GLMessage_DataType *arg_param = glmsg.add_args(); 14901 arg_param->set_isarray(false); 14902 arg_param->set_type(GLMessage::DataType::INT); 14903 arg_param->add_intvalue(param); 14904 14905 // call function 14906 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14907 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14908 glContext->hooks->gl.glTexParameterxOES(target, pname, param); 14909 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14910 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14911 14912 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14913 threadStartTime, threadEndTime, 14914 &glmsg); 14915 glContext->traceGLMessage(&glmsg); 14916} 14917 14918void GLTrace_glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params) { 14919 GLMessage glmsg; 14920 GLTraceContext *glContext = getGLTraceContext(); 14921 14922 glmsg.set_function(GLMessage::glTexParameterxvOES); 14923 14924 // copy argument target 14925 GLMessage_DataType *arg_target = glmsg.add_args(); 14926 arg_target->set_isarray(false); 14927 arg_target->set_type(GLMessage::DataType::ENUM); 14928 arg_target->add_intvalue((int)target); 14929 14930 // copy argument pname 14931 GLMessage_DataType *arg_pname = glmsg.add_args(); 14932 arg_pname->set_isarray(false); 14933 arg_pname->set_type(GLMessage::DataType::ENUM); 14934 arg_pname->add_intvalue((int)pname); 14935 14936 // copy argument params 14937 GLMessage_DataType *arg_params = glmsg.add_args(); 14938 arg_params->set_isarray(false); 14939 arg_params->set_type(GLMessage::DataType::INT); 14940 arg_params->add_intvalue((int)params); 14941 14942 // call function 14943 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14944 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14945 glContext->hooks->gl.glTexParameterxvOES(target, pname, params); 14946 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14947 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14948 14949 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14950 threadStartTime, threadEndTime, 14951 &glmsg); 14952 glContext->traceGLMessage(&glmsg); 14953} 14954 14955void GLTrace_glTranslatexOES(GLfixed x, GLfixed y, GLfixed z) { 14956 GLMessage glmsg; 14957 GLTraceContext *glContext = getGLTraceContext(); 14958 14959 glmsg.set_function(GLMessage::glTranslatexOES); 14960 14961 // copy argument x 14962 GLMessage_DataType *arg_x = glmsg.add_args(); 14963 arg_x->set_isarray(false); 14964 arg_x->set_type(GLMessage::DataType::INT); 14965 arg_x->add_intvalue(x); 14966 14967 // copy argument y 14968 GLMessage_DataType *arg_y = glmsg.add_args(); 14969 arg_y->set_isarray(false); 14970 arg_y->set_type(GLMessage::DataType::INT); 14971 arg_y->add_intvalue(y); 14972 14973 // copy argument z 14974 GLMessage_DataType *arg_z = glmsg.add_args(); 14975 arg_z->set_isarray(false); 14976 arg_z->set_type(GLMessage::DataType::INT); 14977 arg_z->add_intvalue(z); 14978 14979 // call function 14980 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 14981 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 14982 glContext->hooks->gl.glTranslatexOES(x, y, z); 14983 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 14984 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 14985 14986 fixupGLMessage(glContext, wallStartTime, wallEndTime, 14987 threadStartTime, threadEndTime, 14988 &glmsg); 14989 glContext->traceGLMessage(&glmsg); 14990} 14991 14992GLboolean GLTrace_glIsRenderbufferOES(GLuint renderbuffer) { 14993 GLMessage glmsg; 14994 GLTraceContext *glContext = getGLTraceContext(); 14995 14996 glmsg.set_function(GLMessage::glIsRenderbufferOES); 14997 14998 // copy argument renderbuffer 14999 GLMessage_DataType *arg_renderbuffer = glmsg.add_args(); 15000 arg_renderbuffer->set_isarray(false); 15001 arg_renderbuffer->set_type(GLMessage::DataType::INT); 15002 arg_renderbuffer->add_intvalue(renderbuffer); 15003 15004 // call function 15005 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15006 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15007 GLboolean retValue = glContext->hooks->gl.glIsRenderbufferOES(renderbuffer); 15008 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15009 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15010 15011 // set return value 15012 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 15013 rt->set_isarray(false); 15014 rt->set_type(GLMessage::DataType::BOOL); 15015 rt->add_boolvalue(retValue); 15016 15017 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15018 threadStartTime, threadEndTime, 15019 &glmsg); 15020 glContext->traceGLMessage(&glmsg); 15021 15022 return retValue; 15023} 15024 15025void GLTrace_glBindRenderbufferOES(GLenum target, GLuint renderbuffer) { 15026 GLMessage glmsg; 15027 GLTraceContext *glContext = getGLTraceContext(); 15028 15029 glmsg.set_function(GLMessage::glBindRenderbufferOES); 15030 15031 // copy argument target 15032 GLMessage_DataType *arg_target = glmsg.add_args(); 15033 arg_target->set_isarray(false); 15034 arg_target->set_type(GLMessage::DataType::ENUM); 15035 arg_target->add_intvalue((int)target); 15036 15037 // copy argument renderbuffer 15038 GLMessage_DataType *arg_renderbuffer = glmsg.add_args(); 15039 arg_renderbuffer->set_isarray(false); 15040 arg_renderbuffer->set_type(GLMessage::DataType::INT); 15041 arg_renderbuffer->add_intvalue(renderbuffer); 15042 15043 // call function 15044 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15045 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15046 glContext->hooks->gl.glBindRenderbufferOES(target, renderbuffer); 15047 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15048 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15049 15050 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15051 threadStartTime, threadEndTime, 15052 &glmsg); 15053 glContext->traceGLMessage(&glmsg); 15054} 15055 15056void GLTrace_glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers) { 15057 GLMessage glmsg; 15058 GLTraceContext *glContext = getGLTraceContext(); 15059 15060 glmsg.set_function(GLMessage::glDeleteRenderbuffersOES); 15061 15062 // copy argument n 15063 GLMessage_DataType *arg_n = glmsg.add_args(); 15064 arg_n->set_isarray(false); 15065 arg_n->set_type(GLMessage::DataType::INT); 15066 arg_n->add_intvalue(n); 15067 15068 // copy argument renderbuffers 15069 GLMessage_DataType *arg_renderbuffers = glmsg.add_args(); 15070 arg_renderbuffers->set_isarray(false); 15071 arg_renderbuffers->set_type(GLMessage::DataType::INT); 15072 arg_renderbuffers->add_intvalue((int)renderbuffers); 15073 15074 // call function 15075 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15076 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15077 glContext->hooks->gl.glDeleteRenderbuffersOES(n, renderbuffers); 15078 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15079 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15080 15081 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15082 threadStartTime, threadEndTime, 15083 &glmsg); 15084 glContext->traceGLMessage(&glmsg); 15085} 15086 15087void GLTrace_glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers) { 15088 GLMessage glmsg; 15089 GLTraceContext *glContext = getGLTraceContext(); 15090 15091 glmsg.set_function(GLMessage::glGenRenderbuffersOES); 15092 15093 // copy argument n 15094 GLMessage_DataType *arg_n = glmsg.add_args(); 15095 arg_n->set_isarray(false); 15096 arg_n->set_type(GLMessage::DataType::INT); 15097 arg_n->add_intvalue(n); 15098 15099 // copy argument renderbuffers 15100 GLMessage_DataType *arg_renderbuffers = glmsg.add_args(); 15101 arg_renderbuffers->set_isarray(false); 15102 arg_renderbuffers->set_type(GLMessage::DataType::INT); 15103 arg_renderbuffers->add_intvalue((int)renderbuffers); 15104 15105 // call function 15106 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15107 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15108 glContext->hooks->gl.glGenRenderbuffersOES(n, renderbuffers); 15109 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15110 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15111 15112 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15113 threadStartTime, threadEndTime, 15114 &glmsg); 15115 glContext->traceGLMessage(&glmsg); 15116} 15117 15118void GLTrace_glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { 15119 GLMessage glmsg; 15120 GLTraceContext *glContext = getGLTraceContext(); 15121 15122 glmsg.set_function(GLMessage::glRenderbufferStorageOES); 15123 15124 // copy argument target 15125 GLMessage_DataType *arg_target = glmsg.add_args(); 15126 arg_target->set_isarray(false); 15127 arg_target->set_type(GLMessage::DataType::ENUM); 15128 arg_target->add_intvalue((int)target); 15129 15130 // copy argument internalformat 15131 GLMessage_DataType *arg_internalformat = glmsg.add_args(); 15132 arg_internalformat->set_isarray(false); 15133 arg_internalformat->set_type(GLMessage::DataType::ENUM); 15134 arg_internalformat->add_intvalue((int)internalformat); 15135 15136 // copy argument width 15137 GLMessage_DataType *arg_width = glmsg.add_args(); 15138 arg_width->set_isarray(false); 15139 arg_width->set_type(GLMessage::DataType::INT); 15140 arg_width->add_intvalue(width); 15141 15142 // copy argument height 15143 GLMessage_DataType *arg_height = glmsg.add_args(); 15144 arg_height->set_isarray(false); 15145 arg_height->set_type(GLMessage::DataType::INT); 15146 arg_height->add_intvalue(height); 15147 15148 // call function 15149 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15150 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15151 glContext->hooks->gl.glRenderbufferStorageOES(target, internalformat, width, height); 15152 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15153 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15154 15155 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15156 threadStartTime, threadEndTime, 15157 &glmsg); 15158 glContext->traceGLMessage(&glmsg); 15159} 15160 15161void GLTrace_glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params) { 15162 GLMessage glmsg; 15163 GLTraceContext *glContext = getGLTraceContext(); 15164 15165 glmsg.set_function(GLMessage::glGetRenderbufferParameterivOES); 15166 15167 // copy argument target 15168 GLMessage_DataType *arg_target = glmsg.add_args(); 15169 arg_target->set_isarray(false); 15170 arg_target->set_type(GLMessage::DataType::ENUM); 15171 arg_target->add_intvalue((int)target); 15172 15173 // copy argument pname 15174 GLMessage_DataType *arg_pname = glmsg.add_args(); 15175 arg_pname->set_isarray(false); 15176 arg_pname->set_type(GLMessage::DataType::ENUM); 15177 arg_pname->add_intvalue((int)pname); 15178 15179 // copy argument params 15180 GLMessage_DataType *arg_params = glmsg.add_args(); 15181 arg_params->set_isarray(false); 15182 arg_params->set_type(GLMessage::DataType::INT); 15183 arg_params->add_intvalue((int)params); 15184 15185 // call function 15186 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15187 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15188 glContext->hooks->gl.glGetRenderbufferParameterivOES(target, pname, params); 15189 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15190 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15191 15192 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15193 threadStartTime, threadEndTime, 15194 &glmsg); 15195 glContext->traceGLMessage(&glmsg); 15196} 15197 15198GLboolean GLTrace_glIsFramebufferOES(GLuint framebuffer) { 15199 GLMessage glmsg; 15200 GLTraceContext *glContext = getGLTraceContext(); 15201 15202 glmsg.set_function(GLMessage::glIsFramebufferOES); 15203 15204 // copy argument framebuffer 15205 GLMessage_DataType *arg_framebuffer = glmsg.add_args(); 15206 arg_framebuffer->set_isarray(false); 15207 arg_framebuffer->set_type(GLMessage::DataType::INT); 15208 arg_framebuffer->add_intvalue(framebuffer); 15209 15210 // call function 15211 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15212 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15213 GLboolean retValue = glContext->hooks->gl.glIsFramebufferOES(framebuffer); 15214 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15215 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15216 15217 // set return value 15218 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 15219 rt->set_isarray(false); 15220 rt->set_type(GLMessage::DataType::BOOL); 15221 rt->add_boolvalue(retValue); 15222 15223 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15224 threadStartTime, threadEndTime, 15225 &glmsg); 15226 glContext->traceGLMessage(&glmsg); 15227 15228 return retValue; 15229} 15230 15231void GLTrace_glBindFramebufferOES(GLenum target, GLuint framebuffer) { 15232 GLMessage glmsg; 15233 GLTraceContext *glContext = getGLTraceContext(); 15234 15235 glmsg.set_function(GLMessage::glBindFramebufferOES); 15236 15237 // copy argument target 15238 GLMessage_DataType *arg_target = glmsg.add_args(); 15239 arg_target->set_isarray(false); 15240 arg_target->set_type(GLMessage::DataType::ENUM); 15241 arg_target->add_intvalue((int)target); 15242 15243 // copy argument framebuffer 15244 GLMessage_DataType *arg_framebuffer = glmsg.add_args(); 15245 arg_framebuffer->set_isarray(false); 15246 arg_framebuffer->set_type(GLMessage::DataType::INT); 15247 arg_framebuffer->add_intvalue(framebuffer); 15248 15249 // call function 15250 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15251 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15252 glContext->hooks->gl.glBindFramebufferOES(target, framebuffer); 15253 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15254 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15255 15256 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15257 threadStartTime, threadEndTime, 15258 &glmsg); 15259 glContext->traceGLMessage(&glmsg); 15260} 15261 15262void GLTrace_glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers) { 15263 GLMessage glmsg; 15264 GLTraceContext *glContext = getGLTraceContext(); 15265 15266 glmsg.set_function(GLMessage::glDeleteFramebuffersOES); 15267 15268 // copy argument n 15269 GLMessage_DataType *arg_n = glmsg.add_args(); 15270 arg_n->set_isarray(false); 15271 arg_n->set_type(GLMessage::DataType::INT); 15272 arg_n->add_intvalue(n); 15273 15274 // copy argument framebuffers 15275 GLMessage_DataType *arg_framebuffers = glmsg.add_args(); 15276 arg_framebuffers->set_isarray(false); 15277 arg_framebuffers->set_type(GLMessage::DataType::INT); 15278 arg_framebuffers->add_intvalue((int)framebuffers); 15279 15280 // call function 15281 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15282 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15283 glContext->hooks->gl.glDeleteFramebuffersOES(n, framebuffers); 15284 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15285 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15286 15287 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15288 threadStartTime, threadEndTime, 15289 &glmsg); 15290 glContext->traceGLMessage(&glmsg); 15291} 15292 15293void GLTrace_glGenFramebuffersOES(GLsizei n, GLuint* framebuffers) { 15294 GLMessage glmsg; 15295 GLTraceContext *glContext = getGLTraceContext(); 15296 15297 glmsg.set_function(GLMessage::glGenFramebuffersOES); 15298 15299 // copy argument n 15300 GLMessage_DataType *arg_n = glmsg.add_args(); 15301 arg_n->set_isarray(false); 15302 arg_n->set_type(GLMessage::DataType::INT); 15303 arg_n->add_intvalue(n); 15304 15305 // copy argument framebuffers 15306 GLMessage_DataType *arg_framebuffers = glmsg.add_args(); 15307 arg_framebuffers->set_isarray(false); 15308 arg_framebuffers->set_type(GLMessage::DataType::INT); 15309 arg_framebuffers->add_intvalue((int)framebuffers); 15310 15311 // call function 15312 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15313 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15314 glContext->hooks->gl.glGenFramebuffersOES(n, framebuffers); 15315 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15316 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15317 15318 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15319 threadStartTime, threadEndTime, 15320 &glmsg); 15321 glContext->traceGLMessage(&glmsg); 15322} 15323 15324GLenum GLTrace_glCheckFramebufferStatusOES(GLenum target) { 15325 GLMessage glmsg; 15326 GLTraceContext *glContext = getGLTraceContext(); 15327 15328 glmsg.set_function(GLMessage::glCheckFramebufferStatusOES); 15329 15330 // copy argument target 15331 GLMessage_DataType *arg_target = glmsg.add_args(); 15332 arg_target->set_isarray(false); 15333 arg_target->set_type(GLMessage::DataType::ENUM); 15334 arg_target->add_intvalue((int)target); 15335 15336 // call function 15337 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15338 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15339 GLenum retValue = glContext->hooks->gl.glCheckFramebufferStatusOES(target); 15340 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15341 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15342 15343 // set return value 15344 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 15345 rt->set_isarray(false); 15346 rt->set_type(GLMessage::DataType::ENUM); 15347 rt->add_intvalue((int)retValue); 15348 15349 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15350 threadStartTime, threadEndTime, 15351 &glmsg); 15352 glContext->traceGLMessage(&glmsg); 15353 15354 return retValue; 15355} 15356 15357void GLTrace_glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { 15358 GLMessage glmsg; 15359 GLTraceContext *glContext = getGLTraceContext(); 15360 15361 glmsg.set_function(GLMessage::glFramebufferRenderbufferOES); 15362 15363 // copy argument target 15364 GLMessage_DataType *arg_target = glmsg.add_args(); 15365 arg_target->set_isarray(false); 15366 arg_target->set_type(GLMessage::DataType::ENUM); 15367 arg_target->add_intvalue((int)target); 15368 15369 // copy argument attachment 15370 GLMessage_DataType *arg_attachment = glmsg.add_args(); 15371 arg_attachment->set_isarray(false); 15372 arg_attachment->set_type(GLMessage::DataType::ENUM); 15373 arg_attachment->add_intvalue((int)attachment); 15374 15375 // copy argument renderbuffertarget 15376 GLMessage_DataType *arg_renderbuffertarget = glmsg.add_args(); 15377 arg_renderbuffertarget->set_isarray(false); 15378 arg_renderbuffertarget->set_type(GLMessage::DataType::ENUM); 15379 arg_renderbuffertarget->add_intvalue((int)renderbuffertarget); 15380 15381 // copy argument renderbuffer 15382 GLMessage_DataType *arg_renderbuffer = glmsg.add_args(); 15383 arg_renderbuffer->set_isarray(false); 15384 arg_renderbuffer->set_type(GLMessage::DataType::INT); 15385 arg_renderbuffer->add_intvalue(renderbuffer); 15386 15387 // call function 15388 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15389 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15390 glContext->hooks->gl.glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer); 15391 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15392 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15393 15394 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15395 threadStartTime, threadEndTime, 15396 &glmsg); 15397 glContext->traceGLMessage(&glmsg); 15398} 15399 15400void GLTrace_glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { 15401 GLMessage glmsg; 15402 GLTraceContext *glContext = getGLTraceContext(); 15403 15404 glmsg.set_function(GLMessage::glFramebufferTexture2DOES); 15405 15406 // copy argument target 15407 GLMessage_DataType *arg_target = glmsg.add_args(); 15408 arg_target->set_isarray(false); 15409 arg_target->set_type(GLMessage::DataType::ENUM); 15410 arg_target->add_intvalue((int)target); 15411 15412 // copy argument attachment 15413 GLMessage_DataType *arg_attachment = glmsg.add_args(); 15414 arg_attachment->set_isarray(false); 15415 arg_attachment->set_type(GLMessage::DataType::ENUM); 15416 arg_attachment->add_intvalue((int)attachment); 15417 15418 // copy argument textarget 15419 GLMessage_DataType *arg_textarget = glmsg.add_args(); 15420 arg_textarget->set_isarray(false); 15421 arg_textarget->set_type(GLMessage::DataType::ENUM); 15422 arg_textarget->add_intvalue((int)textarget); 15423 15424 // copy argument texture 15425 GLMessage_DataType *arg_texture = glmsg.add_args(); 15426 arg_texture->set_isarray(false); 15427 arg_texture->set_type(GLMessage::DataType::INT); 15428 arg_texture->add_intvalue(texture); 15429 15430 // copy argument level 15431 GLMessage_DataType *arg_level = glmsg.add_args(); 15432 arg_level->set_isarray(false); 15433 arg_level->set_type(GLMessage::DataType::INT); 15434 arg_level->add_intvalue(level); 15435 15436 // call function 15437 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15438 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15439 glContext->hooks->gl.glFramebufferTexture2DOES(target, attachment, textarget, texture, level); 15440 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15441 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15442 15443 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15444 threadStartTime, threadEndTime, 15445 &glmsg); 15446 glContext->traceGLMessage(&glmsg); 15447} 15448 15449void GLTrace_glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params) { 15450 GLMessage glmsg; 15451 GLTraceContext *glContext = getGLTraceContext(); 15452 15453 glmsg.set_function(GLMessage::glGetFramebufferAttachmentParameterivOES); 15454 15455 // copy argument target 15456 GLMessage_DataType *arg_target = glmsg.add_args(); 15457 arg_target->set_isarray(false); 15458 arg_target->set_type(GLMessage::DataType::ENUM); 15459 arg_target->add_intvalue((int)target); 15460 15461 // copy argument attachment 15462 GLMessage_DataType *arg_attachment = glmsg.add_args(); 15463 arg_attachment->set_isarray(false); 15464 arg_attachment->set_type(GLMessage::DataType::ENUM); 15465 arg_attachment->add_intvalue((int)attachment); 15466 15467 // copy argument pname 15468 GLMessage_DataType *arg_pname = glmsg.add_args(); 15469 arg_pname->set_isarray(false); 15470 arg_pname->set_type(GLMessage::DataType::ENUM); 15471 arg_pname->add_intvalue((int)pname); 15472 15473 // copy argument params 15474 GLMessage_DataType *arg_params = glmsg.add_args(); 15475 arg_params->set_isarray(false); 15476 arg_params->set_type(GLMessage::DataType::INT); 15477 arg_params->add_intvalue((int)params); 15478 15479 // call function 15480 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15481 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15482 glContext->hooks->gl.glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params); 15483 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15484 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15485 15486 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15487 threadStartTime, threadEndTime, 15488 &glmsg); 15489 glContext->traceGLMessage(&glmsg); 15490} 15491 15492void GLTrace_glGenerateMipmapOES(GLenum target) { 15493 GLMessage glmsg; 15494 GLTraceContext *glContext = getGLTraceContext(); 15495 15496 glmsg.set_function(GLMessage::glGenerateMipmapOES); 15497 15498 // copy argument target 15499 GLMessage_DataType *arg_target = glmsg.add_args(); 15500 arg_target->set_isarray(false); 15501 arg_target->set_type(GLMessage::DataType::ENUM); 15502 arg_target->add_intvalue((int)target); 15503 15504 // call function 15505 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15506 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15507 glContext->hooks->gl.glGenerateMipmapOES(target); 15508 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15509 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15510 15511 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15512 threadStartTime, threadEndTime, 15513 &glmsg); 15514 glContext->traceGLMessage(&glmsg); 15515} 15516 15517void GLTrace_glCurrentPaletteMatrixOES(GLuint matrixpaletteindex) { 15518 GLMessage glmsg; 15519 GLTraceContext *glContext = getGLTraceContext(); 15520 15521 glmsg.set_function(GLMessage::glCurrentPaletteMatrixOES); 15522 15523 // copy argument matrixpaletteindex 15524 GLMessage_DataType *arg_matrixpaletteindex = glmsg.add_args(); 15525 arg_matrixpaletteindex->set_isarray(false); 15526 arg_matrixpaletteindex->set_type(GLMessage::DataType::INT); 15527 arg_matrixpaletteindex->add_intvalue(matrixpaletteindex); 15528 15529 // call function 15530 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15531 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15532 glContext->hooks->gl.glCurrentPaletteMatrixOES(matrixpaletteindex); 15533 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15534 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15535 15536 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15537 threadStartTime, threadEndTime, 15538 &glmsg); 15539 glContext->traceGLMessage(&glmsg); 15540} 15541 15542void GLTrace_glLoadPaletteFromModelViewMatrixOES(void) { 15543 GLMessage glmsg; 15544 GLTraceContext *glContext = getGLTraceContext(); 15545 15546 glmsg.set_function(GLMessage::glLoadPaletteFromModelViewMatrixOES); 15547 15548 // call function 15549 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15550 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15551 glContext->hooks->gl.glLoadPaletteFromModelViewMatrixOES(); 15552 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15553 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15554 15555 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15556 threadStartTime, threadEndTime, 15557 &glmsg); 15558 glContext->traceGLMessage(&glmsg); 15559} 15560 15561void GLTrace_glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { 15562 GLMessage glmsg; 15563 GLTraceContext *glContext = getGLTraceContext(); 15564 15565 glmsg.set_function(GLMessage::glMatrixIndexPointerOES); 15566 15567 // copy argument size 15568 GLMessage_DataType *arg_size = glmsg.add_args(); 15569 arg_size->set_isarray(false); 15570 arg_size->set_type(GLMessage::DataType::INT); 15571 arg_size->add_intvalue(size); 15572 15573 // copy argument type 15574 GLMessage_DataType *arg_type = glmsg.add_args(); 15575 arg_type->set_isarray(false); 15576 arg_type->set_type(GLMessage::DataType::ENUM); 15577 arg_type->add_intvalue((int)type); 15578 15579 // copy argument stride 15580 GLMessage_DataType *arg_stride = glmsg.add_args(); 15581 arg_stride->set_isarray(false); 15582 arg_stride->set_type(GLMessage::DataType::INT); 15583 arg_stride->add_intvalue(stride); 15584 15585 // copy argument pointer 15586 GLMessage_DataType *arg_pointer = glmsg.add_args(); 15587 arg_pointer->set_isarray(false); 15588 arg_pointer->set_type(GLMessage::DataType::INT); 15589 arg_pointer->add_intvalue((int)pointer); 15590 15591 // call function 15592 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15593 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15594 glContext->hooks->gl.glMatrixIndexPointerOES(size, type, stride, pointer); 15595 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15596 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15597 15598 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15599 threadStartTime, threadEndTime, 15600 &glmsg); 15601 glContext->traceGLMessage(&glmsg); 15602} 15603 15604void GLTrace_glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) { 15605 GLMessage glmsg; 15606 GLTraceContext *glContext = getGLTraceContext(); 15607 15608 glmsg.set_function(GLMessage::glWeightPointerOES); 15609 15610 // copy argument size 15611 GLMessage_DataType *arg_size = glmsg.add_args(); 15612 arg_size->set_isarray(false); 15613 arg_size->set_type(GLMessage::DataType::INT); 15614 arg_size->add_intvalue(size); 15615 15616 // copy argument type 15617 GLMessage_DataType *arg_type = glmsg.add_args(); 15618 arg_type->set_isarray(false); 15619 arg_type->set_type(GLMessage::DataType::ENUM); 15620 arg_type->add_intvalue((int)type); 15621 15622 // copy argument stride 15623 GLMessage_DataType *arg_stride = glmsg.add_args(); 15624 arg_stride->set_isarray(false); 15625 arg_stride->set_type(GLMessage::DataType::INT); 15626 arg_stride->add_intvalue(stride); 15627 15628 // copy argument pointer 15629 GLMessage_DataType *arg_pointer = glmsg.add_args(); 15630 arg_pointer->set_isarray(false); 15631 arg_pointer->set_type(GLMessage::DataType::INT); 15632 arg_pointer->add_intvalue((int)pointer); 15633 15634 // call function 15635 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15636 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15637 glContext->hooks->gl.glWeightPointerOES(size, type, stride, pointer); 15638 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15639 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15640 15641 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15642 threadStartTime, threadEndTime, 15643 &glmsg); 15644 glContext->traceGLMessage(&glmsg); 15645} 15646 15647GLbitfield GLTrace_glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]) { 15648 GLMessage glmsg; 15649 GLTraceContext *glContext = getGLTraceContext(); 15650 15651 glmsg.set_function(GLMessage::glQueryMatrixxOES); 15652 15653 // copy argument mantissa 15654 GLMessage_DataType *arg_mantissa = glmsg.add_args(); 15655 arg_mantissa->set_isarray(false); 15656 arg_mantissa->set_type(GLMessage::DataType::INT); 15657 arg_mantissa->add_intvalue((int)mantissa); 15658 15659 // copy argument exponent 15660 GLMessage_DataType *arg_exponent = glmsg.add_args(); 15661 arg_exponent->set_isarray(false); 15662 arg_exponent->set_type(GLMessage::DataType::INT); 15663 arg_exponent->add_intvalue((int)exponent); 15664 15665 // call function 15666 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15667 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15668 GLbitfield retValue = glContext->hooks->gl.glQueryMatrixxOES(mantissa, exponent); 15669 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15670 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15671 15672 // set return value 15673 GLMessage_DataType *rt = glmsg.mutable_returnvalue(); 15674 rt->set_isarray(false); 15675 rt->set_type(GLMessage::DataType::INT); 15676 rt->add_intvalue(retValue); 15677 15678 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15679 threadStartTime, threadEndTime, 15680 &glmsg); 15681 glContext->traceGLMessage(&glmsg); 15682 15683 return retValue; 15684} 15685 15686void GLTrace_glDepthRangefOES(GLclampf zNear, GLclampf zFar) { 15687 GLMessage glmsg; 15688 GLTraceContext *glContext = getGLTraceContext(); 15689 15690 glmsg.set_function(GLMessage::glDepthRangefOES); 15691 15692 // copy argument zNear 15693 GLMessage_DataType *arg_zNear = glmsg.add_args(); 15694 arg_zNear->set_isarray(false); 15695 arg_zNear->set_type(GLMessage::DataType::FLOAT); 15696 arg_zNear->add_floatvalue(zNear); 15697 15698 // copy argument zFar 15699 GLMessage_DataType *arg_zFar = glmsg.add_args(); 15700 arg_zFar->set_isarray(false); 15701 arg_zFar->set_type(GLMessage::DataType::FLOAT); 15702 arg_zFar->add_floatvalue(zFar); 15703 15704 // call function 15705 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15706 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15707 glContext->hooks->gl.glDepthRangefOES(zNear, zFar); 15708 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15709 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15710 15711 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15712 threadStartTime, threadEndTime, 15713 &glmsg); 15714 glContext->traceGLMessage(&glmsg); 15715} 15716 15717void GLTrace_glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { 15718 GLMessage glmsg; 15719 GLTraceContext *glContext = getGLTraceContext(); 15720 15721 glmsg.set_function(GLMessage::glFrustumfOES); 15722 15723 // copy argument left 15724 GLMessage_DataType *arg_left = glmsg.add_args(); 15725 arg_left->set_isarray(false); 15726 arg_left->set_type(GLMessage::DataType::FLOAT); 15727 arg_left->add_floatvalue(left); 15728 15729 // copy argument right 15730 GLMessage_DataType *arg_right = glmsg.add_args(); 15731 arg_right->set_isarray(false); 15732 arg_right->set_type(GLMessage::DataType::FLOAT); 15733 arg_right->add_floatvalue(right); 15734 15735 // copy argument bottom 15736 GLMessage_DataType *arg_bottom = glmsg.add_args(); 15737 arg_bottom->set_isarray(false); 15738 arg_bottom->set_type(GLMessage::DataType::FLOAT); 15739 arg_bottom->add_floatvalue(bottom); 15740 15741 // copy argument top 15742 GLMessage_DataType *arg_top = glmsg.add_args(); 15743 arg_top->set_isarray(false); 15744 arg_top->set_type(GLMessage::DataType::FLOAT); 15745 arg_top->add_floatvalue(top); 15746 15747 // copy argument zNear 15748 GLMessage_DataType *arg_zNear = glmsg.add_args(); 15749 arg_zNear->set_isarray(false); 15750 arg_zNear->set_type(GLMessage::DataType::FLOAT); 15751 arg_zNear->add_floatvalue(zNear); 15752 15753 // copy argument zFar 15754 GLMessage_DataType *arg_zFar = glmsg.add_args(); 15755 arg_zFar->set_isarray(false); 15756 arg_zFar->set_type(GLMessage::DataType::FLOAT); 15757 arg_zFar->add_floatvalue(zFar); 15758 15759 // call function 15760 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15761 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15762 glContext->hooks->gl.glFrustumfOES(left, right, bottom, top, zNear, zFar); 15763 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15764 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15765 15766 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15767 threadStartTime, threadEndTime, 15768 &glmsg); 15769 glContext->traceGLMessage(&glmsg); 15770} 15771 15772void GLTrace_glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { 15773 GLMessage glmsg; 15774 GLTraceContext *glContext = getGLTraceContext(); 15775 15776 glmsg.set_function(GLMessage::glOrthofOES); 15777 15778 // copy argument left 15779 GLMessage_DataType *arg_left = glmsg.add_args(); 15780 arg_left->set_isarray(false); 15781 arg_left->set_type(GLMessage::DataType::FLOAT); 15782 arg_left->add_floatvalue(left); 15783 15784 // copy argument right 15785 GLMessage_DataType *arg_right = glmsg.add_args(); 15786 arg_right->set_isarray(false); 15787 arg_right->set_type(GLMessage::DataType::FLOAT); 15788 arg_right->add_floatvalue(right); 15789 15790 // copy argument bottom 15791 GLMessage_DataType *arg_bottom = glmsg.add_args(); 15792 arg_bottom->set_isarray(false); 15793 arg_bottom->set_type(GLMessage::DataType::FLOAT); 15794 arg_bottom->add_floatvalue(bottom); 15795 15796 // copy argument top 15797 GLMessage_DataType *arg_top = glmsg.add_args(); 15798 arg_top->set_isarray(false); 15799 arg_top->set_type(GLMessage::DataType::FLOAT); 15800 arg_top->add_floatvalue(top); 15801 15802 // copy argument zNear 15803 GLMessage_DataType *arg_zNear = glmsg.add_args(); 15804 arg_zNear->set_isarray(false); 15805 arg_zNear->set_type(GLMessage::DataType::FLOAT); 15806 arg_zNear->add_floatvalue(zNear); 15807 15808 // copy argument zFar 15809 GLMessage_DataType *arg_zFar = glmsg.add_args(); 15810 arg_zFar->set_isarray(false); 15811 arg_zFar->set_type(GLMessage::DataType::FLOAT); 15812 arg_zFar->add_floatvalue(zFar); 15813 15814 // call function 15815 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15816 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15817 glContext->hooks->gl.glOrthofOES(left, right, bottom, top, zNear, zFar); 15818 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15819 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15820 15821 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15822 threadStartTime, threadEndTime, 15823 &glmsg); 15824 glContext->traceGLMessage(&glmsg); 15825} 15826 15827void GLTrace_glClipPlanefOES(GLenum plane, const GLfloat *equation) { 15828 GLMessage glmsg; 15829 GLTraceContext *glContext = getGLTraceContext(); 15830 15831 glmsg.set_function(GLMessage::glClipPlanefOES); 15832 15833 // copy argument plane 15834 GLMessage_DataType *arg_plane = glmsg.add_args(); 15835 arg_plane->set_isarray(false); 15836 arg_plane->set_type(GLMessage::DataType::ENUM); 15837 arg_plane->add_intvalue((int)plane); 15838 15839 // copy argument equation 15840 GLMessage_DataType *arg_equation = glmsg.add_args(); 15841 arg_equation->set_isarray(false); 15842 arg_equation->set_type(GLMessage::DataType::INT); 15843 arg_equation->add_intvalue((int)equation); 15844 15845 // call function 15846 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15847 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15848 glContext->hooks->gl.glClipPlanefOES(plane, equation); 15849 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15850 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15851 15852 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15853 threadStartTime, threadEndTime, 15854 &glmsg); 15855 glContext->traceGLMessage(&glmsg); 15856} 15857 15858void GLTrace_glGetClipPlanefOES(GLenum pname, GLfloat eqn[4]) { 15859 GLMessage glmsg; 15860 GLTraceContext *glContext = getGLTraceContext(); 15861 15862 glmsg.set_function(GLMessage::glGetClipPlanefOES); 15863 15864 // copy argument pname 15865 GLMessage_DataType *arg_pname = glmsg.add_args(); 15866 arg_pname->set_isarray(false); 15867 arg_pname->set_type(GLMessage::DataType::ENUM); 15868 arg_pname->add_intvalue((int)pname); 15869 15870 // copy argument eqn 15871 GLMessage_DataType *arg_eqn = glmsg.add_args(); 15872 arg_eqn->set_isarray(false); 15873 arg_eqn->set_type(GLMessage::DataType::INT); 15874 arg_eqn->add_intvalue((int)eqn); 15875 15876 // call function 15877 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15878 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15879 glContext->hooks->gl.glGetClipPlanefOES(pname, eqn); 15880 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15881 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15882 15883 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15884 threadStartTime, threadEndTime, 15885 &glmsg); 15886 glContext->traceGLMessage(&glmsg); 15887} 15888 15889void GLTrace_glClearDepthfOES(GLclampf depth) { 15890 GLMessage glmsg; 15891 GLTraceContext *glContext = getGLTraceContext(); 15892 15893 glmsg.set_function(GLMessage::glClearDepthfOES); 15894 15895 // copy argument depth 15896 GLMessage_DataType *arg_depth = glmsg.add_args(); 15897 arg_depth->set_isarray(false); 15898 arg_depth->set_type(GLMessage::DataType::FLOAT); 15899 arg_depth->add_floatvalue(depth); 15900 15901 // call function 15902 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15903 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15904 glContext->hooks->gl.glClearDepthfOES(depth); 15905 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15906 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15907 15908 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15909 threadStartTime, threadEndTime, 15910 &glmsg); 15911 glContext->traceGLMessage(&glmsg); 15912} 15913 15914void GLTrace_glTexGenfOES(GLenum coord, GLenum pname, GLfloat param) { 15915 GLMessage glmsg; 15916 GLTraceContext *glContext = getGLTraceContext(); 15917 15918 glmsg.set_function(GLMessage::glTexGenfOES); 15919 15920 // copy argument coord 15921 GLMessage_DataType *arg_coord = glmsg.add_args(); 15922 arg_coord->set_isarray(false); 15923 arg_coord->set_type(GLMessage::DataType::ENUM); 15924 arg_coord->add_intvalue((int)coord); 15925 15926 // copy argument pname 15927 GLMessage_DataType *arg_pname = glmsg.add_args(); 15928 arg_pname->set_isarray(false); 15929 arg_pname->set_type(GLMessage::DataType::ENUM); 15930 arg_pname->add_intvalue((int)pname); 15931 15932 // copy argument param 15933 GLMessage_DataType *arg_param = glmsg.add_args(); 15934 arg_param->set_isarray(false); 15935 arg_param->set_type(GLMessage::DataType::FLOAT); 15936 arg_param->add_floatvalue(param); 15937 15938 // call function 15939 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15940 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15941 glContext->hooks->gl.glTexGenfOES(coord, pname, param); 15942 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15943 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15944 15945 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15946 threadStartTime, threadEndTime, 15947 &glmsg); 15948 glContext->traceGLMessage(&glmsg); 15949} 15950 15951void GLTrace_glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params) { 15952 GLMessage glmsg; 15953 GLTraceContext *glContext = getGLTraceContext(); 15954 15955 glmsg.set_function(GLMessage::glTexGenfvOES); 15956 15957 // copy argument coord 15958 GLMessage_DataType *arg_coord = glmsg.add_args(); 15959 arg_coord->set_isarray(false); 15960 arg_coord->set_type(GLMessage::DataType::ENUM); 15961 arg_coord->add_intvalue((int)coord); 15962 15963 // copy argument pname 15964 GLMessage_DataType *arg_pname = glmsg.add_args(); 15965 arg_pname->set_isarray(false); 15966 arg_pname->set_type(GLMessage::DataType::ENUM); 15967 arg_pname->add_intvalue((int)pname); 15968 15969 // copy argument params 15970 GLMessage_DataType *arg_params = glmsg.add_args(); 15971 arg_params->set_isarray(false); 15972 arg_params->set_type(GLMessage::DataType::INT); 15973 arg_params->add_intvalue((int)params); 15974 15975 // call function 15976 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 15977 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 15978 glContext->hooks->gl.glTexGenfvOES(coord, pname, params); 15979 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 15980 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 15981 15982 fixupGLMessage(glContext, wallStartTime, wallEndTime, 15983 threadStartTime, threadEndTime, 15984 &glmsg); 15985 glContext->traceGLMessage(&glmsg); 15986} 15987 15988void GLTrace_glTexGeniOES(GLenum coord, GLenum pname, GLint param) { 15989 GLMessage glmsg; 15990 GLTraceContext *glContext = getGLTraceContext(); 15991 15992 glmsg.set_function(GLMessage::glTexGeniOES); 15993 15994 // copy argument coord 15995 GLMessage_DataType *arg_coord = glmsg.add_args(); 15996 arg_coord->set_isarray(false); 15997 arg_coord->set_type(GLMessage::DataType::ENUM); 15998 arg_coord->add_intvalue((int)coord); 15999 16000 // copy argument pname 16001 GLMessage_DataType *arg_pname = glmsg.add_args(); 16002 arg_pname->set_isarray(false); 16003 arg_pname->set_type(GLMessage::DataType::ENUM); 16004 arg_pname->add_intvalue((int)pname); 16005 16006 // copy argument param 16007 GLMessage_DataType *arg_param = glmsg.add_args(); 16008 arg_param->set_isarray(false); 16009 arg_param->set_type(GLMessage::DataType::INT); 16010 arg_param->add_intvalue(param); 16011 16012 // call function 16013 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16014 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16015 glContext->hooks->gl.glTexGeniOES(coord, pname, param); 16016 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16017 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16018 16019 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16020 threadStartTime, threadEndTime, 16021 &glmsg); 16022 glContext->traceGLMessage(&glmsg); 16023} 16024 16025void GLTrace_glTexGenivOES(GLenum coord, GLenum pname, const GLint *params) { 16026 GLMessage glmsg; 16027 GLTraceContext *glContext = getGLTraceContext(); 16028 16029 glmsg.set_function(GLMessage::glTexGenivOES); 16030 16031 // copy argument coord 16032 GLMessage_DataType *arg_coord = glmsg.add_args(); 16033 arg_coord->set_isarray(false); 16034 arg_coord->set_type(GLMessage::DataType::ENUM); 16035 arg_coord->add_intvalue((int)coord); 16036 16037 // copy argument pname 16038 GLMessage_DataType *arg_pname = glmsg.add_args(); 16039 arg_pname->set_isarray(false); 16040 arg_pname->set_type(GLMessage::DataType::ENUM); 16041 arg_pname->add_intvalue((int)pname); 16042 16043 // copy argument params 16044 GLMessage_DataType *arg_params = glmsg.add_args(); 16045 arg_params->set_isarray(false); 16046 arg_params->set_type(GLMessage::DataType::INT); 16047 arg_params->add_intvalue((int)params); 16048 16049 // call function 16050 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16051 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16052 glContext->hooks->gl.glTexGenivOES(coord, pname, params); 16053 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16054 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16055 16056 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16057 threadStartTime, threadEndTime, 16058 &glmsg); 16059 glContext->traceGLMessage(&glmsg); 16060} 16061 16062void GLTrace_glTexGenxOES(GLenum coord, GLenum pname, GLfixed param) { 16063 GLMessage glmsg; 16064 GLTraceContext *glContext = getGLTraceContext(); 16065 16066 glmsg.set_function(GLMessage::glTexGenxOES); 16067 16068 // copy argument coord 16069 GLMessage_DataType *arg_coord = glmsg.add_args(); 16070 arg_coord->set_isarray(false); 16071 arg_coord->set_type(GLMessage::DataType::ENUM); 16072 arg_coord->add_intvalue((int)coord); 16073 16074 // copy argument pname 16075 GLMessage_DataType *arg_pname = glmsg.add_args(); 16076 arg_pname->set_isarray(false); 16077 arg_pname->set_type(GLMessage::DataType::ENUM); 16078 arg_pname->add_intvalue((int)pname); 16079 16080 // copy argument param 16081 GLMessage_DataType *arg_param = glmsg.add_args(); 16082 arg_param->set_isarray(false); 16083 arg_param->set_type(GLMessage::DataType::INT); 16084 arg_param->add_intvalue(param); 16085 16086 // call function 16087 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16088 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16089 glContext->hooks->gl.glTexGenxOES(coord, pname, param); 16090 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16091 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16092 16093 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16094 threadStartTime, threadEndTime, 16095 &glmsg); 16096 glContext->traceGLMessage(&glmsg); 16097} 16098 16099void GLTrace_glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params) { 16100 GLMessage glmsg; 16101 GLTraceContext *glContext = getGLTraceContext(); 16102 16103 glmsg.set_function(GLMessage::glTexGenxvOES); 16104 16105 // copy argument coord 16106 GLMessage_DataType *arg_coord = glmsg.add_args(); 16107 arg_coord->set_isarray(false); 16108 arg_coord->set_type(GLMessage::DataType::ENUM); 16109 arg_coord->add_intvalue((int)coord); 16110 16111 // copy argument pname 16112 GLMessage_DataType *arg_pname = glmsg.add_args(); 16113 arg_pname->set_isarray(false); 16114 arg_pname->set_type(GLMessage::DataType::ENUM); 16115 arg_pname->add_intvalue((int)pname); 16116 16117 // copy argument params 16118 GLMessage_DataType *arg_params = glmsg.add_args(); 16119 arg_params->set_isarray(false); 16120 arg_params->set_type(GLMessage::DataType::INT); 16121 arg_params->add_intvalue((int)params); 16122 16123 // call function 16124 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16125 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16126 glContext->hooks->gl.glTexGenxvOES(coord, pname, params); 16127 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16128 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16129 16130 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16131 threadStartTime, threadEndTime, 16132 &glmsg); 16133 glContext->traceGLMessage(&glmsg); 16134} 16135 16136void GLTrace_glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) { 16137 GLMessage glmsg; 16138 GLTraceContext *glContext = getGLTraceContext(); 16139 16140 glmsg.set_function(GLMessage::glGetTexGenfvOES); 16141 16142 // copy argument coord 16143 GLMessage_DataType *arg_coord = glmsg.add_args(); 16144 arg_coord->set_isarray(false); 16145 arg_coord->set_type(GLMessage::DataType::ENUM); 16146 arg_coord->add_intvalue((int)coord); 16147 16148 // copy argument pname 16149 GLMessage_DataType *arg_pname = glmsg.add_args(); 16150 arg_pname->set_isarray(false); 16151 arg_pname->set_type(GLMessage::DataType::ENUM); 16152 arg_pname->add_intvalue((int)pname); 16153 16154 // copy argument params 16155 GLMessage_DataType *arg_params = glmsg.add_args(); 16156 arg_params->set_isarray(false); 16157 arg_params->set_type(GLMessage::DataType::INT); 16158 arg_params->add_intvalue((int)params); 16159 16160 // call function 16161 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16162 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16163 glContext->hooks->gl.glGetTexGenfvOES(coord, pname, params); 16164 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16165 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16166 16167 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16168 threadStartTime, threadEndTime, 16169 &glmsg); 16170 glContext->traceGLMessage(&glmsg); 16171} 16172 16173void GLTrace_glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params) { 16174 GLMessage glmsg; 16175 GLTraceContext *glContext = getGLTraceContext(); 16176 16177 glmsg.set_function(GLMessage::glGetTexGenivOES); 16178 16179 // copy argument coord 16180 GLMessage_DataType *arg_coord = glmsg.add_args(); 16181 arg_coord->set_isarray(false); 16182 arg_coord->set_type(GLMessage::DataType::ENUM); 16183 arg_coord->add_intvalue((int)coord); 16184 16185 // copy argument pname 16186 GLMessage_DataType *arg_pname = glmsg.add_args(); 16187 arg_pname->set_isarray(false); 16188 arg_pname->set_type(GLMessage::DataType::ENUM); 16189 arg_pname->add_intvalue((int)pname); 16190 16191 // copy argument params 16192 GLMessage_DataType *arg_params = glmsg.add_args(); 16193 arg_params->set_isarray(false); 16194 arg_params->set_type(GLMessage::DataType::INT); 16195 arg_params->add_intvalue((int)params); 16196 16197 // call function 16198 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16199 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16200 glContext->hooks->gl.glGetTexGenivOES(coord, pname, params); 16201 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16202 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16203 16204 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16205 threadStartTime, threadEndTime, 16206 &glmsg); 16207 glContext->traceGLMessage(&glmsg); 16208} 16209 16210void GLTrace_glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) { 16211 GLMessage glmsg; 16212 GLTraceContext *glContext = getGLTraceContext(); 16213 16214 glmsg.set_function(GLMessage::glGetTexGenxvOES); 16215 16216 // copy argument coord 16217 GLMessage_DataType *arg_coord = glmsg.add_args(); 16218 arg_coord->set_isarray(false); 16219 arg_coord->set_type(GLMessage::DataType::ENUM); 16220 arg_coord->add_intvalue((int)coord); 16221 16222 // copy argument pname 16223 GLMessage_DataType *arg_pname = glmsg.add_args(); 16224 arg_pname->set_isarray(false); 16225 arg_pname->set_type(GLMessage::DataType::ENUM); 16226 arg_pname->add_intvalue((int)pname); 16227 16228 // copy argument params 16229 GLMessage_DataType *arg_params = glmsg.add_args(); 16230 arg_params->set_isarray(false); 16231 arg_params->set_type(GLMessage::DataType::INT); 16232 arg_params->add_intvalue((int)params); 16233 16234 // call function 16235 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16236 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16237 glContext->hooks->gl.glGetTexGenxvOES(coord, pname, params); 16238 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16239 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16240 16241 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16242 threadStartTime, threadEndTime, 16243 &glmsg); 16244 glContext->traceGLMessage(&glmsg); 16245} 16246 16247void GLTrace_glClipPlanefIMG(GLenum p, const GLfloat *eqn) { 16248 GLMessage glmsg; 16249 GLTraceContext *glContext = getGLTraceContext(); 16250 16251 glmsg.set_function(GLMessage::glClipPlanefIMG); 16252 16253 // copy argument p 16254 GLMessage_DataType *arg_p = glmsg.add_args(); 16255 arg_p->set_isarray(false); 16256 arg_p->set_type(GLMessage::DataType::ENUM); 16257 arg_p->add_intvalue((int)p); 16258 16259 // copy argument eqn 16260 GLMessage_DataType *arg_eqn = glmsg.add_args(); 16261 arg_eqn->set_isarray(false); 16262 arg_eqn->set_type(GLMessage::DataType::INT); 16263 arg_eqn->add_intvalue((int)eqn); 16264 16265 // call function 16266 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16267 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16268 glContext->hooks->gl.glClipPlanefIMG(p, eqn); 16269 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16270 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16271 16272 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16273 threadStartTime, threadEndTime, 16274 &glmsg); 16275 glContext->traceGLMessage(&glmsg); 16276} 16277 16278void GLTrace_glClipPlanexIMG(GLenum p, const GLfixed *eqn) { 16279 GLMessage glmsg; 16280 GLTraceContext *glContext = getGLTraceContext(); 16281 16282 glmsg.set_function(GLMessage::glClipPlanexIMG); 16283 16284 // copy argument p 16285 GLMessage_DataType *arg_p = glmsg.add_args(); 16286 arg_p->set_isarray(false); 16287 arg_p->set_type(GLMessage::DataType::ENUM); 16288 arg_p->add_intvalue((int)p); 16289 16290 // copy argument eqn 16291 GLMessage_DataType *arg_eqn = glmsg.add_args(); 16292 arg_eqn->set_isarray(false); 16293 arg_eqn->set_type(GLMessage::DataType::INT); 16294 arg_eqn->add_intvalue((int)eqn); 16295 16296 // call function 16297 nsecs_t wallStartTime = systemTime(SYSTEM_TIME_MONOTONIC); 16298 nsecs_t threadStartTime = systemTime(SYSTEM_TIME_THREAD); 16299 glContext->hooks->gl.glClipPlanexIMG(p, eqn); 16300 nsecs_t threadEndTime = systemTime(SYSTEM_TIME_THREAD); 16301 nsecs_t wallEndTime = systemTime(SYSTEM_TIME_MONOTONIC); 16302 16303 fixupGLMessage(glContext, wallStartTime, wallEndTime, 16304 threadStartTime, threadEndTime, 16305 &glmsg); 16306 glContext->traceGLMessage(&glmsg); 16307} 16308 16309 16310}; // namespace gltrace 16311}; // namespace android 16312