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 32093.
   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 glwBindProgramPipeline (GLuint pipeline)
 152 {
 153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 154         if (!gl)
 155                 return;
 156         gl->bindProgramPipeline(pipeline);
 157 }
 158
 159 void glwBindRenderbuffer (GLenum target, GLuint renderbuffer)
 160 {
 161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 162         if (!gl)
 163                 return;
 164         gl->bindRenderbuffer(target, renderbuffer);
 165 }
 166
 167 void glwBindSampler (GLuint unit, GLuint sampler)
 168 {
 169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 170         if (!gl)
 171                 return;
 172         gl->bindSampler(unit, sampler);
 173 }
 174
 175 void glwBindSamplers (GLuint first, GLsizei count, const GLuint *samplers)
 176 {
 177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 178         if (!gl)
 179                 return;
 180         gl->bindSamplers(first, count, samplers);
 181 }
 182
 183 void glwBindTexture (GLenum target, GLuint texture)
 184 {
 185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 186         if (!gl)
 187                 return;
 188         gl->bindTexture(target, texture);
 189 }
 190
 191 void glwBindTextureUnit (GLuint unit, GLuint texture)
 192 {
 193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 194         if (!gl)
 195                 return;
 196         gl->bindTextureUnit(unit, texture);
 197 }
 198
 199 void glwBindTextures (GLuint first, GLsizei count, const GLuint *textures)
 200 {
 201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 202         if (!gl)
 203                 return;
 204         gl->bindTextures(first, count, textures);
 205 }
 206
 207 void glwBindTransformFeedback (GLenum target, GLuint id)
 208 {
 209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 210         if (!gl)
 211                 return;
 212         gl->bindTransformFeedback(target, id);
 213 }
 214
 215 void glwBindVertexArray (GLuint array)
 216 {
 217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 218         if (!gl)
 219                 return;
 220         gl->bindVertexArray(array);
 221 }
 222
 223 void glwBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 224 {
 225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 226         if (!gl)
 227                 return;
 228         gl->bindVertexBuffer(bindingindex, buffer, offset, stride);
 229 }
 230
 231 void glwBindVertexBuffers (GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
 232 {
 233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 234         if (!gl)
 235                 return;
 236         gl->bindVertexBuffers(first, count, buffers, offsets, strides);
 237 }
 238
 239 void glwBlendBarrier (void)
 240 {
 241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 242         if (!gl)
 243                 return;
 244         gl->blendBarrier();
 245 }
 246
 247 void glwBlendColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 248 {
 249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 250         if (!gl)
 251                 return;
 252         gl->blendColor(red, green, blue, alpha);
 253 }
 254
 255 void glwBlendEquation (GLenum mode)
 256 {
 257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 258         if (!gl)
 259                 return;
 260         gl->blendEquation(mode);
 261 }
 262
 263 void glwBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
 264 {
 265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 266         if (!gl)
 267                 return;
 268         gl->blendEquationSeparate(modeRGB, modeAlpha);
 269 }
 270
 271 void glwBlendEquationSeparatei (GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 272 {
 273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 274         if (!gl)
 275                 return;
 276         gl->blendEquationSeparatei(buf, modeRGB, modeAlpha);
 277 }
 278
 279 void glwBlendEquationi (GLuint buf, GLenum mode)
 280 {
 281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 282         if (!gl)
 283                 return;
 284         gl->blendEquationi(buf, mode);
 285 }
 286
 287 void glwBlendFunc (GLenum sfactor, GLenum dfactor)
 288 {
 289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 290         if (!gl)
 291                 return;
 292         gl->blendFunc(sfactor, dfactor);
 293 }
 294
 295 void glwBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 296 {
 297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 298         if (!gl)
 299                 return;
 300         gl->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 301 }
 302
 303 void glwBlendFuncSeparatei (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 304 {
 305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 306         if (!gl)
 307                 return;
 308         gl->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 309 }
 310
 311 void glwBlendFunci (GLuint buf, GLenum src, GLenum dst)
 312 {
 313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 314         if (!gl)
 315                 return;
 316         gl->blendFunci(buf, src, dst);
 317 }
 318
 319 void glwBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 320 {
 321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 322         if (!gl)
 323                 return;
 324         gl->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 325 }
 326
 327 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)
 328 {
 329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 330         if (!gl)
 331                 return;
 332         gl->blitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 333 }
 334
 335 void glwBufferData (GLenum target, GLsizeiptr size, const void *data, GLenum usage)
 336 {
 337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 338         if (!gl)
 339                 return;
 340         gl->bufferData(target, size, data, usage);
 341 }
 342
 343 void glwBufferStorage (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
 344 {
 345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 346         if (!gl)
 347                 return;
 348         gl->bufferStorage(target, size, data, flags);
 349 }
 350
 351 void glwBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
 352 {
 353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 354         if (!gl)
 355                 return;
 356         gl->bufferSubData(target, offset, size, data);
 357 }
 358
 359 GLenum glwCheckFramebufferStatus (GLenum target)
 360 {
 361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 362         if (!gl)
 363                 return (GLenum)0;
 364         return gl->checkFramebufferStatus(target);
 365 }
 366
 367 GLenum glwCheckNamedFramebufferStatus (GLuint framebuffer, GLenum target)
 368 {
 369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 370         if (!gl)
 371                 return (GLenum)0;
 372         return gl->checkNamedFramebufferStatus(framebuffer, target);
 373 }
 374
 375 void glwClampColor (GLenum target, GLenum clamp)
 376 {
 377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 378         if (!gl)
 379                 return;
 380         gl->clampColor(target, clamp);
 381 }
 382
 383 void glwClear (GLbitfield mask)
 384 {
 385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 386         if (!gl)
 387                 return;
 388         gl->clear(mask);
 389 }
 390
 391 void glwClearBufferData (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
 392 {
 393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 394         if (!gl)
 395                 return;
 396         gl->clearBufferData(target, internalformat, format, type, data);
 397 }
 398
 399 void glwClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 400 {
 401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 402         if (!gl)
 403                 return;
 404         gl->clearBufferSubData(target, internalformat, offset, size, format, type, data);
 405 }
 406
 407 void glwClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 408 {
 409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 410         if (!gl)
 411                 return;
 412         gl->clearBufferfi(buffer, drawbuffer, depth, stencil);
 413 }
 414
 415 void glwClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat *value)
 416 {
 417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 418         if (!gl)
 419                 return;
 420         gl->clearBufferfv(buffer, drawbuffer, value);
 421 }
 422
 423 void glwClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint *value)
 424 {
 425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 426         if (!gl)
 427                 return;
 428         gl->clearBufferiv(buffer, drawbuffer, value);
 429 }
 430
 431 void glwClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint *value)
 432 {
 433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 434         if (!gl)
 435                 return;
 436         gl->clearBufferuiv(buffer, drawbuffer, value);
 437 }
 438
 439 void glwClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 440 {
 441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 442         if (!gl)
 443                 return;
 444         gl->clearColor(red, green, blue, alpha);
 445 }
 446
 447 void glwClearDepth (GLdouble depth)
 448 {
 449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 450         if (!gl)
 451                 return;
 452         gl->clearDepth(depth);
 453 }
 454
 455 void glwClearDepthf (GLfloat d)
 456 {
 457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 458         if (!gl)
 459                 return;
 460         gl->clearDepthf(d);
 461 }
 462
 463 void glwClearNamedBufferData (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
 464 {
 465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 466         if (!gl)
 467                 return;
 468         gl->clearNamedBufferData(buffer, internalformat, format, type, data);
 469 }
 470
 471 void glwClearNamedBufferSubData (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 472 {
 473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 474         if (!gl)
 475                 return;
 476         gl->clearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
 477 }
 478
 479 void glwClearNamedFramebufferfi (GLuint framebuffer, GLenum buffer, const GLfloat depth, GLint stencil)
 480 {
 481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 482         if (!gl)
 483                 return;
 484         gl->clearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
 485 }
 486
 487 void glwClearNamedFramebufferfv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)
 488 {
 489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 490         if (!gl)
 491                 return;
 492         gl->clearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
 493 }
 494
 495 void glwClearNamedFramebufferiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)
 496 {
 497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 498         if (!gl)
 499                 return;
 500         gl->clearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
 501 }
 502
 503 void glwClearNamedFramebufferuiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)
 504 {
 505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 506         if (!gl)
 507                 return;
 508         gl->clearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
 509 }
 510
 511 void glwClearStencil (GLint s)
 512 {
 513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 514         if (!gl)
 515                 return;
 516         gl->clearStencil(s);
 517 }
 518
 519 void glwClearTexImage (GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
 520 {
 521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 522         if (!gl)
 523                 return;
 524         gl->clearTexImage(texture, level, format, type, data);
 525 }
 526
 527 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)
 528 {
 529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 530         if (!gl)
 531                 return;
 532         gl->clearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
 533 }
 534
 535 GLenum glwClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout)
 536 {
 537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 538         if (!gl)
 539                 return (GLenum)0;
 540         return gl->clientWaitSync(sync, flags, timeout);
 541 }
 542
 543 void glwClipControl (GLenum origin, GLenum depth)
 544 {
 545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 546         if (!gl)
 547                 return;
 548         gl->clipControl(origin, depth);
 549 }
 550
 551 void glwColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 552 {
 553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 554         if (!gl)
 555                 return;
 556         gl->colorMask(red, green, blue, alpha);
 557 }
 558
 559 void glwColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 560 {
 561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 562         if (!gl)
 563                 return;
 564         gl->colorMaski(index, r, g, b, a);
 565 }
 566
 567 void glwCompileShader (GLuint shader)
 568 {
 569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 570         if (!gl)
 571                 return;
 572         gl->compileShader(shader);
 573 }
 574
 575 void glwCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
 576 {
 577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 578         if (!gl)
 579                 return;
 580         gl->compressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 581 }
 582
 583 void glwCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
 584 {
 585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 586         if (!gl)
 587                 return;
 588         gl->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 589 }
 590
 591 void glwCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
 592 {
 593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 594         if (!gl)
 595                 return;
 596         gl->compressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 597 }
 598
 599 void glwCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 600 {
 601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 602         if (!gl)
 603                 return;
 604         gl->compressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 605 }
 606
 607 void glwCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 608 {
 609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 610         if (!gl)
 611                 return;
 612         gl->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 613 }
 614
 615 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)
 616 {
 617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 618         if (!gl)
 619                 return;
 620         gl->compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 621 }
 622
 623 void glwCompressedTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 624 {
 625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 626         if (!gl)
 627                 return;
 628         gl->compressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
 629 }
 630
 631 void glwCompressedTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 632 {
 633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 634         if (!gl)
 635                 return;
 636         gl->compressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
 637 }
 638
 639 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)
 640 {
 641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 642         if (!gl)
 643                 return;
 644         gl->compressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 645 }
 646
 647 void glwCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 648 {
 649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 650         if (!gl)
 651                 return;
 652         gl->copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 653 }
 654
 655 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)
 656 {
 657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 658         if (!gl)
 659                 return;
 660         gl->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 661 }
 662
 663 void glwCopyNamedBufferSubData (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 664 {
 665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 666         if (!gl)
 667                 return;
 668         gl->copyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
 669 }
 670
 671 void glwCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 672 {
 673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 674         if (!gl)
 675                 return;
 676         gl->copyTexImage1D(target, level, internalformat, x, y, width, border);
 677 }
 678
 679 void glwCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 680 {
 681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 682         if (!gl)
 683                 return;
 684         gl->copyTexImage2D(target, level, internalformat, x, y, width, height, border);
 685 }
 686
 687 void glwCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 688 {
 689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 690         if (!gl)
 691                 return;
 692         gl->copyTexSubImage1D(target, level, xoffset, x, y, width);
 693 }
 694
 695 void glwCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 696 {
 697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 698         if (!gl)
 699                 return;
 700         gl->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 701 }
 702
 703 void glwCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 704 {
 705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 706         if (!gl)
 707                 return;
 708         gl->copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 709 }
 710
 711 void glwCopyTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 712 {
 713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 714         if (!gl)
 715                 return;
 716         gl->copyTextureSubImage1D(texture, level, xoffset, x, y, width);
 717 }
 718
 719 void glwCopyTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 720 {
 721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 722         if (!gl)
 723                 return;
 724         gl->copyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
 725 }
 726
 727 void glwCopyTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 728 {
 729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 730         if (!gl)
 731                 return;
 732         gl->copyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
 733 }
 734
 735 void glwCreateBuffers (GLsizei n, GLuint *buffers)
 736 {
 737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 738         if (!gl)
 739                 return;
 740         gl->createBuffers(n, buffers);
 741 }
 742
 743 void glwCreateFramebuffers (GLsizei n, GLuint *framebuffers)
 744 {
 745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 746         if (!gl)
 747                 return;
 748         gl->createFramebuffers(n, framebuffers);
 749 }
 750
 751 GLuint glwCreateProgram (void)
 752 {
 753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 754         if (!gl)
 755                 return (GLuint)0;
 756         return gl->createProgram();
 757 }
 758
 759 void glwCreateProgramPipelines (GLsizei n, GLuint *pipelines)
 760 {
 761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 762         if (!gl)
 763                 return;
 764         gl->createProgramPipelines(n, pipelines);
 765 }
 766
 767 void glwCreateQueries (GLenum target, GLsizei n, GLuint *ids)
 768 {
 769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 770         if (!gl)
 771                 return;
 772         gl->createQueries(target, n, ids);
 773 }
 774
 775 void glwCreateRenderbuffers (GLsizei n, GLuint *renderbuffers)
 776 {
 777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 778         if (!gl)
 779                 return;
 780         gl->createRenderbuffers(n, renderbuffers);
 781 }
 782
 783 void glwCreateSamplers (GLsizei n, GLuint *samplers)
 784 {
 785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 786         if (!gl)
 787                 return;
 788         gl->createSamplers(n, samplers);
 789 }
 790
 791 GLuint glwCreateShader (GLenum type)
 792 {
 793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 794         if (!gl)
 795                 return (GLuint)0;
 796         return gl->createShader(type);
 797 }
 798
 799 GLuint glwCreateShaderProgramv (GLenum type, GLsizei count, const GLchar *const*strings)
 800 {
 801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 802         if (!gl)
 803                 return (GLuint)0;
 804         return gl->createShaderProgramv(type, count, strings);
 805 }
 806
 807 void glwCreateTextures (GLenum target, GLsizei n, GLuint *textures)
 808 {
 809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 810         if (!gl)
 811                 return;
 812         gl->createTextures(target, n, textures);
 813 }
 814
 815 void glwCreateTransformFeedbacks (GLsizei n, GLuint *ids)
 816 {
 817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 818         if (!gl)
 819                 return;
 820         gl->createTransformFeedbacks(n, ids);
 821 }
 822
 823 void glwCreateVertexArrays (GLsizei n, GLuint *arrays)
 824 {
 825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 826         if (!gl)
 827                 return;
 828         gl->createVertexArrays(n, arrays);
 829 }
 830
 831 void glwCullFace (GLenum mode)
 832 {
 833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 834         if (!gl)
 835                 return;
 836         gl->cullFace(mode);
 837 }
 838
 839 void glwDebugMessageCallback (GLDEBUGPROC callback, const void *userParam)
 840 {
 841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 842         if (!gl)
 843                 return;
 844         gl->debugMessageCallback(callback, userParam);
 845 }
 846
 847 void glwDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
 848 {
 849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 850         if (!gl)
 851                 return;
 852         gl->debugMessageControl(source, type, severity, count, ids, enabled);
 853 }
 854
 855 void glwDebugMessageInsert (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
 856 {
 857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 858         if (!gl)
 859                 return;
 860         gl->debugMessageInsert(source, type, id, severity, length, buf);
 861 }
 862
 863 void glwDeleteBuffers (GLsizei n, const GLuint *buffers)
 864 {
 865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 866         if (!gl)
 867                 return;
 868         gl->deleteBuffers(n, buffers);
 869 }
 870
 871 void glwDeleteFramebuffers (GLsizei n, const GLuint *framebuffers)
 872 {
 873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 874         if (!gl)
 875                 return;
 876         gl->deleteFramebuffers(n, framebuffers);
 877 }
 878
 879 void glwDeleteProgram (GLuint program)
 880 {
 881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 882         if (!gl)
 883                 return;
 884         gl->deleteProgram(program);
 885 }
 886
 887 void glwDeleteProgramPipelines (GLsizei n, const GLuint *pipelines)
 888 {
 889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 890         if (!gl)
 891                 return;
 892         gl->deleteProgramPipelines(n, pipelines);
 893 }
 894
 895 void glwDeleteQueries (GLsizei n, const GLuint *ids)
 896 {
 897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 898         if (!gl)
 899                 return;
 900         gl->deleteQueries(n, ids);
 901 }
 902
 903 void glwDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers)
 904 {
 905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 906         if (!gl)
 907                 return;
 908         gl->deleteRenderbuffers(n, renderbuffers);
 909 }
 910
 911 void glwDeleteSamplers (GLsizei count, const GLuint *samplers)
 912 {
 913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 914         if (!gl)
 915                 return;
 916         gl->deleteSamplers(count, samplers);
 917 }
 918
 919 void glwDeleteShader (GLuint shader)
 920 {
 921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 922         if (!gl)
 923                 return;
 924         gl->deleteShader(shader);
 925 }
 926
 927 void glwDeleteSync (GLsync sync)
 928 {
 929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 930         if (!gl)
 931                 return;
 932         gl->deleteSync(sync);
 933 }
 934
 935 void glwDeleteTextures (GLsizei n, const GLuint *textures)
 936 {
 937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 938         if (!gl)
 939                 return;
 940         gl->deleteTextures(n, textures);
 941 }
 942
 943 void glwDeleteTransformFeedbacks (GLsizei n, const GLuint *ids)
 944 {
 945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 946         if (!gl)
 947                 return;
 948         gl->deleteTransformFeedbacks(n, ids);
 949 }
 950
 951 void glwDeleteVertexArrays (GLsizei n, const GLuint *arrays)
 952 {
 953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 954         if (!gl)
 955                 return;
 956         gl->deleteVertexArrays(n, arrays);
 957 }
 958
 959 void glwDepthFunc (GLenum func)
 960 {
 961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 962         if (!gl)
 963                 return;
 964         gl->depthFunc(func);
 965 }
 966
 967 void glwDepthMask (GLboolean flag)
 968 {
 969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 970         if (!gl)
 971                 return;
 972         gl->depthMask(flag);
 973 }
 974
 975 void glwDepthRange (GLdouble near, GLdouble far)
 976 {
 977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 978         if (!gl)
 979                 return;
 980         gl->depthRange(near, far);
 981 }
 982
 983 void glwDepthRangeArrayv (GLuint first, GLsizei count, const GLdouble *v)
 984 {
 985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 986         if (!gl)
 987                 return;
 988         gl->depthRangeArrayv(first, count, v);
 989 }
 990
 991 void glwDepthRangeIndexed (GLuint index, GLdouble n, GLdouble f)
 992 {
 993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
 994         if (!gl)
 995                 return;
 996         gl->depthRangeIndexed(index, n, f);
 997 }
 998
 999 void glwDepthRangef (GLfloat n, GLfloat f)
1000 {
1001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1002         if (!gl)
1003                 return;
1004         gl->depthRangef(n, f);
1005 }
1006
1007 void glwDetachShader (GLuint program, GLuint shader)
1008 {
1009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1010         if (!gl)
1011                 return;
1012         gl->detachShader(program, shader);
1013 }
1014
1015 void glwDisable (GLenum cap)
1016 {
1017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1018         if (!gl)
1019                 return;
1020         gl->disable(cap);
1021 }
1022
1023 void glwDisableVertexArrayAttrib (GLuint vaobj, GLuint index)
1024 {
1025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1026         if (!gl)
1027                 return;
1028         gl->disableVertexArrayAttrib(vaobj, index);
1029 }
1030
1031 void glwDisableVertexAttribArray (GLuint index)
1032 {
1033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1034         if (!gl)
1035                 return;
1036         gl->disableVertexAttribArray(index);
1037 }
1038
1039 void glwDisablei (GLenum target, GLuint index)
1040 {
1041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1042         if (!gl)
1043                 return;
1044         gl->disablei(target, index);
1045 }
1046
1047 void glwDispatchCompute (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
1048 {
1049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1050         if (!gl)
1051                 return;
1052         gl->dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
1053 }
1054
1055 void glwDispatchComputeIndirect (GLintptr indirect)
1056 {
1057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1058         if (!gl)
1059                 return;
1060         gl->dispatchComputeIndirect(indirect);
1061 }
1062
1063 void glwDrawArrays (GLenum mode, GLint first, GLsizei count)
1064 {
1065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1066         if (!gl)
1067                 return;
1068         gl->drawArrays(mode, first, count);
1069 }
1070
1071 void glwDrawArraysIndirect (GLenum mode, const void *indirect)
1072 {
1073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1074         if (!gl)
1075                 return;
1076         gl->drawArraysIndirect(mode, indirect);
1077 }
1078
1079 void glwDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
1080 {
1081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1082         if (!gl)
1083                 return;
1084         gl->drawArraysInstanced(mode, first, count, instancecount);
1085 }
1086
1087 void glwDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
1088 {
1089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1090         if (!gl)
1091                 return;
1092         gl->drawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
1093 }
1094
1095 void glwDrawBuffer (GLenum buf)
1096 {
1097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1098         if (!gl)
1099                 return;
1100         gl->drawBuffer(buf);
1101 }
1102
1103 void glwDrawBuffers (GLsizei n, const GLenum *bufs)
1104 {
1105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1106         if (!gl)
1107                 return;
1108         gl->drawBuffers(n, bufs);
1109 }
1110
1111 void glwDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices)
1112 {
1113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1114         if (!gl)
1115                 return;
1116         gl->drawElements(mode, count, type, indices);
1117 }
1118
1119 void glwDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
1120 {
1121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1122         if (!gl)
1123                 return;
1124         gl->drawElementsBaseVertex(mode, count, type, indices, basevertex);
1125 }
1126
1127 void glwDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect)
1128 {
1129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1130         if (!gl)
1131                 return;
1132         gl->drawElementsIndirect(mode, type, indirect);
1133 }
1134
1135 void glwDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
1136 {
1137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1138         if (!gl)
1139                 return;
1140         gl->drawElementsInstanced(mode, count, type, indices, instancecount);
1141 }
1142
1143 void glwDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
1144 {
1145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1146         if (!gl)
1147                 return;
1148         gl->drawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
1149 }
1150
1151 void glwDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
1152 {
1153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1154         if (!gl)
1155                 return;
1156         gl->drawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
1157 }
1158
1159 void glwDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
1160 {
1161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1162         if (!gl)
1163                 return;
1164         gl->drawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
1165 }
1166
1167 void glwDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
1168 {
1169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1170         if (!gl)
1171                 return;
1172         gl->drawRangeElements(mode, start, end, count, type, indices);
1173 }
1174
1175 void glwDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
1176 {
1177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1178         if (!gl)
1179                 return;
1180         gl->drawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
1181 }
1182
1183 void glwDrawTransformFeedback (GLenum mode, GLuint id)
1184 {
1185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1186         if (!gl)
1187                 return;
1188         gl->drawTransformFeedback(mode, id);
1189 }
1190
1191 void glwDrawTransformFeedbackInstanced (GLenum mode, GLuint id, GLsizei instancecount)
1192 {
1193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1194         if (!gl)
1195                 return;
1196         gl->drawTransformFeedbackInstanced(mode, id, instancecount);
1197 }
1198
1199 void glwDrawTransformFeedbackStream (GLenum mode, GLuint id, GLuint stream)
1200 {
1201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1202         if (!gl)
1203                 return;
1204         gl->drawTransformFeedbackStream(mode, id, stream);
1205 }
1206
1207 void glwDrawTransformFeedbackStreamInstanced (GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
1208 {
1209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1210         if (!gl)
1211                 return;
1212         gl->drawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
1213 }
1214
1215 void glwEGLImageTargetRenderbufferStorageOES (GLenum target, GLeglImageOES image)
1216 {
1217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1218         if (!gl)
1219                 return;
1220         gl->eglImageTargetRenderbufferStorageOES(target, image);
1221 }
1222
1223 void glwEGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image)
1224 {
1225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1226         if (!gl)
1227                 return;
1228         gl->eglImageTargetTexture2DOES(target, image);
1229 }
1230
1231 void glwEnable (GLenum cap)
1232 {
1233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1234         if (!gl)
1235                 return;
1236         gl->enable(cap);
1237 }
1238
1239 void glwEnableVertexArrayAttrib (GLuint vaobj, GLuint index)
1240 {
1241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1242         if (!gl)
1243                 return;
1244         gl->enableVertexArrayAttrib(vaobj, index);
1245 }
1246
1247 void glwEnableVertexAttribArray (GLuint index)
1248 {
1249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1250         if (!gl)
1251                 return;
1252         gl->enableVertexAttribArray(index);
1253 }
1254
1255 void glwEnablei (GLenum target, GLuint index)
1256 {
1257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1258         if (!gl)
1259                 return;
1260         gl->enablei(target, index);
1261 }
1262
1263 void glwEndConditionalRender (void)
1264 {
1265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1266         if (!gl)
1267                 return;
1268         gl->endConditionalRender();
1269 }
1270
1271 void glwEndQuery (GLenum target)
1272 {
1273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1274         if (!gl)
1275                 return;
1276         gl->endQuery(target);
1277 }
1278
1279 void glwEndQueryIndexed (GLenum target, GLuint index)
1280 {
1281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1282         if (!gl)
1283                 return;
1284         gl->endQueryIndexed(target, index);
1285 }
1286
1287 void glwEndTransformFeedback (void)
1288 {
1289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1290         if (!gl)
1291                 return;
1292         gl->endTransformFeedback();
1293 }
1294
1295 GLsync glwFenceSync (GLenum condition, GLbitfield flags)
1296 {
1297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1298         if (!gl)
1299                 return (GLsync)0;
1300         return gl->fenceSync(condition, flags);
1301 }
1302
1303 void glwFinish (void)
1304 {
1305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1306         if (!gl)
1307                 return;
1308         gl->finish();
1309 }
1310
1311 void glwFlush (void)
1312 {
1313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1314         if (!gl)
1315                 return;
1316         gl->flush();
1317 }
1318
1319 void glwFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length)
1320 {
1321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1322         if (!gl)
1323                 return;
1324         gl->flushMappedBufferRange(target, offset, length);
1325 }
1326
1327 void glwFlushMappedNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length)
1328 {
1329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1330         if (!gl)
1331                 return;
1332         gl->flushMappedNamedBufferRange(buffer, offset, length);
1333 }
1334
1335 void glwFramebufferParameteri (GLenum target, GLenum pname, GLint param)
1336 {
1337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1338         if (!gl)
1339                 return;
1340         gl->framebufferParameteri(target, pname, param);
1341 }
1342
1343 void glwFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1344 {
1345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1346         if (!gl)
1347                 return;
1348         gl->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
1349 }
1350
1351 void glwFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level)
1352 {
1353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1354         if (!gl)
1355                 return;
1356         gl->framebufferTexture(target, attachment, texture, level);
1357 }
1358
1359 void glwFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1360 {
1361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1362         if (!gl)
1363                 return;
1364         gl->framebufferTexture1D(target, attachment, textarget, texture, level);
1365 }
1366
1367 void glwFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1368 {
1369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1370         if (!gl)
1371                 return;
1372         gl->framebufferTexture2D(target, attachment, textarget, texture, level);
1373 }
1374
1375 void glwFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
1376 {
1377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1378         if (!gl)
1379                 return;
1380         gl->framebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
1381 }
1382
1383 void glwFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
1384 {
1385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1386         if (!gl)
1387                 return;
1388         gl->framebufferTextureLayer(target, attachment, texture, level, layer);
1389 }
1390
1391 void glwFrontFace (GLenum mode)
1392 {
1393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1394         if (!gl)
1395                 return;
1396         gl->frontFace(mode);
1397 }
1398
1399 void glwGenBuffers (GLsizei n, GLuint *buffers)
1400 {
1401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1402         if (!gl)
1403                 return;
1404         gl->genBuffers(n, buffers);
1405 }
1406
1407 void glwGenFramebuffers (GLsizei n, GLuint *framebuffers)
1408 {
1409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1410         if (!gl)
1411                 return;
1412         gl->genFramebuffers(n, framebuffers);
1413 }
1414
1415 void glwGenProgramPipelines (GLsizei n, GLuint *pipelines)
1416 {
1417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1418         if (!gl)
1419                 return;
1420         gl->genProgramPipelines(n, pipelines);
1421 }
1422
1423 void glwGenQueries (GLsizei n, GLuint *ids)
1424 {
1425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1426         if (!gl)
1427                 return;
1428         gl->genQueries(n, ids);
1429 }
1430
1431 void glwGenRenderbuffers (GLsizei n, GLuint *renderbuffers)
1432 {
1433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1434         if (!gl)
1435                 return;
1436         gl->genRenderbuffers(n, renderbuffers);
1437 }
1438
1439 void glwGenSamplers (GLsizei count, GLuint *samplers)
1440 {
1441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1442         if (!gl)
1443                 return;
1444         gl->genSamplers(count, samplers);
1445 }
1446
1447 void glwGenTextures (GLsizei n, GLuint *textures)
1448 {
1449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1450         if (!gl)
1451                 return;
1452         gl->genTextures(n, textures);
1453 }
1454
1455 void glwGenTransformFeedbacks (GLsizei n, GLuint *ids)
1456 {
1457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1458         if (!gl)
1459                 return;
1460         gl->genTransformFeedbacks(n, ids);
1461 }
1462
1463 void glwGenVertexArrays (GLsizei n, GLuint *arrays)
1464 {
1465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1466         if (!gl)
1467                 return;
1468         gl->genVertexArrays(n, arrays);
1469 }
1470
1471 void glwGenerateMipmap (GLenum target)
1472 {
1473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1474         if (!gl)
1475                 return;
1476         gl->generateMipmap(target);
1477 }
1478
1479 void glwGenerateTextureMipmap (GLuint texture)
1480 {
1481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1482         if (!gl)
1483                 return;
1484         gl->generateTextureMipmap(texture);
1485 }
1486
1487 void glwGetActiveAtomicCounterBufferiv (GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
1488 {
1489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1490         if (!gl)
1491                 return;
1492         gl->getActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
1493 }
1494
1495 void glwGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
1496 {
1497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1498         if (!gl)
1499                 return;
1500         gl->getActiveAttrib(program, index, bufSize, length, size, type, name);
1501 }
1502
1503 void glwGetActiveSubroutineName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
1504 {
1505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1506         if (!gl)
1507                 return;
1508         gl->getActiveSubroutineName(program, shadertype, index, bufsize, length, name);
1509 }
1510
1511 void glwGetActiveSubroutineUniformName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
1512 {
1513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1514         if (!gl)
1515                 return;
1516         gl->getActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
1517 }
1518
1519 void glwGetActiveSubroutineUniformiv (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
1520 {
1521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1522         if (!gl)
1523                 return;
1524         gl->getActiveSubroutineUniformiv(program, shadertype, index, pname, values);
1525 }
1526
1527 void glwGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
1528 {
1529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1530         if (!gl)
1531                 return;
1532         gl->getActiveUniform(program, index, bufSize, length, size, type, name);
1533 }
1534
1535 void glwGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
1536 {
1537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1538         if (!gl)
1539                 return;
1540         gl->getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
1541 }
1542
1543 void glwGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
1544 {
1545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1546         if (!gl)
1547                 return;
1548         gl->getActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
1549 }
1550
1551 void glwGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
1552 {
1553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1554         if (!gl)
1555                 return;
1556         gl->getActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
1557 }
1558
1559 void glwGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
1560 {
1561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1562         if (!gl)
1563                 return;
1564         gl->getActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
1565 }
1566
1567 void glwGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
1568 {
1569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1570         if (!gl)
1571                 return;
1572         gl->getAttachedShaders(program, maxCount, count, shaders);
1573 }
1574
1575 GLint glwGetAttribLocation (GLuint program, const GLchar *name)
1576 {
1577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1578         if (!gl)
1579                 return (GLint)0;
1580         return gl->getAttribLocation(program, name);
1581 }
1582
1583 void glwGetBooleani_v (GLenum target, GLuint index, GLboolean *data)
1584 {
1585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1586         if (!gl)
1587                 return;
1588         gl->getBooleani_v(target, index, data);
1589 }
1590
1591 void glwGetBooleanv (GLenum pname, GLboolean *data)
1592 {
1593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1594         if (!gl)
1595                 return;
1596         gl->getBooleanv(pname, data);
1597 }
1598
1599 void glwGetBufferParameteri64v (GLenum target, GLenum pname, GLint64 *params)
1600 {
1601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1602         if (!gl)
1603                 return;
1604         gl->getBufferParameteri64v(target, pname, params);
1605 }
1606
1607 void glwGetBufferParameteriv (GLenum target, GLenum pname, GLint *params)
1608 {
1609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1610         if (!gl)
1611                 return;
1612         gl->getBufferParameteriv(target, pname, params);
1613 }
1614
1615 void glwGetBufferPointerv (GLenum target, GLenum pname, void **params)
1616 {
1617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1618         if (!gl)
1619                 return;
1620         gl->getBufferPointerv(target, pname, params);
1621 }
1622
1623 void glwGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, void *data)
1624 {
1625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1626         if (!gl)
1627                 return;
1628         gl->getBufferSubData(target, offset, size, data);
1629 }
1630
1631 void glwGetCompressedTexImage (GLenum target, GLint level, void *img)
1632 {
1633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1634         if (!gl)
1635                 return;
1636         gl->getCompressedTexImage(target, level, img);
1637 }
1638
1639 void glwGetCompressedTextureImage (GLuint texture, GLint level, GLsizei bufSize, void *pixels)
1640 {
1641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1642         if (!gl)
1643                 return;
1644         gl->getCompressedTextureImage(texture, level, bufSize, pixels);
1645 }
1646
1647 void glwGetCompressedTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)
1648 {
1649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1650         if (!gl)
1651                 return;
1652         gl->getCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
1653 }
1654
1655 GLuint glwGetDebugMessageLog (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
1656 {
1657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1658         if (!gl)
1659                 return (GLuint)0;
1660         return gl->getDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
1661 }
1662
1663 void glwGetDoublei_v (GLenum target, GLuint index, GLdouble *data)
1664 {
1665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1666         if (!gl)
1667                 return;
1668         gl->getDoublei_v(target, index, data);
1669 }
1670
1671 void glwGetDoublev (GLenum pname, GLdouble *data)
1672 {
1673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1674         if (!gl)
1675                 return;
1676         gl->getDoublev(pname, data);
1677 }
1678
1679 GLenum glwGetError (void)
1680 {
1681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1682         if (!gl)
1683                 return GL_INVALID_OPERATION;
1684         return gl->getError();
1685 }
1686
1687 void glwGetFloati_v (GLenum target, GLuint index, GLfloat *data)
1688 {
1689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1690         if (!gl)
1691                 return;
1692         gl->getFloati_v(target, index, data);
1693 }
1694
1695 void glwGetFloatv (GLenum pname, GLfloat *data)
1696 {
1697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1698         if (!gl)
1699                 return;
1700         gl->getFloatv(pname, data);
1701 }
1702
1703 GLint glwGetFragDataIndex (GLuint program, const GLchar *name)
1704 {
1705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1706         if (!gl)
1707                 return (GLint)0;
1708         return gl->getFragDataIndex(program, name);
1709 }
1710
1711 GLint glwGetFragDataLocation (GLuint program, const GLchar *name)
1712 {
1713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1714         if (!gl)
1715                 return (GLint)0;
1716         return gl->getFragDataLocation(program, name);
1717 }
1718
1719 void glwGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params)
1720 {
1721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1722         if (!gl)
1723                 return;
1724         gl->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
1725 }
1726
1727 void glwGetFramebufferParameteriv (GLenum target, GLenum pname, GLint *params)
1728 {
1729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1730         if (!gl)
1731                 return;
1732         gl->getFramebufferParameteriv(target, pname, params);
1733 }
1734
1735 GLenum glwGetGraphicsResetStatus (void)
1736 {
1737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1738         if (!gl)
1739                 return (GLenum)0;
1740         return gl->getGraphicsResetStatus();
1741 }
1742
1743 void glwGetInteger64i_v (GLenum target, GLuint index, GLint64 *data)
1744 {
1745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1746         if (!gl)
1747                 return;
1748         gl->getInteger64i_v(target, index, data);
1749 }
1750
1751 void glwGetInteger64v (GLenum pname, GLint64 *data)
1752 {
1753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1754         if (!gl)
1755                 return;
1756         gl->getInteger64v(pname, data);
1757 }
1758
1759 void glwGetIntegeri_v (GLenum target, GLuint index, GLint *data)
1760 {
1761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1762         if (!gl)
1763                 return;
1764         gl->getIntegeri_v(target, index, data);
1765 }
1766
1767 void glwGetIntegerv (GLenum pname, GLint *data)
1768 {
1769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1770         if (!gl)
1771                 return;
1772         gl->getIntegerv(pname, data);
1773 }
1774
1775 void glwGetInternalformati64v (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
1776 {
1777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1778         if (!gl)
1779                 return;
1780         gl->getInternalformati64v(target, internalformat, pname, bufSize, params);
1781 }
1782
1783 void glwGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
1784 {
1785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1786         if (!gl)
1787                 return;
1788         gl->getInternalformativ(target, internalformat, pname, bufSize, params);
1789 }
1790
1791 void glwGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val)
1792 {
1793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1794         if (!gl)
1795                 return;
1796         gl->getMultisamplefv(pname, index, val);
1797 }
1798
1799 void glwGetNamedBufferParameteri64v (GLuint buffer, GLenum pname, GLint64 *params)
1800 {
1801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1802         if (!gl)
1803                 return;
1804         gl->getNamedBufferParameteri64v(buffer, pname, params);
1805 }
1806
1807 void glwGetNamedBufferParameteriv (GLuint buffer, GLenum pname, GLint *params)
1808 {
1809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1810         if (!gl)
1811                 return;
1812         gl->getNamedBufferParameteriv(buffer, pname, params);
1813 }
1814
1815 void glwGetNamedBufferPointerv (GLuint buffer, GLenum pname, void **params)
1816 {
1817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1818         if (!gl)
1819                 return;
1820         gl->getNamedBufferPointerv(buffer, pname, params);
1821 }
1822
1823 void glwGetNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, void *data)
1824 {
1825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1826         if (!gl)
1827                 return;
1828         gl->getNamedBufferSubData(buffer, offset, size, data);
1829 }
1830
1831 void glwGetNamedFramebufferAttachmentParameteriv (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
1832 {
1833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1834         if (!gl)
1835                 return;
1836         gl->getNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
1837 }
1838
1839 void glwGetNamedFramebufferParameteriv (GLuint framebuffer, GLenum pname, GLint *param)
1840 {
1841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1842         if (!gl)
1843                 return;
1844         gl->getNamedFramebufferParameteriv(framebuffer, pname, param);
1845 }
1846
1847 void glwGetNamedRenderbufferParameteriv (GLuint renderbuffer, GLenum pname, GLint *params)
1848 {
1849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1850         if (!gl)
1851                 return;
1852         gl->getNamedRenderbufferParameteriv(renderbuffer, pname, params);
1853 }
1854
1855 void glwGetObjectLabel (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
1856 {
1857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1858         if (!gl)
1859                 return;
1860         gl->getObjectLabel(identifier, name, bufSize, length, label);
1861 }
1862
1863 void glwGetObjectPtrLabel (const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
1864 {
1865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1866         if (!gl)
1867                 return;
1868         gl->getObjectPtrLabel(ptr, bufSize, length, label);
1869 }
1870
1871 void glwGetPointerv (GLenum pname, void **params)
1872 {
1873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1874         if (!gl)
1875                 return;
1876         gl->getPointerv(pname, params);
1877 }
1878
1879 void glwGetProgramBinary (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
1880 {
1881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1882         if (!gl)
1883                 return;
1884         gl->getProgramBinary(program, bufSize, length, binaryFormat, binary);
1885 }
1886
1887 void glwGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
1888 {
1889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1890         if (!gl)
1891                 return;
1892         gl->getProgramInfoLog(program, bufSize, length, infoLog);
1893 }
1894
1895 void glwGetProgramInterfaceiv (GLuint program, GLenum programInterface, GLenum pname, GLint *params)
1896 {
1897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1898         if (!gl)
1899                 return;
1900         gl->getProgramInterfaceiv(program, programInterface, pname, params);
1901 }
1902
1903 void glwGetProgramPipelineInfoLog (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
1904 {
1905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1906         if (!gl)
1907                 return;
1908         gl->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
1909 }
1910
1911 void glwGetProgramPipelineiv (GLuint pipeline, GLenum pname, GLint *params)
1912 {
1913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1914         if (!gl)
1915                 return;
1916         gl->getProgramPipelineiv(pipeline, pname, params);
1917 }
1918
1919 GLuint glwGetProgramResourceIndex (GLuint program, GLenum programInterface, const GLchar *name)
1920 {
1921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1922         if (!gl)
1923                 return (GLuint)0;
1924         return gl->getProgramResourceIndex(program, programInterface, name);
1925 }
1926
1927 GLint glwGetProgramResourceLocation (GLuint program, GLenum programInterface, const GLchar *name)
1928 {
1929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1930         if (!gl)
1931                 return (GLint)0;
1932         return gl->getProgramResourceLocation(program, programInterface, name);
1933 }
1934
1935 GLint glwGetProgramResourceLocationIndex (GLuint program, GLenum programInterface, const GLchar *name)
1936 {
1937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1938         if (!gl)
1939                 return (GLint)0;
1940         return gl->getProgramResourceLocationIndex(program, programInterface, name);
1941 }
1942
1943 void glwGetProgramResourceName (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
1944 {
1945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1946         if (!gl)
1947                 return;
1948         gl->getProgramResourceName(program, programInterface, index, bufSize, length, name);
1949 }
1950
1951 void glwGetProgramResourceiv (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
1952 {
1953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1954         if (!gl)
1955                 return;
1956         gl->getProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
1957 }
1958
1959 void glwGetProgramStageiv (GLuint program, GLenum shadertype, GLenum pname, GLint *values)
1960 {
1961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1962         if (!gl)
1963                 return;
1964         gl->getProgramStageiv(program, shadertype, pname, values);
1965 }
1966
1967 void glwGetProgramiv (GLuint program, GLenum pname, GLint *params)
1968 {
1969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1970         if (!gl)
1971                 return;
1972         gl->getProgramiv(program, pname, params);
1973 }
1974
1975 void glwGetQueryBufferObjecti64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
1976 {
1977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1978         if (!gl)
1979                 return;
1980         gl->getQueryBufferObjecti64v(id, buffer, pname, offset);
1981 }
1982
1983 void glwGetQueryBufferObjectiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
1984 {
1985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1986         if (!gl)
1987                 return;
1988         gl->getQueryBufferObjectiv(id, buffer, pname, offset);
1989 }
1990
1991 void glwGetQueryBufferObjectui64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
1992 {
1993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
1994         if (!gl)
1995                 return;
1996         gl->getQueryBufferObjectui64v(id, buffer, pname, offset);
1997 }
1998
1999 void glwGetQueryBufferObjectuiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
2000 {
2001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2002         if (!gl)
2003                 return;
2004         gl->getQueryBufferObjectuiv(id, buffer, pname, offset);
2005 }
2006
2007 void glwGetQueryIndexediv (GLenum target, GLuint index, GLenum pname, GLint *params)
2008 {
2009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2010         if (!gl)
2011                 return;
2012         gl->getQueryIndexediv(target, index, pname, params);
2013 }
2014
2015 void glwGetQueryObjecti64v (GLuint id, GLenum pname, GLint64 *params)
2016 {
2017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2018         if (!gl)
2019                 return;
2020         gl->getQueryObjecti64v(id, pname, params);
2021 }
2022
2023 void glwGetQueryObjectiv (GLuint id, GLenum pname, GLint *params)
2024 {
2025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2026         if (!gl)
2027                 return;
2028         gl->getQueryObjectiv(id, pname, params);
2029 }
2030
2031 void glwGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64 *params)
2032 {
2033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2034         if (!gl)
2035                 return;
2036         gl->getQueryObjectui64v(id, pname, params);
2037 }
2038
2039 void glwGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params)
2040 {
2041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2042         if (!gl)
2043                 return;
2044         gl->getQueryObjectuiv(id, pname, params);
2045 }
2046
2047 void glwGetQueryiv (GLenum target, GLenum pname, GLint *params)
2048 {
2049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2050         if (!gl)
2051                 return;
2052         gl->getQueryiv(target, pname, params);
2053 }
2054
2055 void glwGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params)
2056 {
2057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2058         if (!gl)
2059                 return;
2060         gl->getRenderbufferParameteriv(target, pname, params);
2061 }
2062
2063 void glwGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint *params)
2064 {
2065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2066         if (!gl)
2067                 return;
2068         gl->getSamplerParameterIiv(sampler, pname, params);
2069 }
2070
2071 void glwGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint *params)
2072 {
2073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2074         if (!gl)
2075                 return;
2076         gl->getSamplerParameterIuiv(sampler, pname, params);
2077 }
2078
2079 void glwGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat *params)
2080 {
2081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2082         if (!gl)
2083                 return;
2084         gl->getSamplerParameterfv(sampler, pname, params);
2085 }
2086
2087 void glwGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint *params)
2088 {
2089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2090         if (!gl)
2091                 return;
2092         gl->getSamplerParameteriv(sampler, pname, params);
2093 }
2094
2095 void glwGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
2096 {
2097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2098         if (!gl)
2099                 return;
2100         gl->getShaderInfoLog(shader, bufSize, length, infoLog);
2101 }
2102
2103 void glwGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
2104 {
2105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2106         if (!gl)
2107                 return;
2108         gl->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
2109 }
2110
2111 void glwGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
2112 {
2113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2114         if (!gl)
2115                 return;
2116         gl->getShaderSource(shader, bufSize, length, source);
2117 }
2118
2119 void glwGetShaderiv (GLuint shader, GLenum pname, GLint *params)
2120 {
2121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2122         if (!gl)
2123                 return;
2124         gl->getShaderiv(shader, pname, params);
2125 }
2126
2127 const GLubyte * glwGetString (GLenum name)
2128 {
2129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2130         if (!gl)
2131                 return (const GLubyte *)0;
2132         return gl->getString(name);
2133 }
2134
2135 const GLubyte * glwGetStringi (GLenum name, GLuint index)
2136 {
2137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2138         if (!gl)
2139                 return (const GLubyte *)0;
2140         return gl->getStringi(name, index);
2141 }
2142
2143 GLuint glwGetSubroutineIndex (GLuint program, GLenum shadertype, const GLchar *name)
2144 {
2145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2146         if (!gl)
2147                 return (GLuint)0;
2148         return gl->getSubroutineIndex(program, shadertype, name);
2149 }
2150
2151 GLint glwGetSubroutineUniformLocation (GLuint program, GLenum shadertype, const GLchar *name)
2152 {
2153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2154         if (!gl)
2155                 return (GLint)0;
2156         return gl->getSubroutineUniformLocation(program, shadertype, name);
2157 }
2158
2159 void glwGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
2160 {
2161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2162         if (!gl)
2163                 return;
2164         gl->getSynciv(sync, pname, bufSize, length, values);
2165 }
2166
2167 void glwGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
2168 {
2169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2170         if (!gl)
2171                 return;
2172         gl->getTexImage(target, level, format, type, pixels);
2173 }
2174
2175 void glwGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params)
2176 {
2177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2178         if (!gl)
2179                 return;
2180         gl->getTexLevelParameterfv(target, level, pname, params);
2181 }
2182
2183 void glwGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params)
2184 {
2185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2186         if (!gl)
2187                 return;
2188         gl->getTexLevelParameteriv(target, level, pname, params);
2189 }
2190
2191 void glwGetTexParameterIiv (GLenum target, GLenum pname, GLint *params)
2192 {
2193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2194         if (!gl)
2195                 return;
2196         gl->getTexParameterIiv(target, pname, params);
2197 }
2198
2199 void glwGetTexParameterIuiv (GLenum target, GLenum pname, GLuint *params)
2200 {
2201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2202         if (!gl)
2203                 return;
2204         gl->getTexParameterIuiv(target, pname, params);
2205 }
2206
2207 void glwGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)
2208 {
2209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2210         if (!gl)
2211                 return;
2212         gl->getTexParameterfv(target, pname, params);
2213 }
2214
2215 void glwGetTexParameteriv (GLenum target, GLenum pname, GLint *params)
2216 {
2217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2218         if (!gl)
2219                 return;
2220         gl->getTexParameteriv(target, pname, params);
2221 }
2222
2223 void glwGetTextureImage (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
2224 {
2225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2226         if (!gl)
2227                 return;
2228         gl->getTextureImage(texture, level, format, type, bufSize, pixels);
2229 }
2230
2231 void glwGetTextureLevelParameterfv (GLuint texture, GLint level, GLenum pname, GLfloat *params)
2232 {
2233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2234         if (!gl)
2235                 return;
2236         gl->getTextureLevelParameterfv(texture, level, pname, params);
2237 }
2238
2239 void glwGetTextureLevelParameteriv (GLuint texture, GLint level, GLenum pname, GLint *params)
2240 {
2241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2242         if (!gl)
2243                 return;
2244         gl->getTextureLevelParameteriv(texture, level, pname, params);
2245 }
2246
2247 void glwGetTextureParameterIiv (GLuint texture, GLenum pname, GLint *params)
2248 {
2249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2250         if (!gl)
2251                 return;
2252         gl->getTextureParameterIiv(texture, pname, params);
2253 }
2254
2255 void glwGetTextureParameterIuiv (GLuint texture, GLenum pname, GLuint *params)
2256 {
2257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2258         if (!gl)
2259                 return;
2260         gl->getTextureParameterIuiv(texture, pname, params);
2261 }
2262
2263 void glwGetTextureParameterfv (GLuint texture, GLenum pname, GLfloat *params)
2264 {
2265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2266         if (!gl)
2267                 return;
2268         gl->getTextureParameterfv(texture, pname, params);
2269 }
2270
2271 void glwGetTextureParameteriv (GLuint texture, GLenum pname, GLint *params)
2272 {
2273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2274         if (!gl)
2275                 return;
2276         gl->getTextureParameteriv(texture, pname, params);
2277 }
2278
2279 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)
2280 {
2281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2282         if (!gl)
2283                 return;
2284         gl->getTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
2285 }
2286
2287 void glwGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
2288 {
2289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2290         if (!gl)
2291                 return;
2292         gl->getTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
2293 }
2294
2295 void glwGetTransformFeedbacki64_v (GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
2296 {
2297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2298         if (!gl)
2299                 return;
2300         gl->getTransformFeedbacki64_v(xfb, pname, index, param);
2301 }
2302
2303 void glwGetTransformFeedbacki_v (GLuint xfb, GLenum pname, GLuint index, GLint *param)
2304 {
2305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2306         if (!gl)
2307                 return;
2308         gl->getTransformFeedbacki_v(xfb, pname, index, param);
2309 }
2310
2311 void glwGetTransformFeedbackiv (GLuint xfb, GLenum pname, GLint *param)
2312 {
2313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2314         if (!gl)
2315                 return;
2316         gl->getTransformFeedbackiv(xfb, pname, param);
2317 }
2318
2319 GLuint glwGetUniformBlockIndex (GLuint program, const GLchar *uniformBlockName)
2320 {
2321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2322         if (!gl)
2323                 return (GLuint)0;
2324         return gl->getUniformBlockIndex(program, uniformBlockName);
2325 }
2326
2327 void glwGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices)
2328 {
2329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2330         if (!gl)
2331                 return;
2332         gl->getUniformIndices(program, uniformCount, uniformNames, uniformIndices);
2333 }
2334
2335 GLint glwGetUniformLocation (GLuint program, const GLchar *name)
2336 {
2337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2338         if (!gl)
2339                 return (GLint)0;
2340         return gl->getUniformLocation(program, name);
2341 }
2342
2343 void glwGetUniformSubroutineuiv (GLenum shadertype, GLint location, GLuint *params)
2344 {
2345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2346         if (!gl)
2347                 return;
2348         gl->getUniformSubroutineuiv(shadertype, location, params);
2349 }
2350
2351 void glwGetUniformdv (GLuint program, GLint location, GLdouble *params)
2352 {
2353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2354         if (!gl)
2355                 return;
2356         gl->getUniformdv(program, location, params);
2357 }
2358
2359 void glwGetUniformfv (GLuint program, GLint location, GLfloat *params)
2360 {
2361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2362         if (!gl)
2363                 return;
2364         gl->getUniformfv(program, location, params);
2365 }
2366
2367 void glwGetUniformiv (GLuint program, GLint location, GLint *params)
2368 {
2369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2370         if (!gl)
2371                 return;
2372         gl->getUniformiv(program, location, params);
2373 }
2374
2375 void glwGetUniformuiv (GLuint program, GLint location, GLuint *params)
2376 {
2377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2378         if (!gl)
2379                 return;
2380         gl->getUniformuiv(program, location, params);
2381 }
2382
2383 void glwGetVertexArrayIndexed64iv (GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)
2384 {
2385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2386         if (!gl)
2387                 return;
2388         gl->getVertexArrayIndexed64iv(vaobj, index, pname, param);
2389 }
2390
2391 void glwGetVertexArrayIndexediv (GLuint vaobj, GLuint index, GLenum pname, GLint *param)
2392 {
2393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2394         if (!gl)
2395                 return;
2396         gl->getVertexArrayIndexediv(vaobj, index, pname, param);
2397 }
2398
2399 void glwGetVertexArrayiv (GLuint vaobj, GLenum pname, GLint *param)
2400 {
2401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2402         if (!gl)
2403                 return;
2404         gl->getVertexArrayiv(vaobj, pname, param);
2405 }
2406
2407 void glwGetVertexAttribIiv (GLuint index, GLenum pname, GLint *params)
2408 {
2409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2410         if (!gl)
2411                 return;
2412         gl->getVertexAttribIiv(index, pname, params);
2413 }
2414
2415 void glwGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint *params)
2416 {
2417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2418         if (!gl)
2419                 return;
2420         gl->getVertexAttribIuiv(index, pname, params);
2421 }
2422
2423 void glwGetVertexAttribLdv (GLuint index, GLenum pname, GLdouble *params)
2424 {
2425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2426         if (!gl)
2427                 return;
2428         gl->getVertexAttribLdv(index, pname, params);
2429 }
2430
2431 void glwGetVertexAttribPointerv (GLuint index, GLenum pname, void **pointer)
2432 {
2433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2434         if (!gl)
2435                 return;
2436         gl->getVertexAttribPointerv(index, pname, pointer);
2437 }
2438
2439 void glwGetVertexAttribdv (GLuint index, GLenum pname, GLdouble *params)
2440 {
2441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2442         if (!gl)
2443                 return;
2444         gl->getVertexAttribdv(index, pname, params);
2445 }
2446
2447 void glwGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params)
2448 {
2449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2450         if (!gl)
2451                 return;
2452         gl->getVertexAttribfv(index, pname, params);
2453 }
2454
2455 void glwGetVertexAttribiv (GLuint index, GLenum pname, GLint *params)
2456 {
2457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2458         if (!gl)
2459                 return;
2460         gl->getVertexAttribiv(index, pname, params);
2461 }
2462
2463 void glwGetnCompressedTexImage (GLenum target, GLint lod, GLsizei bufSize, void *pixels)
2464 {
2465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2466         if (!gl)
2467                 return;
2468         gl->getnCompressedTexImage(target, lod, bufSize, pixels);
2469 }
2470
2471 void glwGetnTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
2472 {
2473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2474         if (!gl)
2475                 return;
2476         gl->getnTexImage(target, level, format, type, bufSize, pixels);
2477 }
2478
2479 void glwGetnUniformdv (GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
2480 {
2481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2482         if (!gl)
2483                 return;
2484         gl->getnUniformdv(program, location, bufSize, params);
2485 }
2486
2487 void glwGetnUniformfv (GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
2488 {
2489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2490         if (!gl)
2491                 return;
2492         gl->getnUniformfv(program, location, bufSize, params);
2493 }
2494
2495 void glwGetnUniformiv (GLuint program, GLint location, GLsizei bufSize, GLint *params)
2496 {
2497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2498         if (!gl)
2499                 return;
2500         gl->getnUniformiv(program, location, bufSize, params);
2501 }
2502
2503 void glwGetnUniformuiv (GLuint program, GLint location, GLsizei bufSize, GLuint *params)
2504 {
2505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2506         if (!gl)
2507                 return;
2508         gl->getnUniformuiv(program, location, bufSize, params);
2509 }
2510
2511 void glwHint (GLenum target, GLenum mode)
2512 {
2513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2514         if (!gl)
2515                 return;
2516         gl->hint(target, mode);
2517 }
2518
2519 void glwInsertEventMarkerEXT (GLsizei length, const GLchar *marker)
2520 {
2521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2522         if (!gl)
2523                 return;
2524         gl->insertEventMarkerEXT(length, marker);
2525 }
2526
2527 void glwInvalidateBufferData (GLuint buffer)
2528 {
2529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2530         if (!gl)
2531                 return;
2532         gl->invalidateBufferData(buffer);
2533 }
2534
2535 void glwInvalidateBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr length)
2536 {
2537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2538         if (!gl)
2539                 return;
2540         gl->invalidateBufferSubData(buffer, offset, length);
2541 }
2542
2543 void glwInvalidateFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments)
2544 {
2545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2546         if (!gl)
2547                 return;
2548         gl->invalidateFramebuffer(target, numAttachments, attachments);
2549 }
2550
2551 void glwInvalidateNamedFramebufferData (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)
2552 {
2553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2554         if (!gl)
2555                 return;
2556         gl->invalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
2557 }
2558
2559 void glwInvalidateNamedFramebufferSubData (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
2560 {
2561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2562         if (!gl)
2563                 return;
2564         gl->invalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
2565 }
2566
2567 void glwInvalidateSubFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
2568 {
2569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2570         if (!gl)
2571                 return;
2572         gl->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
2573 }
2574
2575 void glwInvalidateTexImage (GLuint texture, GLint level)
2576 {
2577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2578         if (!gl)
2579                 return;
2580         gl->invalidateTexImage(texture, level);
2581 }
2582
2583 void glwInvalidateTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
2584 {
2585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2586         if (!gl)
2587                 return;
2588         gl->invalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
2589 }
2590
2591 GLboolean glwIsBuffer (GLuint buffer)
2592 {
2593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2594         if (!gl)
2595                 return (GLboolean)0;
2596         return gl->isBuffer(buffer);
2597 }
2598
2599 GLboolean glwIsEnabled (GLenum cap)
2600 {
2601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2602         if (!gl)
2603                 return (GLboolean)0;
2604         return gl->isEnabled(cap);
2605 }
2606
2607 GLboolean glwIsEnabledi (GLenum target, GLuint index)
2608 {
2609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2610         if (!gl)
2611                 return (GLboolean)0;
2612         return gl->isEnabledi(target, index);
2613 }
2614
2615 GLboolean glwIsFramebuffer (GLuint framebuffer)
2616 {
2617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2618         if (!gl)
2619                 return (GLboolean)0;
2620         return gl->isFramebuffer(framebuffer);
2621 }
2622
2623 GLboolean glwIsProgram (GLuint program)
2624 {
2625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2626         if (!gl)
2627                 return (GLboolean)0;
2628         return gl->isProgram(program);
2629 }
2630
2631 GLboolean glwIsProgramPipeline (GLuint pipeline)
2632 {
2633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2634         if (!gl)
2635                 return (GLboolean)0;
2636         return gl->isProgramPipeline(pipeline);
2637 }
2638
2639 GLboolean glwIsQuery (GLuint id)
2640 {
2641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2642         if (!gl)
2643                 return (GLboolean)0;
2644         return gl->isQuery(id);
2645 }
2646
2647 GLboolean glwIsRenderbuffer (GLuint renderbuffer)
2648 {
2649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2650         if (!gl)
2651                 return (GLboolean)0;
2652         return gl->isRenderbuffer(renderbuffer);
2653 }
2654
2655 GLboolean glwIsSampler (GLuint sampler)
2656 {
2657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2658         if (!gl)
2659                 return (GLboolean)0;
2660         return gl->isSampler(sampler);
2661 }
2662
2663 GLboolean glwIsShader (GLuint shader)
2664 {
2665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2666         if (!gl)
2667                 return (GLboolean)0;
2668         return gl->isShader(shader);
2669 }
2670
2671 GLboolean glwIsSync (GLsync sync)
2672 {
2673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2674         if (!gl)
2675                 return (GLboolean)0;
2676         return gl->isSync(sync);
2677 }
2678
2679 GLboolean glwIsTexture (GLuint texture)
2680 {
2681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2682         if (!gl)
2683                 return (GLboolean)0;
2684         return gl->isTexture(texture);
2685 }
2686
2687 GLboolean glwIsTransformFeedback (GLuint id)
2688 {
2689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2690         if (!gl)
2691                 return (GLboolean)0;
2692         return gl->isTransformFeedback(id);
2693 }
2694
2695 GLboolean glwIsVertexArray (GLuint array)
2696 {
2697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2698         if (!gl)
2699                 return (GLboolean)0;
2700         return gl->isVertexArray(array);
2701 }
2702
2703 void glwLineWidth (GLfloat width)
2704 {
2705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2706         if (!gl)
2707                 return;
2708         gl->lineWidth(width);
2709 }
2710
2711 void glwLinkProgram (GLuint program)
2712 {
2713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2714         if (!gl)
2715                 return;
2716         gl->linkProgram(program);
2717 }
2718
2719 void glwLogicOp (GLenum opcode)
2720 {
2721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2722         if (!gl)
2723                 return;
2724         gl->logicOp(opcode);
2725 }
2726
2727 void * glwMapBuffer (GLenum target, GLenum access)
2728 {
2729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2730         if (!gl)
2731                 return (void *)0;
2732         return gl->mapBuffer(target, access);
2733 }
2734
2735 void * glwMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
2736 {
2737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2738         if (!gl)
2739                 return (void *)0;
2740         return gl->mapBufferRange(target, offset, length, access);
2741 }
2742
2743 void * glwMapNamedBuffer (GLuint buffer, GLenum access)
2744 {
2745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2746         if (!gl)
2747                 return (void *)0;
2748         return gl->mapNamedBuffer(buffer, access);
2749 }
2750
2751 void * glwMapNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access)
2752 {
2753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2754         if (!gl)
2755                 return (void *)0;
2756         return gl->mapNamedBufferRange(buffer, offset, length, access);
2757 }
2758
2759 void glwMemoryBarrier (GLbitfield barriers)
2760 {
2761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2762         if (!gl)
2763                 return;
2764         gl->memoryBarrier(barriers);
2765 }
2766
2767 void glwMemoryBarrierByRegion (GLbitfield barriers)
2768 {
2769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2770         if (!gl)
2771                 return;
2772         gl->memoryBarrierByRegion(barriers);
2773 }
2774
2775 void glwMinSampleShading (GLfloat value)
2776 {
2777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2778         if (!gl)
2779                 return;
2780         gl->minSampleShading(value);
2781 }
2782
2783 void glwMultiDrawArrays (GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
2784 {
2785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2786         if (!gl)
2787                 return;
2788         gl->multiDrawArrays(mode, first, count, drawcount);
2789 }
2790
2791 void glwMultiDrawArraysIndirect (GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
2792 {
2793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2794         if (!gl)
2795                 return;
2796         gl->multiDrawArraysIndirect(mode, indirect, drawcount, stride);
2797 }
2798
2799 void glwMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount)
2800 {
2801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2802         if (!gl)
2803                 return;
2804         gl->multiDrawElements(mode, count, type, indices, drawcount);
2805 }
2806
2807 void glwMultiDrawElementsBaseVertex (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex)
2808 {
2809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2810         if (!gl)
2811                 return;
2812         gl->multiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
2813 }
2814
2815 void glwMultiDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
2816 {
2817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2818         if (!gl)
2819                 return;
2820         gl->multiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
2821 }
2822
2823 void glwNamedBufferData (GLuint buffer, GLsizeiptr size, const void *data, GLenum usage)
2824 {
2825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2826         if (!gl)
2827                 return;
2828         gl->namedBufferData(buffer, size, data, usage);
2829 }
2830
2831 void glwNamedBufferStorage (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)
2832 {
2833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2834         if (!gl)
2835                 return;
2836         gl->namedBufferStorage(buffer, size, data, flags);
2837 }
2838
2839 void glwNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
2840 {
2841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2842         if (!gl)
2843                 return;
2844         gl->namedBufferSubData(buffer, offset, size, data);
2845 }
2846
2847 void glwNamedFramebufferDrawBuffer (GLuint framebuffer, GLenum buf)
2848 {
2849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2850         if (!gl)
2851                 return;
2852         gl->namedFramebufferDrawBuffer(framebuffer, buf);
2853 }
2854
2855 void glwNamedFramebufferDrawBuffers (GLuint framebuffer, GLsizei n, const GLenum *bufs)
2856 {
2857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2858         if (!gl)
2859                 return;
2860         gl->namedFramebufferDrawBuffers(framebuffer, n, bufs);
2861 }
2862
2863 void glwNamedFramebufferParameteri (GLuint framebuffer, GLenum pname, GLint param)
2864 {
2865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2866         if (!gl)
2867                 return;
2868         gl->namedFramebufferParameteri(framebuffer, pname, param);
2869 }
2870
2871 void glwNamedFramebufferReadBuffer (GLuint framebuffer, GLenum src)
2872 {
2873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2874         if (!gl)
2875                 return;
2876         gl->namedFramebufferReadBuffer(framebuffer, src);
2877 }
2878
2879 void glwNamedFramebufferRenderbuffer (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
2880 {
2881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2882         if (!gl)
2883                 return;
2884         gl->namedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
2885 }
2886
2887 void glwNamedFramebufferTexture (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
2888 {
2889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2890         if (!gl)
2891                 return;
2892         gl->namedFramebufferTexture(framebuffer, attachment, texture, level);
2893 }
2894
2895 void glwNamedFramebufferTextureLayer (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
2896 {
2897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2898         if (!gl)
2899                 return;
2900         gl->namedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
2901 }
2902
2903 void glwNamedRenderbufferStorage (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
2904 {
2905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2906         if (!gl)
2907                 return;
2908         gl->namedRenderbufferStorage(renderbuffer, internalformat, width, height);
2909 }
2910
2911 void glwNamedRenderbufferStorageMultisample (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
2912 {
2913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2914         if (!gl)
2915                 return;
2916         gl->namedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
2917 }
2918
2919 void glwObjectLabel (GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
2920 {
2921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2922         if (!gl)
2923                 return;
2924         gl->objectLabel(identifier, name, length, label);
2925 }
2926
2927 void glwObjectPtrLabel (const void *ptr, GLsizei length, const GLchar *label)
2928 {
2929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2930         if (!gl)
2931                 return;
2932         gl->objectPtrLabel(ptr, length, label);
2933 }
2934
2935 void glwPatchParameterfv (GLenum pname, const GLfloat *values)
2936 {
2937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2938         if (!gl)
2939                 return;
2940         gl->patchParameterfv(pname, values);
2941 }
2942
2943 void glwPatchParameteri (GLenum pname, GLint value)
2944 {
2945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2946         if (!gl)
2947                 return;
2948         gl->patchParameteri(pname, value);
2949 }
2950
2951 void glwPauseTransformFeedback (void)
2952 {
2953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2954         if (!gl)
2955                 return;
2956         gl->pauseTransformFeedback();
2957 }
2958
2959 void glwPixelStoref (GLenum pname, GLfloat param)
2960 {
2961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2962         if (!gl)
2963                 return;
2964         gl->pixelStoref(pname, param);
2965 }
2966
2967 void glwPixelStorei (GLenum pname, GLint param)
2968 {
2969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2970         if (!gl)
2971                 return;
2972         gl->pixelStorei(pname, param);
2973 }
2974
2975 void glwPointParameterf (GLenum pname, GLfloat param)
2976 {
2977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2978         if (!gl)
2979                 return;
2980         gl->pointParameterf(pname, param);
2981 }
2982
2983 void glwPointParameterfv (GLenum pname, const GLfloat *params)
2984 {
2985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2986         if (!gl)
2987                 return;
2988         gl->pointParameterfv(pname, params);
2989 }
2990
2991 void glwPointParameteri (GLenum pname, GLint param)
2992 {
2993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
2994         if (!gl)
2995                 return;
2996         gl->pointParameteri(pname, param);
2997 }
2998
2999 void glwPointParameteriv (GLenum pname, const GLint *params)
3000 {
3001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3002         if (!gl)
3003                 return;
3004         gl->pointParameteriv(pname, params);
3005 }
3006
3007 void glwPointSize (GLfloat size)
3008 {
3009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3010         if (!gl)
3011                 return;
3012         gl->pointSize(size);
3013 }
3014
3015 void glwPolygonMode (GLenum face, GLenum mode)
3016 {
3017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3018         if (!gl)
3019                 return;
3020         gl->polygonMode(face, mode);
3021 }
3022
3023 void glwPolygonOffset (GLfloat factor, GLfloat units)
3024 {
3025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3026         if (!gl)
3027                 return;
3028         gl->polygonOffset(factor, units);
3029 }
3030
3031 void glwPopDebugGroup (void)
3032 {
3033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3034         if (!gl)
3035                 return;
3036         gl->popDebugGroup();
3037 }
3038
3039 void glwPopGroupMarkerEXT (void)
3040 {
3041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3042         if (!gl)
3043                 return;
3044         gl->popGroupMarkerEXT();
3045 }
3046
3047 void glwPrimitiveBoundingBox (GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
3048 {
3049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3050         if (!gl)
3051                 return;
3052         gl->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
3053 }
3054
3055 void glwPrimitiveRestartIndex (GLuint index)
3056 {
3057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3058         if (!gl)
3059                 return;
3060         gl->primitiveRestartIndex(index);
3061 }
3062
3063 void glwProgramBinary (GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
3064 {
3065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3066         if (!gl)
3067                 return;
3068         gl->programBinary(program, binaryFormat, binary, length);
3069 }
3070
3071 void glwProgramParameteri (GLuint program, GLenum pname, GLint value)
3072 {
3073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3074         if (!gl)
3075                 return;
3076         gl->programParameteri(program, pname, value);
3077 }
3078
3079 void glwProgramUniform1d (GLuint program, GLint location, GLdouble v0)
3080 {
3081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3082         if (!gl)
3083                 return;
3084         gl->programUniform1d(program, location, v0);
3085 }
3086
3087 void glwProgramUniform1dv (GLuint program, GLint location, GLsizei count, const GLdouble *value)
3088 {
3089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3090         if (!gl)
3091                 return;
3092         gl->programUniform1dv(program, location, count, value);
3093 }
3094
3095 void glwProgramUniform1f (GLuint program, GLint location, GLfloat v0)
3096 {
3097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3098         if (!gl)
3099                 return;
3100         gl->programUniform1f(program, location, v0);
3101 }
3102
3103 void glwProgramUniform1fv (GLuint program, GLint location, GLsizei count, const GLfloat *value)
3104 {
3105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3106         if (!gl)
3107                 return;
3108         gl->programUniform1fv(program, location, count, value);
3109 }
3110
3111 void glwProgramUniform1i (GLuint program, GLint location, GLint v0)
3112 {
3113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3114         if (!gl)
3115                 return;
3116         gl->programUniform1i(program, location, v0);
3117 }
3118
3119 void glwProgramUniform1iv (GLuint program, GLint location, GLsizei count, const GLint *value)
3120 {
3121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3122         if (!gl)
3123                 return;
3124         gl->programUniform1iv(program, location, count, value);
3125 }
3126
3127 void glwProgramUniform1ui (GLuint program, GLint location, GLuint v0)
3128 {
3129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3130         if (!gl)
3131                 return;
3132         gl->programUniform1ui(program, location, v0);
3133 }
3134
3135 void glwProgramUniform1uiv (GLuint program, GLint location, GLsizei count, const GLuint *value)
3136 {
3137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3138         if (!gl)
3139                 return;
3140         gl->programUniform1uiv(program, location, count, value);
3141 }
3142
3143 void glwProgramUniform2d (GLuint program, GLint location, GLdouble v0, GLdouble v1)
3144 {
3145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3146         if (!gl)
3147                 return;
3148         gl->programUniform2d(program, location, v0, v1);
3149 }
3150
3151 void glwProgramUniform2dv (GLuint program, GLint location, GLsizei count, const GLdouble *value)
3152 {
3153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3154         if (!gl)
3155                 return;
3156         gl->programUniform2dv(program, location, count, value);
3157 }
3158
3159 void glwProgramUniform2f (GLuint program, GLint location, GLfloat v0, GLfloat v1)
3160 {
3161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3162         if (!gl)
3163                 return;
3164         gl->programUniform2f(program, location, v0, v1);
3165 }
3166
3167 void glwProgramUniform2fv (GLuint program, GLint location, GLsizei count, const GLfloat *value)
3168 {
3169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3170         if (!gl)
3171                 return;
3172         gl->programUniform2fv(program, location, count, value);
3173 }
3174
3175 void glwProgramUniform2i (GLuint program, GLint location, GLint v0, GLint v1)
3176 {
3177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3178         if (!gl)
3179                 return;
3180         gl->programUniform2i(program, location, v0, v1);
3181 }
3182
3183 void glwProgramUniform2iv (GLuint program, GLint location, GLsizei count, const GLint *value)
3184 {
3185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3186         if (!gl)
3187                 return;
3188         gl->programUniform2iv(program, location, count, value);
3189 }
3190
3191 void glwProgramUniform2ui (GLuint program, GLint location, GLuint v0, GLuint v1)
3192 {
3193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3194         if (!gl)
3195                 return;
3196         gl->programUniform2ui(program, location, v0, v1);
3197 }
3198
3199 void glwProgramUniform2uiv (GLuint program, GLint location, GLsizei count, const GLuint *value)
3200 {
3201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3202         if (!gl)
3203                 return;
3204         gl->programUniform2uiv(program, location, count, value);
3205 }
3206
3207 void glwProgramUniform3d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
3208 {
3209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3210         if (!gl)
3211                 return;
3212         gl->programUniform3d(program, location, v0, v1, v2);
3213 }
3214
3215 void glwProgramUniform3dv (GLuint program, GLint location, GLsizei count, const GLdouble *value)
3216 {
3217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3218         if (!gl)
3219                 return;
3220         gl->programUniform3dv(program, location, count, value);
3221 }
3222
3223 void glwProgramUniform3f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
3224 {
3225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3226         if (!gl)
3227                 return;
3228         gl->programUniform3f(program, location, v0, v1, v2);
3229 }
3230
3231 void glwProgramUniform3fv (GLuint program, GLint location, GLsizei count, const GLfloat *value)
3232 {
3233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3234         if (!gl)
3235                 return;
3236         gl->programUniform3fv(program, location, count, value);
3237 }
3238
3239 void glwProgramUniform3i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
3240 {
3241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3242         if (!gl)
3243                 return;
3244         gl->programUniform3i(program, location, v0, v1, v2);
3245 }
3246
3247 void glwProgramUniform3iv (GLuint program, GLint location, GLsizei count, const GLint *value)
3248 {
3249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3250         if (!gl)
3251                 return;
3252         gl->programUniform3iv(program, location, count, value);
3253 }
3254
3255 void glwProgramUniform3ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
3256 {
3257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3258         if (!gl)
3259                 return;
3260         gl->programUniform3ui(program, location, v0, v1, v2);
3261 }
3262
3263 void glwProgramUniform3uiv (GLuint program, GLint location, GLsizei count, const GLuint *value)
3264 {
3265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3266         if (!gl)
3267                 return;
3268         gl->programUniform3uiv(program, location, count, value);
3269 }
3270
3271 void glwProgramUniform4d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
3272 {
3273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3274         if (!gl)
3275                 return;
3276         gl->programUniform4d(program, location, v0, v1, v2, v3);
3277 }
3278
3279 void glwProgramUniform4dv (GLuint program, GLint location, GLsizei count, const GLdouble *value)
3280 {
3281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3282         if (!gl)
3283                 return;
3284         gl->programUniform4dv(program, location, count, value);
3285 }
3286
3287 void glwProgramUniform4f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
3288 {
3289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3290         if (!gl)
3291                 return;
3292         gl->programUniform4f(program, location, v0, v1, v2, v3);
3293 }
3294
3295 void glwProgramUniform4fv (GLuint program, GLint location, GLsizei count, const GLfloat *value)
3296 {
3297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3298         if (!gl)
3299                 return;
3300         gl->programUniform4fv(program, location, count, value);
3301 }
3302
3303 void glwProgramUniform4i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
3304 {
3305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3306         if (!gl)
3307                 return;
3308         gl->programUniform4i(program, location, v0, v1, v2, v3);
3309 }
3310
3311 void glwProgramUniform4iv (GLuint program, GLint location, GLsizei count, const GLint *value)
3312 {
3313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3314         if (!gl)
3315                 return;
3316         gl->programUniform4iv(program, location, count, value);
3317 }
3318
3319 void glwProgramUniform4ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
3320 {
3321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3322         if (!gl)
3323                 return;
3324         gl->programUniform4ui(program, location, v0, v1, v2, v3);
3325 }
3326
3327 void glwProgramUniform4uiv (GLuint program, GLint location, GLsizei count, const GLuint *value)
3328 {
3329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3330         if (!gl)
3331                 return;
3332         gl->programUniform4uiv(program, location, count, value);
3333 }
3334
3335 void glwProgramUniformMatrix2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3336 {
3337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3338         if (!gl)
3339                 return;
3340         gl->programUniformMatrix2dv(program, location, count, transpose, value);
3341 }
3342
3343 void glwProgramUniformMatrix2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3344 {
3345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3346         if (!gl)
3347                 return;
3348         gl->programUniformMatrix2fv(program, location, count, transpose, value);
3349 }
3350
3351 void glwProgramUniformMatrix2x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3352 {
3353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3354         if (!gl)
3355                 return;
3356         gl->programUniformMatrix2x3dv(program, location, count, transpose, value);
3357 }
3358
3359 void glwProgramUniformMatrix2x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3360 {
3361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3362         if (!gl)
3363                 return;
3364         gl->programUniformMatrix2x3fv(program, location, count, transpose, value);
3365 }
3366
3367 void glwProgramUniformMatrix2x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3368 {
3369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3370         if (!gl)
3371                 return;
3372         gl->programUniformMatrix2x4dv(program, location, count, transpose, value);
3373 }
3374
3375 void glwProgramUniformMatrix2x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3376 {
3377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3378         if (!gl)
3379                 return;
3380         gl->programUniformMatrix2x4fv(program, location, count, transpose, value);
3381 }
3382
3383 void glwProgramUniformMatrix3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3384 {
3385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3386         if (!gl)
3387                 return;
3388         gl->programUniformMatrix3dv(program, location, count, transpose, value);
3389 }
3390
3391 void glwProgramUniformMatrix3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3392 {
3393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3394         if (!gl)
3395                 return;
3396         gl->programUniformMatrix3fv(program, location, count, transpose, value);
3397 }
3398
3399 void glwProgramUniformMatrix3x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3400 {
3401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3402         if (!gl)
3403                 return;
3404         gl->programUniformMatrix3x2dv(program, location, count, transpose, value);
3405 }
3406
3407 void glwProgramUniformMatrix3x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3408 {
3409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3410         if (!gl)
3411                 return;
3412         gl->programUniformMatrix3x2fv(program, location, count, transpose, value);
3413 }
3414
3415 void glwProgramUniformMatrix3x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3416 {
3417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3418         if (!gl)
3419                 return;
3420         gl->programUniformMatrix3x4dv(program, location, count, transpose, value);
3421 }
3422
3423 void glwProgramUniformMatrix3x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3424 {
3425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3426         if (!gl)
3427                 return;
3428         gl->programUniformMatrix3x4fv(program, location, count, transpose, value);
3429 }
3430
3431 void glwProgramUniformMatrix4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3432 {
3433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3434         if (!gl)
3435                 return;
3436         gl->programUniformMatrix4dv(program, location, count, transpose, value);
3437 }
3438
3439 void glwProgramUniformMatrix4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3440 {
3441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3442         if (!gl)
3443                 return;
3444         gl->programUniformMatrix4fv(program, location, count, transpose, value);
3445 }
3446
3447 void glwProgramUniformMatrix4x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3448 {
3449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3450         if (!gl)
3451                 return;
3452         gl->programUniformMatrix4x2dv(program, location, count, transpose, value);
3453 }
3454
3455 void glwProgramUniformMatrix4x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3456 {
3457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3458         if (!gl)
3459                 return;
3460         gl->programUniformMatrix4x2fv(program, location, count, transpose, value);
3461 }
3462
3463 void glwProgramUniformMatrix4x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
3464 {
3465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3466         if (!gl)
3467                 return;
3468         gl->programUniformMatrix4x3dv(program, location, count, transpose, value);
3469 }
3470
3471 void glwProgramUniformMatrix4x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
3472 {
3473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3474         if (!gl)
3475                 return;
3476         gl->programUniformMatrix4x3fv(program, location, count, transpose, value);
3477 }
3478
3479 void glwProvokingVertex (GLenum mode)
3480 {
3481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3482         if (!gl)
3483                 return;
3484         gl->provokingVertex(mode);
3485 }
3486
3487 void glwPushDebugGroup (GLenum source, GLuint id, GLsizei length, const GLchar *message)
3488 {
3489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3490         if (!gl)
3491                 return;
3492         gl->pushDebugGroup(source, id, length, message);
3493 }
3494
3495 void glwPushGroupMarkerEXT (GLsizei length, const GLchar *marker)
3496 {
3497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3498         if (!gl)
3499                 return;
3500         gl->pushGroupMarkerEXT(length, marker);
3501 }
3502
3503 void glwQueryCounter (GLuint id, GLenum target)
3504 {
3505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3506         if (!gl)
3507                 return;
3508         gl->queryCounter(id, target);
3509 }
3510
3511 void glwReadBuffer (GLenum src)
3512 {
3513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3514         if (!gl)
3515                 return;
3516         gl->readBuffer(src);
3517 }
3518
3519 void glwReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
3520 {
3521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3522         if (!gl)
3523                 return;
3524         gl->readPixels(x, y, width, height, format, type, pixels);
3525 }
3526
3527 void glwReadnPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
3528 {
3529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3530         if (!gl)
3531                 return;
3532         gl->readnPixels(x, y, width, height, format, type, bufSize, data);
3533 }
3534
3535 void glwReleaseShaderCompiler (void)
3536 {
3537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3538         if (!gl)
3539                 return;
3540         gl->releaseShaderCompiler();
3541 }
3542
3543 void glwRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
3544 {
3545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3546         if (!gl)
3547                 return;
3548         gl->renderbufferStorage(target, internalformat, width, height);
3549 }
3550
3551 void glwRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
3552 {
3553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3554         if (!gl)
3555                 return;
3556         gl->renderbufferStorageMultisample(target, samples, internalformat, width, height);
3557 }
3558
3559 void glwResumeTransformFeedback (void)
3560 {
3561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3562         if (!gl)
3563                 return;
3564         gl->resumeTransformFeedback();
3565 }
3566
3567 void glwSampleCoverage (GLfloat value, GLboolean invert)
3568 {
3569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3570         if (!gl)
3571                 return;
3572         gl->sampleCoverage(value, invert);
3573 }
3574
3575 void glwSampleMaski (GLuint maskNumber, GLbitfield mask)
3576 {
3577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3578         if (!gl)
3579                 return;
3580         gl->sampleMaski(maskNumber, mask);
3581 }
3582
3583 void glwSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint *param)
3584 {
3585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3586         if (!gl)
3587                 return;
3588         gl->samplerParameterIiv(sampler, pname, param);
3589 }
3590
3591 void glwSamplerParameterIuiv (GLuint sampler, GLenum pname, const GLuint *param)
3592 {
3593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3594         if (!gl)
3595                 return;
3596         gl->samplerParameterIuiv(sampler, pname, param);
3597 }
3598
3599 void glwSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param)
3600 {
3601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3602         if (!gl)
3603                 return;
3604         gl->samplerParameterf(sampler, pname, param);
3605 }
3606
3607 void glwSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat *param)
3608 {
3609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3610         if (!gl)
3611                 return;
3612         gl->samplerParameterfv(sampler, pname, param);
3613 }
3614
3615 void glwSamplerParameteri (GLuint sampler, GLenum pname, GLint param)
3616 {
3617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3618         if (!gl)
3619                 return;
3620         gl->samplerParameteri(sampler, pname, param);
3621 }
3622
3623 void glwSamplerParameteriv (GLuint sampler, GLenum pname, const GLint *param)
3624 {
3625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3626         if (!gl)
3627                 return;
3628         gl->samplerParameteriv(sampler, pname, param);
3629 }
3630
3631 void glwScissor (GLint x, GLint y, GLsizei width, GLsizei height)
3632 {
3633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3634         if (!gl)
3635                 return;
3636         gl->scissor(x, y, width, height);
3637 }
3638
3639 void glwScissorArrayv (GLuint first, GLsizei count, const GLint *v)
3640 {
3641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3642         if (!gl)
3643                 return;
3644         gl->scissorArrayv(first, count, v);
3645 }
3646
3647 void glwScissorIndexed (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
3648 {
3649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3650         if (!gl)
3651                 return;
3652         gl->scissorIndexed(index, left, bottom, width, height);
3653 }
3654
3655 void glwScissorIndexedv (GLuint index, const GLint *v)
3656 {
3657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3658         if (!gl)
3659                 return;
3660         gl->scissorIndexedv(index, v);
3661 }
3662
3663 void glwShaderBinary (GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
3664 {
3665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3666         if (!gl)
3667                 return;
3668         gl->shaderBinary(count, shaders, binaryformat, binary, length);
3669 }
3670
3671 void glwShaderSource (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length)
3672 {
3673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3674         if (!gl)
3675                 return;
3676         gl->shaderSource(shader, count, string, length);
3677 }
3678
3679 void glwShaderStorageBlockBinding (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
3680 {
3681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3682         if (!gl)
3683                 return;
3684         gl->shaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
3685 }
3686
3687 void glwStencilFunc (GLenum func, GLint ref, GLuint mask)
3688 {
3689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3690         if (!gl)
3691                 return;
3692         gl->stencilFunc(func, ref, mask);
3693 }
3694
3695 void glwStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
3696 {
3697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3698         if (!gl)
3699                 return;
3700         gl->stencilFuncSeparate(face, func, ref, mask);
3701 }
3702
3703 void glwStencilMask (GLuint mask)
3704 {
3705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3706         if (!gl)
3707                 return;
3708         gl->stencilMask(mask);
3709 }
3710
3711 void glwStencilMaskSeparate (GLenum face, GLuint mask)
3712 {
3713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3714         if (!gl)
3715                 return;
3716         gl->stencilMaskSeparate(face, mask);
3717 }
3718
3719 void glwStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
3720 {
3721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3722         if (!gl)
3723                 return;
3724         gl->stencilOp(fail, zfail, zpass);
3725 }
3726
3727 void glwStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
3728 {
3729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3730         if (!gl)
3731                 return;
3732         gl->stencilOpSeparate(face, sfail, dpfail, dppass);
3733 }
3734
3735 void glwTexBuffer (GLenum target, GLenum internalformat, GLuint buffer)
3736 {
3737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3738         if (!gl)
3739                 return;
3740         gl->texBuffer(target, internalformat, buffer);
3741 }
3742
3743 void glwTexBufferRange (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
3744 {
3745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3746         if (!gl)
3747                 return;
3748         gl->texBufferRange(target, internalformat, buffer, offset, size);
3749 }
3750
3751 void glwTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
3752 {
3753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3754         if (!gl)
3755                 return;
3756         gl->texImage1D(target, level, internalformat, width, border, format, type, pixels);
3757 }
3758
3759 void glwTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
3760 {
3761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3762         if (!gl)
3763                 return;
3764         gl->texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
3765 }
3766
3767 void glwTexImage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
3768 {
3769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3770         if (!gl)
3771                 return;
3772         gl->texImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
3773 }
3774
3775 void glwTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
3776 {
3777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3778         if (!gl)
3779                 return;
3780         gl->texImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
3781 }
3782
3783 void glwTexImage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
3784 {
3785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3786         if (!gl)
3787                 return;
3788         gl->texImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
3789 }
3790
3791 void glwTexParameterIiv (GLenum target, GLenum pname, const GLint *params)
3792 {
3793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3794         if (!gl)
3795                 return;
3796         gl->texParameterIiv(target, pname, params);
3797 }
3798
3799 void glwTexParameterIuiv (GLenum target, GLenum pname, const GLuint *params)
3800 {
3801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3802         if (!gl)
3803                 return;
3804         gl->texParameterIuiv(target, pname, params);
3805 }
3806
3807 void glwTexParameterf (GLenum target, GLenum pname, GLfloat param)
3808 {
3809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3810         if (!gl)
3811                 return;
3812         gl->texParameterf(target, pname, param);
3813 }
3814
3815 void glwTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)
3816 {
3817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3818         if (!gl)
3819                 return;
3820         gl->texParameterfv(target, pname, params);
3821 }
3822
3823 void glwTexParameteri (GLenum target, GLenum pname, GLint param)
3824 {
3825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3826         if (!gl)
3827                 return;
3828         gl->texParameteri(target, pname, param);
3829 }
3830
3831 void glwTexParameteriv (GLenum target, GLenum pname, const GLint *params)
3832 {
3833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3834         if (!gl)
3835                 return;
3836         gl->texParameteriv(target, pname, params);
3837 }
3838
3839 void glwTexStorage1D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
3840 {
3841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3842         if (!gl)
3843                 return;
3844         gl->texStorage1D(target, levels, internalformat, width);
3845 }
3846
3847 void glwTexStorage2D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
3848 {
3849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3850         if (!gl)
3851                 return;
3852         gl->texStorage2D(target, levels, internalformat, width, height);
3853 }
3854
3855 void glwTexStorage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
3856 {
3857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3858         if (!gl)
3859                 return;
3860         gl->texStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
3861 }
3862
3863 void glwTexStorage3D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
3864 {
3865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3866         if (!gl)
3867                 return;
3868         gl->texStorage3D(target, levels, internalformat, width, height, depth);
3869 }
3870
3871 void glwTexStorage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
3872 {
3873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3874         if (!gl)
3875                 return;
3876         gl->texStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
3877 }
3878
3879 void glwTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
3880 {
3881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3882         if (!gl)
3883                 return;
3884         gl->texSubImage1D(target, level, xoffset, width, format, type, pixels);
3885 }
3886
3887 void glwTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
3888 {
3889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3890         if (!gl)
3891                 return;
3892         gl->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
3893 }
3894
3895 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)
3896 {
3897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3898         if (!gl)
3899                 return;
3900         gl->texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
3901 }
3902
3903 void glwTextureBarrier (void)
3904 {
3905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3906         if (!gl)
3907                 return;
3908         gl->textureBarrier();
3909 }
3910
3911 void glwTextureBuffer (GLuint texture, GLenum internalformat, GLuint buffer)
3912 {
3913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3914         if (!gl)
3915                 return;
3916         gl->textureBuffer(texture, internalformat, buffer);
3917 }
3918
3919 void glwTextureBufferRange (GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
3920 {
3921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3922         if (!gl)
3923                 return;
3924         gl->textureBufferRange(texture, internalformat, buffer, offset, size);
3925 }
3926
3927 void glwTextureParameterIiv (GLuint texture, GLenum pname, const GLint *params)
3928 {
3929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3930         if (!gl)
3931                 return;
3932         gl->textureParameterIiv(texture, pname, params);
3933 }
3934
3935 void glwTextureParameterIuiv (GLuint texture, GLenum pname, const GLuint *params)
3936 {
3937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3938         if (!gl)
3939                 return;
3940         gl->textureParameterIuiv(texture, pname, params);
3941 }
3942
3943 void glwTextureParameterf (GLuint texture, GLenum pname, GLfloat param)
3944 {
3945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3946         if (!gl)
3947                 return;
3948         gl->textureParameterf(texture, pname, param);
3949 }
3950
3951 void glwTextureParameterfv (GLuint texture, GLenum pname, const GLfloat *param)
3952 {
3953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3954         if (!gl)
3955                 return;
3956         gl->textureParameterfv(texture, pname, param);
3957 }
3958
3959 void glwTextureParameteri (GLuint texture, GLenum pname, GLint param)
3960 {
3961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3962         if (!gl)
3963                 return;
3964         gl->textureParameteri(texture, pname, param);
3965 }
3966
3967 void glwTextureParameteriv (GLuint texture, GLenum pname, const GLint *param)
3968 {
3969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3970         if (!gl)
3971                 return;
3972         gl->textureParameteriv(texture, pname, param);
3973 }
3974
3975 void glwTextureStorage1D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
3976 {
3977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3978         if (!gl)
3979                 return;
3980         gl->textureStorage1D(texture, levels, internalformat, width);
3981 }
3982
3983 void glwTextureStorage2D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
3984 {
3985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3986         if (!gl)
3987                 return;
3988         gl->textureStorage2D(texture, levels, internalformat, width, height);
3989 }
3990
3991 void glwTextureStorage2DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
3992 {
3993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
3994         if (!gl)
3995                 return;
3996         gl->textureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
3997 }
3998
3999 void glwTextureStorage3D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
4000 {
4001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4002         if (!gl)
4003                 return;
4004         gl->textureStorage3D(texture, levels, internalformat, width, height, depth);
4005 }
4006
4007 void glwTextureStorage3DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
4008 {
4009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4010         if (!gl)
4011                 return;
4012         gl->textureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
4013 }
4014
4015 void glwTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
4016 {
4017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4018         if (!gl)
4019                 return;
4020         gl->textureSubImage1D(texture, level, xoffset, width, format, type, pixels);
4021 }
4022
4023 void glwTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
4024 {
4025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4026         if (!gl)
4027                 return;
4028         gl->textureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
4029 }
4030
4031 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)
4032 {
4033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4034         if (!gl)
4035                 return;
4036         gl->textureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
4037 }
4038
4039 void glwTextureView (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
4040 {
4041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4042         if (!gl)
4043                 return;
4044         gl->textureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
4045 }
4046
4047 void glwTransformFeedbackBufferBase (GLuint xfb, GLuint index, GLuint buffer)
4048 {
4049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4050         if (!gl)
4051                 return;
4052         gl->transformFeedbackBufferBase(xfb, index, buffer);
4053 }
4054
4055 void glwTransformFeedbackBufferRange (GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
4056 {
4057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4058         if (!gl)
4059                 return;
4060         gl->transformFeedbackBufferRange(xfb, index, buffer, offset, size);
4061 }
4062
4063 void glwTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode)
4064 {
4065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4066         if (!gl)
4067                 return;
4068         gl->transformFeedbackVaryings(program, count, varyings, bufferMode);
4069 }
4070
4071 void glwUniform1d (GLint location, GLdouble x)
4072 {
4073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4074         if (!gl)
4075                 return;
4076         gl->uniform1d(location, x);
4077 }
4078
4079 void glwUniform1dv (GLint location, GLsizei count, const GLdouble *value)
4080 {
4081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4082         if (!gl)
4083                 return;
4084         gl->uniform1dv(location, count, value);
4085 }
4086
4087 void glwUniform1f (GLint location, GLfloat v0)
4088 {
4089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4090         if (!gl)
4091                 return;
4092         gl->uniform1f(location, v0);
4093 }
4094
4095 void glwUniform1fv (GLint location, GLsizei count, const GLfloat *value)
4096 {
4097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4098         if (!gl)
4099                 return;
4100         gl->uniform1fv(location, count, value);
4101 }
4102
4103 void glwUniform1i (GLint location, GLint v0)
4104 {
4105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4106         if (!gl)
4107                 return;
4108         gl->uniform1i(location, v0);
4109 }
4110
4111 void glwUniform1iv (GLint location, GLsizei count, const GLint *value)
4112 {
4113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4114         if (!gl)
4115                 return;
4116         gl->uniform1iv(location, count, value);
4117 }
4118
4119 void glwUniform1ui (GLint location, GLuint v0)
4120 {
4121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4122         if (!gl)
4123                 return;
4124         gl->uniform1ui(location, v0);
4125 }
4126
4127 void glwUniform1uiv (GLint location, GLsizei count, const GLuint *value)
4128 {
4129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4130         if (!gl)
4131                 return;
4132         gl->uniform1uiv(location, count, value);
4133 }
4134
4135 void glwUniform2d (GLint location, GLdouble x, GLdouble y)
4136 {
4137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4138         if (!gl)
4139                 return;
4140         gl->uniform2d(location, x, y);
4141 }
4142
4143 void glwUniform2dv (GLint location, GLsizei count, const GLdouble *value)
4144 {
4145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4146         if (!gl)
4147                 return;
4148         gl->uniform2dv(location, count, value);
4149 }
4150
4151 void glwUniform2f (GLint location, GLfloat v0, GLfloat v1)
4152 {
4153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4154         if (!gl)
4155                 return;
4156         gl->uniform2f(location, v0, v1);
4157 }
4158
4159 void glwUniform2fv (GLint location, GLsizei count, const GLfloat *value)
4160 {
4161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4162         if (!gl)
4163                 return;
4164         gl->uniform2fv(location, count, value);
4165 }
4166
4167 void glwUniform2i (GLint location, GLint v0, GLint v1)
4168 {
4169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4170         if (!gl)
4171                 return;
4172         gl->uniform2i(location, v0, v1);
4173 }
4174
4175 void glwUniform2iv (GLint location, GLsizei count, const GLint *value)
4176 {
4177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4178         if (!gl)
4179                 return;
4180         gl->uniform2iv(location, count, value);
4181 }
4182
4183 void glwUniform2ui (GLint location, GLuint v0, GLuint v1)
4184 {
4185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4186         if (!gl)
4187                 return;
4188         gl->uniform2ui(location, v0, v1);
4189 }
4190
4191 void glwUniform2uiv (GLint location, GLsizei count, const GLuint *value)
4192 {
4193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4194         if (!gl)
4195                 return;
4196         gl->uniform2uiv(location, count, value);
4197 }
4198
4199 void glwUniform3d (GLint location, GLdouble x, GLdouble y, GLdouble z)
4200 {
4201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4202         if (!gl)
4203                 return;
4204         gl->uniform3d(location, x, y, z);
4205 }
4206
4207 void glwUniform3dv (GLint location, GLsizei count, const GLdouble *value)
4208 {
4209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4210         if (!gl)
4211                 return;
4212         gl->uniform3dv(location, count, value);
4213 }
4214
4215 void glwUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
4216 {
4217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4218         if (!gl)
4219                 return;
4220         gl->uniform3f(location, v0, v1, v2);
4221 }
4222
4223 void glwUniform3fv (GLint location, GLsizei count, const GLfloat *value)
4224 {
4225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4226         if (!gl)
4227                 return;
4228         gl->uniform3fv(location, count, value);
4229 }
4230
4231 void glwUniform3i (GLint location, GLint v0, GLint v1, GLint v2)
4232 {
4233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4234         if (!gl)
4235                 return;
4236         gl->uniform3i(location, v0, v1, v2);
4237 }
4238
4239 void glwUniform3iv (GLint location, GLsizei count, const GLint *value)
4240 {
4241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4242         if (!gl)
4243                 return;
4244         gl->uniform3iv(location, count, value);
4245 }
4246
4247 void glwUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2)
4248 {
4249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4250         if (!gl)
4251                 return;
4252         gl->uniform3ui(location, v0, v1, v2);
4253 }
4254
4255 void glwUniform3uiv (GLint location, GLsizei count, const GLuint *value)
4256 {
4257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4258         if (!gl)
4259                 return;
4260         gl->uniform3uiv(location, count, value);
4261 }
4262
4263 void glwUniform4d (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
4264 {
4265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4266         if (!gl)
4267                 return;
4268         gl->uniform4d(location, x, y, z, w);
4269 }
4270
4271 void glwUniform4dv (GLint location, GLsizei count, const GLdouble *value)
4272 {
4273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4274         if (!gl)
4275                 return;
4276         gl->uniform4dv(location, count, value);
4277 }
4278
4279 void glwUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
4280 {
4281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4282         if (!gl)
4283                 return;
4284         gl->uniform4f(location, v0, v1, v2, v3);
4285 }
4286
4287 void glwUniform4fv (GLint location, GLsizei count, const GLfloat *value)
4288 {
4289         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4290         if (!gl)
4291                 return;
4292         gl->uniform4fv(location, count, value);
4293 }
4294
4295 void glwUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
4296 {
4297         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4298         if (!gl)
4299                 return;
4300         gl->uniform4i(location, v0, v1, v2, v3);
4301 }
4302
4303 void glwUniform4iv (GLint location, GLsizei count, const GLint *value)
4304 {
4305         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4306         if (!gl)
4307                 return;
4308         gl->uniform4iv(location, count, value);
4309 }
4310
4311 void glwUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
4312 {
4313         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4314         if (!gl)
4315                 return;
4316         gl->uniform4ui(location, v0, v1, v2, v3);
4317 }
4318
4319 void glwUniform4uiv (GLint location, GLsizei count, const GLuint *value)
4320 {
4321         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4322         if (!gl)
4323                 return;
4324         gl->uniform4uiv(location, count, value);
4325 }
4326
4327 void glwUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
4328 {
4329         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4330         if (!gl)
4331                 return;
4332         gl->uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
4333 }
4334
4335 void glwUniformMatrix2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4336 {
4337         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4338         if (!gl)
4339                 return;
4340         gl->uniformMatrix2dv(location, count, transpose, value);
4341 }
4342
4343 void glwUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4344 {
4345         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4346         if (!gl)
4347                 return;
4348         gl->uniformMatrix2fv(location, count, transpose, value);
4349 }
4350
4351 void glwUniformMatrix2x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4352 {
4353         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4354         if (!gl)
4355                 return;
4356         gl->uniformMatrix2x3dv(location, count, transpose, value);
4357 }
4358
4359 void glwUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4360 {
4361         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4362         if (!gl)
4363                 return;
4364         gl->uniformMatrix2x3fv(location, count, transpose, value);
4365 }
4366
4367 void glwUniformMatrix2x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4368 {
4369         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4370         if (!gl)
4371                 return;
4372         gl->uniformMatrix2x4dv(location, count, transpose, value);
4373 }
4374
4375 void glwUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4376 {
4377         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4378         if (!gl)
4379                 return;
4380         gl->uniformMatrix2x4fv(location, count, transpose, value);
4381 }
4382
4383 void glwUniformMatrix3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4384 {
4385         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4386         if (!gl)
4387                 return;
4388         gl->uniformMatrix3dv(location, count, transpose, value);
4389 }
4390
4391 void glwUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4392 {
4393         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4394         if (!gl)
4395                 return;
4396         gl->uniformMatrix3fv(location, count, transpose, value);
4397 }
4398
4399 void glwUniformMatrix3x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4400 {
4401         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4402         if (!gl)
4403                 return;
4404         gl->uniformMatrix3x2dv(location, count, transpose, value);
4405 }
4406
4407 void glwUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4408 {
4409         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4410         if (!gl)
4411                 return;
4412         gl->uniformMatrix3x2fv(location, count, transpose, value);
4413 }
4414
4415 void glwUniformMatrix3x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4416 {
4417         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4418         if (!gl)
4419                 return;
4420         gl->uniformMatrix3x4dv(location, count, transpose, value);
4421 }
4422
4423 void glwUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4424 {
4425         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4426         if (!gl)
4427                 return;
4428         gl->uniformMatrix3x4fv(location, count, transpose, value);
4429 }
4430
4431 void glwUniformMatrix4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4432 {
4433         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4434         if (!gl)
4435                 return;
4436         gl->uniformMatrix4dv(location, count, transpose, value);
4437 }
4438
4439 void glwUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4440 {
4441         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4442         if (!gl)
4443                 return;
4444         gl->uniformMatrix4fv(location, count, transpose, value);
4445 }
4446
4447 void glwUniformMatrix4x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4448 {
4449         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4450         if (!gl)
4451                 return;
4452         gl->uniformMatrix4x2dv(location, count, transpose, value);
4453 }
4454
4455 void glwUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4456 {
4457         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4458         if (!gl)
4459                 return;
4460         gl->uniformMatrix4x2fv(location, count, transpose, value);
4461 }
4462
4463 void glwUniformMatrix4x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
4464 {
4465         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4466         if (!gl)
4467                 return;
4468         gl->uniformMatrix4x3dv(location, count, transpose, value);
4469 }
4470
4471 void glwUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
4472 {
4473         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4474         if (!gl)
4475                 return;
4476         gl->uniformMatrix4x3fv(location, count, transpose, value);
4477 }
4478
4479 void glwUniformSubroutinesuiv (GLenum shadertype, GLsizei count, const GLuint *indices)
4480 {
4481         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4482         if (!gl)
4483                 return;
4484         gl->uniformSubroutinesuiv(shadertype, count, indices);
4485 }
4486
4487 GLboolean glwUnmapBuffer (GLenum target)
4488 {
4489         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4490         if (!gl)
4491                 return (GLboolean)0;
4492         return gl->unmapBuffer(target);
4493 }
4494
4495 GLboolean glwUnmapNamedBuffer (GLuint buffer)
4496 {
4497         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4498         if (!gl)
4499                 return (GLboolean)0;
4500         return gl->unmapNamedBuffer(buffer);
4501 }
4502
4503 void glwUseProgram (GLuint program)
4504 {
4505         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4506         if (!gl)
4507                 return;
4508         gl->useProgram(program);
4509 }
4510
4511 void glwUseProgramStages (GLuint pipeline, GLbitfield stages, GLuint program)
4512 {
4513         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4514         if (!gl)
4515                 return;
4516         gl->useProgramStages(pipeline, stages, program);
4517 }
4518
4519 void glwValidateProgram (GLuint program)
4520 {
4521         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4522         if (!gl)
4523                 return;
4524         gl->validateProgram(program);
4525 }
4526
4527 void glwValidateProgramPipeline (GLuint pipeline)
4528 {
4529         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4530         if (!gl)
4531                 return;
4532         gl->validateProgramPipeline(pipeline);
4533 }
4534
4535 void glwVertexArrayAttribBinding (GLuint vaobj, GLuint attribindex, GLuint bindingindex)
4536 {
4537         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4538         if (!gl)
4539                 return;
4540         gl->vertexArrayAttribBinding(vaobj, attribindex, bindingindex);
4541 }
4542
4543 void glwVertexArrayAttribFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
4544 {
4545         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4546         if (!gl)
4547                 return;
4548         gl->vertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
4549 }
4550
4551 void glwVertexArrayAttribIFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
4552 {
4553         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4554         if (!gl)
4555                 return;
4556         gl->vertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
4557 }
4558
4559 void glwVertexArrayAttribLFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
4560 {
4561         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4562         if (!gl)
4563                 return;
4564         gl->vertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
4565 }
4566
4567 void glwVertexArrayBindingDivisor (GLuint vaobj, GLuint bindingindex, GLuint divisor)
4568 {
4569         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4570         if (!gl)
4571                 return;
4572         gl->vertexArrayBindingDivisor(vaobj, bindingindex, divisor);
4573 }
4574
4575 void glwVertexArrayElementBuffer (GLuint vaobj, GLuint buffer)
4576 {
4577         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4578         if (!gl)
4579                 return;
4580         gl->vertexArrayElementBuffer(vaobj, buffer);
4581 }
4582
4583 void glwVertexArrayVertexBuffer (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
4584 {
4585         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4586         if (!gl)
4587                 return;
4588         gl->vertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
4589 }
4590
4591 void glwVertexArrayVertexBuffers (GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
4592 {
4593         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4594         if (!gl)
4595                 return;
4596         gl->vertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
4597 }
4598
4599 void glwVertexAttrib1d (GLuint index, GLdouble x)
4600 {
4601         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4602         if (!gl)
4603                 return;
4604         gl->vertexAttrib1d(index, x);
4605 }
4606
4607 void glwVertexAttrib1dv (GLuint index, const GLdouble *v)
4608 {
4609         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4610         if (!gl)
4611                 return;
4612         gl->vertexAttrib1dv(index, v);
4613 }
4614
4615 void glwVertexAttrib1f (GLuint index, GLfloat x)
4616 {
4617         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4618         if (!gl)
4619                 return;
4620         gl->vertexAttrib1f(index, x);
4621 }
4622
4623 void glwVertexAttrib1fv (GLuint index, const GLfloat *v)
4624 {
4625         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4626         if (!gl)
4627                 return;
4628         gl->vertexAttrib1fv(index, v);
4629 }
4630
4631 void glwVertexAttrib1s (GLuint index, GLshort x)
4632 {
4633         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4634         if (!gl)
4635                 return;
4636         gl->vertexAttrib1s(index, x);
4637 }
4638
4639 void glwVertexAttrib1sv (GLuint index, const GLshort *v)
4640 {
4641         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4642         if (!gl)
4643                 return;
4644         gl->vertexAttrib1sv(index, v);
4645 }
4646
4647 void glwVertexAttrib2d (GLuint index, GLdouble x, GLdouble y)
4648 {
4649         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4650         if (!gl)
4651                 return;
4652         gl->vertexAttrib2d(index, x, y);
4653 }
4654
4655 void glwVertexAttrib2dv (GLuint index, const GLdouble *v)
4656 {
4657         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4658         if (!gl)
4659                 return;
4660         gl->vertexAttrib2dv(index, v);
4661 }
4662
4663 void glwVertexAttrib2f (GLuint index, GLfloat x, GLfloat y)
4664 {
4665         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4666         if (!gl)
4667                 return;
4668         gl->vertexAttrib2f(index, x, y);
4669 }
4670
4671 void glwVertexAttrib2fv (GLuint index, const GLfloat *v)
4672 {
4673         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4674         if (!gl)
4675                 return;
4676         gl->vertexAttrib2fv(index, v);
4677 }
4678
4679 void glwVertexAttrib2s (GLuint index, GLshort x, GLshort y)
4680 {
4681         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4682         if (!gl)
4683                 return;
4684         gl->vertexAttrib2s(index, x, y);
4685 }
4686
4687 void glwVertexAttrib2sv (GLuint index, const GLshort *v)
4688 {
4689         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4690         if (!gl)
4691                 return;
4692         gl->vertexAttrib2sv(index, v);
4693 }
4694
4695 void glwVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)
4696 {
4697         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4698         if (!gl)
4699                 return;
4700         gl->vertexAttrib3d(index, x, y, z);
4701 }
4702
4703 void glwVertexAttrib3dv (GLuint index, const GLdouble *v)
4704 {
4705         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4706         if (!gl)
4707                 return;
4708         gl->vertexAttrib3dv(index, v);
4709 }
4710
4711 void glwVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z)
4712 {
4713         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4714         if (!gl)
4715                 return;
4716         gl->vertexAttrib3f(index, x, y, z);
4717 }
4718
4719 void glwVertexAttrib3fv (GLuint index, const GLfloat *v)
4720 {
4721         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4722         if (!gl)
4723                 return;
4724         gl->vertexAttrib3fv(index, v);
4725 }
4726
4727 void glwVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z)
4728 {
4729         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4730         if (!gl)
4731                 return;
4732         gl->vertexAttrib3s(index, x, y, z);
4733 }
4734
4735 void glwVertexAttrib3sv (GLuint index, const GLshort *v)
4736 {
4737         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4738         if (!gl)
4739                 return;
4740         gl->vertexAttrib3sv(index, v);
4741 }
4742
4743 void glwVertexAttrib4Nbv (GLuint index, const GLbyte *v)
4744 {
4745         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4746         if (!gl)
4747                 return;
4748         gl->vertexAttrib4Nbv(index, v);
4749 }
4750
4751 void glwVertexAttrib4Niv (GLuint index, const GLint *v)
4752 {
4753         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4754         if (!gl)
4755                 return;
4756         gl->vertexAttrib4Niv(index, v);
4757 }
4758
4759 void glwVertexAttrib4Nsv (GLuint index, const GLshort *v)
4760 {
4761         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4762         if (!gl)
4763                 return;
4764         gl->vertexAttrib4Nsv(index, v);
4765 }
4766
4767 void glwVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
4768 {
4769         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4770         if (!gl)
4771                 return;
4772         gl->vertexAttrib4Nub(index, x, y, z, w);
4773 }
4774
4775 void glwVertexAttrib4Nubv (GLuint index, const GLubyte *v)
4776 {
4777         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4778         if (!gl)
4779                 return;
4780         gl->vertexAttrib4Nubv(index, v);
4781 }
4782
4783 void glwVertexAttrib4Nuiv (GLuint index, const GLuint *v)
4784 {
4785         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4786         if (!gl)
4787                 return;
4788         gl->vertexAttrib4Nuiv(index, v);
4789 }
4790
4791 void glwVertexAttrib4Nusv (GLuint index, const GLushort *v)
4792 {
4793         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4794         if (!gl)
4795                 return;
4796         gl->vertexAttrib4Nusv(index, v);
4797 }
4798
4799 void glwVertexAttrib4bv (GLuint index, const GLbyte *v)
4800 {
4801         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4802         if (!gl)
4803                 return;
4804         gl->vertexAttrib4bv(index, v);
4805 }
4806
4807 void glwVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
4808 {
4809         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4810         if (!gl)
4811                 return;
4812         gl->vertexAttrib4d(index, x, y, z, w);
4813 }
4814
4815 void glwVertexAttrib4dv (GLuint index, const GLdouble *v)
4816 {
4817         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4818         if (!gl)
4819                 return;
4820         gl->vertexAttrib4dv(index, v);
4821 }
4822
4823 void glwVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4824 {
4825         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4826         if (!gl)
4827                 return;
4828         gl->vertexAttrib4f(index, x, y, z, w);
4829 }
4830
4831 void glwVertexAttrib4fv (GLuint index, const GLfloat *v)
4832 {
4833         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4834         if (!gl)
4835                 return;
4836         gl->vertexAttrib4fv(index, v);
4837 }
4838
4839 void glwVertexAttrib4iv (GLuint index, const GLint *v)
4840 {
4841         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4842         if (!gl)
4843                 return;
4844         gl->vertexAttrib4iv(index, v);
4845 }
4846
4847 void glwVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
4848 {
4849         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4850         if (!gl)
4851                 return;
4852         gl->vertexAttrib4s(index, x, y, z, w);
4853 }
4854
4855 void glwVertexAttrib4sv (GLuint index, const GLshort *v)
4856 {
4857         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4858         if (!gl)
4859                 return;
4860         gl->vertexAttrib4sv(index, v);
4861 }
4862
4863 void glwVertexAttrib4ubv (GLuint index, const GLubyte *v)
4864 {
4865         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4866         if (!gl)
4867                 return;
4868         gl->vertexAttrib4ubv(index, v);
4869 }
4870
4871 void glwVertexAttrib4uiv (GLuint index, const GLuint *v)
4872 {
4873         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4874         if (!gl)
4875                 return;
4876         gl->vertexAttrib4uiv(index, v);
4877 }
4878
4879 void glwVertexAttrib4usv (GLuint index, const GLushort *v)
4880 {
4881         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4882         if (!gl)
4883                 return;
4884         gl->vertexAttrib4usv(index, v);
4885 }
4886
4887 void glwVertexAttribBinding (GLuint attribindex, GLuint bindingindex)
4888 {
4889         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4890         if (!gl)
4891                 return;
4892         gl->vertexAttribBinding(attribindex, bindingindex);
4893 }
4894
4895 void glwVertexAttribDivisor (GLuint index, GLuint divisor)
4896 {
4897         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4898         if (!gl)
4899                 return;
4900         gl->vertexAttribDivisor(index, divisor);
4901 }
4902
4903 void glwVertexAttribFormat (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
4904 {
4905         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4906         if (!gl)
4907                 return;
4908         gl->vertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
4909 }
4910
4911 void glwVertexAttribI1i (GLuint index, GLint x)
4912 {
4913         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4914         if (!gl)
4915                 return;
4916         gl->vertexAttribI1i(index, x);
4917 }
4918
4919 void glwVertexAttribI1iv (GLuint index, const GLint *v)
4920 {
4921         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4922         if (!gl)
4923                 return;
4924         gl->vertexAttribI1iv(index, v);
4925 }
4926
4927 void glwVertexAttribI1ui (GLuint index, GLuint x)
4928 {
4929         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4930         if (!gl)
4931                 return;
4932         gl->vertexAttribI1ui(index, x);
4933 }
4934
4935 void glwVertexAttribI1uiv (GLuint index, const GLuint *v)
4936 {
4937         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4938         if (!gl)
4939                 return;
4940         gl->vertexAttribI1uiv(index, v);
4941 }
4942
4943 void glwVertexAttribI2i (GLuint index, GLint x, GLint y)
4944 {
4945         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4946         if (!gl)
4947                 return;
4948         gl->vertexAttribI2i(index, x, y);
4949 }
4950
4951 void glwVertexAttribI2iv (GLuint index, const GLint *v)
4952 {
4953         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4954         if (!gl)
4955                 return;
4956         gl->vertexAttribI2iv(index, v);
4957 }
4958
4959 void glwVertexAttribI2ui (GLuint index, GLuint x, GLuint y)
4960 {
4961         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4962         if (!gl)
4963                 return;
4964         gl->vertexAttribI2ui(index, x, y);
4965 }
4966
4967 void glwVertexAttribI2uiv (GLuint index, const GLuint *v)
4968 {
4969         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4970         if (!gl)
4971                 return;
4972         gl->vertexAttribI2uiv(index, v);
4973 }
4974
4975 void glwVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z)
4976 {
4977         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4978         if (!gl)
4979                 return;
4980         gl->vertexAttribI3i(index, x, y, z);
4981 }
4982
4983 void glwVertexAttribI3iv (GLuint index, const GLint *v)
4984 {
4985         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4986         if (!gl)
4987                 return;
4988         gl->vertexAttribI3iv(index, v);
4989 }
4990
4991 void glwVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z)
4992 {
4993         const glw::Functions* gl = glw::getCurrentThreadFunctions();
4994         if (!gl)
4995                 return;
4996         gl->vertexAttribI3ui(index, x, y, z);
4997 }
4998
4999 void glwVertexAttribI3uiv (GLuint index, const GLuint *v)
5000 {
5001         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5002         if (!gl)
5003                 return;
5004         gl->vertexAttribI3uiv(index, v);
5005 }
5006
5007 void glwVertexAttribI4bv (GLuint index, const GLbyte *v)
5008 {
5009         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5010         if (!gl)
5011                 return;
5012         gl->vertexAttribI4bv(index, v);
5013 }
5014
5015 void glwVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w)
5016 {
5017         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5018         if (!gl)
5019                 return;
5020         gl->vertexAttribI4i(index, x, y, z, w);
5021 }
5022
5023 void glwVertexAttribI4iv (GLuint index, const GLint *v)
5024 {
5025         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5026         if (!gl)
5027                 return;
5028         gl->vertexAttribI4iv(index, v);
5029 }
5030
5031 void glwVertexAttribI4sv (GLuint index, const GLshort *v)
5032 {
5033         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5034         if (!gl)
5035                 return;
5036         gl->vertexAttribI4sv(index, v);
5037 }
5038
5039 void glwVertexAttribI4ubv (GLuint index, const GLubyte *v)
5040 {
5041         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5042         if (!gl)
5043                 return;
5044         gl->vertexAttribI4ubv(index, v);
5045 }
5046
5047 void glwVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
5048 {
5049         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5050         if (!gl)
5051                 return;
5052         gl->vertexAttribI4ui(index, x, y, z, w);
5053 }
5054
5055 void glwVertexAttribI4uiv (GLuint index, const GLuint *v)
5056 {
5057         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5058         if (!gl)
5059                 return;
5060         gl->vertexAttribI4uiv(index, v);
5061 }
5062
5063 void glwVertexAttribI4usv (GLuint index, const GLushort *v)
5064 {
5065         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5066         if (!gl)
5067                 return;
5068         gl->vertexAttribI4usv(index, v);
5069 }
5070
5071 void glwVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
5072 {
5073         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5074         if (!gl)
5075                 return;
5076         gl->vertexAttribIFormat(attribindex, size, type, relativeoffset);
5077 }
5078
5079 void glwVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
5080 {
5081         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5082         if (!gl)
5083                 return;
5084         gl->vertexAttribIPointer(index, size, type, stride, pointer);
5085 }
5086
5087 void glwVertexAttribL1d (GLuint index, GLdouble x)
5088 {
5089         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5090         if (!gl)
5091                 return;
5092         gl->vertexAttribL1d(index, x);
5093 }
5094
5095 void glwVertexAttribL1dv (GLuint index, const GLdouble *v)
5096 {
5097         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5098         if (!gl)
5099                 return;
5100         gl->vertexAttribL1dv(index, v);
5101 }
5102
5103 void glwVertexAttribL2d (GLuint index, GLdouble x, GLdouble y)
5104 {
5105         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5106         if (!gl)
5107                 return;
5108         gl->vertexAttribL2d(index, x, y);
5109 }
5110
5111 void glwVertexAttribL2dv (GLuint index, const GLdouble *v)
5112 {
5113         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5114         if (!gl)
5115                 return;
5116         gl->vertexAttribL2dv(index, v);
5117 }
5118
5119 void glwVertexAttribL3d (GLuint index, GLdouble x, GLdouble y, GLdouble z)
5120 {
5121         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5122         if (!gl)
5123                 return;
5124         gl->vertexAttribL3d(index, x, y, z);
5125 }
5126
5127 void glwVertexAttribL3dv (GLuint index, const GLdouble *v)
5128 {
5129         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5130         if (!gl)
5131                 return;
5132         gl->vertexAttribL3dv(index, v);
5133 }
5134
5135 void glwVertexAttribL4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
5136 {
5137         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5138         if (!gl)
5139                 return;
5140         gl->vertexAttribL4d(index, x, y, z, w);
5141 }
5142
5143 void glwVertexAttribL4dv (GLuint index, const GLdouble *v)
5144 {
5145         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5146         if (!gl)
5147                 return;
5148         gl->vertexAttribL4dv(index, v);
5149 }
5150
5151 void glwVertexAttribLFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
5152 {
5153         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5154         if (!gl)
5155                 return;
5156         gl->vertexAttribLFormat(attribindex, size, type, relativeoffset);
5157 }
5158
5159 void glwVertexAttribLPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
5160 {
5161         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5162         if (!gl)
5163                 return;
5164         gl->vertexAttribLPointer(index, size, type, stride, pointer);
5165 }
5166
5167 void glwVertexAttribP1ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
5168 {
5169         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5170         if (!gl)
5171                 return;
5172         gl->vertexAttribP1ui(index, type, normalized, value);
5173 }
5174
5175 void glwVertexAttribP1uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
5176 {
5177         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5178         if (!gl)
5179                 return;
5180         gl->vertexAttribP1uiv(index, type, normalized, value);
5181 }
5182
5183 void glwVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
5184 {
5185         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5186         if (!gl)
5187                 return;
5188         gl->vertexAttribP2ui(index, type, normalized, value);
5189 }
5190
5191 void glwVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
5192 {
5193         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5194         if (!gl)
5195                 return;
5196         gl->vertexAttribP2uiv(index, type, normalized, value);
5197 }
5198
5199 void glwVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
5200 {
5201         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5202         if (!gl)
5203                 return;
5204         gl->vertexAttribP3ui(index, type, normalized, value);
5205 }
5206
5207 void glwVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
5208 {
5209         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5210         if (!gl)
5211                 return;
5212         gl->vertexAttribP3uiv(index, type, normalized, value);
5213 }
5214
5215 void glwVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value)
5216 {
5217         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5218         if (!gl)
5219                 return;
5220         gl->vertexAttribP4ui(index, type, normalized, value);
5221 }
5222
5223 void glwVertexAttribP4uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
5224 {
5225         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5226         if (!gl)
5227                 return;
5228         gl->vertexAttribP4uiv(index, type, normalized, value);
5229 }
5230
5231 void glwVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
5232 {
5233         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5234         if (!gl)
5235                 return;
5236         gl->vertexAttribPointer(index, size, type, normalized, stride, pointer);
5237 }
5238
5239 void glwVertexBindingDivisor (GLuint bindingindex, GLuint divisor)
5240 {
5241         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5242         if (!gl)
5243                 return;
5244         gl->vertexBindingDivisor(bindingindex, divisor);
5245 }
5246
5247 void glwViewport (GLint x, GLint y, GLsizei width, GLsizei height)
5248 {
5249         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5250         if (!gl)
5251                 return;
5252         gl->viewport(x, y, width, height);
5253 }
5254
5255 void glwViewportArrayv (GLuint first, GLsizei count, const GLfloat *v)
5256 {
5257         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5258         if (!gl)
5259                 return;
5260         gl->viewportArrayv(first, count, v);
5261 }
5262
5263 void glwViewportIndexedf (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
5264 {
5265         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5266         if (!gl)
5267                 return;
5268         gl->viewportIndexedf(index, x, y, w, h);
5269 }
5270
5271 void glwViewportIndexedfv (GLuint index, const GLfloat *v)
5272 {
5273         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5274         if (!gl)
5275                 return;
5276         gl->viewportIndexedfv(index, v);
5277 }
5278
5279 void glwWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout)
5280 {
5281         const glw::Functions* gl = glw::getCurrentThreadFunctions();
5282         if (!gl)
5283                 return;
5284         gl->waitSync(sync, flags, timeout);
5285 }