framework/opengl/wrapper/glwImpl.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  *
   4  * Generated from Khronos GL API description (gl.xml) revision 33312.
   5  */
   6
   7 void glwActiveShaderProgram (GLuint pipeline, GLuint program)
   8 {
   9         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  10         if (!gl)
  11                 return;
  12         gl->activeShaderProgram(pipeline, program);
  13 }
  14
  15 void glwActiveTexture (GLenum texture)
  16 {
  17         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  18         if (!gl)
  19                 return;
  20         gl->activeTexture(texture);
  21 }
  22
  23 void glwAttachShader (GLuint program, GLuint shader)
  24 {
  25         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  26         if (!gl)
  27                 return;
  28         gl->attachShader(program, shader);
  29 }
  30
  31 void glwBeginConditionalRender (GLuint id, GLenum mode)
  32 {
  33         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  34         if (!gl)
  35                 return;
  36         gl->beginConditionalRender(id, mode);
  37 }
  38
  39 void glwBeginQuery (GLenum target, GLuint id)
  40 {
  41         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  42         if (!gl)
  43                 return;
  44         gl->beginQuery(target, id);
  45 }
  46
  47 void glwBeginQueryIndexed (GLenum target, GLuint index, GLuint id)
  48 {
  49         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  50         if (!gl)
  51                 return;
  52         gl->beginQueryIndexed(target, index, id);
  53 }
  54
  55 void glwBeginTransformFeedback (GLenum primitiveMode)
  56 {
  57         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  58         if (!gl)
  59                 return;
  60         gl->beginTransformFeedback(primitiveMode);
  61 }
  62
  63 void glwBindAttribLocation (GLuint program, GLuint index, const GLchar *name)
  64 {
  65         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  66         if (!gl)
  67                 return;
  68         gl->bindAttribLocation(program, index, name);
  69 }
  70
  71 void glwBindBuffer (GLenum target, GLuint buffer)
  72 {
  73         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  74         if (!gl)
  75                 return;
  76         gl->bindBuffer(target, buffer);
  77 }
  78
  79 void glwBindBufferBase (GLenum target, GLuint index, GLuint buffer)
  80 {
  81         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  82         if (!gl)
  83                 return;
  84         gl->bindBufferBase(target, index, buffer);
  85 }
  86
  87 void glwBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
  88 {
  89         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  90         if (!gl)
  91                 return;
  92         gl->bindBufferRange(target, index, buffer, offset, size);
  93 }
  94
  95 void glwBindBuffersBase (GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
  96 {
  97         const glw::Functions* gl = glw::getCurrentThreadFunctions();
  98         if (!gl)
  99                 return;
 100         gl->bindBuffersBase(target, first, count, buffers);
 101 }
 102
 103 void glwBindBuffersRange (GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
 104 {
 105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 106         if (!gl)
 107                 return;
 108         gl->bindBuffersRange(target, first, count, buffers, offsets, sizes);
 109 }
 110
 111 void glwBindFragDataLocation (GLuint program, GLuint color, const GLchar *name)
 112 {
 113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 114         if (!gl)
 115                 return;
 116         gl->bindFragDataLocation(program, color, name);
 117 }
 118
 119 void glwBindFragDataLocationIndexed (GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 120 {
 121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 122         if (!gl)
 123                 return;
 124         gl->bindFragDataLocationIndexed(program, colorNumber, index, name);
 125 }
 126
 127 void glwBindFramebuffer (GLenum target, GLuint framebuffer)
 128 {
 129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 130         if (!gl)
 131                 return;
 132         gl->bindFramebuffer(target, framebuffer);
 133 }
 134
 135 void glwBindImageTexture (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 136 {
 137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 138         if (!gl)
 139                 return;
 140         gl->bindImageTexture(unit, texture, level, layered, layer, access, format);
 141 }
 142
 143 void glwBindImageTextures (GLuint first, GLsizei count, const GLuint *textures)
 144 {
 145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 146         if (!gl)
 147                 return;
 148         gl->bindImageTextures(first, count, textures);
 149 }
 150
 151 void glwBindMultiTextureEXT (GLenum texunit, GLenum target, GLuint texture)
 152 {
 153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 154         if (!gl)
 155                 return;
 156         gl->bindMultiTextureEXT(texunit, target, texture);
 157 }
 158
 159 void glwBindProgramPipeline (GLuint pipeline)
 160 {
 161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 162         if (!gl)
 163                 return;
 164         gl->bindProgramPipeline(pipeline);
 165 }
 166
 167 void glwBindRenderbuffer (GLenum target, GLuint renderbuffer)
 168 {
 169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 170         if (!gl)
 171                 return;
 172         gl->bindRenderbuffer(target, renderbuffer);
 173 }
 174
 175 void glwBindSampler (GLuint unit, GLuint sampler)
 176 {
 177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 178         if (!gl)
 179                 return;
 180         gl->bindSampler(unit, sampler);
 181 }
 182
 183 void glwBindSamplers (GLuint first, GLsizei count, const GLuint *samplers)
 184 {
 185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 186         if (!gl)
 187                 return;
 188         gl->bindSamplers(first, count, samplers);
 189 }
 190
 191 void glwBindTexture (GLenum target, GLuint texture)
 192 {
 193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 194         if (!gl)
 195                 return;
 196         gl->bindTexture(target, texture);
 197 }
 198
 199 void glwBindTextureUnit (GLuint unit, GLuint texture)
 200 {
 201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 202         if (!gl)
 203                 return;
 204         gl->bindTextureUnit(unit, texture);
 205 }
 206
 207 void glwBindTextures (GLuint first, GLsizei count, const GLuint *textures)
 208 {
 209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 210         if (!gl)
 211                 return;
 212         gl->bindTextures(first, count, textures);
 213 }
 214
 215 void glwBindTransformFeedback (GLenum target, GLuint id)
 216 {
 217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 218         if (!gl)
 219                 return;
 220         gl->bindTransformFeedback(target, id);
 221 }
 222
 223 void glwBindVertexArray (GLuint array)
 224 {
 225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 226         if (!gl)
 227                 return;
 228         gl->bindVertexArray(array);
 229 }
 230
 231 void glwBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 232 {
 233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 234         if (!gl)
 235                 return;
 236         gl->bindVertexBuffer(bindingindex, buffer, offset, stride);
 237 }
 238
 239 void glwBindVertexBuffers (GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
 240 {
 241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 242         if (!gl)
 243                 return;
 244         gl->bindVertexBuffers(first, count, buffers, offsets, strides);
 245 }
 246
 247 void glwBlendBarrier (void)
 248 {
 249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 250         if (!gl)
 251                 return;
 252         gl->blendBarrier();
 253 }
 254
 255 void glwBlendColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 256 {
 257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 258         if (!gl)
 259                 return;
 260         gl->blendColor(red, green, blue, alpha);
 261 }
 262
 263 void glwBlendEquation (GLenum mode)
 264 {
 265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 266         if (!gl)
 267                 return;
 268         gl->blendEquation(mode);
 269 }
 270
 271 void glwBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
 272 {
 273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 274         if (!gl)
 275                 return;
 276         gl->blendEquationSeparate(modeRGB, modeAlpha);
 277 }
 278
 279 void glwBlendEquationSeparatei (GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 280 {
 281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 282         if (!gl)
 283                 return;
 284         gl->blendEquationSeparatei(buf, modeRGB, modeAlpha);
 285 }
 286
 287 void glwBlendEquationi (GLuint buf, GLenum mode)
 288 {
 289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 290         if (!gl)
 291                 return;
 292         gl->blendEquationi(buf, mode);
 293 }
 294
 295 void glwBlendFunc (GLenum sfactor, GLenum dfactor)
 296 {
 297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 298         if (!gl)
 299                 return;
 300         gl->blendFunc(sfactor, dfactor);
 301 }
 302
 303 void glwBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 304 {
 305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 306         if (!gl)
 307                 return;
 308         gl->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 309 }
 310
 311 void glwBlendFuncSeparatei (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 312 {
 313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 314         if (!gl)
 315                 return;
 316         gl->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 317 }
 318
 319 void glwBlendFunci (GLuint buf, GLenum src, GLenum dst)
 320 {
 321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 322         if (!gl)
 323                 return;
 324         gl->blendFunci(buf, src, dst);
 325 }
 326
 327 void glwBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 328 {
 329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 330         if (!gl)
 331                 return;
 332         gl->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 333 }
 334
 335 void glwBlitNamedFramebuffer (GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 336 {
 337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 338         if (!gl)
 339                 return;
 340         gl->blitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 341 }
 342
 343 void glwBufferData (GLenum target, GLsizeiptr size, const void *data, GLenum usage)
 344 {
 345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 346         if (!gl)
 347                 return;
 348         gl->bufferData(target, size, data, usage);
 349 }
 350
 351 void glwBufferPageCommitmentARB (GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit)
 352 {
 353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 354         if (!gl)
 355                 return;
 356         gl->bufferPageCommitmentARB(target, offset, size, commit);
 357 }
 358
 359 void glwBufferStorage (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
 360 {
 361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 362         if (!gl)
 363                 return;
 364         gl->bufferStorage(target, size, data, flags);
 365 }
 366
 367 void glwBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
 368 {
 369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 370         if (!gl)
 371                 return;
 372         gl->bufferSubData(target, offset, size, data);
 373 }
 374
 375 GLenum glwCheckFramebufferStatus (GLenum target)
 376 {
 377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 378         if (!gl)
 379                 return (GLenum)0;
 380         return gl->checkFramebufferStatus(target);
 381 }
 382
 383 GLenum glwCheckNamedFramebufferStatus (GLuint framebuffer, GLenum target)
 384 {
 385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 386         if (!gl)
 387                 return (GLenum)0;
 388         return gl->checkNamedFramebufferStatus(framebuffer, target);
 389 }
 390
 391 void glwClampColor (GLenum target, GLenum clamp)
 392 {
 393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 394         if (!gl)
 395                 return;
 396         gl->clampColor(target, clamp);
 397 }
 398
 399 void glwClear (GLbitfield mask)
 400 {
 401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 402         if (!gl)
 403                 return;
 404         gl->clear(mask);
 405 }
 406
 407 void glwClearBufferData (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
 408 {
 409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 410         if (!gl)
 411                 return;
 412         gl->clearBufferData(target, internalformat, format, type, data);
 413 }
 414
 415 void glwClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 416 {
 417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 418         if (!gl)
 419                 return;
 420         gl->clearBufferSubData(target, internalformat, offset, size, format, type, data);
 421 }
 422
 423 void glwClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 424 {
 425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 426         if (!gl)
 427                 return;
 428         gl->clearBufferfi(buffer, drawbuffer, depth, stencil);
 429 }
 430
 431 void glwClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat *value)
 432 {
 433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 434         if (!gl)
 435                 return;
 436         gl->clearBufferfv(buffer, drawbuffer, value);
 437 }
 438
 439 void glwClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint *value)
 440 {
 441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 442         if (!gl)
 443                 return;
 444         gl->clearBufferiv(buffer, drawbuffer, value);
 445 }
 446
 447 void glwClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint *value)
 448 {
 449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 450         if (!gl)
 451                 return;
 452         gl->clearBufferuiv(buffer, drawbuffer, value);
 453 }
 454
 455 void glwClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 456 {
 457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 458         if (!gl)
 459                 return;
 460         gl->clearColor(red, green, blue, alpha);
 461 }
 462
 463 void glwClearDepth (GLdouble depth)
 464 {
 465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 466         if (!gl)
 467                 return;
 468         gl->clearDepth(depth);
 469 }
 470
 471 void glwClearDepthf (GLfloat d)
 472 {
 473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 474         if (!gl)
 475                 return;
 476         gl->clearDepthf(d);
 477 }
 478
 479 void glwClearNamedBufferData (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
 480 {
 481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 482         if (!gl)
 483                 return;
 484         gl->clearNamedBufferData(buffer, internalformat, format, type, data);
 485 }
 486
 487 void glwClearNamedBufferSubData (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 488 {
 489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 490         if (!gl)
 491                 return;
 492         gl->clearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
 493 }
 494
 495 void glwClearNamedFramebufferfi (GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 496 {
 497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 498         if (!gl)
 499                 return;
 500         gl->clearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);
 501 }
 502
 503 void glwClearNamedFramebufferfv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)
 504 {
 505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 506         if (!gl)
 507                 return;
 508         gl->clearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
 509 }
 510
 511 void glwClearNamedFramebufferiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)
 512 {
 513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 514         if (!gl)
 515                 return;
 516         gl->clearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
 517 }
 518
 519 void glwClearNamedFramebufferuiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)
 520 {
 521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 522         if (!gl)
 523                 return;
 524         gl->clearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
 525 }
 526
 527 void glwClearStencil (GLint s)
 528 {
 529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 530         if (!gl)
 531                 return;
 532         gl->clearStencil(s);
 533 }
 534
 535 void glwClearTexImage (GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
 536 {
 537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 538         if (!gl)
 539                 return;
 540         gl->clearTexImage(texture, level, format, type, data);
 541 }
 542
 543 void glwClearTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
 544 {
 545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 546         if (!gl)
 547                 return;
 548         gl->clearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
 549 }
 550
 551 void glwClientAttribDefaultEXT (GLbitfield mask)
 552 {
 553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 554         if (!gl)
 555                 return;
 556         gl->clientAttribDefaultEXT(mask);
 557 }
 558
 559 GLenum glwClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout)
 560 {
 561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 562         if (!gl)
 563                 return (GLenum)0;
 564         return gl->clientWaitSync(sync, flags, timeout);
 565 }
 566
 567 void glwClipControl (GLenum origin, GLenum depth)
 568 {
 569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 570         if (!gl)
 571                 return;
 572         gl->clipControl(origin, depth);
 573 }
 574
 575 void glwColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 576 {
 577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 578         if (!gl)
 579                 return;
 580         gl->colorMask(red, green, blue, alpha);
 581 }
 582
 583 void glwColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 584 {
 585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 586         if (!gl)
 587                 return;
 588         gl->colorMaski(index, r, g, b, a);
 589 }
 590
 591 void glwCompileShader (GLuint shader)
 592 {
 593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 594         if (!gl)
 595                 return;
 596         gl->compileShader(shader);
 597 }
 598
 599 void glwCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits)
 600 {
 601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 602         if (!gl)
 603                 return;
 604         gl->compressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);
 605 }
 606
 607 void glwCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits)
 608 {
 609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 610         if (!gl)
 611                 return;
 612         gl->compressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);
 613 }
 614
 615 void glwCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits)
 616 {
 617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 618         if (!gl)
 619                 return;
 620         gl->compressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);
 621 }
 622
 623 void glwCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits)
 624 {
 625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 626         if (!gl)
 627                 return;
 628         gl->compressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);
 629 }
 630
 631 void glwCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits)
 632 {
 633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 634         if (!gl)
 635                 return;
 636         gl->compressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
 637 }
 638
 639 void glwCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits)
 640 {
 641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 642         if (!gl)
 643                 return;
 644         gl->compressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
 645 }
 646
 647 void glwCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
 648 {
 649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 650         if (!gl)
 651                 return;
 652         gl->compressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 653 }
 654
 655 void glwCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
 656 {
 657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 658         if (!gl)
 659                 return;
 660         gl->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 661 }
 662
 663 void glwCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
 664 {
 665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 666         if (!gl)
 667                 return;
 668         gl->compressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 669 }
 670
 671 void glwCompressedTexImage3DOES (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
 672 {
 673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 674         if (!gl)
 675                 return;
 676         gl->compressedTexImage3DOES(target, level, internalformat, width, height, depth, border, imageSize, data);
 677 }
 678
 679 void glwCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 680 {
 681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 682         if (!gl)
 683                 return;
 684         gl->compressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 685 }
 686
 687 void glwCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 688 {
 689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 690         if (!gl)
 691                 return;
 692         gl->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 693 }
 694
 695 void glwCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 696 {
 697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 698         if (!gl)
 699                 return;
 700         gl->compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 701 }
 702
 703 void glwCompressedTexSubImage3DOES (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 704 {
 705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 706         if (!gl)
 707                 return;
 708         gl->compressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 709 }
 710
 711 void glwCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits)
 712 {
 713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 714         if (!gl)
 715                 return;
 716         gl->compressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);
 717 }
 718
 719 void glwCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits)
 720 {
 721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 722         if (!gl)
 723                 return;
 724         gl->compressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);
 725 }
 726
 727 void glwCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits)
 728 {
 729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 730         if (!gl)
 731                 return;
 732         gl->compressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);
 733 }
 734
 735 void glwCompressedTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 736 {
 737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 738         if (!gl)
 739                 return;
 740         gl->compressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
 741 }
 742
 743 void glwCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits)
 744 {
 745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 746         if (!gl)
 747                 return;
 748         gl->compressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);
 749 }
 750
 751 void glwCompressedTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 752 {
 753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 754         if (!gl)
 755                 return;
 756         gl->compressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
 757 }
 758
 759 void glwCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits)
 760 {
 761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 762         if (!gl)
 763                 return;
 764         gl->compressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
 765 }
 766
 767 void glwCompressedTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 768 {
 769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 770         if (!gl)
 771                 return;
 772         gl->compressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 773 }
 774
 775 void glwCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits)
 776 {
 777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 778         if (!gl)
 779                 return;
 780         gl->compressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
 781 }
 782
 783 void glwCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 784 {
 785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 786         if (!gl)
 787                 return;
 788         gl->copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 789 }
 790
 791 void glwCopyImageSubData (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
 792 {
 793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 794         if (!gl)
 795                 return;
 796         gl->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 797 }
 798
 799 void glwCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 800 {
 801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 802         if (!gl)
 803                 return;
 804         gl->copyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border);
 805 }
 806
 807 void glwCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 808 {
 809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 810         if (!gl)
 811                 return;
 812         gl->copyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border);
 813 }
 814
 815 void glwCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 816 {
 817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 818         if (!gl)
 819                 return;
 820         gl->copyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width);
 821 }
 822
 823 void glwCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 824 {
 825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 826         if (!gl)
 827                 return;
 828         gl->copyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height);
 829 }
 830
 831 void glwCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 832 {
 833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 834         if (!gl)
 835                 return;
 836         gl->copyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
 837 }
 838
 839 void glwCopyNamedBufferSubData (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 840 {
 841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 842         if (!gl)
 843                 return;
 844         gl->copyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
 845 }
 846
 847 void glwCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 848 {
 849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 850         if (!gl)
 851                 return;
 852         gl->copyTexImage1D(target, level, internalformat, x, y, width, border);
 853 }
 854
 855 void glwCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 856 {
 857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 858         if (!gl)
 859                 return;
 860         gl->copyTexImage2D(target, level, internalformat, x, y, width, height, border);
 861 }
 862
 863 void glwCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 864 {
 865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 866         if (!gl)
 867                 return;
 868         gl->copyTexSubImage1D(target, level, xoffset, x, y, width);
 869 }
 870
 871 void glwCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 872 {
 873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 874         if (!gl)
 875                 return;
 876         gl->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 877 }
 878
 879 void glwCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 880 {
 881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 882         if (!gl)
 883                 return;
 884         gl->copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 885 }
 886
 887 void glwCopyTexSubImage3DOES (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 888 {
 889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 890         if (!gl)
 891                 return;
 892         gl->copyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 893 }
 894
 895 void glwCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 896 {
 897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 898         if (!gl)
 899                 return;
 900         gl->copyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border);
 901 }
 902
 903 void glwCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 904 {
 905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 906         if (!gl)
 907                 return;
 908         gl->copyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);
 909 }
 910
 911 void glwCopyTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 912 {
 913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 914         if (!gl)
 915                 return;
 916         gl->copyTextureSubImage1D(texture, level, xoffset, x, y, width);
 917 }
 918
 919 void glwCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 920 {
 921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 922         if (!gl)
 923                 return;
 924         gl->copyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width);
 925 }
 926
 927 void glwCopyTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 928 {
 929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 930         if (!gl)
 931                 return;
 932         gl->copyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
 933 }
 934
 935 void glwCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 936 {
 937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 938         if (!gl)
 939                 return;
 940         gl->copyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height);
 941 }
 942
 943 void glwCopyTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 944 {
 945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 946         if (!gl)
 947                 return;
 948         gl->copyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
 949 }
 950
 951 void glwCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 952 {
 953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 954         if (!gl)
 955                 return;
 956         gl->copyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
 957 }
 958
 959 void glwCreateBuffers (GLsizei n, GLuint *buffers)
 960 {
 961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 962         if (!gl)
 963                 return;
 964         gl->createBuffers(n, buffers);
 965 }
 966
 967 void glwCreateFramebuffers (GLsizei n, GLuint *framebuffers)
 968 {
 969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 970         if (!gl)
 971                 return;
 972         gl->createFramebuffers(n, framebuffers);
 973 }
 974
 975 GLuint glwCreateProgram (void)
 976 {
 977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 978         if (!gl)
 979                 return (GLuint)0;
 980         return gl->createProgram();
 981 }
 982
 983 void glwCreateProgramPipelines (GLsizei n, GLuint *pipelines)
 984 {
 985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 986         if (!gl)
 987                 return;
 988         gl->createProgramPipelines(n, pipelines);
 989 }
 990
 991 void glwCreateQueries (GLenum target, GLsizei n, GLuint *ids)
 992 {
 993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 994         if (!gl)
 995                 return;
 996         gl->createQueries(target, n, ids);
 997 }
 998
 999 void glwCreateRenderbuffers (GLsizei n, GLuint *renderbuffers)
