arch/all-hosted/libs/hostgl/hostgl_gl_api.c

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