1000 {
1001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1002         if (!gl)
1003                 return;
1004         gl->createRenderbuffers(n, renderbuffers);
1005 }
1006
1007 void glwCreateSamplers (GLsizei n, GLuint *samplers)
1008 {
1009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1010         if (!gl)
1011                 return;
1012         gl->createSamplers(n, samplers);
1013 }
1014
1015 GLuint glwCreateShader (GLenum type)
1016 {
1017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1018         if (!gl)
1019                 return (GLuint)0;
1020         return gl->createShader(type);
1021 }
1022
1023 GLuint glwCreateShaderProgramv (GLenum type, GLsizei count, const GLchar *const*strings)
1024 {
1025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1026         if (!gl)
1027                 return (GLuint)0;
1028         return gl->createShaderProgramv(type, count, strings);
1029 }
1030
1031 void glwCreateTextures (GLenum target, GLsizei n, GLuint *textures)
1032 {
1033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1034         if (!gl)
1035                 return;
1036         gl->createTextures(target, n, textures);
1037 }
1038
1039 void glwCreateTransformFeedbacks (GLsizei n, GLuint *ids)
1040 {
1041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1042         if (!gl)
1043                 return;
1044         gl->createTransformFeedbacks(n, ids);
1045 }
1046
1047 void glwCreateVertexArrays (GLsizei n, GLuint *arrays)
1048 {
1049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1050         if (!gl)
1051                 return;
1052         gl->createVertexArrays(n, arrays);
1053 }
1054
1055 void glwCullFace (GLenum mode)
1056 {
1057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1058         if (!gl)
1059                 return;
1060         gl->cullFace(mode);
1061 }
1062
1063 void glwDebugMessageCallback (GLDEBUGPROC callback, const void *userParam)
1064 {
1065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1066         if (!gl)
1067                 return;
1068         gl->debugMessageCallback(callback, userParam);
1069 }
1070
1071 void glwDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
1072 {
1073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1074         if (!gl)
1075                 return;
1076         gl->debugMessageControl(source, type, severity, count, ids, enabled);
1077 }
1078
1079 void glwDebugMessageInsert (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
1080 {
1081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1082         if (!gl)
1083                 return;
1084         gl->debugMessageInsert(source, type, id, severity, length, buf);
1085 }
1086
1087 void glwDeleteBuffers (GLsizei n, const GLuint *buffers)
1088 {
1089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1090         if (!gl)
1091                 return;
1092         gl->deleteBuffers(n, buffers);
1093 }
1094
1095 void glwDeleteFramebuffers (GLsizei n, const GLuint *framebuffers)
1096 {
1097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1098         if (!gl)
1099                 return;
1100         gl->deleteFramebuffers(n, framebuffers);
1101 }
1102
1103 void glwDeleteProgram (GLuint program)
1104 {
1105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1106         if (!gl)
1107                 return;
1108         gl->deleteProgram(program);
1109 }
1110
1111 void glwDeleteProgramPipelines (GLsizei n, const GLuint *pipelines)
1112 {
1113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1114         if (!gl)
1115                 return;
1116         gl->deleteProgramPipelines(n, pipelines);
1117 }
1118
1119 void glwDeleteQueries (GLsizei n, const GLuint *ids)
1120 {
1121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1122         if (!gl)
1123                 return;
1124         gl->deleteQueries(n, ids);
1125 }
1126
1127 void glwDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers)
1128 {
1129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1130         if (!gl)
1131                 return;
1132         gl->deleteRenderbuffers(n, renderbuffers);
1133 }
1134
1135 void glwDeleteSamplers (GLsizei count, const GLuint *samplers)
1136 {
1137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1138         if (!gl)
1139                 return;
1140         gl->deleteSamplers(count, samplers);
1141 }
1142
1143 void glwDeleteShader (GLuint shader)
1144 {
1145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1146         if (!gl)
1147                 return;
1148         gl->deleteShader(shader);
1149 }
1150
1151 void glwDeleteSync (GLsync sync)
1152 {
1153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1154         if (!gl)
1155                 return;
1156         gl->deleteSync(sync);
1157 }
1158
1159 void glwDeleteTextures (GLsizei n, const GLuint *textures)
1160 {
1161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1162         if (!gl)
1163                 return;
1164         gl->deleteTextures(n, textures);
1165 }
1166
1167 void glwDeleteTransformFeedbacks (GLsizei n, const GLuint *ids)
1168 {
1169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1170         if (!gl)
1171                 return;
1172         gl->deleteTransformFeedbacks(n, ids);
1173 }
1174
1175 void glwDeleteVertexArrays (GLsizei n, const GLuint *arrays)
1176 {
1177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1178         if (!gl)
1179                 return;
1180         gl->deleteVertexArrays(n, arrays);
1181 }
1182
1183 void glwDepthFunc (GLenum func)
1184 {
1185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1186         if (!gl)
1187                 return;
1188         gl->depthFunc(func);
1189 }
1190
1191 void glwDepthMask (GLboolean flag)
1192 {
1193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1194         if (!gl)
1195                 return;
1196         gl->depthMask(flag);
1197 }
1198
1199 void glwDepthRange (GLdouble near, GLdouble far)
1200 {
1201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1202         if (!gl)
1203                 return;
1204         gl->depthRange(near, far);
1205 }
1206
1207 void glwDepthRangeArrayfvOES (GLuint first, GLsizei count, const GLfloat *v)
1208 {
1209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1210         if (!gl)
1211                 return;
1212         gl->depthRangeArrayfvOES(first, count, v);
1213 }
1214
1215 void glwDepthRangeArrayv (GLuint first, GLsizei count, const GLdouble *v)
1216 {
1217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1218         if (!gl)
1219                 return;
1220         gl->depthRangeArrayv(first, count, v);
1221 }
1222
1223 void glwDepthRangeIndexed (GLuint index, GLdouble n, GLdouble f)
1224 {
1225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1226         if (!gl)
1227                 return;
1228         gl->depthRangeIndexed(index, n, f);
1229 }
1230
1231 void glwDepthRangeIndexedfOES (GLuint index, GLfloat n, GLfloat f)
1232 {
1233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1234         if (!gl)
1235                 return;
1236         gl->depthRangeIndexedfOES(index, n, f);
1237 }
1238
1239 void glwDepthRangef (GLfloat n, GLfloat f)
1240 {
1241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1242         if (!gl)
1243                 return;
1244         gl->depthRangef(n, f);
1245 }
1246
1247 void glwDetachShader (GLuint program, GLuint shader)
1248 {
1249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1250         if (!gl)
1251                 return;
1252         gl->detachShader(program, shader);
1253 }
1254
1255 void glwDisable (GLenum cap)
1256 {
1257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1258         if (!gl)
1259                 return;
1260         gl->disable(cap);
1261 }
1262
1263 void glwDisableClientStateIndexedEXT (GLenum array, GLuint index)
1264 {
1265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1266         if (!gl)
1267                 return;
1268         gl->disableClientStateIndexedEXT(array, index);
1269 }
1270
1271 void glwDisableClientStateiEXT (GLenum array, GLuint index)
1272 {
1273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1274         if (!gl)
1275                 return;
1276         gl->disableClientStateiEXT(array, index);
1277 }
1278
1279 void glwDisableIndexedEXT (GLenum target, GLuint index)
1280 {
1281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1282         if (!gl)
1283                 return;
1284         gl->disableIndexedEXT(target, index);
1285 }
1286
1287 void glwDisableVertexArrayAttrib (GLuint vaobj, GLuint index)
1288 {
1289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1290         if (!gl)
1291                 return;
1292         gl->disableVertexArrayAttrib(vaobj, index);
1293 }
1294
1295 void glwDisableVertexArrayEXT (GLuint vaobj, GLenum array)
1296 {
1297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1298         if (!gl)
1299                 return;
1300         gl->disableVertexArrayEXT(vaobj, array);
1301 }
1302
1303 void glwDisableVertexAttribArray (GLuint index)
1304 {
1305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1306         if (!gl)
1307                 return;
1308         gl->disableVertexAttribArray(index);
1309 }
1310
1311 void glwDisablei (GLenum target, GLuint index)
1312 {
1313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1314         if (!gl)
1315                 return;
1316         gl->disablei(target, index);
1317 }
1318
1319 void glwDispatchCompute (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
1320 {
1321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1322         if (!gl)
1323                 return;
1324         gl->dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
1325 }
1326
1327 void glwDispatchComputeIndirect (GLintptr indirect)
1328 {
1329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1330         if (!gl)
1331                 return;
1332         gl->dispatchComputeIndirect(indirect);
1333 }
1334
1335 void glwDrawArrays (GLenum mode, GLint first, GLsizei count)
1336 {
1337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1338         if (!gl)
1339                 return;
1340         gl->drawArrays(mode, first, count);
1341 }
1342
1343 void glwDrawArraysIndirect (GLenum mode, const void *indirect)
1344 {
1345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1346         if (!gl)
1347                 return;
1348         gl->drawArraysIndirect(mode, indirect);
1349 }
1350
1351 void glwDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
1352 {
1353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1354         if (!gl)
1355                 return;
1356         gl->drawArraysInstanced(mode, first, count, instancecount);
1357 }
1358
1359 void glwDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
1360 {
1361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1362         if (!gl)
1363                 return;
1364         gl->drawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
1365 }
1366
1367 void glwDrawBuffer (GLenum buf)
1368 {
1369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1370         if (!gl)
1371                 return;
1372         gl->drawBuffer(buf);
1373 }
1374
1375 void glwDrawBuffers (GLsizei n, const GLenum *bufs)
1376 {
1377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1378         if (!gl)
1379                 return;
1380         gl->drawBuffers(n, bufs);
1381 }
1382
1383 void glwDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices)
1384 {
1385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1386         if (!gl)
1387                 return;
1388         gl->drawElements(mode, count, type, indices);
1389 }
1390
1391 void glwDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
1392 {
1393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1394         if (!gl)
1395                 return;
1396         gl->drawElementsBaseVertex(mode, count, type, indices, basevertex);
1397 }
1398
1399 void glwDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect)
1400 {
1401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1402         if (!gl)
1403                 return;
1404         gl->drawElementsIndirect(mode, type, indirect);
1405 }
1406
1407 void glwDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
1408 {
1409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1410         if (!gl)
1411                 return;
1412         gl->drawElementsInstanced(mode, count, type, indices, instancecount);
1413 }
1414
1415 void glwDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
1416 {
1417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1418         if (!gl)
1419                 return;
1420         gl->drawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
1421 }
1422
1423 void glwDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
1424 {
1425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1426         if (!gl)
1427                 return;
1428         gl->drawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
1429 }
1430
1431 void glwDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
1432 {
1433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1434         if (!gl)
1435                 return;
1436         gl->drawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
1437 }
1438
1439 void glwDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
1440 {
1441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1442         if (!gl)
1443                 return;
1444         gl->drawRangeElements(mode, start, end, count, type, indices);
1445 }
1446
1447 void glwDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
1448 {
1449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1450         if (!gl)
1451                 return;
1452         gl->drawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
1453 }
1454
1455 void glwDrawTransformFeedback (GLenum mode, GLuint id)
1456 {
1457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1458         if (!gl)
1459                 return;
1460         gl->drawTransformFeedback(mode, id);
1461 }
1462
1463 void glwDrawTransformFeedbackInstanced (GLenum mode, GLuint id, GLsizei instancecount)
1464 {
1465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1466         if (!gl)
1467                 return;
1468         gl->drawTransformFeedbackInstanced(mode, id, instancecount);
1469 }
1470
1471 void glwDrawTransformFeedbackStream (GLenum mode, GLuint id, GLuint stream)
1472 {
1473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1474         if (!gl)
1475                 return;
1476         gl->drawTransformFeedbackStream(mode, id, stream);
1477 }
1478
1479 void glwDrawTransformFeedbackStreamInstanced (GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
1480 {
1481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1482         if (!gl)
1483                 return;
1484         gl->drawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
1485 }
1486
1487 void glwEGLImageTargetRenderbufferStorageOES (GLenum target, GLeglImageOES image)
1488 {
1489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1490         if (!gl)
1491                 return;
1492         gl->eglImageTargetRenderbufferStorageOES(target, image);
1493 }
1494
1495 void glwEGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)
1496 {
1497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1498         if (!gl)
1499                 return;
1500         gl->eglImageTargetTexture2DOES(target, image);
1501 }
1502
1503 void glwEnable (GLenum cap)
1504 {
1505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1506         if (!gl)
1507                 return;
1508         gl->enable(cap);
1509 }
1510
1511 void glwEnableClientStateIndexedEXT (GLenum array, GLuint index)
1512 {
1513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1514         if (!gl)
1515                 return;
1516         gl->enableClientStateIndexedEXT(array, index);
1517 }
1518
1519 void glwEnableClientStateiEXT (GLenum array, GLuint index)
1520 {
1521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1522         if (!gl)
1523                 return;
1524         gl->enableClientStateiEXT(array, index);
1525 }
1526
1527 void glwEnableIndexedEXT (GLenum target, GLuint index)
1528 {
1529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1530         if (!gl)
1531                 return;
1532         gl->enableIndexedEXT(target, index);
1533 }
1534
1535 void glwEnableVertexArrayAttrib (GLuint vaobj, GLuint index)
1536 {
1537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1538         if (!gl)
1539                 return;
1540         gl->enableVertexArrayAttrib(vaobj, index);
1541 }
1542
1543 void glwEnableVertexArrayEXT (GLuint vaobj, GLenum array)
1544 {
1545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1546         if (!gl)
1547                 return;
1548         gl->enableVertexArrayEXT(vaobj, array);
1549 }
1550
1551 void glwEnableVertexAttribArray (GLuint index)
1552 {
1553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1554         if (!gl)
1555                 return;
1556         gl->enableVertexAttribArray(index);
1557 }
1558
1559 void glwEnablei (GLenum target, GLuint index)
1560 {
1561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1562         if (!gl)
1563                 return;
1564         gl->enablei(target, index);
1565 }
1566
1567 void glwEndConditionalRender (void)
1568 {
1569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1570         if (!gl)
1571                 return;
1572         gl->endConditionalRender();
1573 }
1574
1575 void glwEndQuery (GLenum target)
1576 {
1577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1578         if (!gl)
1579                 return;
1580         gl->endQuery(target);
1581 }
1582
1583 void glwEndQueryIndexed (GLenum target, GLuint index)
1584 {
1585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1586         if (!gl)
1587                 return;
1588         gl->endQueryIndexed(target, index);
1589 }
1590
1591 void glwEndTransformFeedback (void)
1592 {
1593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1594         if (!gl)
1595                 return;
1596         gl->endTransformFeedback();
1597 }
1598
1599 GLsync glwFenceSync (GLenum condition, GLbitfield flags)
1600 {
1601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1602         if (!gl)
1603                 return (GLsync)0;
1604         return gl->fenceSync(condition, flags);
1605 }
1606
1607 void glwFinish (void)
1608 {
1609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1610         if (!gl)
1611                 return;
1612         gl->finish();
1613 }
1614
1615 void glwFlush (void)
1616 {
1617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1618         if (!gl)
1619                 return;
1620         gl->flush();
1621 }
1622
1623 void glwFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length)
1624 {
1625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1626         if (!gl)
1627                 return;
1628         gl->flushMappedBufferRange(target, offset, length);
1629 }
1630
1631 void glwFlushMappedNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length)
1632 {
1633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1634         if (!gl)
1635                 return;
1636         gl->flushMappedNamedBufferRange(buffer, offset, length);
1637 }
1638
1639 void glwFramebufferDrawBufferEXT (GLuint framebuffer, GLenum mode)
1640 {
1641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1642         if (!gl)
1643                 return;
1644         gl->framebufferDrawBufferEXT(framebuffer, mode);
1645 }
1646
1647 void glwFramebufferDrawBuffersEXT (GLuint framebuffer, GLsizei n, const GLenum *bufs)
1648 {
1649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1650         if (!gl)
1651                 return;
1652         gl->framebufferDrawBuffersEXT(framebuffer, n, bufs);
1653 }
1654
1655 void glwFramebufferParameteri (GLenum target, GLenum pname, GLint param)
1656 {
1657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1658         if (!gl)
1659                 return;
1660         gl->framebufferParameteri(target, pname, param);
1661 }
1662
1663 void glwFramebufferReadBufferEXT (GLuint framebuffer, GLenum mode)
1664 {
1665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1666         if (!gl)
1667                 return;
1668         gl->framebufferReadBufferEXT(framebuffer, mode);
1669 }
1670
1671 void glwFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1672 {
1673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1674         if (!gl)
1675                 return;
1676         gl->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
1677 }
1678
1679 void glwFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level)
1680 {
1681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1682         if (!gl)
1683                 return;
1684         gl->framebufferTexture(target, attachment, texture, level);
1685 }
1686
1687 void glwFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1688 {
1689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1690         if (!gl)
1691                 return;
1692         gl->framebufferTexture1D(target, attachment, textarget, texture, level);
1693 }
1694
1695 void glwFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1696 {
1697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1698         if (!gl)
1699                 return;
1700         gl->framebufferTexture2D(target, attachment, textarget, texture, level);
1701 }
1702
1703 void glwFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
1704 {
1705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1706         if (!gl)
1707                 return;
1708         gl->framebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
1709 }
1710
1711 void glwFramebufferTexture3DOES (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
1712 {
1713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1714         if (!gl)
1715                 return;
1716         gl->framebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
1717 }
1718
1719 void glwFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1720 {
1721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1722         if (!gl)
1723                 return;
1724         gl->framebufferTextureLayer(target, attachment, texture, level, layer);
1725 }
1726
1727 void glwFrontFace (GLenum mode)
1728 {
1729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1730         if (!gl)
1731                 return;
1732         gl->frontFace(mode);
1733 }
1734
1735 void glwGenBuffers (GLsizei n, GLuint *buffers)
1736 {
1737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1738         if (!gl)
1739                 return;
1740         gl->genBuffers(n, buffers);
1741 }
1742
1743 void glwGenFramebuffers (GLsizei n, GLuint *framebuffers)
1744 {
1745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1746         if (!gl)
1747                 return;
1748         gl->genFramebuffers(n, framebuffers);
1749 }
1750
1751 void glwGenProgramPipelines (GLsizei n, GLuint *pipelines)
1752 {
1753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1754         if (!gl)
1755                 return;
1756         gl->genProgramPipelines(n, pipelines);
1757 }
1758
1759 void glwGenQueries (GLsizei n, GLuint *ids)
1760 {
1761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1762         if (!gl)
1763                 return;
1764         gl->genQueries(n, ids);
1765 }
1766
1767 void glwGenRenderbuffers (GLsizei n, GLuint *renderbuffers)
1768 {
1769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1770         if (!gl)
1771                 return;
1772         gl->genRenderbuffers(n, renderbuffers);
1773 }
1774
1775 void glwGenSamplers (GLsizei count, GLuint *samplers)
1776 {
1777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1778         if (!gl)
1779                 return;
1780         gl->genSamplers(count, samplers);
1781 }
1782
1783 void glwGenTextures (GLsizei n, GLuint *textures)
1784 {
1785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1786         if (!gl)
1787                 return;
1788         gl->genTextures(n, textures);
1789 }
1790
1791 void glwGenTransformFeedbacks (GLsizei n, GLuint *ids)
1792 {
1793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1794         if (!gl)
1795                 return;
1796         gl->genTransformFeedbacks(n, ids);
1797 }
1798
1799 void glwGenVertexArrays (GLsizei n, GLuint *arrays)
1800 {
1801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1802         if (!gl)
1803                 return;
1804         gl->genVertexArrays(n, arrays);
1805 }
1806
1807 void glwGenerateMipmap (GLenum target)
1808 {
1809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1810         if (!gl)
1811                 return;
1812         gl->generateMipmap(target);
1813 }
1814
1815 void glwGenerateMultiTexMipmapEXT (GLenum texunit, GLenum target)
1816 {
1817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1818         if (!gl)
1819                 return;
1820         gl->generateMultiTexMipmapEXT(texunit, target);
1821 }
1822
1823 void glwGenerateTextureMipmap (GLuint texture)
1824 {
1825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1826         if (!gl)
1827                 return;
1828         gl->generateTextureMipmap(texture);
1829 }
1830
1831 void glwGetActiveAtomicCounterBufferiv (GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
1832 {
1833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1834         if (!gl)
1835                 return;
1836         gl->getActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
1837 }
1838
1839 void glwGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
1840 {
1841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1842         if (!gl)
1843                 return;
1844         gl->getActiveAttrib(program, index, bufSize, length, size, type, name);
1845 }
1846
1847 void glwGetActiveSubroutineName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
1848 {
1849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1850         if (!gl)
1851                 return;
1852         gl->getActiveSubroutineName(program, shadertype, index, bufsize, length, name);
1853 }
1854
1855 void glwGetActiveSubroutineUniformName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
1856 {
1857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1858         if (!gl)
1859                 return;
1860         gl->getActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
1861 }
1862
1863 void glwGetActiveSubroutineUniformiv (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
1864 {
1865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1866         if (!gl)
1867                 return;
1868         gl->getActiveSubroutineUniformiv(program, shadertype, index, pname, values);
1869 }
1870
1871 void glwGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
1872 {
1873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1874         if (!gl)
1875                 return;
1876         gl->getActiveUniform(program, index, bufSize, length, size, type, name);
1877 }
1878
1879 void glwGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
1880 {
1881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1882         if (!gl)
1883                 return;
1884         gl->getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
1885 }
1886
1887 void glwGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
1888 {
1889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1890         if (!gl)
1891                 return;
1892         gl->getActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1893 }
1894
1895 void glwGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
1896 {
1897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1898         if (!gl)
1899                 return;
1900         gl->getActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
1901 }
1902
1903 void glwGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
1904 {
1905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1906         if (!gl)
1907                 return;
1908         gl->getActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
1909 }
1910
1911 void glwGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
1912 {
1913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1914         if (!gl)
1915                 return;
1916         gl->getAttachedShaders(program, maxCount, count, shaders);
1917 }
1918
1919 GLint glwGetAttribLocation (GLuint program, const GLchar *name)
1920 {
1921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1922         if (!gl)
1923                 return (GLint)0;
1924         return gl->getAttribLocation(program, name);
1925 }
1926
1927 void glwGetBooleanIndexedvEXT (GLenum target, GLuint index, GLboolean *data)
1928 {
1929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1930         if (!gl)
1931                 return;
1932         gl->getBooleanIndexedvEXT(target, index, data);
1933 }
1934
1935 void glwGetBooleani_v (GLenum target, GLuint index, GLboolean *data)
1936 {
1937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1938         if (!gl)
1939                 return;
1940         gl->getBooleani_v(target, index, data);
1941 }
1942
1943 void glwGetBooleanv (GLenum pname, GLboolean *data)
1944 {
1945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1946         if (!gl)
1947                 return;
1948         gl->getBooleanv(pname, data);
1949 }
1950
1951 void glwGetBufferParameteri64v (GLenum target, GLenum pname, GLint64 *params)
1952 {
1953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1954         if (!gl)
1955                 return;
1956         gl->getBufferParameteri64v(target, pname, params);
1957 }
1958
1959 void glwGetBufferParameteriv (GLenum target, GLenum pname, GLint *params)
1960 {
1961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1962         if (!gl)
1963                 return;
1964         gl->getBufferParameteriv(target, pname, params);
1965 }
1966
1967 void glwGetBufferPointerv (GLenum target, GLenum pname, void **params)
1968 {
1969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1970         if (!gl)
1971                 return;
1972         gl->getBufferPointerv(target, pname, params);
1973 }
1974
1975 void glwGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, void *data)
1976 {
1977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1978         if (!gl)
1979                 return;
1980         gl->getBufferSubData(target, offset, size, data);
1981 }
1982
1983 void glwGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target, GLint lod, void *img)
1984 {
1985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1986         if (!gl)
1987                 return;
1988         gl->getCompressedMultiTexImageEXT(texunit, target, lod, img);
1989 }
1990
1991 void glwGetCompressedTexImage (GLenum target, GLint level, void *img)
1992 {
1993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1994         if (!gl)
1995                 return;
1996         gl->getCompressedTexImage(target, level, img);
1997 }
1998
1999 void glwGetCompressedTextureImage (GLuint texture, GLint level, GLsizei bufSize, void *pixels)
2000 {
2001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2002         if (!gl)
2003                 return;
2004         gl->getCompressedTextureImage(texture, level, bufSize, pixels);
2005 }
2006
2007 void glwGetCompressedTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)
2008 {
2009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2010         if (!gl)
2011                 return;
2012         gl->getCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
2013 }
2014
2015 GLuint glwGetDebugMessageLog (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
2016 {
2017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2018         if (!gl)
2019                 return (GLuint)0;
2020         return gl->getDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
2021 }
2022
2023 void glwGetDoubleIndexedvEXT (GLenum target, GLuint index, GLdouble *data)
2024 {
2025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2026         if (!gl)
2027                 return;
2028         gl->getDoubleIndexedvEXT(target, index, data);
2029 }
2030
2031 void glwGetDoublei_v (GLenum target, GLuint index, GLdouble *data)
2032 {
2033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2034         if (!gl)
2035                 return;
2036         gl->getDoublei_v(target, index, data);
2037 }
2038
2039 void glwGetDoublev (GLenum pname, GLdouble *data)
2040 {
2041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2042         if (!gl)
2043                 return;
2044         gl->getDoublev(pname, data);
2045 }
2046
2047 GLenum glwGetError (void)
2048 {
2049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2050         if (!gl)
2051                 return GL_INVALID_OPERATION;
2052         return gl->getError();
2053 }
2054
2055 void glwGetFloatIndexedvEXT (GLenum target, GLuint index, GLfloat *data)
2056 {
2057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2058         if (!gl)
2059                 return;
2060         gl->getFloatIndexedvEXT(target, index, data);
2061 }
2062
2063 void glwGetFloati_v (GLenum target, GLuint index, GLfloat *data)
2064 {
2065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2066         if (!gl)
2067                 return;
2068         gl->getFloati_v(target, index, data);
2069 }
2070
2071 void glwGetFloatv (GLenum pname, GLfloat *data)
2072 {
2073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2074         if (!gl)
2075                 return;
2076         gl->getFloatv(pname, data);
2077 }
2078
2079 GLint glwGetFragDataIndex (GLuint program, const GLchar *name)
2080 {
2081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2082         if (!gl)
2083                 return (GLint)0;
2084         return gl->getFragDataIndex(program, name);
2085 }
2086
2087 GLint glwGetFragDataLocation (GLuint program, const GLchar *name)
2088 {
2089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2090         if (!gl)
2091                 return (GLint)0;
2092         return gl->getFragDataLocation(program, name);
2093 }
2094
2095 void glwGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params)
2096 {
2097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2098         if (!gl)
2099                 return;
2100         gl->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
2101 }
2102
2103 void glwGetFramebufferParameteriv (GLenum target, GLenum pname, GLint *params)
2104 {
2105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2106         if (!gl)
2107                 return;
2108         gl->getFramebufferParameteriv(target, pname, params);
2109 }
2110
2111 GLenum glwGetGraphicsResetStatus (void)
2112 {
2113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2114         if (!gl)
2115                 return (GLenum)0;
2116         return gl->getGraphicsResetStatus();
2117 }
2118
2119 void glwGetInteger64i_v (GLenum target, GLuint index, GLint64 *data)
2120 {
2121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2122         if (!gl)
2123                 return;
2124         gl->getInteger64i_v(target, index, data);
2125 }
2126
2127 void glwGetInteger64v (GLenum pname, GLint64 *data)
2128 {
2129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2130         if (!gl)
2131                 return;
2132         gl->getInteger64v(pname, data);
2133 }
2134
2135 void glwGetIntegerIndexedvEXT (GLenum target, GLuint index, GLint *data)
2136 {
2137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2138         if (!gl)
2139                 return;
2140         gl->getIntegerIndexedvEXT(target, index, data);
2141 }
2142
2143 void glwGetIntegeri_v (GLenum target, GLuint index, GLint *data)
2144 {
2145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2146         if (!gl)
2147                 return;
2148         gl->getIntegeri_v(target, index, data);
2149 }
2150
2151 void glwGetIntegerv (GLenum pname, GLint *data)
2152 {
2153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2154         if (!gl)
2155                 return;
2156         gl->getIntegerv(pname, data);
2157 }
2158
2159 void glwGetInternalformatSampleivNV (GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint *params)
2160 {
2161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2162         if (!gl)
2163                 return;
2164         gl->getInternalformatSampleivNV(target, internalformat, samples, pname, bufSize, params);
2165 }
2166
2167 void glwGetInternalformati64v (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
2168 {
2169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2170         if (!gl)
2171                 return;
2172         gl->getInternalformati64v(target, internalformat, pname, bufSize, params);
2173 }
2174
2175 void glwGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
2176 {
2177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2178         if (!gl)
2179                 return;
2180         gl->getInternalformativ(target, internalformat, pname, bufSize, params);
2181 }
2182
2183 void glwGetMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat *params)
2184 {
2185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2186         if (!gl)
2187                 return;
2188         gl->getMultiTexEnvfvEXT(texunit, target, pname, params);
2189 }
2190
2191 void glwGetMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params)
2192 {
2193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2194         if (!gl)
2195                 return;
2196         gl->getMultiTexEnvivEXT(texunit, target, pname, params);
2197 }
2198
2199 void glwGetMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble *params)
2200 {
2201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2202         if (!gl)
2203                 return;
2204         gl->getMultiTexGendvEXT(texunit, coord, pname, params);
2205 }
2206
2207 void glwGetMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat *params)
2208 {
2209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2210         if (!gl)
2211                 return;
2212         gl->getMultiTexGenfvEXT(texunit, coord, pname, params);
2213 }
2214
2215 void glwGetMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, GLint *params)
2216 {
2217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2218         if (!gl)
2219                 return;
2220         gl->getMultiTexGenivEXT(texunit, coord, pname, params);
2221 }
2222
2223 void glwGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
2224 {
2225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2226         if (!gl)
2227                 return;
2228         gl->getMultiTexImageEXT(texunit, target, level, format, type, pixels);
2229 }
2230
2231 void glwGetMultiTexLevelParameterfvEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params)
2232 {
2233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2234         if (!gl)
2235                 return;
2236         gl->getMultiTexLevelParameterfvEXT(texunit, target, level, pname, params);
2237 }
2238
2239 void glwGetMultiTexLevelParameterivEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params)
2240 {
2241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2242         if (!gl)
2243                 return;
2244         gl->getMultiTexLevelParameterivEXT(texunit, target, level, pname, params);
2245 }
2246
2247 void glwGetMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params)
2248 {
2249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2250         if (!gl)
2251                 return;
2252         gl->getMultiTexParameterIivEXT(texunit, target, pname, params);
2253 }
2254
2255 void glwGetMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, GLuint *params)
2256 {
2257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2258         if (!gl)
2259                 return;
2260         gl->getMultiTexParameterIuivEXT(texunit, target, pname, params);
2261 }
2262
2263 void glwGetMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat *params)
2264 {
2265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2266         if (!gl)
2267                 return;
2268         gl->getMultiTexParameterfvEXT(texunit, target, pname, params);
2269 }
2270
2271 void glwGetMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params)
2272 {
2273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2274         if (!gl)
2275                 return;
2276         gl->getMultiTexParameterivEXT(texunit, target, pname, params);
2277 }
2278
2279 void glwGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val)
2280 {
2281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2282         if (!gl)
2283                 return;
2284         gl->getMultisamplefv(pname, index, val);
2285 }
2286
2287 void glwGetNamedBufferParameteri64v (GLuint buffer, GLenum pname, GLint64 *params)
2288 {
2289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2290         if (!gl)
2291                 return;
2292         gl->getNamedBufferParameteri64v(buffer, pname, params);
2293 }
2294
2295 void glwGetNamedBufferParameteriv (GLuint buffer, GLenum pname, GLint *params)
2296 {
2297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2298         if (!gl)
2299                 return;
2300         gl->getNamedBufferParameteriv(buffer, pname, params);
2301 }
2302
2303 void glwGetNamedBufferPointerv (GLuint buffer, GLenum pname, void **params)
2304 {
2305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2306         if (!gl)
2307                 return;
2308         gl->getNamedBufferPointerv(buffer, pname, params);
2309 }
2310
2311 void glwGetNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, void *data)
2312 {
2313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2314         if (!gl)
2315                 return;
2316         gl->getNamedBufferSubData(buffer, offset, size, data);
2317 }
2318
2319 void glwGetNamedFramebufferAttachmentParameteriv (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
2320 {
2321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2322         if (!gl)
2323                 return;
2324         gl->getNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
2325 }
2326
2327 void glwGetNamedFramebufferParameteriv (GLuint framebuffer, GLenum pname, GLint *param)
2328 {
2329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2330         if (!gl)
2331                 return;
2332         gl->getNamedFramebufferParameteriv(framebuffer, pname, param);
2333 }
2334
2335 void glwGetNamedProgramLocalParameterIivEXT (GLuint program, GLenum target, GLuint index, GLint *params)
2336 {
2337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2338         if (!gl)
2339                 return;
2340         gl->getNamedProgramLocalParameterIivEXT(program, target, index, params);
2341 }
2342
2343 void glwGetNamedProgramLocalParameterIuivEXT (GLuint program, GLenum target, GLuint index, GLuint *params)
2344 {
2345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2346         if (!gl)
2347                 return;
2348         gl->getNamedProgramLocalParameterIuivEXT(program, target, index, params);
2349 }
2350
2351 void glwGetNamedProgramLocalParameterdvEXT (GLuint program, GLenum target, GLuint index, GLdouble *params)
2352 {
2353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2354         if (!gl)
2355                 return;
2356         gl->getNamedProgramLocalParameterdvEXT(program, target, index, params);
2357 }
2358
2359 void glwGetNamedProgramLocalParameterfvEXT (GLuint program, GLenum target, GLuint index, GLfloat *params)
2360 {
2361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2362         if (!gl)
2363                 return;
2364         gl->getNamedProgramLocalParameterfvEXT(program, target, index, params);
2365 }
2366
2367 void glwGetNamedProgramStringEXT (GLuint program, GLenum target, GLenum pname, void *string)
2368 {
2369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2370         if (!gl)
2371                 return;
2372         gl->getNamedProgramStringEXT(program, target, pname, string);
2373 }
2374
2375 void glwGetNamedProgramivEXT (GLuint program, GLenum target, GLenum pname, GLint *params)
2376 {
2377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2378         if (!gl)
2379                 return;
2380         gl->getNamedProgramivEXT(program, target, pname, params);
2381 }
2382
2383 void glwGetNamedRenderbufferParameteriv (GLuint renderbuffer, GLenum pname, GLint *params)
2384 {
2385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2386         if (!gl)
2387                 return;
2388         gl->getNamedRenderbufferParameteriv(renderbuffer, pname, params);
2389 }
2390
2391 void glwGetObjectLabel (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
2392 {
2393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2394         if (!gl)
2395                 return;
2396         gl->getObjectLabel(identifier, name, bufSize, length, label);
2397 }
2398
2399 void glwGetObjectPtrLabel (const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
2400 {
2401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2402         if (!gl)
2403                 return;
2404         gl->getObjectPtrLabel(ptr, bufSize, length, label);
2405 }
2406
2407 void glwGetPointerIndexedvEXT (GLenum target, GLuint index, void **data)
2408 {
2409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2410         if (!gl)
2411                 return;
2412         gl->getPointerIndexedvEXT(target, index, data);
2413 }
2414
2415 void glwGetPointeri_vEXT (GLenum pname, GLuint index, void **params)
2416 {
2417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2418         if (!gl)
2419                 return;
2420         gl->getPointeri_vEXT(pname, index, params);
2421 }
2422
2423 void glwGetPointerv (GLenum pname, void **params)
2424 {
2425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2426         if (!gl)
2427                 return;
2428         gl->getPointerv(pname, params);
2429 }
2430
2431 void glwGetProgramBinary (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
2432 {
2433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2434         if (!gl)
2435                 return;
2436         gl->getProgramBinary(program, bufSize, length, binaryFormat, binary);
2437 }
2438
2439 void glwGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
2440 {
2441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2442         if (!gl)
2443                 return;
2444         gl->getProgramInfoLog(program, bufSize, length, infoLog);
2445 }
2446
2447 void glwGetProgramInterfaceiv (GLuint program, GLenum programInterface, GLenum pname, GLint *params)
2448 {
2449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2450         if (!gl)
2451                 return;
2452         gl->getProgramInterfaceiv(program, programInterface, pname, params);
2453 }
2454
2455 void glwGetProgramPipelineInfoLog (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
2456 {
2457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2458         if (!gl)
2459                 return;
2460         gl->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
2461 }
2462
2463 void glwGetProgramPipelineiv (GLuint pipeline, GLenum pname, GLint *params)
2464 {
2465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2466         if (!gl)
2467                 return;
2468         gl->getProgramPipelineiv(pipeline, pname, params);
2469 }
2470
2471 GLuint glwGetProgramResourceIndex (GLuint program, GLenum programInterface, const GLchar *name)
2472 {
2473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2474         if (!gl)
2475                 return (GLuint)0;
2476         return gl->getProgramResourceIndex(program, programInterface, name);
2477 }
2478
2479 GLint glwGetProgramResourceLocation (GLuint program, GLenum programInterface, const GLchar *name)
2480 {
2481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2482         if (!gl)
2483                 return (GLint)0;
2484         return gl->getProgramResourceLocation(program, programInterface, name);
2485 }
2486
2487 GLint glwGetProgramResourceLocationIndex (GLuint program, GLenum programInterface, const GLchar *name)
2488 {
2489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2490         if (!gl)
2491                 return (GLint)0;
2492         return gl->getProgramResourceLocationIndex(program, programInterface, name);
2493 }
2494
2495 void glwGetProgramResourceName (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
2496 {
2497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2498         if (!gl)
2499                 return;
2500         gl->getProgramResourceName(program, programInterface, index, bufSize, length, name);
2501 }
2502
2503 void glwGetProgramResourceiv (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
2504 {
2505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2506         if (!gl)
2507                 return;
2508         gl->getProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
2509 }
2510
2511 void glwGetProgramStageiv (GLuint program, GLenum shadertype, GLenum pname, GLint *values)
2512 {
2513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2514         if (!gl)
2515                 return;
2516         gl->getProgramStageiv(program, shadertype, pname, values);
2517 }
2518
2519 void glwGetProgramiv (GLuint program, GLenum pname, GLint *params)
2520 {
2521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2522         if (!gl)
2523                 return;
2524         gl->getProgramiv(program, pname, params);
2525 }
2526
2527 void glwGetQueryBufferObjecti64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
2528 {
2529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2530         if (!gl)
2531                 return;
2532         gl->getQueryBufferObjecti64v(id, buffer, pname, offset);
2533 }
2534
2535 void glwGetQueryBufferObjectiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
2536 {
2537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2538         if (!gl)
2539                 return;
2540         gl->getQueryBufferObjectiv(id, buffer, pname, offset);
2541 }
2542
2543 void glwGetQueryBufferObjectui64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
2544 {
2545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2546         if (!gl)
2547                 return;
2548         gl->getQueryBufferObjectui64v(id, buffer, pname, offset);
2549 }
2550
2551 void glwGetQueryBufferObjectuiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
2552 {
2553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2554         if (!gl)
2555                 return;
2556         gl->getQueryBufferObjectuiv(id, buffer, pname, offset);
2557 }
2558
2559 void glwGetQueryIndexediv (GLenum target, GLuint index, GLenum pname, GLint *params)
2560 {
2561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2562         if (!gl)
2563                 return;
2564         gl->getQueryIndexediv(target, index, pname, params);
2565 }
2566
2567 void glwGetQueryObjecti64v (GLuint id, GLenum pname, GLint64 *params)
2568 {
2569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2570         if (!gl)
2571                 return;
2572         gl->getQueryObjecti64v(id, pname, params);
2573 }
2574
2575 void glwGetQueryObjectiv (GLuint id, GLenum pname, GLint *params)
2576 {
2577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2578         if (!gl)
2579                 return;
2580         gl->getQueryObjectiv(id, pname, params);
2581 }
2582
2583 void glwGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64 *params)
2584 {
2585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2586         if (!gl)
2587                 return;
2588         gl->getQueryObjectui64v(id, pname, params);
2589 }
2590
2591 void glwGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params)
2592 {
2593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2594         if (!gl)
2595                 return;
2596         gl->getQueryObjectuiv(id, pname, params);
2597 }
2598
2599 void glwGetQueryiv (GLenum target, GLenum pname, GLint *params)
2600 {
2601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2602         if (!gl)
2603                 return;
2604         gl->getQueryiv(target, pname, params);
2605 }
2606
2607 void glwGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params)
2608 {
2609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2610         if (!gl)
2611                 return;
2612         gl->getRenderbufferParameteriv(target, pname, params);
2613 }
2614
2615 void glwGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint *params)
2616 {
2617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2618         if (!gl)
2619                 return;
2620         gl->getSamplerParameterIiv(sampler, pname, params);
2621 }
2622
2623 void glwGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint *params)
2624 {
2625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2626         if (!gl)
2627                 return;
2628         gl->getSamplerParameterIuiv(sampler, pname, params);
2629 }
2630
2631 void glwGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat *params)
2632 {
2633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2634         if (!gl)
2635                 return;
2636         gl->getSamplerParameterfv(sampler, pname, params);
2637 }
2638
2639 void glwGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint *params)
2640 {
2641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2642         if (!gl)
2643                 return;
2644         gl->getSamplerParameteriv(sampler, pname, params);
2645 }
2646
2647 void glwGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
2648 {
2649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2650         if (!gl)
2651                 return;
2652         gl->getShaderInfoLog(shader, bufSize, length, infoLog);
2653 }
2654
2655 void glwGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
2656 {
2657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2658         if (!gl)
2659                 return;
2660         gl->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
2661 }
2662
2663 void glwGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
2664 {
2665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2666         if (!gl)
2667                 return;
2668         gl->getShaderSource(shader, bufSize, length, source);
2669 }
2670
2671 void glwGetShaderiv (GLuint shader, GLenum pname, GLint *params)
2672 {
2673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2674         if (!gl)
2675                 return;
2676         gl->getShaderiv(shader, pname, params);
2677 }
2678
2679 const GLubyte * glwGetString (GLenum name)
2680 {
2681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2682         if (!gl)
2683                 return (const GLubyte *)0;
2684         return gl->getString(name);
2685 }
2686
2687 const GLubyte * glwGetStringi (GLenum name, GLuint index)
2688 {
2689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2690         if (!gl)
2691                 return (const GLubyte *)0;
2692         return gl->getStringi(name, index);
2693 }
2694
2695 GLuint glwGetSubroutineIndex (GLuint program, GLenum shadertype, const GLchar *name)
2696 {
2697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2698         if (!gl)
2699                 return (GLuint)0;
2700         return gl->getSubroutineIndex(program, shadertype, name);
2701 }
2702
2703 GLint glwGetSubroutineUniformLocation (GLuint program, GLenum shadertype, const GLchar *name)
2704 {
2705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2706         if (!gl)
2707                 return (GLint)0;
2708         return gl->getSubroutineUniformLocation(program, shadertype, name);
2709 }
2710
2711 void glwGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
2712 {
2713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2714         if (!gl)
2715                 return;
2716         gl->getSynciv(sync, pname, bufSize, length, values);
2717 }
2718
2719 void glwGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
2720 {
2721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2722         if (!gl)
2723                 return;
2724         gl->getTexImage(target, level, format, type, pixels);
2725 }
2726
2727 void glwGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params)
2728 {
2729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2730         if (!gl)
2731                 return;
2732         gl->getTexLevelParameterfv(target, level, pname, params);
2733 }
2734
2735 void glwGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params)
2736 {
2737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2738         if (!gl)
2739                 return;
2740         gl->getTexLevelParameteriv(target, level, pname, params);
2741 }
2742
2743 void glwGetTexParameterIiv (GLenum target, GLenum pname, GLint *params)
2744 {
2745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2746         if (!gl)
2747                 return;
2748         gl->getTexParameterIiv(target, pname, params);
2749 }
2750
2751 void glwGetTexParameterIuiv (GLenum target, GLenum pname, GLuint *params)
2752 {
2753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2754         if (!gl)
2755                 return;
2756         gl->getTexParameterIuiv(target, pname, params);
2757 }
2758
2759 void glwGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)
2760 {
2761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2762         if (!gl)
2763                 return;
2764         gl->getTexParameterfv(target, pname, params);
2765 }
2766
2767 void glwGetTexParameteriv (GLenum target, GLenum pname, GLint *params)
2768 {
2769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2770         if (!gl)
2771                 return;
2772         gl->getTexParameteriv(target, pname, params);
2773 }
2774
2775 void glwGetTextureImage (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
2776 {
2777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2778         if (!gl)
2779                 return;
2780         gl->getTextureImage(texture, level, format, type, bufSize, pixels);
2781 }
2782
2783 void glwGetTextureLevelParameterfv (GLuint texture, GLint level, GLenum pname, GLfloat *params)
2784 {
2785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2786         if (!gl)
2787                 return;
2788         gl->getTextureLevelParameterfv(texture, level, pname, params);
2789 }
2790
2791 void glwGetTextureLevelParameteriv (GLuint texture, GLint level, GLenum pname, GLint *params)
2792 {
2793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2794         if (!gl)
2795                 return;
2796         gl->getTextureLevelParameteriv(texture, level, pname, params);
2797 }
2798
2799 void glwGetTextureParameterIiv (GLuint texture, GLenum pname, GLint *params)
2800 {
2801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2802         if (!gl)
2803                 return;
2804         gl->getTextureParameterIiv(texture, pname, params);
2805 }
2806
2807 void glwGetTextureParameterIuiv (GLuint texture, GLenum pname, GLuint *params)
2808 {
2809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2810         if (!gl)
2811                 return;
2812         gl->getTextureParameterIuiv(texture, pname, params);
2813 }
2814
2815 void glwGetTextureParameterfv (GLuint texture, GLenum pname, GLfloat *params)
2816 {
2817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2818         if (!gl)
2819                 return;
2820         gl->getTextureParameterfv(texture, pname, params);
2821 }
2822
2823 void glwGetTextureParameteriv (GLuint texture, GLenum pname, GLint *params)
2824 {
2825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2826         if (!gl)
2827                 return;
2828         gl->getTextureParameteriv(texture, pname, params);
2829 }
2830
2831 void glwGetTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
2832 {
2833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2834         if (!gl)
2835                 return;
2836         gl->getTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
2837 }
2838
2839 void glwGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
2840 {
2841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2842         if (!gl)
2843                 return;
2844         gl->getTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
2845 }
2846
2847 void glwGetTransformFeedbacki64_v (GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
2848 {
2849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2850         if (!gl)
2851                 return;
2852         gl->getTransformFeedbacki64_v(xfb, pname, index, param);
2853 }
2854
2855 void glwGetTransformFeedbacki_v (GLuint xfb, GLenum pname, GLuint index, GLint *param)
2856 {
2857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2858         if (!gl)
2859                 return;
2860         gl->getTransformFeedbacki_v(xfb, pname, index, param);
2861 }
2862
2863 void glwGetTransformFeedbackiv (GLuint xfb, GLenum pname, GLint *param)
2864 {
2865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2866         if (!gl)
2867                 return;
2868         gl->getTransformFeedbackiv(xfb, pname, param);
2869 }
2870
2871 GLuint glwGetUniformBlockIndex (GLuint program, const GLchar *uniformBlockName)
2872 {
2873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2874         if (!gl)
2875                 return (GLuint)0;
2876         return gl->getUniformBlockIndex(program, uniformBlockName);
2877 }
2878
2879 void glwGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices)
2880 {
2881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2882         if (!gl)
2883                 return;
2884         gl->getUniformIndices(program, uniformCount, uniformNames, uniformIndices);
2885 }
2886
2887 GLint glwGetUniformLocation (GLuint program, const GLchar *name)
2888 {
2889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2890         if (!gl)
2891                 return (GLint)0;
2892         return gl->getUniformLocation(program, name);
2893 }
2894
2895 void glwGetUniformSubroutineuiv (GLenum shadertype, GLint location, GLuint *params)
2896 {
2897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2898         if (!gl)
2899                 return;
2900         gl->getUniformSubroutineuiv(shadertype, location, params);
2901 }
2902
2903 void glwGetUniformdv (GLuint program, GLint location, GLdouble *params)
2904 {
2905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2906         if (!gl)
2907                 return;
2908         gl->getUniformdv(program, location, params);
2909 }
2910
2911 void glwGetUniformfv (GLuint program, GLint location, GLfloat *params)
2912 {
2913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2914         if (!gl)
2915                 return;
2916         gl->getUniformfv(program, location, params);
2917 }
2918
2919 void glwGetUniformiv (GLuint program, GLint location, GLint *params)
2920 {
2921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2922         if (!gl)
2923                 return;
2924         gl->getUniformiv(program, location, params);
2925 }
2926
2927 void glwGetUniformuiv (GLuint program, GLint location, GLuint *params)
2928 {
2929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2930         if (!gl)
2931                 return;
2932         gl->getUniformuiv(program, location, params);
2933 }
2934
2935 void glwGetVertexArrayIndexed64iv (GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)
2936 {
2937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2938         if (!gl)
2939                 return;
2940         gl->getVertexArrayIndexed64iv(vaobj, index, pname, param);
2941 }
2942
2943 void glwGetVertexArrayIndexediv (GLuint vaobj, GLuint index, GLenum pname, GLint *param)
2944 {
2945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2946         if (!gl)
2947                 return;
2948         gl->getVertexArrayIndexediv(vaobj, index, pname, param);
2949 }
2950
2951 void glwGetVertexArrayIntegeri_vEXT (GLuint vaobj, GLuint index, GLenum pname, GLint *param)
2952 {
2953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2954         if (!gl)
2955                 return;
2956         gl->getVertexArrayIntegeri_vEXT(vaobj, index, pname, param);
2957 }
2958
2959 void glwGetVertexArrayIntegervEXT (GLuint vaobj, GLenum pname, GLint *param)
2960 {
2961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2962         if (!gl)
2963                 return;
2964         gl->getVertexArrayIntegervEXT(vaobj, pname, param);
2965 }
2966
2967 void glwGetVertexArrayPointeri_vEXT (GLuint vaobj, GLuint index, GLenum pname, void **param)
2968 {
2969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2970         if (!gl)
2971                 return;
2972         gl->getVertexArrayPointeri_vEXT(vaobj, index, pname, param);
2973 }
2974
2975 void glwGetVertexArrayPointervEXT (GLuint vaobj, GLenum pname, void **param)
2976 {
2977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2978         if (!gl)
2979                 return;
2980         gl->getVertexArrayPointervEXT(vaobj, pname, param);
2981 }
2982
2983 void glwGetVertexArrayiv (GLuint vaobj, GLenum pname, GLint *param)
2984 {
2985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2986         if (!gl)
2987                 return;
2988         gl->getVertexArrayiv(vaobj, pname, param);
2989 }
2990
2991 void glwGetVertexAttribIiv (GLuint index, GLenum pname, GLint *params)
2992 {
2993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2994         if (!gl)
2995                 return;
2996         gl->getVertexAttribIiv(index, pname, params);
2997 }
2998
2999 void glwGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint *params)
3000 {
3001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3002         if (!gl)
3003                 return;
3004         gl->getVertexAttribIuiv(index, pname, params);
3005 }
3006
3007 void glwGetVertexAttribLdv (GLuint index, GLenum pname, GLdouble *params)
3008 {
3009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3010         if (!gl)
3011                 return;
3012         gl->getVertexAttribLdv(index, pname, params);
3013 }
3014
3015 void glwGetVertexAttribPointerv (GLuint index, GLenum pname, void **pointer)
3016 {
3017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3018         if (!gl)
3019                 return;
3020         gl->getVertexAttribPointerv(index, pname, pointer);
3021 }
3022
3023 void glwGetVertexAttribdv (GLuint index, GLenum pname, GLdouble *params)
3024 {
3025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3026         if (!gl)
3027                 return;
3028         gl->getVertexAttribdv(index, pname, params);
3029 }
3030
3031 void glwGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params)
3032 {
3033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3034         if (!gl)
3035                 return;
3036         gl->getVertexAttribfv(index, pname, params);
3037 }
3038
3039 void glwGetVertexAttribiv (GLuint index, GLenum pname, GLint *params)
3040 {
3041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3042         if (!gl)
3043                 return;
3044         gl->getVertexAttribiv(index, pname, params);
3045 }
3046
3047 void glwGetnCompressedTexImage (GLenum target, GLint lod, GLsizei bufSize, void *pixels)
3048 {
3049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3050         if (!gl)
3051                 return;
3052         gl->getnCompressedTexImage(target, lod, bufSize, pixels);
3053 }
3054
3055 void glwGetnTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
3056 {
3057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3058         if (!gl)
3059                 return;
3060         gl->getnTexImage(target, level, format, type, bufSize, pixels);
3061 }
3062
3063 void glwGetnUniformdv (GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
3064 {
3065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3066         if (!gl)
3067                 return;
3068         gl->getnUniformdv(program, location, bufSize, params);
3069 }
3070
3071 void glwGetnUniformfv (GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
3072 {
3073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3074         if (!gl)
3075                 return;
3076         gl->getnUniformfv(program, location, bufSize, params);
3077 }
3078
3079 void glwGetnUniformiv (GLuint program, GLint location, GLsizei bufSize, GLint *params)
3080 {
3081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3082         if (!gl)
3083                 return;
3084         gl->getnUniformiv(program, location, bufSize, params);
3085 }
3086
3087 void glwGetnUniformuiv (GLuint program, GLint location, GLsizei bufSize, GLuint *params)
3088 {
3089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3090         if (!gl)
3091                 return;
3092         gl->getnUniformuiv(program, location, bufSize, params);
3093 }
3094
3095 void glwHint (GLenum target, GLenum mode)
3096 {
3097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3098         if (!gl)
3099                 return;
3100         gl->hint(target, mode);
3101 }
3102
3103 void glwInsertEventMarkerEXT (GLsizei length, const GLchar *marker)
3104 {
3105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3106         if (!gl)
3107                 return;
3108         gl->insertEventMarkerEXT(length, marker);
3109 }
3110
3111 void glwInvalidateBufferData (GLuint buffer)
3112 {
3113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3114         if (!gl)
3115                 return;
3116         gl->invalidateBufferData(buffer);
3117 }
3118
3119 void glwInvalidateBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr length)
3120 {
3121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3122         if (!gl)
3123                 return;
3124         gl->invalidateBufferSubData(buffer, offset, length);
3125 }
3126
3127 void glwInvalidateFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments)
3128 {
3129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3130         if (!gl)
3131                 return;
3132         gl->invalidateFramebuffer(target, numAttachments, attachments);
3133 }
3134
3135 void glwInvalidateNamedFramebufferData (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)
3136 {
3137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3138         if (!gl)
3139                 return;
3140         gl->invalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
3141 }
3142
3143 void glwInvalidateNamedFramebufferSubData (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
3144 {
3145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3146         if (!gl)
3147                 return;
3148         gl->invalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
3149 }
3150
3151 void glwInvalidateSubFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
3152 {
3153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3154         if (!gl)
3155                 return;
3156         gl->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
3157 }
3158
3159 void glwInvalidateTexImage (GLuint texture, GLint level)
3160 {
3161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3162         if (!gl)
3163                 return;
3164         gl->invalidateTexImage(texture, level);
3165 }
3166
3167 void glwInvalidateTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
3168 {
3169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3170         if (!gl)
3171                 return;
3172         gl->invalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
3173 }
3174
3175 GLboolean glwIsBuffer (GLuint buffer)
3176 {
3177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3178         if (!gl)
3179                 return (GLboolean)0;
3180         return gl->isBuffer(buffer);
3181 }
3182
3183 GLboolean glwIsEnabled (GLenum cap)
3184 {
3185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3186         if (!gl)
3187                 return (GLboolean)0;
3188         return gl->isEnabled(cap);
3189 }
3190
3191 GLboolean glwIsEnabledIndexedEXT (GLenum target, GLuint index)
3192 {
3193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3194         if (!gl)
3195                 return (GLboolean)0;
3196         return gl->isEnabledIndexedEXT(target, index);
3197 }
3198
3199 GLboolean glwIsEnabledi (GLenum target, GLuint index)
3200 {
3201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3202         if (!gl)
3203                 return (GLboolean)0;
3204         return gl->isEnabledi(target, index);
3205 }
3206
3207 GLboolean glwIsFramebuffer (GLuint framebuffer)
3208 {
3209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3210         if (!gl)
3211                 return (GLboolean)0;
3212         return gl->isFramebuffer(framebuffer);
3213 }
3214
3215 GLboolean glwIsProgram (GLuint program)
3216 {
3217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3218         if (!gl)
3219                 return (GLboolean)0;
3220         return gl->isProgram(program);
3221 }
3222
3223 GLboolean glwIsProgramPipeline (GLuint pipeline)
3224 {
3225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3226         if (!gl)
3227                 return (GLboolean)0;
3228         return gl->isProgramPipeline(pipeline);
3229 }
3230
3231 GLboolean glwIsQuery (GLuint id)
3232 {
3233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3234         if (!gl)
3235                 return (GLboolean)0;
3236         return gl->isQuery(id);
3237 }
3238
3239 GLboolean glwIsRenderbuffer (GLuint renderbuffer)
3240 {
3241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3242         if (!gl)
3243                 return (GLboolean)0;
3244         return gl->isRenderbuffer(renderbuffer);
3245 }
3246
3247 GLboolean glwIsSampler (GLuint sampler)
3248 {
3249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3250         if (!gl)
3251                 return (GLboolean)0;
3252         return gl->isSampler(sampler);
3253 }
3254
3255 GLboolean glwIsShader (GLuint shader)
3256 {
3257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3258         if (!gl)
3259                 return (GLboolean)0;
3260         return gl->isShader(shader);
3261 }
3262
3263 GLboolean glwIsSync (GLsync sync)
3264 {
3265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3266         if (!gl)
3267                 return (GLboolean)0;
3268         return gl->isSync(sync);
3269 }
3270
3271 GLboolean glwIsTexture (GLuint texture)
3272 {
3273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3274         if (!gl)
3275                 return (GLboolean)0;
3276         return gl->isTexture(texture);
3277 }
3278
3279 GLboolean glwIsTransformFeedback (GLuint id)
3280 {
3281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3282         if (!gl)
3283                 return (GLboolean)0;
3284         return gl->isTransformFeedback(id);
3285 }
3286
3287 GLboolean glwIsVertexArray (GLuint array)
3288 {
3289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3290         if (!gl)
3291                 return (GLboolean)0;
3292         return gl->isVertexArray(array);
3293 }
3294
3295 void glwLineWidth (GLfloat width)
3296 {
3297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3298         if (!gl)
3299                 return;
3300         gl->lineWidth(width);
3301 }
3302
3303 void glwLinkProgram (GLuint program)
3304 {
3305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3306         if (!gl)
3307                 return;
3308         gl->linkProgram(program);
3309 }
3310
3311 void glwLogicOp (GLenum opcode)
3312 {
3313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3314         if (!gl)
3315                 return;
3316         gl->logicOp(opcode);
3317 }
3318
3319 void * glwMapBuffer (GLenum target, GLenum access)
3320 {
3321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3322         if (!gl)
3323                 return (void *)0;
3324         return gl->mapBuffer(target, access);
3325 }
3326
3327 void * glwMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
3328 {
3329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3330         if (!gl)
3331                 return (void *)0;
3332         return gl->mapBufferRange(target, offset, length, access);
3333 }
3334
3335 void * glwMapNamedBuffer (GLuint buffer, GLenum access)
3336 {
3337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3338         if (!gl)
3339                 return (void *)0;
3340         return gl->mapNamedBuffer(buffer, access);
3341 }
3342
3343 void * glwMapNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access)
3344 {
3345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3346         if (!gl)
3347                 return (void *)0;
3348         return gl->mapNamedBufferRange(buffer, offset, length, access);
3349 }
3350
3351 void glwMatrixFrustumEXT (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3352 {
3353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3354         if (!gl)
3355                 return;
3356         gl->matrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar);
3357 }
3358
3359 void glwMatrixLoadIdentityEXT (GLenum mode)
3360 {
3361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3362         if (!gl)
3363                 return;
3364         gl->matrixLoadIdentityEXT(mode);
3365 }
3366
3367 void glwMatrixLoadTransposedEXT (GLenum mode, const GLdouble *m)
3368 {
3369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3370         if (!gl)
3371                 return;
3372         gl->matrixLoadTransposedEXT(mode, m);
3373 }
3374
3375 void glwMatrixLoadTransposefEXT (GLenum mode, const GLfloat *m)
3376 {
3377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3378         if (!gl)
3379                 return;
3380         gl->matrixLoadTransposefEXT(mode, m);
3381 }
3382
3383 void glwMatrixLoaddEXT (GLenum mode, const GLdouble *m)
3384 {
3385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3386         if (!gl)
3387                 return;
3388         gl->matrixLoaddEXT(mode, m);
3389 }
3390
3391 void glwMatrixLoadfEXT (GLenum mode, const GLfloat *m)
3392 {
3393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3394         if (!gl)
3395                 return;
3396         gl->matrixLoadfEXT(mode, m);
3397 }
3398
3399 void glwMatrixMultTransposedEXT (GLenum mode, const GLdouble *m)
3400 {
3401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3402         if (!gl)
3403                 return;
3404         gl->matrixMultTransposedEXT(mode, m);
3405 }
3406
3407 void glwMatrixMultTransposefEXT (GLenum mode, const GLfloat *m)
3408 {
3409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3410         if (!gl)
3411                 return;
3412         gl->matrixMultTransposefEXT(mode, m);
3413 }
3414
3415 void glwMatrixMultdEXT (GLenum mode, const GLdouble *m)
3416 {
3417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3418         if (!gl)
3419                 return;
3420         gl->matrixMultdEXT(mode, m);
3421 }
3422
3423 void glwMatrixMultfEXT (GLenum mode, const GLfloat *m)
3424 {
3425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3426         if (!gl)
3427                 return;
3428         gl->matrixMultfEXT(mode, m);
3429 }
3430
3431 void glwMatrixOrthoEXT (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3432 {
3433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3434         if (!gl)
3435                 return;
3436         gl->matrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar);
3437 }
3438
3439 void glwMatrixPopEXT (GLenum mode)
3440 {
3441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3442         if (!gl)
3443                 return;
3444         gl->matrixPopEXT(mode);
3445 }
3446
3447 void glwMatrixPushEXT (GLenum mode)
3448 {
3449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3450         if (!gl)
3451                 return;
3452         gl->matrixPushEXT(mode);
3453 }
3454
3455 void glwMatrixRotatedEXT (GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
3456 {
3457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3458         if (!gl)
3459                 return;
3460         gl->matrixRotatedEXT(mode, angle, x, y, z);
3461 }
3462
3463 void glwMatrixRotatefEXT (GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
3464 {
3465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3466         if (!gl)
3467                 return;
3468         gl->matrixRotatefEXT(mode, angle, x, y, z);
3469 }
3470
3471 void glwMatrixScaledEXT (GLenum mode, GLdouble x, GLdouble y, GLdouble z)
3472 {
3473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3474         if (!gl)
3475                 return;
3476         gl->matrixScaledEXT(mode, x, y, z);
3477 }
3478
3479 void glwMatrixScalefEXT (GLenum mode, GLfloat x, GLfloat y, GLfloat z)
3480 {
3481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3482         if (!gl)
3483                 return;
3484         gl->matrixScalefEXT(mode, x, y, z);
3485 }
3486
3487 void glwMatrixTranslatedEXT (GLenum mode, GLdouble x, GLdouble y, GLdouble z)
3488 {
3489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3490         if (!gl)
3491                 return;
3492         gl->matrixTranslatedEXT(mode, x, y, z);
3493 }
3494
3495 void glwMatrixTranslatefEXT (GLenum mode, GLfloat x, GLfloat y, GLfloat z)
3496 {
3497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3498         if (!gl)
3499                 return;
3500         gl->matrixTranslatefEXT(mode, x, y, z);
3501 }
3502
3503 void glwMaxShaderCompilerThreadsARB (GLuint count)
3504 {
3505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3506         if (!gl)
3507                 return;
3508         gl->maxShaderCompilerThreadsARB(count);
3509 }
3510
3511 void glwMemoryBarrier (GLbitfield barriers)
3512 {
3513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3514         if (!gl)
3515                 return;
3516         gl->memoryBarrier(barriers);
3517 }
3518
3519 void glwMemoryBarrierByRegion (GLbitfield barriers)
3520 {
3521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3522         if (!gl)
3523                 return;
3524         gl->memoryBarrierByRegion(barriers);
3525 }
3526
3527 void glwMinSampleShading (GLfloat value)
3528 {
3529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3530         if (!gl)
3531                 return;
3532         gl->minSampleShading(value);
3533 }
3534
3535 void glwMultiDrawArrays (GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
3536 {
3537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3538         if (!gl)
3539                 return;
3540         gl->multiDrawArrays(mode, first, count, drawcount);
3541 }
3542
3543 void glwMultiDrawArraysIndirect (GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
3544 {
3545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3546         if (!gl)
3547                 return;
3548         gl->multiDrawArraysIndirect(mode, indirect, drawcount, stride);
3549 }
3550
3551 void glwMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount)
3552 {
3553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3554         if (!gl)
3555                 return;
3556         gl->multiDrawElements(mode, count, type, indices, drawcount);
3557 }
3558
3559 void glwMultiDrawElementsBaseVertex (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex)
3560 {
3561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3562         if (!gl)
3563                 return;
3564         gl->multiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
3565 }
3566
3567 void glwMultiDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
3568 {
3569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3570         if (!gl)
3571                 return;
3572         gl->multiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
3573 }
3574
3575 void glwMultiTexBufferEXT (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer)
3576 {
3577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3578         if (!gl)
3579                 return;
3580         gl->multiTexBufferEXT(texunit, target, internalformat, buffer);
3581 }
3582
3583 void glwMultiTexCoordPointerEXT (GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer)
3584 {
3585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3586         if (!gl)
3587                 return;
3588         gl->multiTexCoordPointerEXT(texunit, size, type, stride, pointer);
3589 }
3590
3591 void glwMultiTexEnvfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param)
3592 {
3593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3594         if (!gl)
3595                 return;
3596         gl->multiTexEnvfEXT(texunit, target, pname, param);
3597 }
3598
3599 void glwMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params)
3600 {
3601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3602         if (!gl)
3603                 return;
3604         gl->multiTexEnvfvEXT(texunit, target, pname, params);
3605 }
3606
3607 void glwMultiTexEnviEXT (GLenum texunit, GLenum target, GLenum pname, GLint param)
3608 {
3609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3610         if (!gl)
3611                 return;
3612         gl->multiTexEnviEXT(texunit, target, pname, param);
3613 }
3614
3615 void glwMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params)
3616 {
3617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3618         if (!gl)
3619                 return;
3620         gl->multiTexEnvivEXT(texunit, target, pname, params);
3621 }
3622
3623 void glwMultiTexGendEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble param)
3624 {
3625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3626         if (!gl)
3627                 return;
3628         gl->multiTexGendEXT(texunit, coord, pname, param);
3629 }
3630
3631 void glwMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params)
3632 {
3633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3634         if (!gl)
3635                 return;
3636         gl->multiTexGendvEXT(texunit, coord, pname, params);
3637 }
3638
3639 void glwMultiTexGenfEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat param)
3640 {
3641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3642         if (!gl)
3643                 return;
3644         gl->multiTexGenfEXT(texunit, coord, pname, param);
3645 }
3646
3647 void glwMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params)
3648 {
3649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3650         if (!gl)
3651                 return;
3652         gl->multiTexGenfvEXT(texunit, coord, pname, params);
3653 }
3654
3655 void glwMultiTexGeniEXT (GLenum texunit, GLenum coord, GLenum pname, GLint param)
3656 {
3657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3658         if (!gl)
3659                 return;
3660         gl->multiTexGeniEXT(texunit, coord, pname, param);
3661 }
3662
3663 void glwMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, const GLint *params)
3664 {
3665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3666         if (!gl)
3667                 return;
3668         gl->multiTexGenivEXT(texunit, coord, pname, params);
3669 }
3670
3671 void glwMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
3672 {
3673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3674         if (!gl)
3675                 return;
3676         gl->multiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels);
3677 }
3678
3679 void glwMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
3680 {
3681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3682         if (!gl)
3683                 return;
3684         gl->multiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels);
3685 }
3686
3687 void glwMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
3688 {
3689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3690         if (!gl)
3691                 return;
3692         gl->multiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels);
3693 }
3694
3695 void glwMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params)
3696 {
3697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3698         if (!gl)
3699                 return;
3700         gl->multiTexParameterIivEXT(texunit, target, pname, params);
3701 }
3702
3703 void glwMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, const GLuint *params)
3704 {
3705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3706         if (!gl)
3707                 return;
3708         gl->multiTexParameterIuivEXT(texunit, target, pname, params);
3709 }
3710
3711 void glwMultiTexParameterfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param)
3712 {
3713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3714         if (!gl)
3715                 return;
3716         gl->multiTexParameterfEXT(texunit, target, pname, param);
3717 }
3718
3719 void glwMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params)
3720 {
3721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3722         if (!gl)
3723                 return;
3724         gl->multiTexParameterfvEXT(texunit, target, pname, params);
3725 }
3726
3727 void glwMultiTexParameteriEXT (GLenum texunit, GLenum target, GLenum pname, GLint param)
3728 {
3729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3730         if (!gl)
3731                 return;
3732         gl->multiTexParameteriEXT(texunit, target, pname, param);
3733 }
3734
3735 void glwMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params)
3736 {
3737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3738         if (!gl)
3739                 return;
3740         gl->multiTexParameterivEXT(texunit, target, pname, params);
3741 }
3742
3743 void glwMultiTexRenderbufferEXT (GLenum texunit, GLenum target, GLuint renderbuffer)
3744 {
3745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3746         if (!gl)
3747                 return;
3748         gl->multiTexRenderbufferEXT(texunit, target, renderbuffer);
3749 }
3750
3751 void glwMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
3752 {
3753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3754         if (!gl)
3755                 return;
3756         gl->multiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels);
3757 }
3758
3759 void glwMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
3760 {
3761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3762         if (!gl)
3763                 return;
3764         gl->multiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels);
3765 }
3766
3767 void glwMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
3768 {
3769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3770         if (!gl)
3771                 return;
3772         gl->multiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3773 }
3774
3775 void glwNamedBufferData (GLuint buffer, GLsizeiptr size, const void *data, GLenum usage)
3776 {
3777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3778         if (!gl)
3779                 return;
3780         gl->namedBufferData(buffer, size, data, usage);
3781 }
3782
3783 void glwNamedBufferPageCommitmentARB (GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit)
3784 {
3785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3786         if (!gl)
3787                 return;
3788         gl->namedBufferPageCommitmentARB(buffer, offset, size, commit);
3789 }
3790
3791 void glwNamedBufferPageCommitmentEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit)
3792 {
3793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3794         if (!gl)
3795                 return;
3796         gl->namedBufferPageCommitmentEXT(buffer, offset, size, commit);
3797 }
3798
3799 void glwNamedBufferStorage (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)
3800 {
3801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3802         if (!gl)
3803                 return;
3804         gl->namedBufferStorage(buffer, size, data, flags);
3805 }
3806
3807 void glwNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
3808 {
3809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3810         if (!gl)
3811                 return;
3812         gl->namedBufferSubData(buffer, offset, size, data);
3813 }
3814
3815 void glwNamedCopyBufferSubDataEXT (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
3816 {
3817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3818         if (!gl)
3819                 return;
3820         gl->namedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size);
3821 }
3822
3823 void glwNamedFramebufferDrawBuffer (GLuint framebuffer, GLenum buf)
3824 {
3825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3826         if (!gl)
3827                 return;
3828         gl->namedFramebufferDrawBuffer(framebuffer, buf);
3829 }
3830
3831 void glwNamedFramebufferDrawBuffers (GLuint framebuffer, GLsizei n, const GLenum *bufs)
3832 {
3833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3834         if (!gl)
3835                 return;
3836         gl->namedFramebufferDrawBuffers(framebuffer, n, bufs);
3837 }
3838
3839 void glwNamedFramebufferParameteri (GLuint framebuffer, GLenum pname, GLint param)
3840 {
3841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3842         if (!gl)
3843                 return;
3844         gl->namedFramebufferParameteri(framebuffer, pname, param);
3845 }
3846
3847 void glwNamedFramebufferReadBuffer (GLuint framebuffer, GLenum src)
3848 {
3849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3850         if (!gl)
3851                 return;
3852         gl->namedFramebufferReadBuffer(framebuffer, src);
3853 }
3854
3855 void glwNamedFramebufferRenderbuffer (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
3856 {
3857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3858         if (!gl)
3859                 return;
3860         gl->namedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
3861 }
3862
3863 void glwNamedFramebufferTexture (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
3864 {
3865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3866         if (!gl)
3867                 return;
3868         gl->namedFramebufferTexture(framebuffer, attachment, texture, level);
3869 }
3870
3871 void glwNamedFramebufferTexture1DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
3872 {
3873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3874         if (!gl)
3875                 return;
3876         gl->namedFramebufferTexture1DEXT(framebuffer, attachment, textarget, texture, level);
3877 }
3878
3879 void glwNamedFramebufferTexture2DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
3880 {
3881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3882         if (!gl)
3883                 return;
3884         gl->namedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level);
3885 }
3886
3887 void glwNamedFramebufferTexture3DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
3888 {
3889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3890         if (!gl)
3891                 return;
3892         gl->namedFramebufferTexture3DEXT(framebuffer, attachment, textarget, texture, level, zoffset);
3893 }
3894
3895 void glwNamedFramebufferTextureFaceEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face)
3896 {
3897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3898         if (!gl)
3899                 return;
3900         gl->namedFramebufferTextureFaceEXT(framebuffer, attachment, texture, level, face);
3901 }
3902
3903 void glwNamedFramebufferTextureLayer (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
3904 {
3905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3906         if (!gl)
3907                 return;
3908         gl->namedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
3909 }
3910
3911 void glwNamedProgramLocalParameter4dEXT (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
3912 {
3913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3914         if (!gl)
3915                 return;
3916         gl->namedProgramLocalParameter4dEXT(program, target, index, x, y, z, w);
3917 }
3918
3919 void glwNamedProgramLocalParameter4dvEXT (GLuint program, GLenum target, GLuint index, const GLdouble *params)
3920 {
3921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3922         if (!gl)
3923                 return;
3924         gl->namedProgramLocalParameter4dvEXT(program, target, index, params);
3925 }
3926
3927 void glwNamedProgramLocalParameter4fEXT (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3928 {
3929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3930         if (!gl)
3931                 return;
3932         gl->namedProgramLocalParameter4fEXT(program, target, index, x, y, z, w);
3933 }
3934
3935 void glwNamedProgramLocalParameter4fvEXT (GLuint program, GLenum target, GLuint index, const GLfloat *params)
3936 {
3937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3938         if (!gl)
3939                 return;
3940         gl->namedProgramLocalParameter4fvEXT(program, target, index, params);
3941 }
3942
3943 void glwNamedProgramLocalParameterI4iEXT (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
3944 {
3945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3946         if (!gl)
3947                 return;
3948         gl->namedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w);
3949 }
3950
3951 void glwNamedProgramLocalParameterI4ivEXT (GLuint program, GLenum target, GLuint index, const GLint *params)
3952 {
3953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3954         if (!gl)
3955                 return;
3956         gl->namedProgramLocalParameterI4ivEXT(program, target, index, params);
3957 }
3958
3959 void glwNamedProgramLocalParameterI4uiEXT (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
3960 {
3961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3962         if (!gl)
3963                 return;
3964         gl->namedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w);
3965 }
3966
3967 void glwNamedProgramLocalParameterI4uivEXT (GLuint program, GLenum target, GLuint index, const GLuint *params)
3968 {
3969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3970         if (!gl)
3971                 return;
3972         gl->namedProgramLocalParameterI4uivEXT(program, target, index, params);
3973 }
3974
3975 void glwNamedProgramLocalParameters4fvEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params)
3976 {
3977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3978         if (!gl)
3979                 return;
3980         gl->namedProgramLocalParameters4fvEXT(program, target, index, count, params);
3981 }
3982
3983 void glwNamedProgramLocalParametersI4ivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params)
3984 {
3985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3986         if (!gl)
3987                 return;
3988         gl->namedProgramLocalParametersI4ivEXT(program, target, index, count, params);
3989 }
3990
3991 void glwNamedProgramLocalParametersI4uivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params)
3992 {
3993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3994         if (!gl)
3995                 return;
3996         gl->namedProgramLocalParametersI4uivEXT(program, target, index, count, params);
3997 }
3998
3999 void glwNamedProgramStringEXT (GLuint program, GLenum target, GLenum format, GLsizei len, const void *string)
4000 {
4001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4002         if (!gl)
4003                 return;
4004         gl->namedProgramStringEXT(program, target, format, len, string);
4005 }
4006
4007 void glwNamedRenderbufferStorage (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
4008 {
4009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4010         if (!gl)
4011                 return;
4012         gl->namedRenderbufferStorage(renderbuffer, internalformat, width, height);
4013 }
4014
4015 void glwNamedRenderbufferStorageMultisample (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
4016 {
4017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4018         if (!gl)
4019                 return;
4020         gl->namedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
4021 }
4022
4023 void glwNamedRenderbufferStorageMultisampleCoverageEXT (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)
4024 {
4025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4026         if (!gl)
4027                 return;
4028         gl->namedRenderbufferStorageMultisampleCoverageEXT(renderbuffer, coverageSamples, colorSamples, internalformat, width, height);
4029 }
4030
4031 void glwObjectLabel (GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
4032 {
4033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4034         if (!gl)
4035                 return;
4036         gl->objectLabel(identifier, name, length, label);
4037 }
4038
4039 void glwObjectPtrLabel (const void *ptr, GLsizei length, const GLchar *label)
4040 {
4041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4042         if (!gl)
4043                 return;
4044         gl->objectPtrLabel(ptr, length, label);
4045 }
4046
4047 void glwPatchParameterfv (GLenum pname, const GLfloat *values)
4048 {
4049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4050         if (!gl)
4051                 return;
4052         gl->patchParameterfv(pname, values);
4053 }
4054
4055 void glwPatchParameteri (GLenum pname, GLint value)
4056 {
4057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4058         if (!gl)
4059                 return;
4060         gl->patchParameteri(pname, value);
4061 }
4062
4063 void glwPauseTransformFeedback (void)
4064 {
4065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4066         if (!gl)
4067                 return;
4068         gl->pauseTransformFeedback();
4069 }
4070
4071 void glwPixelStoref (GLenum pname, GLfloat param)
4072 {
4073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4074         if (!gl)
4075                 return;
4076         gl->pixelStoref(pname, param);
4077 }
4078
4079 void glwPixelStorei (GLenum pname, GLint param)
4080 {
4081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4082         if (!gl)
4083                 return;
4084         gl->pixelStorei(pname, param);
4085 }
4086
4087 void glwPointParameterf (GLenum pname, GLfloat param)
4088 {
4089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4090         if (!gl)
4091                 return;
4092         gl->pointParameterf(pname, param);
4093 }
4094
4095 void glwPointParameterfv (GLenum pname, const GLfloat *params)
4096 {
4097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4098         if (!gl)
4099                 return;
4100         gl->pointParameterfv(pname, params);
4101 }
4102
4103 void glwPointParameteri (GLenum pname, GLint param)
4104 {
4105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4106         if (!gl)
4107                 return;
4108         gl->pointParameteri(pname, param);
4109 }
4110
4111 void glwPointParameteriv (GLenum pname, const GLint *params)
4112 {
4113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4114         if (!gl)
4115                 return;
4116         gl->pointParameteriv(pname, params);
4117 }
4118
4119 void glwPointSize (GLfloat size)
4120 {
4121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4122         if (!gl)
4123                 return;
4124         gl->pointSize(size);
4125 }
4126
4127 void glwPolygonMode (GLenum face, GLenum mode)
4128 {
4129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4130         if (!gl)
4131                 return;
4132         gl->polygonMode(face, mode);
4133 }
4134
4135 void glwPolygonOffset (GLfloat factor, GLfloat units)
4136 {
4137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4138         if (!gl)
4139                 return;
4140         gl->polygonOffset(factor, units);
4141 }
4142
4143 void glwPopDebugGroup (void)
4144 {
4145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4146         if (!gl)
4147                 return;
4148         gl->popDebugGroup();
4149 }
4150
4151 void glwPopGroupMarkerEXT (void)
4152 {
4153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4154         if (!gl)
4155                 return;
4156         gl->popGroupMarkerEXT();
4157 }
4158
4159 void glwPrimitiveBoundingBox (GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
4160 {
4161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4162         if (!gl)
4163                 return;
4164         gl->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
4165 }
4166
4167 void glwPrimitiveRestartIndex (GLuint index)
4168 {
4169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4170         if (!gl)
4171                 return;
4172         gl->primitiveRestartIndex(index);
4173 }
4174
4175 void glwProgramBinary (GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
4176 {
4177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4178         if (!gl)
4179                 return;
4180         gl->programBinary(program, binaryFormat, binary, length);
4181 }
4182
4183 void glwProgramParameteri (GLuint program, GLenum pname, GLint value)
4184 {
4185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4186         if (!gl)
4187                 return;
4188         gl->programParameteri(program, pname, value);
4189 }
4190
4191 void glwProgramUniform1d (GLuint program, GLint location, GLdouble v0)
4192 {
4193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4194         if (!gl)
4195                 return;
4196         gl->programUniform1d(program, location, v0);
4197 }
4198
4199 void glwProgramUniform1dv (GLuint program, GLint location, GLsizei count, const GLdouble *value)
4200 {
4201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4202         if (!gl)
4203                 return;
4204         gl->programUniform1dv(program, location, count, value);
4205 }
4206
4207 void glwProgramUniform1f (GLuint program, GLint location, GLfloat v0)
4208 {
4209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4210         if (!gl)
4211                 return;
4212         gl->programUniform1f(program, location, v0);
4213 }
4214
4215 void glwProgramUniform1fv (GLuint program, GLint location, GLsizei count, const GLfloat *value)
4216 {
4217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4218         if (!gl)
4219                 return;
4220         gl->programUniform1fv(program, location, count, value);
4221 }
4222
4223 void glwProgramUniform1i (GLuint program, GLint location, GLint v0)
4224 {
4225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4226         if (!gl)
4227                 return;
4228         gl->programUniform1i(program, location, v0);
4229 }
4230
4231 void glwProgramUniform1iv (GLuint program, GLint location, GLsizei count, const GLint *value)
4232 {
4233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4234         if (!gl)
4235                 return;
4236         gl->programUniform1iv(program, location, count, value);
4237 }
4238
4239 void glwProgramUniform1ui (GLuint program, GLint location, GLuint v0)
4240 {
4241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4242         if (!gl)
4243                 return;
4244         gl->programUniform1ui(program, location, v0);
4245 }
4246
4247 void glwProgramUniform1uiv (GLuint program, GLint location, GLsizei count, const GLuint *value)
4248 {
4249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4250         if (!gl)
4251                 return;
4252         gl->programUniform1uiv(program, location, count, value);
4253 }
4254
4255 void glwProgramUniform2d (GLuint program, GLint location, GLdouble v0, GLdouble v1)
4256 {
4257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4258         if (!gl)
4259                 return;
4260         gl->programUniform2d(program, location, v0, v1);
4261 }
4262
4263 void glwProgramUniform2dv (GLuint program, GLint location, GLsizei count, const GLdouble *value)
4264 {
4265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4266         if (!gl)
4267                 return;
4268         gl->programUniform2dv(program, location, count, value);
4269 }
4270
4271 void glwProgramUniform2f (GLuint program, GLint location, GLfloat v0, GLfloat v1)
4272 {
4273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4274         if (!gl)
4275                 return;
4276         gl->programUniform2f(program, location, v0, v1);
4277 }
4278
4279 void glwProgramUniform2fv (GLuint program, GLint location, GLsizei count, const GLfloat *value)
4280 {
4281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4282         if (!gl)
4283                 return;
4284         gl->programUniform2fv(program, location, count, value);
4285 }
4286
4287 void glwProgramUniform2i (GLuint program, GLint location, GLint v0, GLint v1)
4288 {
4289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4290         if (!gl)
4291                 return;
4292         gl->programUniform2i(program, location, v0, v1);
4293 }
4294
4295 void glwProgramUniform2iv (GLuint program, GLint location, GLsizei count, const GLint *value)
4296 {
4297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4298         if (!gl)
4299                 return;
4300         gl->programUniform2iv(program, location, count, value);
4301 }
4302
4303 void glwProgramUniform2ui (GLuint program, GLint location, GLuint v0, GLuint v1)
4304 {
4305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4306         if (!gl)
4307                 return;
4308         gl->programUniform2ui(program, location, v0, v1);
4309 }
4310
4311 void glwProgramUniform2uiv (GLuint program, GLint location, GLsizei count, const GLuint *value)
4312 {
4313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4314         if (!gl)
4315                 return;
4316         gl->programUniform2uiv(program, location, count, value);
4317 }
4318
4319 void glwProgramUniform3d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
4320 {
4321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4322         if (!gl)
4323                 return;
4324         gl->programUniform3d(program, location, v0, v1, v2);
4325 }
4326
4327 void glwProgramUniform3dv (GLuint program, GLint location, GLsizei count, const GLdouble *value)
4328 {
4329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4330         if (!gl)
4331                 return;
4332         gl->programUniform3dv(program, location, count, value);
4333 }
4334
4335 void glwProgramUniform3f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
4336 {
4337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4338         if (!gl)
4339                 return;
4340         gl->programUniform3f(program, location, v0, v1, v2);
4341 }
4342
4343 void glwProgramUniform3fv (GLuint program, GLint location, GLsizei count, const GLfloat *value)
4344 {
4345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4346         if (!gl)
4347                 return;
4348         gl->programUniform3fv(program, location, count, value);
4349 }
4350
4351 void glwProgramUniform3i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
4352 {
4353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4354         if (!gl)
4355                 return;
4356         gl->programUniform3i(program, location, v0, v1, v2);
4357 }
4358
4359 void glwProgramUniform3iv (GLuint program, GLint location, GLsizei count, const GLint *value)
4360 {
4361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4362         if (!gl)
4363                 return;
4364         gl->programUniform3iv(program, location, count, value);
4365 }
4366
4367 void glwProgramUniform3ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
4368 {
4369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4370         if (!gl)
4371                 return;
4372         gl->programUniform3ui(program, location, v0, v1, v2);
4373 }
4374
4375 void glwProgramUniform3uiv (GLuint program, GLint location, GLsizei count, const GLuint *value)
4376 {
4377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4378         if (!gl)
4379                 return;
4380         gl->programUniform3uiv(program, location, count, value);
4381 }
4382
4383 void glwProgramUniform4d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
4384 {
4385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4386         if (!gl)
4387                 return;
4388         gl->programUniform4d(program, location, v0, v1, v2, v3);
4389 }
4390
4391 void glwProgramUniform4dv (GLuint program, GLint location, GLsizei count, const GLdouble *value)
4392 {
4393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4394         if (!gl)
4395                 return;
4396         gl->programUniform4dv(program, location, count, value);
4397 }
4398
4399 void glwProgramUniform4f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
4400 {
4401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4402         if (!gl)
4403                 return;
4404         gl->programUniform4f(program, location, v0, v1, v2, v3);
4405 }
4406
4407 void glwProgramUniform4fv (GLuint program, GLint location, GLsizei count, const GLfloat *value)
4408 {
4409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4410         if (!gl)
4411                 return;
4412         gl->programUniform4fv(program, location, count, value);
4413 }
4414
4415 void glwProgramUniform4i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
4416 {
4417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4418         if (!gl)
4419                 return;
4420         gl->programUniform4i(program, location, v0, v1, v2, v3);
4421 }
4422
4423 void glwProgramUniform4iv (GLuint program, GLint location, GLsizei count, const GLint *value)
4424 {
4425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4426         if (!gl)
4427                 return;
4428         gl->programUniform4iv(program, location, count, value);
4429 }
4430
4431 void glwProgramUniform4ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
4432 {
4433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4434         if (!gl)
4435                 return;
4436         gl->programUniform4ui(program, location, v0, v1, v2, v3);
4437 }
4438
4439 void glwProgramUniform4uiv (GLuint program, GLint location, GLsizei count, const GLuint *value)
4440 {
4441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4442         if (!gl)
4443                 return;
4444         gl->programUniform4uiv(program, location, count, value);
4445 }
4446
4447 void glwProgramUniformMatrix2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4448 {
4449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4450         if (!gl)
4451                 return;
4452         gl->programUniformMatrix2dv(program, location, count, transpose, value);
4453 }
4454
4455 void glwProgramUniformMatrix2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4456 {
4457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4458         if (!gl)
4459                 return;
4460         gl->programUniformMatrix2fv(program, location, count, transpose, value);
4461 }
4462
4463 void glwProgramUniformMatrix2x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4464 {
4465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4466         if (!gl)
4467                 return;
4468         gl->programUniformMatrix2x3dv(program, location, count, transpose, value);
4469 }
4470
4471 void glwProgramUniformMatrix2x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4472 {
4473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4474         if (!gl)
4475                 return;
4476         gl->programUniformMatrix2x3fv(program, location, count, transpose, value);
4477 }
4478
4479 void glwProgramUniformMatrix2x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4480 {
4481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4482         if (!gl)
4483                 return;
4484         gl->programUniformMatrix2x4dv(program, location, count, transpose, value);
4485 }
4486
4487 void glwProgramUniformMatrix2x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4488 {
4489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4490         if (!gl)
4491                 return;
4492         gl->programUniformMatrix2x4fv(program, location, count, transpose, value);
4493 }
4494
4495 void glwProgramUniformMatrix3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4496 {
4497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4498         if (!gl)
4499                 return;
4500         gl->programUniformMatrix3dv(program, location, count, transpose, value);
4501 }
4502
4503 void glwProgramUniformMatrix3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4504 {
4505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4506         if (!gl)
4507                 return;
4508         gl->programUniformMatrix3fv(program, location, count, transpose, value);
4509 }
4510
4511 void glwProgramUniformMatrix3x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4512 {
4513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4514         if (!gl)
4515                 return;
4516         gl->programUniformMatrix3x2dv(program, location, count, transpose, value);
4517 }
4518
4519 void glwProgramUniformMatrix3x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4520 {
4521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4522         if (!gl)
4523                 return;
4524         gl->programUniformMatrix3x2fv(program, location, count, transpose, value);
4525 }
4526
4527 void glwProgramUniformMatrix3x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4528 {
4529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4530         if (!gl)
4531                 return;
4532         gl->programUniformMatrix3x4dv(program, location, count, transpose, value);
4533 }
4534
4535 void glwProgramUniformMatrix3x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4536 {
4537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4538         if (!gl)
4539                 return;
4540         gl->programUniformMatrix3x4fv(program, location, count, transpose, value);
4541 }
4542
4543 void glwProgramUniformMatrix4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4544 {
4545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4546         if (!gl)
4547                 return;
4548         gl->programUniformMatrix4dv(program, location, count, transpose, value);
4549 }
4550
4551 void glwProgramUniformMatrix4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4552 {
4553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4554         if (!gl)
4555                 return;
4556         gl->programUniformMatrix4fv(program, location, count, transpose, value);
4557 }
4558
4559 void glwProgramUniformMatrix4x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4560 {
4561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4562         if (!gl)
4563                 return;
4564         gl->programUniformMatrix4x2dv(program, location, count, transpose, value);
4565 }
4566
4567 void glwProgramUniformMatrix4x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4568 {
4569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4570         if (!gl)
4571                 return;
4572         gl->programUniformMatrix4x2fv(program, location, count, transpose, value);
4573 }
4574
4575 void glwProgramUniformMatrix4x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4576 {
4577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4578         if (!gl)
4579                 return;
4580         gl->programUniformMatrix4x3dv(program, location, count, transpose, value);
4581 }
4582
4583 void glwProgramUniformMatrix4x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4584 {
4585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4586         if (!gl)
4587                 return;
4588         gl->programUniformMatrix4x3fv(program, location, count, transpose, value);
4589 }
4590
4591 void glwProvokingVertex (GLenum mode)
4592 {
4593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4594         if (!gl)
4595                 return;
4596         gl->provokingVertex(mode);
4597 }
4598
4599 void glwPushClientAttribDefaultEXT (GLbitfield mask)
4600 {
4601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4602         if (!gl)
4603                 return;
4604         gl->pushClientAttribDefaultEXT(mask);
4605 }
4606
4607 void glwPushDebugGroup (GLenum source, GLuint id, GLsizei length, const GLchar *message)
4608 {
4609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4610         if (!gl)
4611                 return;
4612         gl->pushDebugGroup(source, id, length, message);
4613 }
4614
4615 void glwPushGroupMarkerEXT (GLsizei length, const GLchar *marker)
4616 {
4617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4618         if (!gl)
4619                 return;
4620         gl->pushGroupMarkerEXT(length, marker);
4621 }
4622
4623 void glwQueryCounter (GLuint id, GLenum target)
4624 {
4625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4626         if (!gl)
4627                 return;
4628         gl->queryCounter(id, target);
4629 }
4630
4631 void glwReadBuffer (GLenum src)
4632 {
4633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4634         if (!gl)
4635                 return;
4636         gl->readBuffer(src);
4637 }
4638
4639 void glwReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
4640 {
4641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4642         if (!gl)
4643                 return;
4644         gl->readPixels(x, y, width, height, format, type, pixels);
4645 }
4646
4647 void glwReadnPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
4648 {
4649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4650         if (!gl)
4651                 return;
4652         gl->readnPixels(x, y, width, height, format, type, bufSize, data);
4653 }
4654
4655 void glwReleaseShaderCompiler (void)
4656 {
4657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4658         if (!gl)
4659                 return;
4660         gl->releaseShaderCompiler();
4661 }
4662
4663 void glwRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
4664 {
4665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4666         if (!gl)
4667                 return;
4668         gl->renderbufferStorage(target, internalformat, width, height);
4669 }
4670
4671 void glwRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
4672 {
4673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4674         if (!gl)
4675                 return;
4676         gl->renderbufferStorageMultisample(target, samples, internalformat, width, height);
4677 }
4678
4679 void glwResumeTransformFeedback (void)
4680 {
4681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4682         if (!gl)
4683                 return;
4684         gl->resumeTransformFeedback();
4685 }
4686
4687 void glwSampleCoverage (GLfloat value, GLboolean invert)
4688 {
4689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4690         if (!gl)
4691                 return;
4692         gl->sampleCoverage(value, invert);
4693 }
4694
4695 void glwSampleMaski (GLuint maskNumber, GLbitfield mask)
4696 {
4697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4698         if (!gl)
4699                 return;
4700         gl->sampleMaski(maskNumber, mask);
4701 }
4702
4703 void glwSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint *param)
4704 {
4705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4706         if (!gl)
4707                 return;
4708         gl->samplerParameterIiv(sampler, pname, param);
4709 }
4710
4711 void glwSamplerParameterIuiv (GLuint sampler, GLenum pname, const GLuint *param)
4712 {
4713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4714         if (!gl)
4715                 return;
4716         gl->samplerParameterIuiv(sampler, pname, param);
4717 }
4718
4719 void glwSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param)
4720 {
4721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4722         if (!gl)
4723                 return;
4724         gl->samplerParameterf(sampler, pname, param);
4725 }
4726
4727 void glwSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat *param)
4728 {
4729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4730         if (!gl)
4731                 return;
4732         gl->samplerParameterfv(sampler, pname, param);
4733 }
4734
4735 void glwSamplerParameteri (GLuint sampler, GLenum pname, GLint param)
4736 {
4737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4738         if (!gl)
4739                 return;
4740         gl->samplerParameteri(sampler, pname, param);
4741 }
4742
4743 void glwSamplerParameteriv (GLuint sampler, GLenum pname, const GLint *param)
4744 {
4745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4746         if (!gl)
4747                 return;
4748         gl->samplerParameteriv(sampler, pname, param);
4749 }
4750
4751 void glwScissor (GLint x, GLint y, GLsizei width, GLsizei height)
4752 {
4753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4754         if (!gl)
4755                 return;
4756         gl->scissor(x, y, width, height);
4757 }
4758
4759 void glwScissorArrayv (GLuint first, GLsizei count, const GLint *v)
4760 {
4761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4762         if (!gl)
4763                 return;
4764         gl->scissorArrayv(first, count, v);
4765 }
4766
4767 void glwScissorIndexed (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
4768 {
4769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4770         if (!gl)
4771                 return;
4772         gl->scissorIndexed(index, left, bottom, width, height);
4773 }
4774
4775 void glwScissorIndexedv (GLuint index, const GLint *v)
4776 {
4777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4778         if (!gl)
4779                 return;
4780         gl->scissorIndexedv(index, v);
4781 }
4782
4783 void glwShaderBinary (GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
4784 {
4785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4786         if (!gl)
4787                 return;
4788         gl->shaderBinary(count, shaders, binaryformat, binary, length);
4789 }
4790
4791 void glwShaderSource (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length)
4792 {
4793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4794         if (!gl)
4795                 return;
4796         gl->shaderSource(shader, count, string, length);
4797 }
4798
4799 void glwShaderStorageBlockBinding (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
4800 {
4801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4802         if (!gl)
4803                 return;
4804         gl->shaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
4805 }
4806
4807 void glwStencilFunc (GLenum func, GLint ref, GLuint mask)
4808 {
4809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4810         if (!gl)
4811                 return;
4812         gl->stencilFunc(func, ref, mask);
4813 }
4814
4815 void glwStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
4816 {
4817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4818         if (!gl)
4819                 return;
4820         gl->stencilFuncSeparate(face, func, ref, mask);
4821 }
4822
4823 void glwStencilMask (GLuint mask)
4824 {
4825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4826         if (!gl)
4827                 return;
4828         gl->stencilMask(mask);
4829 }
4830
4831 void glwStencilMaskSeparate (GLenum face, GLuint mask)
4832 {
4833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4834         if (!gl)
4835                 return;
4836         gl->stencilMaskSeparate(face, mask);
4837 }
4838
4839 void glwStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
4840 {
4841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4842         if (!gl)
4843                 return;
4844         gl->stencilOp(fail, zfail, zpass);
4845 }
4846
4847 void glwStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
4848 {
4849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4850         if (!gl)
4851                 return;
4852         gl->stencilOpSeparate(face, sfail, dpfail, dppass);
4853 }
4854
4855 void glwTexBuffer (GLenum target, GLenum internalformat, GLuint buffer)
4856 {
4857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4858         if (!gl)
4859                 return;
4860         gl->texBuffer(target, internalformat, buffer);
4861 }
4862
4863 void glwTexBufferRange (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
4864 {
4865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4866         if (!gl)
4867                 return;
4868         gl->texBufferRange(target, internalformat, buffer, offset, size);
4869 }
4870
4871 void glwTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
4872 {
4873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4874         if (!gl)
4875                 return;
4876         gl->texImage1D(target, level, internalformat, width, border, format, type, pixels);
4877 }
4878
4879 void glwTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
4880 {
4881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4882         if (!gl)
4883                 return;
4884         gl->texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
4885 }
4886
4887 void glwTexImage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
4888 {
4889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4890         if (!gl)
4891                 return;
4892         gl->texImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
4893 }
4894
4895 void glwTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
4896 {
4897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4898         if (!gl)
4899                 return;
4900         gl->texImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
4901 }
4902
4903 void glwTexImage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
4904 {
4905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4906         if (!gl)
4907                 return;
4908         gl->texImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
4909 }
4910
4911 void glwTexImage3DOES (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
4912 {
4913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4914         if (!gl)
4915                 return;
4916         gl->texImage3DOES(target, level, internalformat, width, height, depth, border, format, type, pixels);
4917 }
4918
4919 void glwTexPageCommitmentARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit)
4920 {
4921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4922         if (!gl)
4923                 return;
4924         gl->texPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
4925 }
4926
4927 void glwTexParameterIiv (GLenum target, GLenum pname, const GLint *params)
4928 {
4929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4930         if (!gl)
4931                 return;
4932         gl->texParameterIiv(target, pname, params);
4933 }
4934
4935 void glwTexParameterIuiv (GLenum target, GLenum pname, const GLuint *params)
4936 {
4937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4938         if (!gl)
4939                 return;
4940         gl->texParameterIuiv(target, pname, params);
4941 }
4942
4943 void glwTexParameterf (GLenum target, GLenum pname, GLfloat param)
4944 {
4945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4946         if (!gl)
4947                 return;
4948         gl->texParameterf(target, pname, param);
4949 }
4950
4951 void glwTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)
4952 {
4953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4954         if (!gl)
4955                 return;
4956         gl->texParameterfv(target, pname, params);
4957 }
4958
4959 void glwTexParameteri (GLenum target, GLenum pname, GLint param)
4960 {
4961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4962         if (!gl)
4963                 return;
4964         gl->texParameteri(target, pname, param);
4965 }
4966
4967 void glwTexParameteriv (GLenum target, GLenum pname, const GLint *params)
4968 {
4969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4970         if (!gl)
4971                 return;
4972         gl->texParameteriv(target, pname, params);
4973 }
4974
4975 void glwTexStorage1D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
4976 {
4977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4978         if (!gl)
4979                 return;
4980         gl->texStorage1D(target, levels, internalformat, width);
4981 }
4982
4983 void glwTexStorage1DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
4984 {
4985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4986         if (!gl)
4987                 return;
4988         gl->texStorage1DEXT(target, levels, internalformat, width);
4989 }
4990
4991 void glwTexStorage2D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
4992 {
4993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4994         if (!gl)
4995                 return;
4996         gl->texStorage2D(target, levels, internalformat, width, height);
4997 }
4998
4999 void glwTexStorage2DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
5000 {
5001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5002         if (!gl)
5003                 return;
5004         gl->texStorage2DEXT(target, levels, internalformat, width, height);
5005 }
5006
5007 void glwTexStorage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
5008 {
5009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5010         if (!gl)
5011                 return;
5012         gl->texStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
5013 }
5014
5015 void glwTexStorage3D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
5016 {
5017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5018         if (!gl)
5019                 return;
5020         gl->texStorage3D(target, levels, internalformat, width, height, depth);
5021 }
5022
5023 void glwTexStorage3DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
5024 {
5025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5026         if (!gl)
5027                 return;
5028         gl->texStorage3DEXT(target, levels, internalformat, width, height, depth);
5029 }
5030
5031 void glwTexStorage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
5032 {
5033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5034         if (!gl)
5035                 return;
5036         gl->texStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
5037 }
5038
5039 void glwTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
5040 {
5041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5042         if (!gl)
5043                 return;
5044         gl->texSubImage1D(target, level, xoffset, width, format, type, pixels);
5045 }
5046
5047 void glwTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
5048 {
5049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5050         if (!gl)
5051                 return;
5052         gl->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
5053 }
5054
5055 void glwTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
5056 {
5057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5058         if (!gl)
5059                 return;
5060         gl->texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
5061 }
5062
5063 void glwTexSubImage3DOES (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
5064 {
5065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5066         if (!gl)
5067                 return;
5068         gl->texSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
5069 }
5070
5071 void glwTextureBarrier (void)
5072 {
5073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5074         if (!gl)
5075                 return;
5076         gl->textureBarrier();
5077 }
5078
5079 void glwTextureBuffer (GLuint texture, GLenum internalformat, GLuint buffer)
5080 {
5081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5082         if (!gl)
5083                 return;
5084         gl->textureBuffer(texture, internalformat, buffer);
5085 }
5086
5087 void glwTextureBufferRange (GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
5088 {
5089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5090         if (!gl)
5091                 return;
5092         gl->textureBufferRange(texture, internalformat, buffer, offset, size);
5093 }
5094
5095 void glwTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
5096 {
5097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5098         if (!gl)
5099                 return;
5100         gl->textureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels);
5101 }
5102
5103 void glwTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
5104 {
5105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5106         if (!gl)
5107                 return;
5108         gl->textureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels);
5109 }
5110
5111 void glwTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
5112 {
5113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5114         if (!gl)
5115                 return;
5116         gl->textureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels);
5117 }
5118
5119 void glwTexturePageCommitmentEXT (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit)
5120 {
5121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5122         if (!gl)
5123                 return;
5124         gl->texturePageCommitmentEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit);
5125 }
5126
5127 void glwTextureParameterIiv (GLuint texture, GLenum pname, const GLint *params)
5128 {
5129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5130         if (!gl)
5131                 return;
5132         gl->textureParameterIiv(texture, pname, params);
5133 }
5134
5135 void glwTextureParameterIuiv (GLuint texture, GLenum pname, const GLuint *params)
5136 {
5137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5138         if (!gl)
5139                 return;
5140         gl->textureParameterIuiv(texture, pname, params);
5141 }
5142
5143 void glwTextureParameterf (GLuint texture, GLenum pname, GLfloat param)
5144 {
5145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5146         if (!gl)
5147                 return;
5148         gl->textureParameterf(texture, pname, param);
5149 }
5150
5151 void glwTextureParameterfv (GLuint texture, GLenum pname, const GLfloat *param)
5152 {
5153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5154         if (!gl)
5155                 return;
5156         gl->textureParameterfv(texture, pname, param);
5157 }
5158
5159 void glwTextureParameteri (GLuint texture, GLenum pname, GLint param)
5160 {
5161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5162         if (!gl)
5163                 return;
5164         gl->textureParameteri(texture, pname, param);
5165 }
5166
5167 void glwTextureParameteriv (GLuint texture, GLenum pname, const GLint *param)
5168 {
5169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5170         if (!gl)
5171                 return;
5172         gl->textureParameteriv(texture, pname, param);
5173 }
5174
5175 void glwTextureRenderbufferEXT (GLuint texture, GLenum target, GLuint renderbuffer)
5176 {
5177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5178         if (!gl)
5179                 return;
5180         gl->textureRenderbufferEXT(texture, target, renderbuffer);
5181 }
5182
5183 void glwTextureStorage1D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
5184 {
5185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5186         if (!gl)
5187                 return;
5188         gl->textureStorage1D(texture, levels, internalformat, width);
5189 }
5190
5191 void glwTextureStorage1DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
5192 {
5193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5194         if (!gl)
5195                 return;
5196         gl->textureStorage1DEXT(texture, target, levels, internalformat, width);
5197 }
5198
5199 void glwTextureStorage2D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
5200 {
5201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5202         if (!gl)
5203                 return;
5204         gl->textureStorage2D(texture, levels, internalformat, width, height);
5205 }
5206
5207 void glwTextureStorage2DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
5208 {
5209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5210         if (!gl)
5211                 return;
5212         gl->textureStorage2DEXT(texture, target, levels, internalformat, width, height);
5213 }
5214
5215 void glwTextureStorage2DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
5216 {
5217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5218         if (!gl)
5219                 return;
5220         gl->textureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
5221 }
5222
5223 void glwTextureStorage3D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
5224 {
5225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5226         if (!gl)
5227                 return;
5228         gl->textureStorage3D(texture, levels, internalformat, width, height, depth);
5229 }
5230
5231 void glwTextureStorage3DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
5232 {
5233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5234         if (!gl)
5235                 return;
5236         gl->textureStorage3DEXT(texture, target, levels, internalformat, width, height, depth);
5237 }
5238
5239 void glwTextureStorage3DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
5240 {
5241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5242         if (!gl)
5243                 return;
5244         gl->textureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
5245 }
5246
5247 void glwTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
5248 {
5249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5250         if (!gl)
5251                 return;
5252         gl->textureSubImage1D(texture, level, xoffset, width, format, type, pixels);
5253 }
5254
5255 void glwTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
5256 {
5257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5258         if (!gl)
5259                 return;
5260         gl->textureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);
5261 }
5262
5263 void glwTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
5264 {
5265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5266         if (!gl)
5267                 return;
5268         gl->textureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
5269 }
5270
5271 void glwTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
5272 {
5273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5274         if (!gl)
5275                 return;
5276         gl->textureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
5277 }
5278
5279 void glwTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
5280 {
5281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5282         if (!gl)
5283                 return;
5284         gl->textureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
5285 }
5286
5287 void glwTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
5288 {
5289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5290         if (!gl)
5291                 return;
5292         gl->textureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
5293 }
5294
5295 void glwTextureView (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
5296 {
5297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5298         if (!gl)
5299                 return;
5300         gl->textureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
5301 }
5302
5303 void glwTransformFeedbackBufferBase (GLuint xfb, GLuint index, GLuint buffer)
5304 {
5305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5306         if (!gl)
5307                 return;
5308         gl->transformFeedbackBufferBase(xfb, index, buffer);
5309 }
5310
5311 void glwTransformFeedbackBufferRange (GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
5312 {
5313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5314         if (!gl)
5315                 return;
5316         gl->transformFeedbackBufferRange(xfb, index, buffer, offset, size);
5317 }
5318
5319 void glwTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode)
5320 {
5321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5322         if (!gl)
5323                 return;
5324         gl->transformFeedbackVaryings(program, count, varyings, bufferMode);
5325 }
5326
5327 void glwUniform1d (GLint location, GLdouble x)
5328 {
5329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5330         if (!gl)
5331                 return;
5332         gl->uniform1d(location, x);
5333 }
5334
5335 void glwUniform1dv (GLint location, GLsizei count, const GLdouble *value)
5336 {
5337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5338         if (!gl)
5339                 return;
5340         gl->uniform1dv(location, count, value);
5341 }
5342
5343 void glwUniform1f (GLint location, GLfloat v0)
5344 {
5345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5346         if (!gl)
5347                 return;
5348         gl->uniform1f(location, v0);
5349 }
5350
5351 void glwUniform1fv (GLint location, GLsizei count, const GLfloat *value)
5352 {
5353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5354         if (!gl)
5355                 return;
5356         gl->uniform1fv(location, count, value);
5357 }
5358
5359 void glwUniform1i (GLint location, GLint v0)
5360 {
5361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5362         if (!gl)
5363                 return;
5364         gl->uniform1i(location, v0);
5365 }
5366
5367 void glwUniform1iv (GLint location, GLsizei count, const GLint *value)
5368 {
5369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5370         if (!gl)
5371                 return;
5372         gl->uniform1iv(location, count, value);
5373 }
5374
5375 void glwUniform1ui (GLint location, GLuint v0)
5376 {
5377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5378         if (!gl)
5379                 return;
5380         gl->uniform1ui(location, v0);
5381 }
5382
5383 void glwUniform1uiv (GLint location, GLsizei count, const GLuint *value)
5384 {
5385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5386         if (!gl)
5387                 return;
5388         gl->uniform1uiv(location, count, value);
5389 }
5390
5391 void glwUniform2d (GLint location, GLdouble x, GLdouble y)
5392 {
5393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5394         if (!gl)
5395                 return;
5396         gl->uniform2d(location, x, y);
5397 }
5398
5399 void glwUniform2dv (GLint location, GLsizei count, const GLdouble *value)
5400 {
5401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5402         if (!gl)
5403                 return;
5404         gl->uniform2dv(location, count, value);
5405 }
5406
5407 void glwUniform2f (GLint location, GLfloat v0, GLfloat v1)
5408 {
5409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5410         if (!gl)
5411                 return;
5412         gl->uniform2f(location, v0, v1);
5413 }
5414
5415 void glwUniform2fv (GLint location, GLsizei count, const GLfloat *value)
5416 {
5417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5418         if (!gl)
5419                 return;
5420         gl->uniform2fv(location, count, value);
5421 }
5422
5423 void glwUniform2i (GLint location, GLint v0, GLint v1)
5424 {
5425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5426         if (!gl)
5427                 return;
5428         gl->uniform2i(location, v0, v1);
5429 }
5430
5431 void glwUniform2iv (GLint location, GLsizei count, const GLint *value)
5432 {
5433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5434         if (!gl)
5435                 return;
5436         gl->uniform2iv(location, count, value);
5437 }
5438
5439 void glwUniform2ui (GLint location, GLuint v0, GLuint v1)
5440 {
5441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5442         if (!gl)
5443                 return;
5444         gl->uniform2ui(location, v0, v1);
5445 }
5446
5447 void glwUniform2uiv (GLint location, GLsizei count, const GLuint *value)
5448 {
5449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5450         if (!gl)
5451                 return;
5452         gl->uniform2uiv(location, count, value);
5453 }
5454
5455 void glwUniform3d (GLint location, GLdouble x, GLdouble y, GLdouble z)
5456 {
5457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5458         if (!gl)
5459                 return;
5460         gl->uniform3d(location, x, y, z);
5461 }
5462
5463 void glwUniform3dv (GLint location, GLsizei count, const GLdouble *value)
5464 {
5465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5466         if (!gl)
5467                 return;
5468         gl->uniform3dv(location, count, value);
5469 }
5470
5471 void glwUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
5472 {
5473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5474         if (!gl)
5475                 return;
5476         gl->uniform3f(location, v0, v1, v2);
5477 }
5478
5479 void glwUniform3fv (GLint location, GLsizei count, const GLfloat *value)
5480 {
5481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5482         if (!gl)
5483                 return;
5484         gl->uniform3fv(location, count, value);
5485 }
5486
5487 void glwUniform3i (GLint location, GLint v0, GLint v1, GLint v2)
5488 {
5489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5490         if (!gl)
5491                 return;
5492         gl->uniform3i(location, v0, v1, v2);
5493 }
5494
5495 void glwUniform3iv (GLint location, GLsizei count, const GLint *value)
5496 {
5497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5498         if (!gl)
5499                 return;
5500         gl->uniform3iv(location, count, value);
5501 }
5502
5503 void glwUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2)
5504 {
5505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5506         if (!gl)
5507                 return;
5508         gl->uniform3ui(location, v0, v1, v2);
5509 }
5510
5511 void glwUniform3uiv (GLint location, GLsizei count, const GLuint *value)
5512 {
5513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5514         if (!gl)
5515                 return;
5516         gl->uniform3uiv(location, count, value);
5517 }
5518
5519 void glwUniform4d (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
5520 {
5521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5522         if (!gl)
5523                 return;
5524         gl->uniform4d(location, x, y, z, w);
5525 }
5526
5527 void glwUniform4dv (GLint location, GLsizei count, const GLdouble *value)
5528 {
5529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5530         if (!gl)
5531                 return;
5532         gl->uniform4dv(location, count, value);
5533 }
5534
5535 void glwUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
5536 {
5537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5538         if (!gl)
5539                 return;
5540         gl->uniform4f(location, v0, v1, v2, v3);
5541 }
5542
5543 void glwUniform4fv (GLint location, GLsizei count, const GLfloat *value)
5544 {
5545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5546         if (!gl)
5547                 return;
5548         gl->uniform4fv(location, count, value);
5549 }
5550
5551 void glwUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
5552 {
5553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5554         if (!gl)
5555                 return;
5556         gl->uniform4i(location, v0, v1, v2, v3);
5557 }
5558
5559 void glwUniform4iv (GLint location, GLsizei count, const GLint *value)
5560 {
5561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5562         if (!gl)
5563                 return;
5564         gl->uniform4iv(location, count, value);
5565 }
5566
5567 void glwUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
5568 {
5569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5570         if (!gl)
5571                 return;
5572         gl->uniform4ui(location, v0, v1, v2, v3);
5573 }
5574
5575 void glwUniform4uiv (GLint location, GLsizei count, const GLuint *value)
5576 {
5577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5578         if (!gl)
5579                 return;
5580         gl->uniform4uiv(location, count, value);
5581 }
5582
5583 void glwUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
5584 {
5585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5586         if (!gl)
5587                 return;
5588         gl->uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
5589 }
5590
5591 void glwUniformMatrix2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5592 {
5593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5594         if (!gl)
5595                 return;
5596         gl->uniformMatrix2dv(location, count, transpose, value);
5597 }
5598
5599 void glwUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5600 {
5601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5602         if (!gl)
5603                 return;
5604         gl->uniformMatrix2fv(location, count, transpose, value);
5605 }
5606
5607 void glwUniformMatrix2x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5608 {
5609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5610         if (!gl)
5611                 return;
5612         gl->uniformMatrix2x3dv(location, count, transpose, value);
5613 }
5614
5615 void glwUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5616 {
5617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5618         if (!gl)
5619                 return;
5620         gl->uniformMatrix2x3fv(location, count, transpose, value);
5621 }
5622
5623 void glwUniformMatrix2x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5624 {
5625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5626         if (!gl)
5627                 return;
5628         gl->uniformMatrix2x4dv(location, count, transpose, value);
5629 }
5630
5631 void glwUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5632 {
5633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5634         if (!gl)
5635                 return;
5636         gl->uniformMatrix2x4fv(location, count, transpose, value);
5637 }
5638
5639 void glwUniformMatrix3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5640 {
5641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5642         if (!gl)
5643                 return;
5644         gl->uniformMatrix3dv(location, count, transpose, value);
5645 }
5646
5647 void glwUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5648 {
5649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5650         if (!gl)
5651                 return;
5652         gl->uniformMatrix3fv(location, count, transpose, value);
5653 }
5654
5655 void glwUniformMatrix3x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5656 {
5657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5658         if (!gl)
5659                 return;
5660         gl->uniformMatrix3x2dv(location, count, transpose, value);
5661 }
5662
5663 void glwUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5664 {
5665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5666         if (!gl)
5667                 return;
5668         gl->uniformMatrix3x2fv(location, count, transpose, value);
5669 }
5670
5671 void glwUniformMatrix3x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5672 {
5673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5674         if (!gl)
5675                 return;
5676         gl->uniformMatrix3x4dv(location, count, transpose, value);
5677 }
5678
5679 void glwUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5680 {
5681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5682         if (!gl)
5683                 return;
5684         gl->uniformMatrix3x4fv(location, count, transpose, value);
5685 }
5686
5687 void glwUniformMatrix4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5688 {
5689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5690         if (!gl)
5691                 return;
5692         gl->uniformMatrix4dv(location, count, transpose, value);
5693 }
5694
5695 void glwUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5696 {
5697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5698         if (!gl)
5699                 return;
5700         gl->uniformMatrix4fv(location, count, transpose, value);
5701 }
5702
5703 void glwUniformMatrix4x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5704 {
5705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5706         if (!gl)
5707                 return;
5708         gl->uniformMatrix4x2dv(location, count, transpose, value);
5709 }
5710
5711 void glwUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5712 {
5713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5714         if (!gl)
5715                 return;
5716         gl->uniformMatrix4x2fv(location, count, transpose, value);
5717 }
5718
5719 void glwUniformMatrix4x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
5720 {
5721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5722         if (!gl)
5723                 return;
5724         gl->uniformMatrix4x3dv(location, count, transpose, value);
5725 }
5726
5727 void glwUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
5728 {
5729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5730         if (!gl)
5731                 return;
5732         gl->uniformMatrix4x3fv(location, count, transpose, value);
5733 }
5734
5735 void glwUniformSubroutinesuiv (GLenum shadertype, GLsizei count, const GLuint *indices)
5736 {
5737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5738         if (!gl)
5739                 return;
5740         gl->uniformSubroutinesuiv(shadertype, count, indices);
5741 }
5742
5743 GLboolean glwUnmapBuffer (GLenum target)
5744 {
5745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5746         if (!gl)
5747                 return (GLboolean)0;
5748         return gl->unmapBuffer(target);
5749 }
5750
5751 GLboolean glwUnmapNamedBuffer (GLuint buffer)
5752 {
5753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5754         if (!gl)
5755                 return (GLboolean)0;
5756         return gl->unmapNamedBuffer(buffer);
5757 }
5758
5759 void glwUseProgram (GLuint program)
5760 {
5761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5762         if (!gl)
5763                 return;
5764         gl->useProgram(program);
5765 }
5766
5767 void glwUseProgramStages (GLuint pipeline, GLbitfield stages, GLuint program)
5768 {
5769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5770         if (!gl)
5771                 return;
5772         gl->useProgramStages(pipeline, stages, program);
5773 }
5774
5775 void glwValidateProgram (GLuint program)
5776 {
5777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5778         if (!gl)
5779                 return;
5780         gl->validateProgram(program);
5781 }
5782
5783 void glwValidateProgramPipeline (GLuint pipeline)
5784 {
5785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5786         if (!gl)
5787                 return;
5788         gl->validateProgramPipeline(pipeline);
5789 }
5790
5791 void glwVertexArrayAttribBinding (GLuint vaobj, GLuint attribindex, GLuint bindingindex)
5792 {
5793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5794         if (!gl)
5795                 return;
5796         gl->vertexArrayAttribBinding(vaobj, attribindex, bindingindex);
5797 }
5798
5799 void glwVertexArrayAttribFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
5800 {
5801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5802         if (!gl)
5803                 return;
5804         gl->vertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
5805 }
5806
5807 void glwVertexArrayAttribIFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
5808 {
5809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5810         if (!gl)
5811                 return;
5812         gl->vertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
5813 }
5814
5815 void glwVertexArrayAttribLFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
5816 {
5817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5818         if (!gl)
5819                 return;
5820         gl->vertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
5821 }
5822
5823 void glwVertexArrayBindVertexBufferEXT (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
5824 {
5825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5826         if (!gl)
5827                 return;
5828         gl->vertexArrayBindVertexBufferEXT(vaobj, bindingindex, buffer, offset, stride);
5829 }
5830
5831 void glwVertexArrayBindingDivisor (GLuint vaobj, GLuint bindingindex, GLuint divisor)
5832 {
5833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5834         if (!gl)
5835                 return;
5836         gl->vertexArrayBindingDivisor(vaobj, bindingindex, divisor);
5837 }
5838
5839 void glwVertexArrayColorOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
5840 {
5841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5842         if (!gl)
5843                 return;
5844         gl->vertexArrayColorOffsetEXT(vaobj, buffer, size, type, stride, offset);
5845 }
5846
5847 void glwVertexArrayEdgeFlagOffsetEXT (GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset)
5848 {
5849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5850         if (!gl)
5851                 return;
5852         gl->vertexArrayEdgeFlagOffsetEXT(vaobj, buffer, stride, offset);
5853 }
5854
5855 void glwVertexArrayElementBuffer (GLuint vaobj, GLuint buffer)
5856 {
5857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5858         if (!gl)
5859                 return;
5860         gl->vertexArrayElementBuffer(vaobj, buffer);
5861 }
5862
5863 void glwVertexArrayFogCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
5864 {
5865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5866         if (!gl)
5867                 return;
5868         gl->vertexArrayFogCoordOffsetEXT(vaobj, buffer, type, stride, offset);
5869 }
5870
5871 void glwVertexArrayIndexOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
5872 {
5873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5874         if (!gl)
5875                 return;
5876         gl->vertexArrayIndexOffsetEXT(vaobj, buffer, type, stride, offset);
5877 }
5878
5879 void glwVertexArrayMultiTexCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset)
5880 {
5881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5882         if (!gl)
5883                 return;
5884         gl->vertexArrayMultiTexCoordOffsetEXT(vaobj, buffer, texunit, size, type, stride, offset);
5885 }
5886
5887 void glwVertexArrayNormalOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
5888 {
5889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5890         if (!gl)
5891                 return;
5892         gl->vertexArrayNormalOffsetEXT(vaobj, buffer, type, stride, offset);
5893 }
5894
5895 void glwVertexArraySecondaryColorOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
5896 {
5897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5898         if (!gl)
5899                 return;
5900         gl->vertexArraySecondaryColorOffsetEXT(vaobj, buffer, size, type, stride, offset);
5901 }
5902
5903 void glwVertexArrayTexCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
5904 {
5905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5906         if (!gl)
5907                 return;
5908         gl->vertexArrayTexCoordOffsetEXT(vaobj, buffer, size, type, stride, offset);
5909 }
5910
5911 void glwVertexArrayVertexAttribBindingEXT (GLuint vaobj, GLuint attribindex, GLuint bindingindex)
5912 {
5913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5914         if (!gl)
5915                 return;
5916         gl->vertexArrayVertexAttribBindingEXT(vaobj, attribindex, bindingindex);
5917 }
5918
5919 void glwVertexArrayVertexAttribDivisorEXT (GLuint vaobj, GLuint index, GLuint divisor)
5920 {
5921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5922         if (!gl)
5923                 return;
5924         gl->vertexArrayVertexAttribDivisorEXT(vaobj, index, divisor);
5925 }
5926
5927 void glwVertexArrayVertexAttribFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
5928 {
5929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5930         if (!gl)
5931                 return;
5932         gl->vertexArrayVertexAttribFormatEXT(vaobj, attribindex, size, type, normalized, relativeoffset);
5933 }
5934
5935 void glwVertexArrayVertexAttribIFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
5936 {
5937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5938         if (!gl)
5939                 return;
5940         gl->vertexArrayVertexAttribIFormatEXT(vaobj, attribindex, size, type, relativeoffset);
5941 }
5942
5943 void glwVertexArrayVertexAttribIOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
5944 {
5945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5946         if (!gl)
5947                 return;
5948         gl->vertexArrayVertexAttribIOffsetEXT(vaobj, buffer, index, size, type, stride, offset);
5949 }
5950
5951 void glwVertexArrayVertexAttribLFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
5952 {
5953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5954         if (!gl)
5955                 return;
5956         gl->vertexArrayVertexAttribLFormatEXT(vaobj, attribindex, size, type, relativeoffset);
5957 }
5958
5959 void glwVertexArrayVertexAttribLOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
5960 {
5961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5962         if (!gl)
5963                 return;
5964         gl->vertexArrayVertexAttribLOffsetEXT(vaobj, buffer, index, size, type, stride, offset);
5965 }
5966
5967 void glwVertexArrayVertexAttribOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset)
5968 {
5969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5970         if (!gl)
5971                 return;
5972         gl->vertexArrayVertexAttribOffsetEXT(vaobj, buffer, index, size, type, normalized, stride, offset);
5973 }
5974
5975 void glwVertexArrayVertexBindingDivisorEXT (GLuint vaobj, GLuint bindingindex, GLuint divisor)
5976 {
5977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5978         if (!gl)
5979                 return;
5980         gl->vertexArrayVertexBindingDivisorEXT(vaobj, bindingindex, divisor);
5981 }
5982
5983 void glwVertexArrayVertexBuffer (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
5984 {
5985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5986         if (!gl)
5987                 return;
5988         gl->vertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
5989 }
5990
5991 void glwVertexArrayVertexBuffers (GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
5992 {
5993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5994         if (!gl)
5995                 return;
5996         gl->vertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
5997 }
5998
5999 void glwVertexArrayVertexOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
6000 {
6001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6002         if (!gl)
6003                 return;
6004         gl->vertexArrayVertexOffsetEXT(vaobj, buffer, size, type, stride, offset);
6005 }
6006
6007 void glwVertexAttrib1d (GLuint index, GLdouble x)
6008 {
6009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6010         if (!gl)
6011                 return;
6012         gl->vertexAttrib1d(index, x);
6013 }
6014
6015 void glwVertexAttrib1dv (GLuint index, const GLdouble *v)
6016 {
6017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6018         if (!gl)
6019                 return;
6020         gl->vertexAttrib1dv(index, v);
6021 }
6022
6023 void glwVertexAttrib1f (GLuint index, GLfloat x)
6024 {
6025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6026         if (!gl)
6027                 return;
6028         gl->vertexAttrib1f(index, x);
6029 }
6030
6031 void glwVertexAttrib1fv (GLuint index, const GLfloat *v)
6032 {
6033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6034         if (!gl)
6035                 return;
6036         gl->vertexAttrib1fv(index, v);
6037 }
6038
6039 void glwVertexAttrib1s (GLuint index, GLshort x)
6040 {
6041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6042         if (!gl)
6043                 return;
6044         gl->vertexAttrib1s(index, x);
6045 }
6046
6047 void glwVertexAttrib1sv (GLuint index, const GLshort *v)
6048 {
6049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6050         if (!gl)
6051                 return;
6052         gl->vertexAttrib1sv(index, v);
6053 }
6054
6055 void glwVertexAttrib2d (GLuint index, GLdouble x, GLdouble y)
6056 {
6057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6058         if (!gl)
6059                 return;
6060         gl->vertexAttrib2d(index, x, y);
6061 }
6062
6063 void glwVertexAttrib2dv (GLuint index, const GLdouble *v)
6064 {
6065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6066         if (!gl)
6067                 return;
6068         gl->vertexAttrib2dv(index, v);
6069 }
6070
6071 void glwVertexAttrib2f (GLuint index, GLfloat x, GLfloat y)
6072 {
6073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6074         if (!gl)
6075                 return;
6076         gl->vertexAttrib2f(index, x, y);
6077 }
6078
6079 void glwVertexAttrib2fv (GLuint index, const GLfloat *v)
6080 {
6081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6082         if (!gl)
6083                 return;
6084         gl->vertexAttrib2fv(index, v);
6085 }
6086
6087 void glwVertexAttrib2s (GLuint index, GLshort x, GLshort y)
6088 {
6089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6090         if (!gl)
6091                 return;
6092         gl->vertexAttrib2s(index, x, y);
6093 }
6094
6095 void glwVertexAttrib2sv (GLuint index, const GLshort *v)
6096 {
6097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6098         if (!gl)
6099                 return;
6100         gl->vertexAttrib2sv(index, v);
6101 }
6102
6103 void glwVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)
6104 {
6105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6106         if (!gl)
6107                 return;
6108         gl->vertexAttrib3d(index, x, y, z);
6109 }
6110
6111 void glwVertexAttrib3dv (GLuint index, const GLdouble *v)
6112 {
6113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6114         if (!gl)
6115                 return;
6116         gl->vertexAttrib3dv(index, v);
6117 }
6118
6119 void glwVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z)
6120 {
6121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6122         if (!gl)
6123                 return;
6124         gl->vertexAttrib3f(index, x, y, z);
6125 }
6126
6127 void glwVertexAttrib3fv (GLuint index, const GLfloat *v)
6128 {
6129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6130         if (!gl)
6131                 return;
6132         gl->vertexAttrib3fv(index, v);
6133 }
6134
6135 void glwVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z)
6136 {
6137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6138         if (!gl)
6139                 return;
6140         gl->vertexAttrib3s(index, x, y, z);
6141 }
6142
6143 void glwVertexAttrib3sv (GLuint index, const GLshort *v)
6144 {
6145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6146         if (!gl)
6147                 return;
6148         gl->vertexAttrib3sv(index, v);
6149 }
6150
6151 void glwVertexAttrib4Nbv (GLuint index, const GLbyte *v)
6152 {
6153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6154         if (!gl)
6155                 return;
6156         gl->vertexAttrib4Nbv(index, v);
6157 }
6158
6159 void glwVertexAttrib4Niv (GLuint index, const GLint *v)
6160 {
6161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6162         if (!gl)
6163                 return;
6164         gl->vertexAttrib4Niv(index, v);
6165 }
6166
6167 void glwVertexAttrib4Nsv (GLuint index, const GLshort *v)
6168 {
6169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6170         if (!gl)
6171                 return;
6172         gl->vertexAttrib4Nsv(index, v);
6173 }
6174
6175 void glwVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
6176 {
6177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6178         if (!gl)
6179                 return;
6180         gl->vertexAttrib4Nub(index, x, y, z, w);
6181 }
6182
6183 void glwVertexAttrib4Nubv (GLuint index, const GLubyte *v)
6184 {
6185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6186         if (!gl)
6187                 return;
6188         gl->vertexAttrib4Nubv(index, v);
6189 }
6190
6191 void glwVertexAttrib4Nuiv (GLuint index, const GLuint *v)
6192 {
6193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6194         if (!gl)
6195                 return;
6196         gl->vertexAttrib4Nuiv(index, v);
6197 }
6198
6199 void glwVertexAttrib4Nusv (GLuint index, const GLushort *v)
6200 {
6201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6202         if (!gl)
6203                 return;
6204         gl->vertexAttrib4Nusv(index, v);
6205 }
6206
6207 void glwVertexAttrib4bv (GLuint index, const GLbyte *v)
6208 {
6209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6210         if (!gl)
6211                 return;
6212         gl->vertexAttrib4bv(index, v);
6213 }
6214
6215 void glwVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6216 {
6217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6218         if (!gl)
6219                 return;
6220         gl->vertexAttrib4d(index, x, y, z, w);
6221 }
6222
6223 void glwVertexAttrib4dv (GLuint index, const GLdouble *v)
6224 {
6225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6226         if (!gl)
6227                 return;
6228         gl->vertexAttrib4dv(index, v);
6229 }
6230
6231 void glwVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6232 {
6233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6234         if (!gl)
6235                 return;
6236         gl->vertexAttrib4f(index, x, y, z, w);
6237 }
6238
6239 void glwVertexAttrib4fv (GLuint index, const GLfloat *v)
6240 {
6241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6242         if (!gl)
6243                 return;
6244         gl->vertexAttrib4fv(index, v);
6245 }
6246
6247 void glwVertexAttrib4iv (GLuint index, const GLint *v)
6248 {
6249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6250         if (!gl)
6251                 return;
6252         gl->vertexAttrib4iv(index, v);
6253 }
6254
6255 void glwVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
6256 {
6257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6258         if (!gl)
6259                 return;
6260         gl->vertexAttrib4s(index, x, y, z, w);
6261 }
6262
6263 void glwVertexAttrib4sv (GLuint index, const GLshort *v)
6264 {
6265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6266         if (!gl)
6267                 return;
6268         gl->vertexAttrib4sv(index, v);
6269 }
6270
6271 void glwVertexAttrib4ubv (GLuint index, const GLubyte *v)
6272 {
6273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6274         if (!gl)
6275                 return;
6276         gl->vertexAttrib4ubv(index, v);
6277 }
6278
6279 void glwVertexAttrib4uiv (GLuint index, const GLuint *v)
6280 {
6281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6282         if (!gl)
6283                 return;
6284         gl->vertexAttrib4uiv(index, v);
6285 }
6286
6287 void glwVertexAttrib4usv (GLuint index, const GLushort *v)
6288 {
6289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6290         if (!gl)
6291                 return;
6292         gl->vertexAttrib4usv(index, v);
6293 }
6294
6295 void glwVertexAttribBinding (GLuint attribindex, GLuint bindingindex)
6296 {
6297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6298         if (!gl)
6299                 return;
6300         gl->vertexAttribBinding(attribindex, bindingindex);
6301 }
6302
6303 void glwVertexAttribDivisor (GLuint index, GLuint divisor)
6304 {
6305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6306         if (!gl)
6307                 return;
6308         gl->vertexAttribDivisor(index, divisor);
6309 }
6310
6311 void glwVertexAttribFormat (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
6312 {
6313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6314         if (!gl)
6315                 return;
6316         gl->vertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
6317 }
6318
6319 void glwVertexAttribI1i (GLuint index, GLint x)
6320 {
6321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6322         if (!gl)
6323                 return;
6324         gl->vertexAttribI1i(index, x);
6325 }
6326
6327 void glwVertexAttribI1iv (GLuint index, const GLint *v)
6328 {
6329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6330         if (!gl)
6331                 return;
6332         gl->vertexAttribI1iv(index, v);
6333 }
6334
6335 void glwVertexAttribI1ui (GLuint index, GLuint x)
6336 {
6337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6338         if (!gl)
6339                 return;
6340         gl->vertexAttribI1ui(index, x);
6341 }
6342
6343 void glwVertexAttribI1uiv (GLuint index, const GLuint *v)
6344 {
6345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6346         if (!gl)
6347                 return;
6348         gl->vertexAttribI1uiv(index, v);
6349 }
6350
6351 void glwVertexAttribI2i (GLuint index, GLint x, GLint y)
6352 {
6353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6354         if (!gl)
6355                 return;
6356         gl->vertexAttribI2i(index, x, y);
6357 }
6358
6359 void glwVertexAttribI2iv (GLuint index, const GLint *v)
6360 {
6361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6362         if (!gl)
6363                 return;
6364         gl->vertexAttribI2iv(index, v);
6365 }
6366
6367 void glwVertexAttribI2ui (GLuint index, GLuint x, GLuint y)
6368 {
6369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6370         if (!gl)
6371                 return;
6372         gl->vertexAttribI2ui(index, x, y);
6373 }
6374
6375 void glwVertexAttribI2uiv (GLuint index, const GLuint *v)
6376 {
6377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6378         if (!gl)
6379                 return;
6380         gl->vertexAttribI2uiv(index, v);
6381 }
6382
6383 void glwVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z)
6384 {
6385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6386         if (!gl)
6387                 return;
6388         gl->vertexAttribI3i(index, x, y, z);
6389 }
6390
6391 void glwVertexAttribI3iv (GLuint index, const GLint *v)
6392 {
6393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6394         if (!gl)
6395                 return;
6396         gl->vertexAttribI3iv(index, v);
6397 }
6398
6399 void glwVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z)
6400 {
6401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6402         if (!gl)
6403                 return;
6404         gl->vertexAttribI3ui(index, x, y, z);
6405 }
6406
6407 void glwVertexAttribI3uiv (GLuint index, const GLuint *v)
6408 {
6409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6410         if (!gl)
6411                 return;
6412         gl->vertexAttribI3uiv(index, v);
6413 }
6414
6415 void glwVertexAttribI4bv (GLuint index, const GLbyte *v)
6416 {
6417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6418         if (!gl)
6419                 return;
6420         gl->vertexAttribI4bv(index, v);
6421 }
6422
6423 void glwVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w)
6424 {
6425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6426         if (!gl)
6427                 return;
6428         gl->vertexAttribI4i(index, x, y, z, w);
6429 }
6430
6431 void glwVertexAttribI4iv (GLuint index, const GLint *v)
6432 {
6433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6434         if (!gl)
6435                 return;
6436         gl->vertexAttribI4iv(index, v);
6437 }
6438
6439 void glwVertexAttribI4sv (GLuint index, const GLshort *v)
6440 {
6441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6442         if (!gl)
6443                 return;
6444         gl->vertexAttribI4sv(index, v);
6445 }
6446
6447 void glwVertexAttribI4ubv (GLuint index, const GLubyte *v)
6448 {
6449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6450         if (!gl)
6451                 return;
6452         gl->vertexAttribI4ubv(index, v);
6453 }
6454
6455 void glwVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
6456 {
6457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6458         if (!gl)
6459                 return;
6460         gl->vertexAttribI4ui(index, x, y, z, w);
6461 }
6462
6463 void glwVertexAttribI4uiv (GLuint index, const GLuint *v)
6464 {
6465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6466         if (!gl)
6467                 return;
6468         gl->vertexAttribI4uiv(index, v);
6469 }
6470
6471 void glwVertexAttribI4usv (GLuint index, const GLushort *v)
6472 {
6473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6474         if (!gl)
6475                 return;
6476         gl->vertexAttribI4usv(index, v);
6477 }
6478
6479 void glwVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
6480 {
6481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6482         if (!gl)
6483                 return;
6484         gl->vertexAttribIFormat(attribindex, size, type, relativeoffset);
6485 }
6486
6487 void glwVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
6488 {
6489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6490         if (!gl)
6491                 return;
6492         gl->vertexAttribIPointer(index, size, type, stride, pointer);
6493 }
6494
6495 void glwVertexAttribL1d (GLuint index, GLdouble x)
6496 {
6497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6498         if (!gl)
6499                 return;
6500         gl->vertexAttribL1d(index, x);
6501 }
6502
6503 void glwVertexAttribL1dv (GLuint index, const GLdouble *v)
6504 {
6505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6506         if (!gl)
6507                 return;
6508         gl->vertexAttribL1dv(index, v);
6509 }
6510
6511 void glwVertexAttribL2d (GLuint index, GLdouble x, GLdouble y)
6512 {
6513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6514         if (!gl)
6515                 return;
6516         gl->vertexAttribL2d(index, x, y);
6517 }
6518
6519 void glwVertexAttribL2dv (GLuint index, const GLdouble *v)
6520 {
6521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6522         if (!gl)
6523                 return;
6524         gl->vertexAttribL2dv(index, v);
6525 }
6526
6527 void glwVertexAttribL3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)
6528 {
6529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6530         if (!gl)
6531                 return;
6532         gl->vertexAttribL3d(index, x, y, z);
6533 }
6534
6535 void glwVertexAttribL3dv (GLuint index, const GLdouble *v)
6536 {
6537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6538         if (!gl)
6539                 return;
6540         gl->vertexAttribL3dv(index, v);
6541 }
6542
6543 void glwVertexAttribL4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
6544 {
6545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6546         if (!gl)
6547                 return;
6548         gl->vertexAttribL4d(index, x, y, z, w);
6549 }
6550
6551 void glwVertexAttribL4dv (GLuint index, const GLdouble *v)
6552 {
6553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6554         if (!gl)
6555                 return;
6556         gl->vertexAttribL4dv(index, v);
6557 }
6558
6559 void glwVertexAttribLFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
6560 {
6561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6562         if (!gl)
6563                 return;
6564         gl->vertexAttribLFormat(attribindex, size, type, relativeoffset);
6565 }
6566
6567 void glwVertexAttribLPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
6568 {
6569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6570         if (!gl)
6571                 return;
6572         gl->vertexAttribLPointer(index, size, type, stride, pointer);
6573 }
6574
6575 void glwVertexAttribP1ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
6576 {
6577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6578         if (!gl)
6579                 return;
6580         gl->vertexAttribP1ui(index, type, normalized, value);
6581 }
6582
6583 void glwVertexAttribP1uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
6584 {
6585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6586         if (!gl)
6587                 return;
6588         gl->vertexAttribP1uiv(index, type, normalized, value);
6589 }
6590
6591 void glwVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
6592 {
6593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6594         if (!gl)
6595                 return;
6596         gl->vertexAttribP2ui(index, type, normalized, value);
6597 }
6598
6599 void glwVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
6600 {
6601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6602         if (!gl)
6603                 return;
6604         gl->vertexAttribP2uiv(index, type, normalized, value);
6605 }
6606
6607 void glwVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
6608 {
6609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6610         if (!gl)
6611                 return;
6612         gl->vertexAttribP3ui(index, type, normalized, value);
6613 }
6614
6615 void glwVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
6616 {
6617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6618         if (!gl)
6619                 return;
6620         gl->vertexAttribP3uiv(index, type, normalized, value);
6621 }
6622
6623 void glwVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
6624 {
6625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6626         if (!gl)
6627                 return;
6628         gl->vertexAttribP4ui(index, type, normalized, value);
6629 }
6630
6631 void glwVertexAttribP4uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
6632 {
6633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6634         if (!gl)
6635                 return;
6636         gl->vertexAttribP4uiv(index, type, normalized, value);
6637 }
6638
6639 void glwVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
6640 {
6641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6642         if (!gl)
6643                 return;
6644         gl->vertexAttribPointer(index, size, type, normalized, stride, pointer);
6645 }
6646
6647 void glwVertexBindingDivisor (GLuint bindingindex, GLuint divisor)
6648 {
6649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6650         if (!gl)
6651                 return;
6652         gl->vertexBindingDivisor(bindingindex, divisor);
6653 }
6654
6655 void glwViewport (GLint x, GLint y, GLsizei width, GLsizei height)
6656 {
6657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6658         if (!gl)
6659                 return;
6660         gl->viewport(x, y, width, height);
6661 }
6662
6663 void glwViewportArrayv (GLuint first, GLsizei count, const GLfloat *v)
6664 {
6665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6666         if (!gl)
6667                 return;
6668         gl->viewportArrayv(first, count, v);
6669 }
6670
6671 void glwViewportIndexedf (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
6672 {
6673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6674         if (!gl)
6675                 return;
6676         gl->viewportIndexedf(index, x, y, w, h);
6677 }
6678
6679 void glwViewportIndexedfv (GLuint index, const GLfloat *v)
6680 {
6681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6682         if (!gl)
6683                 return;
6684         gl->viewportIndexedfv(index, v);
6685 }
6686
6687 void glwWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout)
6688 {
6689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
6690         if (!gl)
6691                 return;
6692         gl->waitSync(sync, flags, timeout);
6693 }