src/third_party/angle/src/libGLESv2/libGLESv2.cpp

   1 #include "precompiled.h"
   2 //
   3 // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style license that can be
   5 // found in the LICENSE file.
   6 //
   7
   8 // libGLESv2.cpp: Implements the exported OpenGL ES 2.0 functions.
   9
  10 #include "common/version.h"
  11
  12 #include "libGLESv2/main.h"
  13 #include "common/utilities.h"
  14 #include "libGLESv2/formatutils.h"
  15 #include "libGLESv2/Buffer.h"
  16 #include "libGLESv2/Fence.h"
  17 #include "libGLESv2/Framebuffer.h"
  18 #include "libGLESv2/Renderbuffer.h"
  19 #include "libGLESv2/Program.h"
  20 #include "libGLESv2/ProgramBinary.h"
  21 #include "libGLESv2/Texture.h"
  22 #include "libGLESv2/Query.h"
  23 #include "libGLESv2/Context.h"
  24 #include "libGLESv2/VertexArray.h"
  25 #include "libGLESv2/TransformFeedback.h"
  26
  27 #include "libGLESv2/validationES.h"
  28 #include "libGLESv2/validationES2.h"
  29 #include "libGLESv2/validationES3.h"
  30 #include "libGLESv2/queryconversions.h"
  31
  32 extern "C"
  33 {
  34
  35 // OpenGL ES 2.0 functions
  36
  37 void __stdcall glActiveTexture(GLenum texture)
  38 {
  39     EVENT("(GLenum texture = 0x%X)", texture);
  40
  41     try
  42     {
  43         gl::Context *context = gl::getNonLostContext();
  44
  45         if (context)
  46         {
  47             if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + context->getMaximumCombinedTextureImageUnits() - 1)
  48             {
  49                 return gl::error(GL_INVALID_ENUM);
  50             }
  51
  52             context->setActiveSampler(texture - GL_TEXTURE0);
  53         }
  54     }
  55     catch (...)
  56     {
  57         return gl::error(GL_OUT_OF_MEMORY);
  58     }
  59 }
  60
  61 void __stdcall glAttachShader(GLuint program, GLuint shader)
  62 {
  63     EVENT("(GLuint program = %d, GLuint shader = %d)", program, shader);
  64
  65     try
  66     {
  67         gl::Context *context = gl::getNonLostContext();
  68
  69         if (context)
  70         {
  71             gl::Program *programObject = context->getProgram(program);
  72             gl::Shader *shaderObject = context->getShader(shader);
  73
  74             if (!programObject)
  75             {
  76                 if (context->getShader(program))
  77                 {
  78                     return gl::error(GL_INVALID_OPERATION);
  79                 }
  80                 else
  81                 {
  82                     return gl::error(GL_INVALID_VALUE);
  83                 }
  84             }
  85
  86             if (!shaderObject)
  87             {
  88                 if (context->getProgram(shader))
  89                 {
  90                     return gl::error(GL_INVALID_OPERATION);
  91                 }
  92                 else
  93                 {
  94                     return gl::error(GL_INVALID_VALUE);
  95                 }
  96             }
  97
  98             if (!programObject->attachShader(shaderObject))
  99             {
 100                 return gl::error(GL_INVALID_OPERATION);
 101             }
 102         }
 103     }
 104     catch (...)
 105     {
 106         return gl::error(GL_OUT_OF_MEMORY);
 107     }
 108 }
 109
 110 void __stdcall glBeginQueryEXT(GLenum target, GLuint id)
 111 {
 112     EVENT("(GLenum target = 0x%X, GLuint %d)", target, id);
 113
 114     try
 115     {
 116         gl::Context *context = gl::getNonLostContext();
 117
 118         if (context)
 119         {
 120             if (!ValidateBeginQuery(context, target, id))
 121             {
 122                 return;
 123             }
 124
 125             context->beginQuery(target, id);
 126         }
 127     }
 128     catch (...)
 129     {
 130         return gl::error(GL_OUT_OF_MEMORY);
 131     }
 132 }
 133
 134 void __stdcall glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
 135 {
 136     EVENT("(GLuint program = %d, GLuint index = %d, const GLchar* name = 0x%0.8p)", program, index, name);
 137
 138     try
 139     {
 140         if (index >= gl::MAX_VERTEX_ATTRIBS)
 141         {
 142             return gl::error(GL_INVALID_VALUE);
 143         }
 144
 145         gl::Context *context = gl::getNonLostContext();
 146
 147         if (context)
 148         {
 149             gl::Program *programObject = context->getProgram(program);
 150
 151             if (!programObject)
 152             {
 153                 if (context->getShader(program))
 154                 {
 155                     return gl::error(GL_INVALID_OPERATION);
 156                 }
 157                 else
 158                 {
 159                     return gl::error(GL_INVALID_VALUE);
 160                 }
 161             }
 162
 163             if (strncmp(name, "gl_", 3) == 0)
 164             {
 165                 return gl::error(GL_INVALID_OPERATION);
 166             }
 167
 168             programObject->bindAttributeLocation(index, name);
 169         }
 170     }
 171     catch (...)
 172     {
 173         return gl::error(GL_OUT_OF_MEMORY);
 174     }
 175 }
 176
 177 void __stdcall glBindBuffer(GLenum target, GLuint buffer)
 178 {
 179     EVENT("(GLenum target = 0x%X, GLuint buffer = %d)", target, buffer);
 180
 181     try
 182     {
 183         gl::Context *context = gl::getNonLostContext();
 184
 185         if (context)
 186         {
 187             if (!gl::ValidBufferTarget(context, target))
 188             {
 189                 return gl::error(GL_INVALID_ENUM);
 190             }
 191
 192             switch (target)
 193             {
 194               case GL_ARRAY_BUFFER:
 195                 context->bindArrayBuffer(buffer);
 196                 return;
 197               case GL_ELEMENT_ARRAY_BUFFER:
 198                 context->bindElementArrayBuffer(buffer);
 199                 return;
 200               case GL_COPY_READ_BUFFER:
 201                 context->bindCopyReadBuffer(buffer);
 202                 return;
 203               case GL_COPY_WRITE_BUFFER:
 204                 context->bindCopyWriteBuffer(buffer);
 205                 return;
 206               case GL_PIXEL_PACK_BUFFER:
 207                 context->bindPixelPackBuffer(buffer);
 208                 return;
 209               case GL_PIXEL_UNPACK_BUFFER:
 210                 context->bindPixelUnpackBuffer(buffer);
 211                 return;
 212               case GL_UNIFORM_BUFFER:
 213                 context->bindGenericUniformBuffer(buffer);
 214                 return;
 215               case GL_TRANSFORM_FEEDBACK_BUFFER:
 216                 context->bindGenericTransformFeedbackBuffer(buffer);
 217                 return;
 218               default:
 219                 return gl::error(GL_INVALID_ENUM);
 220             }
 221         }
 222     }
 223     catch (...)
 224     {
 225         return gl::error(GL_OUT_OF_MEMORY);
 226     }
 227 }
 228
 229 void __stdcall glBindFramebuffer(GLenum target, GLuint framebuffer)
 230 {
 231     EVENT("(GLenum target = 0x%X, GLuint framebuffer = %d)", target, framebuffer);
 232
 233     try
 234     {
 235         if (!gl::ValidFramebufferTarget(target))
 236         {
 237             return gl::error(GL_INVALID_ENUM);
 238         }
 239
 240         gl::Context *context = gl::getNonLostContext();
 241
 242         if (context)
 243         {
 244             if (target == GL_READ_FRAMEBUFFER_ANGLE || target == GL_FRAMEBUFFER)
 245             {
 246                 context->bindReadFramebuffer(framebuffer);
 247             }
 248
 249             if (target == GL_DRAW_FRAMEBUFFER_ANGLE || target == GL_FRAMEBUFFER)
 250             {
 251                 context->bindDrawFramebuffer(framebuffer);
 252             }
 253         }
 254     }
 255     catch (...)
 256     {
 257         return gl::error(GL_OUT_OF_MEMORY);
 258     }
 259 }
 260
 261 void __stdcall glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 262 {
 263     EVENT("(GLenum target = 0x%X, GLuint renderbuffer = %d)", target, renderbuffer);
 264
 265     try
 266     {
 267         if (target != GL_RENDERBUFFER)
 268         {
 269             return gl::error(GL_INVALID_ENUM);
 270         }
 271
 272         gl::Context *context = gl::getNonLostContext();
 273
 274         if (context)
 275         {
 276             context->bindRenderbuffer(renderbuffer);
 277         }
 278     }
 279     catch (...)
 280     {
 281         return gl::error(GL_OUT_OF_MEMORY);
 282     }
 283 }
 284
 285 void __stdcall glBindTexture(GLenum target, GLuint texture)
 286 {
 287     EVENT("(GLenum target = 0x%X, GLuint texture = %d)", target, texture);
 288
 289     try
 290     {
 291         gl::Context *context = gl::getNonLostContext();
 292
 293         if (context)
 294         {
 295             gl::Texture *textureObject = context->getTexture(texture);
 296
 297             if (textureObject && textureObject->getTarget() != target && texture != 0)
 298             {
 299                 return gl::error(GL_INVALID_OPERATION);
 300             }
 301
 302             switch (target)
 303             {
 304               case GL_TEXTURE_2D:
 305                 context->bindTexture2D(texture);
 306                 return;
 307               case GL_TEXTURE_CUBE_MAP:
 308                 context->bindTextureCubeMap(texture);
 309                 return;
 310               case GL_TEXTURE_3D:
 311                 if (context->getClientVersion() < 3)
 312                 {
 313                     return gl::error(GL_INVALID_ENUM);
 314                 }
 315                 context->bindTexture3D(texture);
 316                 return;
 317               case GL_TEXTURE_2D_ARRAY:
 318                 if (context->getClientVersion() < 3)
 319                 {
 320                     return gl::error(GL_INVALID_ENUM);
 321                 }
 322                 context->bindTexture2DArray(texture);
 323                 return;
 324               default:
 325                 return gl::error(GL_INVALID_ENUM);
 326             }
 327         }
 328     }
 329     catch (...)
 330     {
 331         return gl::error(GL_OUT_OF_MEMORY);
 332     }
 333 }
 334
 335 void __stdcall glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 336 {
 337     EVENT("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",
 338           red, green, blue, alpha);
 339
 340     try
 341     {
 342         gl::Context* context = gl::getNonLostContext();
 343
 344         if (context)
 345         {
 346             context->setBlendColor(gl::clamp01(red), gl::clamp01(green), gl::clamp01(blue), gl::clamp01(alpha));
 347         }
 348     }
 349     catch (...)
 350     {
 351         return gl::error(GL_OUT_OF_MEMORY);
 352     }
 353 }
 354
 355 void __stdcall glBlendEquation(GLenum mode)
 356 {
 357     glBlendEquationSeparate(mode, mode);
 358 }
 359
 360 void __stdcall glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 361 {
 362     EVENT("(GLenum modeRGB = 0x%X, GLenum modeAlpha = 0x%X)", modeRGB, modeAlpha);
 363
 364     try
 365     {
 366         gl::Context *context = gl::getNonLostContext();
 367
 368         switch (modeRGB)
 369         {
 370           case GL_FUNC_ADD:
 371           case GL_FUNC_SUBTRACT:
 372           case GL_FUNC_REVERSE_SUBTRACT:
 373           case GL_MIN:
 374           case GL_MAX:
 375             break;
 376
 377           default:
 378             return gl::error(GL_INVALID_ENUM);
 379         }
 380
 381         switch (modeAlpha)
 382         {
 383           case GL_FUNC_ADD:
 384           case GL_FUNC_SUBTRACT:
 385           case GL_FUNC_REVERSE_SUBTRACT:
 386           case GL_MIN:
 387           case GL_MAX:
 388             break;
 389
 390           default:
 391             return gl::error(GL_INVALID_ENUM);
 392         }
 393
 394         if (context)
 395         {
 396             context->setBlendEquation(modeRGB, modeAlpha);
 397         }
 398     }
 399     catch (...)
 400     {
 401         return gl::error(GL_OUT_OF_MEMORY);
 402     }
 403 }
 404
 405 void __stdcall glBlendFunc(GLenum sfactor, GLenum dfactor)
 406 {
 407     glBlendFuncSeparate(sfactor, dfactor, sfactor, dfactor);
 408 }
 409
 410 void __stdcall glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 411 {
 412     EVENT("(GLenum srcRGB = 0x%X, GLenum dstRGB = 0x%X, GLenum srcAlpha = 0x%X, GLenum dstAlpha = 0x%X)",
 413           srcRGB, dstRGB, srcAlpha, dstAlpha);
 414
 415     try
 416     {
 417         gl::Context *context = gl::getNonLostContext();
 418
 419         switch (srcRGB)
 420         {
 421           case GL_ZERO:
 422           case GL_ONE:
 423           case GL_SRC_COLOR:
 424           case GL_ONE_MINUS_SRC_COLOR:
 425           case GL_DST_COLOR:
 426           case GL_ONE_MINUS_DST_COLOR:
 427           case GL_SRC_ALPHA:
 428           case GL_ONE_MINUS_SRC_ALPHA:
 429           case GL_DST_ALPHA:
 430           case GL_ONE_MINUS_DST_ALPHA:
 431           case GL_CONSTANT_COLOR:
 432           case GL_ONE_MINUS_CONSTANT_COLOR:
 433           case GL_CONSTANT_ALPHA:
 434           case GL_ONE_MINUS_CONSTANT_ALPHA:
 435           case GL_SRC_ALPHA_SATURATE:
 436             break;
 437           default:
 438             return gl::error(GL_INVALID_ENUM);
 439         }
 440
 441         switch (dstRGB)
 442         {
 443           case GL_ZERO:
 444           case GL_ONE:
 445           case GL_SRC_COLOR:
 446           case GL_ONE_MINUS_SRC_COLOR:
 447           case GL_DST_COLOR:
 448           case GL_ONE_MINUS_DST_COLOR:
 449           case GL_SRC_ALPHA:
 450           case GL_ONE_MINUS_SRC_ALPHA:
 451           case GL_DST_ALPHA:
 452           case GL_ONE_MINUS_DST_ALPHA:
 453           case GL_CONSTANT_COLOR:
 454           case GL_ONE_MINUS_CONSTANT_COLOR:
 455           case GL_CONSTANT_ALPHA:
 456           case GL_ONE_MINUS_CONSTANT_ALPHA:
 457             break;
 458
 459           case GL_SRC_ALPHA_SATURATE:
 460             if (!context || context->getClientVersion() < 3)
 461             {
 462                 return gl::error(GL_INVALID_ENUM);
 463             }
 464             break;
 465
 466           default:
 467             return gl::error(GL_INVALID_ENUM);
 468         }
 469
 470         switch (srcAlpha)
 471         {
 472           case GL_ZERO:
 473           case GL_ONE:
 474           case GL_SRC_COLOR:
 475           case GL_ONE_MINUS_SRC_COLOR:
 476           case GL_DST_COLOR:
 477           case GL_ONE_MINUS_DST_COLOR:
 478           case GL_SRC_ALPHA:
 479           case GL_ONE_MINUS_SRC_ALPHA:
 480           case GL_DST_ALPHA:
 481           case GL_ONE_MINUS_DST_ALPHA:
 482           case GL_CONSTANT_COLOR:
 483           case GL_ONE_MINUS_CONSTANT_COLOR:
 484           case GL_CONSTANT_ALPHA:
 485           case GL_ONE_MINUS_CONSTANT_ALPHA:
 486           case GL_SRC_ALPHA_SATURATE:
 487             break;
 488           default:
 489             return gl::error(GL_INVALID_ENUM);
 490         }
 491
 492         switch (dstAlpha)
 493         {
 494           case GL_ZERO:
 495           case GL_ONE:
 496           case GL_SRC_COLOR:
 497           case GL_ONE_MINUS_SRC_COLOR:
 498           case GL_DST_COLOR:
 499           case GL_ONE_MINUS_DST_COLOR:
 500           case GL_SRC_ALPHA:
 501           case GL_ONE_MINUS_SRC_ALPHA:
 502           case GL_DST_ALPHA:
 503           case GL_ONE_MINUS_DST_ALPHA:
 504           case GL_CONSTANT_COLOR:
 505           case GL_ONE_MINUS_CONSTANT_COLOR:
 506           case GL_CONSTANT_ALPHA:
 507           case GL_ONE_MINUS_CONSTANT_ALPHA:
 508             break;
 509
 510           case GL_SRC_ALPHA_SATURATE:
 511             if (!context || context->getClientVersion() < 3)
 512             {
 513                 return gl::error(GL_INVALID_ENUM);
 514             }
 515             break;
 516
 517           default:
 518             return gl::error(GL_INVALID_ENUM);
 519         }
 520
 521         bool constantColorUsed = (srcRGB == GL_CONSTANT_COLOR || srcRGB == GL_ONE_MINUS_CONSTANT_COLOR ||
 522                                   dstRGB == GL_CONSTANT_COLOR || dstRGB == GL_ONE_MINUS_CONSTANT_COLOR);
 523
 524         bool constantAlphaUsed = (srcRGB == GL_CONSTANT_ALPHA || srcRGB == GL_ONE_MINUS_CONSTANT_ALPHA ||
 525                                   dstRGB == GL_CONSTANT_ALPHA || dstRGB == GL_ONE_MINUS_CONSTANT_ALPHA);
 526
 527         if (constantColorUsed && constantAlphaUsed)
 528         {
 529             ERR("Simultaneous use of GL_CONSTANT_ALPHA/GL_ONE_MINUS_CONSTANT_ALPHA and GL_CONSTANT_COLOR/GL_ONE_MINUS_CONSTANT_COLOR invalid under WebGL");
 530             return gl::error(GL_INVALID_OPERATION);
 531         }
 532
 533         if (context)
 534         {
 535             context->setBlendFactors(srcRGB, dstRGB, srcAlpha, dstAlpha);
 536         }
 537     }
 538     catch (...)
 539     {
 540         return gl::error(GL_OUT_OF_MEMORY);
 541     }
 542 }
 543
 544 void __stdcall glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
 545 {
 546     EVENT("(GLenum target = 0x%X, GLsizeiptr size = %d, const GLvoid* data = 0x%0.8p, GLenum usage = %d)",
 547           target, size, data, usage);
 548
 549     try
 550     {
 551         if (size < 0)
 552         {
 553             return gl::error(GL_INVALID_VALUE);
 554         }
 555
 556         gl::Context *context = gl::getNonLostContext();
 557
 558         switch (usage)
 559         {
 560           case GL_STREAM_DRAW:
 561           case GL_STATIC_DRAW:
 562           case GL_DYNAMIC_DRAW:
 563             break;
 564
 565           case GL_STREAM_READ:
 566           case GL_STREAM_COPY:
 567           case GL_STATIC_READ:
 568           case GL_STATIC_COPY:
 569           case GL_DYNAMIC_READ:
 570           case GL_DYNAMIC_COPY:
 571             if (context && context->getClientVersion() < 3)
 572             {
 573               return gl::error(GL_INVALID_ENUM);
 574             }
 575             break;
 576
 577           default:
 578             return gl::error(GL_INVALID_ENUM);
 579         }
 580
 581         if (context)
 582         {
 583             if (!gl::ValidBufferTarget(context, target))
 584             {
 585                 return gl::error(GL_INVALID_ENUM);
 586             }
 587
 588             gl::Buffer *buffer = context->getTargetBuffer(target);
 589
 590             if (!buffer)
 591             {
 592                 return gl::error(GL_INVALID_OPERATION);
 593             }
 594
 595             buffer->bufferData(data, size, usage);
 596         }
 597     }
 598     catch (...)
 599     {
 600         return gl::error(GL_OUT_OF_MEMORY);
 601     }
 602 }
 603
 604 void __stdcall glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
 605 {
 606     EVENT("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr size = %d, const GLvoid* data = 0x%0.8p)",
 607           target, offset, size, data);
 608
 609     try
 610     {
 611         if (size < 0 || offset < 0)
 612         {
 613             return gl::error(GL_INVALID_VALUE);
 614         }
 615
 616         if (data == NULL)
 617         {
 618             return;
 619         }
 620
 621         gl::Context *context = gl::getNonLostContext();
 622
 623         if (context)
 624         {
 625             if (!gl::ValidBufferTarget(context, target))
 626             {
 627                 return gl::error(GL_INVALID_ENUM);
 628             }
 629
 630             gl::Buffer *buffer = context->getTargetBuffer(target);
 631
 632             if (!buffer)
 633             {
 634                 return gl::error(GL_INVALID_OPERATION);
 635             }
 636
 637             if (buffer->mapped())
 638             {
 639                 return gl::error(GL_INVALID_OPERATION);
 640             }
 641
 642             // Check for possible overflow of size + offset
 643             if (!rx::IsUnsignedAdditionSafe<size_t>(size, offset))
 644             {
 645                 return gl::error(GL_OUT_OF_MEMORY);
 646             }
 647
 648             if (size + offset > buffer->size())
 649             {
 650                 return gl::error(GL_INVALID_VALUE);
 651             }
 652
 653             buffer->bufferSubData(data, size, offset);
 654         }
 655     }
 656     catch (...)
 657     {
 658         return gl::error(GL_OUT_OF_MEMORY);
 659     }
 660 }
 661
 662 GLenum __stdcall glCheckFramebufferStatus(GLenum target)
 663 {
 664     EVENT("(GLenum target = 0x%X)", target);
 665
 666     try
 667     {
 668         if (!gl::ValidFramebufferTarget(target))
 669         {
 670             return gl::error(GL_INVALID_ENUM, 0);
 671         }
 672
 673         gl::Context *context = gl::getNonLostContext();
 674
 675         if (context)
 676         {
 677             gl::Framebuffer *framebuffer = context->getTargetFramebuffer(target);
 678             ASSERT(framebuffer);
 679             return framebuffer->completeness();
 680         }
 681     }
 682     catch (...)
 683     {
 684         return gl::error(GL_OUT_OF_MEMORY, 0);
 685     }
 686
 687     return 0;
 688 }
 689
 690 void __stdcall glClear(GLbitfield mask)
 691 {
 692     EVENT("(GLbitfield mask = 0x%X)", mask);
 693
 694     try
 695     {
 696         gl::Context *context = gl::getNonLostContext();
 697
 698         if (context)
 699         {
 700             gl::Framebuffer *framebufferObject = context->getDrawFramebuffer();
 701
 702             if (!framebufferObject || framebufferObject->completeness() != GL_FRAMEBUFFER_COMPLETE)
 703             {
 704                 return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
 705             }
 706
 707             if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0)
 708             {
 709                 return gl::error(GL_INVALID_VALUE);
 710             }
 711
 712             context->clear(mask);
 713         }
 714     }
 715     catch (...)
 716     {
 717         return gl::error(GL_OUT_OF_MEMORY);
 718     }
 719 }
 720
 721 void __stdcall glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 722 {
 723     EVENT("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",
 724           red, green, blue, alpha);
 725
 726     try
 727     {
 728         gl::Context *context = gl::getNonLostContext();
 729
 730         if (context)
 731         {
 732             context->setClearColor(red, green, blue, alpha);
 733         }
 734     }
 735     catch (...)
 736     {
 737         return gl::error(GL_OUT_OF_MEMORY);
 738     }
 739 }
 740
 741 void __stdcall glClearDepthf(GLclampf depth)
 742 {
 743     EVENT("(GLclampf depth = %f)", depth);
 744
 745     try
 746     {
 747         gl::Context *context = gl::getNonLostContext();
 748
 749         if (context)
 750         {
 751             context->setClearDepth(depth);
 752         }
 753     }
 754     catch (...)
 755     {
 756         return gl::error(GL_OUT_OF_MEMORY);
 757     }
 758 }
 759
 760 void __stdcall glClearStencil(GLint s)
 761 {
 762     EVENT("(GLint s = %d)", s);
 763
 764     try
 765     {
 766         gl::Context *context = gl::getNonLostContext();
 767
 768         if (context)
 769         {
 770             context->setClearStencil(s);
 771         }
 772     }
 773     catch (...)
 774     {
 775         return gl::error(GL_OUT_OF_MEMORY);
 776     }
 777 }
 778
 779 void __stdcall glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 780 {
 781     EVENT("(GLboolean red = %d, GLboolean green = %u, GLboolean blue = %u, GLboolean alpha = %u)",
 782           red, green, blue, alpha);
 783
 784     try
 785     {
 786         gl::Context *context = gl::getNonLostContext();
 787
 788         if (context)
 789         {
 790             context->setColorMask(red == GL_TRUE, green == GL_TRUE, blue == GL_TRUE, alpha == GL_TRUE);
 791         }
 792     }
 793     catch (...)
 794     {
 795         return gl::error(GL_OUT_OF_MEMORY);
 796     }
 797 }
 798
 799 void __stdcall glCompileShader(GLuint shader)
 800 {
 801     EVENT("(GLuint shader = %d)", shader);
 802
 803     try
 804     {
 805         gl::Context *context = gl::getNonLostContext();
 806
 807         if (context)
 808         {
 809             gl::Shader *shaderObject = context->getShader(shader);
 810
 811             if (!shaderObject)
 812             {
 813                 if (context->getProgram(shader))
 814                 {
 815                     return gl::error(GL_INVALID_OPERATION);
 816                 }
 817                 else
 818                 {
 819                     return gl::error(GL_INVALID_VALUE);
 820                 }
 821             }
 822
 823             shaderObject->compile();
 824         }
 825     }
 826     catch (...)
 827     {
 828         return gl::error(GL_OUT_OF_MEMORY);
 829     }
 830 }
 831
 832 void __stdcall glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
 833                                       GLint border, GLsizei imageSize, const GLvoid* data)
 834 {
 835     EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = %d, "
 836           "GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const GLvoid* data = 0x%0.8p)",
 837           target, level, internalformat, width, height, border, imageSize, data);
 838
 839     try
 840     {
 841         gl::Context *context = gl::getNonLostContext();
 842
 843         if (context)
 844         {
 845             if (context->getClientVersion() < 3 &&
 846                 !ValidateES2TexImageParameters(context, target, level, internalformat, true, false,
 847                                                0, 0, width, height, border, GL_NONE, GL_NONE, data))
 848             {
 849                 return;
 850             }
 851
 852             if (context->getClientVersion() >= 3 &&
 853                 !ValidateES3TexImageParameters(context, target, level, internalformat, true, false,
 854                                                0, 0, 0, width, height, 1, border, GL_NONE, GL_NONE, data))
 855             {
 856                 return;
 857             }
 858
 859             if (imageSize < 0 || imageSize != (GLsizei)gl::GetBlockSize(internalformat, GL_UNSIGNED_BYTE, context->getClientVersion(), width, height))
 860             {
 861                 return gl::error(GL_INVALID_VALUE);
 862             }
 863
 864             switch (target)
 865             {
 866               case GL_TEXTURE_2D:
 867                 {
 868                     gl::Texture2D *texture = context->getTexture2D();
 869                     texture->setCompressedImage(level, internalformat, width, height, imageSize, data);
 870                 }
 871                 break;
 872
 873               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
 874               case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
 875               case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
 876               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
 877               case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
 878               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
 879                 {
 880                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
 881                     texture->setCompressedImage(target, level, internalformat, width, height, imageSize, data);
 882                 }
 883                 break;
 884
 885               default:
 886                 return gl::error(GL_INVALID_ENUM);
 887             }
 888         }
 889     }
 890     catch (...)
 891     {
 892         return gl::error(GL_OUT_OF_MEMORY);
 893     }
 894 }
 895
 896 void __stdcall glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
 897                                          GLenum format, GLsizei imageSize, const GLvoid* data)
 898 {
 899     EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
 900           "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, "
 901           "GLsizei imageSize = %d, const GLvoid* data = 0x%0.8p)",
 902           target, level, xoffset, yoffset, width, height, format, imageSize, data);
 903
 904     try
 905     {
 906         gl::Context *context = gl::getNonLostContext();
 907
 908         if (context)
 909         {
 910             if (context->getClientVersion() < 3 &&
 911                 !ValidateES2TexImageParameters(context, target, level, GL_NONE, true, true,
 912                                                xoffset, yoffset, width, height, 0, GL_NONE, GL_NONE, data))
 913             {
 914                 return;
 915             }
 916
 917             if (context->getClientVersion() >= 3 &&
 918                 !ValidateES3TexImageParameters(context, target, level, GL_NONE, true, true,
 919                                                xoffset, yoffset, 0, width, height, 1, 0, GL_NONE, GL_NONE, data))
 920             {
 921                 return;
 922             }
 923
 924             if (imageSize < 0 || imageSize != (GLsizei)gl::GetBlockSize(format, GL_UNSIGNED_BYTE, context->getClientVersion(), width, height))
 925             {
 926                 return gl::error(GL_INVALID_VALUE);
 927             }
 928
 929             switch (target)
 930             {
 931               case GL_TEXTURE_2D:
 932                 {
 933                     gl::Texture2D *texture = context->getTexture2D();
 934                     texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
 935                 }
 936                 break;
 937
 938               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
 939               case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
 940               case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
 941               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
 942               case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
 943               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
 944                 {
 945                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
 946                     texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 947                 }
 948                 break;
 949
 950               default:
 951                 return gl::error(GL_INVALID_ENUM);
 952             }
 953         }
 954     }
 955     catch (...)
 956     {
 957         return gl::error(GL_OUT_OF_MEMORY);
 958     }
 959 }
 960
 961 void __stdcall glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 962 {
 963     EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
 964           "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d)",
 965           target, level, internalformat, x, y, width, height, border);
 966
 967     try
 968     {
 969         gl::Context *context = gl::getNonLostContext();
 970
 971         if (context)
 972         {
 973             if (context->getClientVersion() < 3 &&
 974                 !ValidateES2CopyTexImageParameters(context, target, level, internalformat, false,
 975                                                    0, 0, x, y, width, height, border))
 976             {
 977                 return;
 978             }
 979
 980             if (context->getClientVersion() >= 3 &&
 981                 !ValidateES3CopyTexImageParameters(context, target, level, internalformat, false,
 982                                                    0, 0, 0, x, y, width, height, border))
 983             {
 984                 return;
 985             }
 986
 987             gl::Framebuffer *framebuffer = context->getReadFramebuffer();
 988
 989             switch (target)
 990             {
 991               case GL_TEXTURE_2D:
 992                 {
 993                     gl::Texture2D *texture = context->getTexture2D();
 994                     texture->copyImage(level, internalformat, x, y, width, height, framebuffer);
 995                 }
 996                 break;
 997
 998               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
 999               case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1000               case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1001               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1002               case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1003               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1004                 {
1005                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
1006                     texture->copyImage(target, level, internalformat, x, y, width, height, framebuffer);
1007                 }
1008                 break;
1009
1010              default:
1011                 return gl::error(GL_INVALID_ENUM);
1012             }
1013         }
1014     }
1015     catch (...)
1016     {
1017         return gl::error(GL_OUT_OF_MEMORY);
1018     }
1019 }
1020
1021 void __stdcall glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1022 {
1023     EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
1024           "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
1025           target, level, xoffset, yoffset, x, y, width, height);
1026
1027     try
1028     {
1029         gl::Context *context = gl::getNonLostContext();
1030
1031         if (context)
1032         {
1033             if (context->getClientVersion() < 3 &&
1034                 !ValidateES2CopyTexImageParameters(context, target, level, GL_NONE, true,
1035                                                    xoffset, yoffset, x, y, width, height, 0))
1036             {
1037                 return;
1038             }
1039
1040             if (context->getClientVersion() >= 3 &&
1041                 !ValidateES3CopyTexImageParameters(context, target, level, GL_NONE, true,
1042                                                    xoffset, yoffset, 0, x, y, width, height, 0))
1043             {
1044                 return;
1045             }
1046
1047             gl::Framebuffer *framebuffer = context->getReadFramebuffer();
1048
1049             switch (target)
1050             {
1051               case GL_TEXTURE_2D:
1052                 {
1053                     gl::Texture2D *texture = context->getTexture2D();
1054                     texture->copySubImage(target, level, xoffset, yoffset, 0, x, y, width, height, framebuffer);
1055                 }
1056                 break;
1057
1058               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1059               case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1060               case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1061               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1062               case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1063               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1064                 {
1065                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
1066                     texture->copySubImage(target, level, xoffset, yoffset, 0, x, y, width, height, framebuffer);
1067                 }
1068                 break;
1069
1070               default:
1071                 return gl::error(GL_INVALID_ENUM);
1072             }
1073         }
1074     }
1075
1076     catch (...)
1077     {
1078         return gl::error(GL_OUT_OF_MEMORY);
1079     }
1080 }
1081
1082 GLuint __stdcall glCreateProgram(void)
1083 {
1084     EVENT("()");
1085
1086     try
1087     {
1088         gl::Context *context = gl::getNonLostContext();
1089
1090         if (context)
1091         {
1092             return context->createProgram();
1093         }
1094     }
1095     catch (...)
1096     {
1097         return gl::error(GL_OUT_OF_MEMORY, 0);
1098     }
1099
1100     return 0;
1101 }
1102
1103 GLuint __stdcall glCreateShader(GLenum type)
1104 {
1105     EVENT("(GLenum type = 0x%X)", type);
1106
1107     try
1108     {
1109         gl::Context *context = gl::getNonLostContext();
1110
1111         if (context)
1112         {
1113             switch (type)
1114             {
1115               case GL_FRAGMENT_SHADER:
1116               case GL_VERTEX_SHADER:
1117                 return context->createShader(type);
1118               default:
1119                 return gl::error(GL_INVALID_ENUM, 0);
1120             }
1121         }
1122     }
1123     catch (...)
1124     {
1125         return gl::error(GL_OUT_OF_MEMORY, 0);
1126     }
1127
1128     return 0;
1129 }
1130
1131 void __stdcall glCullFace(GLenum mode)
1132 {
1133     EVENT("(GLenum mode = 0x%X)", mode);
1134
1135     try
1136     {
1137         switch (mode)
1138         {
1139           case GL_FRONT:
1140           case GL_BACK:
1141           case GL_FRONT_AND_BACK:
1142             {
1143                 gl::Context *context = gl::getNonLostContext();
1144
1145                 if (context)
1146                 {
1147                     context->setCullMode(mode);
1148                 }
1149             }
1150             break;
1151           default:
1152             return gl::error(GL_INVALID_ENUM);
1153         }
1154     }
1155     catch (...)
1156     {
1157         return gl::error(GL_OUT_OF_MEMORY);
1158     }
1159 }
1160
1161 void __stdcall glDeleteBuffers(GLsizei n, const GLuint* buffers)
1162 {
1163     EVENT("(GLsizei n = %d, const GLuint* buffers = 0x%0.8p)", n, buffers);
1164
1165     try
1166     {
1167         if (n < 0)
1168         {
1169             return gl::error(GL_INVALID_VALUE);
1170         }
1171
1172         gl::Context *context = gl::getNonLostContext();
1173
1174         if (context)
1175         {
1176             for (int i = 0; i < n; i++)
1177             {
1178                 context->deleteBuffer(buffers[i]);
1179             }
1180         }
1181     }
1182     catch (...)
1183     {
1184         return gl::error(GL_OUT_OF_MEMORY);
1185     }
1186 }
1187
1188 void __stdcall glDeleteFencesNV(GLsizei n, const GLuint* fences)
1189 {
1190     EVENT("(GLsizei n = %d, const GLuint* fences = 0x%0.8p)", n, fences);
1191
1192     try
1193     {
1194         if (n < 0)
1195         {
1196             return gl::error(GL_INVALID_VALUE);
1197         }
1198
1199         gl::Context *context = gl::getNonLostContext();
1200
1201         if (context)
1202         {
1203             for (int i = 0; i < n; i++)
1204             {
1205                 context->deleteFenceNV(fences[i]);
1206             }
1207         }
1208     }
1209     catch (...)
1210     {
1211         return gl::error(GL_OUT_OF_MEMORY);
1212     }
1213 }
1214
1215 void __stdcall glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
1216 {
1217     EVENT("(GLsizei n = %d, const GLuint* framebuffers = 0x%0.8p)", n, framebuffers);
1218
1219     try
1220     {
1221         if (n < 0)
1222         {
1223             return gl::error(GL_INVALID_VALUE);
1224         }
1225
1226         gl::Context *context = gl::getNonLostContext();
1227
1228         if (context)
1229         {
1230             for (int i = 0; i < n; i++)
1231             {
1232                 if (framebuffers[i] != 0)
1233                 {
1234                     context->deleteFramebuffer(framebuffers[i]);
1235                 }
1236             }
1237         }
1238     }
1239     catch (...)
1240     {
1241         return gl::error(GL_OUT_OF_MEMORY);
1242     }
1243 }
1244
1245 void __stdcall glDeleteProgram(GLuint program)
1246 {
1247     EVENT("(GLuint program = %d)", program);
1248
1249     try
1250     {
1251         if (program == 0)
1252         {
1253             return;
1254         }
1255
1256         gl::Context *context = gl::getNonLostContext();
1257
1258         if (context)
1259         {
1260             if (!context->getProgram(program))
1261             {
1262                 if(context->getShader(program))
1263                 {
1264                     return gl::error(GL_INVALID_OPERATION);
1265                 }
1266                 else
1267                 {
1268                     return gl::error(GL_INVALID_VALUE);
1269                 }
1270             }
1271
1272             context->deleteProgram(program);
1273         }
1274     }
1275     catch (...)
1276     {
1277         return gl::error(GL_OUT_OF_MEMORY);
1278     }
1279 }
1280
1281 void __stdcall glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
1282 {
1283     EVENT("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids);
1284
1285     try
1286     {
1287         if (n < 0)
1288         {
1289             return gl::error(GL_INVALID_VALUE);
1290         }
1291
1292         gl::Context *context = gl::getNonLostContext();
1293
1294         if (context)
1295         {
1296             for (int i = 0; i < n; i++)
1297             {
1298                 context->deleteQuery(ids[i]);
1299             }
1300         }
1301     }
1302     catch (...)
1303     {
1304         return gl::error(GL_OUT_OF_MEMORY);
1305     }
1306 }
1307
1308 void __stdcall glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
1309 {
1310     EVENT("(GLsizei n = %d, const GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);
1311
1312     try
1313     {
1314         if (n < 0)
1315         {
1316             return gl::error(GL_INVALID_VALUE);
1317         }
1318
1319         gl::Context *context = gl::getNonLostContext();
1320
1321         if (context)
1322         {
1323             for (int i = 0; i < n; i++)
1324             {
1325                 context->deleteRenderbuffer(renderbuffers[i]);
1326             }
1327         }
1328     }
1329     catch (...)
1330     {
1331         return gl::error(GL_OUT_OF_MEMORY);
1332     }
1333 }
1334
1335 void __stdcall glDeleteShader(GLuint shader)
1336 {
1337     EVENT("(GLuint shader = %d)", shader);
1338
1339     try
1340     {
1341         if (shader == 0)
1342         {
1343             return;
1344         }
1345
1346         gl::Context *context = gl::getNonLostContext();
1347
1348         if (context)
1349         {
1350             if (!context->getShader(shader))
1351             {
1352                 if(context->getProgram(shader))
1353                 {
1354                     return gl::error(GL_INVALID_OPERATION);
1355                 }
1356                 else
1357                 {
1358                     return gl::error(GL_INVALID_VALUE);
1359                 }
1360             }
1361
1362             context->deleteShader(shader);
1363         }
1364     }
1365     catch (...)
1366     {
1367         return gl::error(GL_OUT_OF_MEMORY);
1368     }
1369 }
1370
1371 void __stdcall glDeleteTextures(GLsizei n, const GLuint* textures)
1372 {
1373     EVENT("(GLsizei n = %d, const GLuint* textures = 0x%0.8p)", n, textures);
1374
1375     try
1376     {
1377         if (n < 0)
1378         {
1379             return gl::error(GL_INVALID_VALUE);
1380         }
1381
1382         gl::Context *context = gl::getNonLostContext();
1383
1384         if (context)
1385         {
1386             for (int i = 0; i < n; i++)
1387             {
1388                 if (textures[i] != 0)
1389                 {
1390                     context->deleteTexture(textures[i]);
1391                 }
1392             }
1393         }
1394     }
1395     catch (...)
1396     {
1397         return gl::error(GL_OUT_OF_MEMORY);
1398     }
1399 }
1400
1401 void __stdcall glDepthFunc(GLenum func)
1402 {
1403     EVENT("(GLenum func = 0x%X)", func);
1404
1405     try
1406     {
1407         switch (func)
1408         {
1409           case GL_NEVER:
1410           case GL_ALWAYS:
1411           case GL_LESS:
1412           case GL_LEQUAL:
1413           case GL_EQUAL:
1414           case GL_GREATER:
1415           case GL_GEQUAL:
1416           case GL_NOTEQUAL:
1417             break;
1418           default:
1419             return gl::error(GL_INVALID_ENUM);
1420         }
1421
1422         gl::Context *context = gl::getNonLostContext();
1423
1424         if (context)
1425         {
1426             context->setDepthFunc(func);
1427         }
1428     }
1429     catch (...)
1430     {
1431         return gl::error(GL_OUT_OF_MEMORY);
1432     }
1433 }
1434
1435 void __stdcall glDepthMask(GLboolean flag)
1436 {
1437     EVENT("(GLboolean flag = %u)", flag);
1438
1439     try
1440     {
1441         gl::Context *context = gl::getNonLostContext();
1442
1443         if (context)
1444         {
1445             context->setDepthMask(flag != GL_FALSE);
1446         }
1447     }
1448     catch (...)
1449     {
1450         return gl::error(GL_OUT_OF_MEMORY);
1451     }
1452 }
1453
1454 void __stdcall glDepthRangef(GLclampf zNear, GLclampf zFar)
1455 {
1456     EVENT("(GLclampf zNear = %f, GLclampf zFar = %f)", zNear, zFar);
1457
1458     try
1459     {
1460         gl::Context *context = gl::getNonLostContext();
1461
1462         if (context)
1463         {
1464             context->setDepthRange(zNear, zFar);
1465         }
1466     }
1467     catch (...)
1468     {
1469         return gl::error(GL_OUT_OF_MEMORY);
1470     }
1471 }
1472
1473 void __stdcall glDetachShader(GLuint program, GLuint shader)
1474 {
1475     EVENT("(GLuint program = %d, GLuint shader = %d)", program, shader);
1476
1477     try
1478     {
1479         gl::Context *context = gl::getNonLostContext();
1480
1481         if (context)
1482         {
1483
1484             gl::Program *programObject = context->getProgram(program);
1485             gl::Shader *shaderObject = context->getShader(shader);
1486
1487             if (!programObject)
1488             {
1489                 gl::Shader *shaderByProgramHandle;
1490                 shaderByProgramHandle = context->getShader(program);
1491                 if (!shaderByProgramHandle)
1492                 {
1493                     return gl::error(GL_INVALID_VALUE);
1494                 }
1495                 else
1496                 {
1497                     return gl::error(GL_INVALID_OPERATION);
1498                 }
1499             }
1500
1501             if (!shaderObject)
1502             {
1503                 gl::Program *programByShaderHandle = context->getProgram(shader);
1504                 if (!programByShaderHandle)
1505                 {
1506                     return gl::error(GL_INVALID_VALUE);
1507                 }
1508                 else
1509                 {
1510                     return gl::error(GL_INVALID_OPERATION);
1511                 }
1512             }
1513
1514             if (!programObject->detachShader(shaderObject))
1515             {
1516                 return gl::error(GL_INVALID_OPERATION);
1517             }
1518         }
1519     }
1520     catch (...)
1521     {
1522         return gl::error(GL_OUT_OF_MEMORY);
1523     }
1524 }
1525
1526 void __stdcall glDisable(GLenum cap)
1527 {
1528     EVENT("(GLenum cap = 0x%X)", cap);
1529
1530     try
1531     {
1532         gl::Context *context = gl::getNonLostContext();
1533
1534         if (context)
1535         {
1536             if (!ValidCap(context, cap))
1537             {
1538                 return gl::error(GL_INVALID_ENUM);
1539             }
1540
1541             context->setCap(cap, false);
1542         }
1543     }
1544     catch (...)
1545     {
1546         return gl::error(GL_OUT_OF_MEMORY);
1547     }
1548 }
1549
1550 void __stdcall glDisableVertexAttribArray(GLuint index)
1551 {
1552     EVENT("(GLuint index = %d)", index);
1553
1554     try
1555     {
1556         if (index >= gl::MAX_VERTEX_ATTRIBS)
1557         {
1558             return gl::error(GL_INVALID_VALUE);
1559         }
1560
1561         gl::Context *context = gl::getNonLostContext();
1562
1563         if (context)
1564         {
1565             context->setEnableVertexAttribArray(index, false);
1566         }
1567     }
1568     catch (...)
1569     {
1570         return gl::error(GL_OUT_OF_MEMORY);
1571     }
1572 }
1573
1574 void __stdcall glDrawArrays(GLenum mode, GLint first, GLsizei count)
1575 {
1576     EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d)", mode, first, count);
1577
1578     try
1579     {
1580         if (count < 0 || first < 0)
1581         {
1582             return gl::error(GL_INVALID_VALUE);
1583         }
1584
1585         gl::Context *context = gl::getNonLostContext();
1586
1587         // Check for mapped buffers
1588         if (context->hasMappedBuffer(GL_ARRAY_BUFFER))
1589         {
1590             return gl::error(GL_INVALID_OPERATION);
1591         }
1592
1593         if (context)
1594         {
1595             gl::TransformFeedback *curTransformFeedback = context->getCurrentTransformFeedback();
1596             if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused() &&
1597                 curTransformFeedback->getDrawMode() != mode)
1598             {
1599                 // It is an invalid operation to call DrawArrays or DrawArraysInstanced with a draw mode
1600                 // that does not match the current transform feedback object's draw mode (if transform feedback
1601                 // is active), (3.0.2, section 2.14, pg 86)
1602                 return gl::error(GL_INVALID_OPERATION);
1603             }
1604
1605             context->drawArrays(mode, first, count, 0);
1606         }
1607     }
1608     catch (...)
1609     {
1610         return gl::error(GL_OUT_OF_MEMORY);
1611     }
1612 }
1613
1614 void __stdcall glDrawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
1615 {
1616     EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei primcount = %d)", mode, first, count, primcount);
1617
1618     try
1619     {
1620         if (count < 0 || first < 0 || primcount < 0)
1621         {
1622             return gl::error(GL_INVALID_VALUE);
1623         }
1624
1625         if (primcount > 0)
1626         {
1627             gl::Context *context = gl::getNonLostContext();
1628
1629             // Check for mapped buffers
1630             if (context->hasMappedBuffer(GL_ARRAY_BUFFER))
1631             {
1632                 return gl::error(GL_INVALID_OPERATION);
1633             }
1634
1635             if (context)
1636             {
1637                 gl::TransformFeedback *curTransformFeedback = context->getCurrentTransformFeedback();
1638                 if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused() &&
1639                     curTransformFeedback->getDrawMode() != mode)
1640                 {
1641                     // It is an invalid operation to call DrawArrays or DrawArraysInstanced with a draw mode
1642                     // that does not match the current transform feedback object's draw mode (if transform feedback
1643                     // is active), (3.0.2, section 2.14, pg 86)
1644                     return gl::error(GL_INVALID_OPERATION);
1645                 }
1646
1647                 context->drawArrays(mode, first, count, primcount);
1648             }
1649         }
1650     }
1651     catch (...)
1652     {
1653         return gl::error(GL_OUT_OF_MEMORY);
1654     }
1655 }
1656
1657 void __stdcall glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
1658 {
1659     EVENT("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = 0x%0.8p)",
1660           mode, count, type, indices);
1661
1662     try
1663     {
1664         if (count < 0)
1665         {
1666             return gl::error(GL_INVALID_VALUE);
1667         }
1668
1669         gl::Context *context = gl::getNonLostContext();
1670
1671         if (context)
1672         {
1673             switch (type)
1674             {
1675               case GL_UNSIGNED_BYTE:
1676               case GL_UNSIGNED_SHORT:
1677                 break;
1678               case GL_UNSIGNED_INT:
1679                 if (!context->supports32bitIndices())
1680                 {
1681                     return gl::error(GL_INVALID_ENUM);
1682                 }
1683                 break;
1684               default:
1685                 return gl::error(GL_INVALID_ENUM);
1686             }
1687
1688             gl::TransformFeedback *curTransformFeedback = context->getCurrentTransformFeedback();
1689             if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused())
1690             {
1691                 // It is an invalid operation to call DrawElements, DrawRangeElements or DrawElementsInstanced
1692                 // while transform feedback is active, (3.0.2, section 2.14, pg 86)
1693                 return gl::error(GL_INVALID_OPERATION);
1694             }
1695
1696             // Check for mapped buffers
1697             if (context->hasMappedBuffer(GL_ARRAY_BUFFER) || context->hasMappedBuffer(GL_ELEMENT_ARRAY_BUFFER))
1698             {
1699                 return gl::error(GL_INVALID_OPERATION);
1700             }
1701
1702             context->drawElements(mode, count, type, indices, 0);
1703         }
1704     }
1705     catch (...)
1706     {
1707         return gl::error(GL_OUT_OF_MEMORY);
1708     }
1709 }
1710
1711 void __stdcall glDrawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)
1712 {
1713     EVENT("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = 0x%0.8p, GLsizei primcount = %d)",
1714           mode, count, type, indices, primcount);
1715
1716     try
1717     {
1718         if (count < 0 || primcount < 0)
1719         {
1720             return gl::error(GL_INVALID_VALUE);
1721         }
1722
1723         if (primcount > 0)
1724         {
1725             gl::Context *context = gl::getNonLostContext();
1726
1727             if (context)
1728             {
1729                 switch (type)
1730                 {
1731                   case GL_UNSIGNED_BYTE:
1732                   case GL_UNSIGNED_SHORT:
1733                     break;
1734                   case GL_UNSIGNED_INT:
1735                     if (!context->supports32bitIndices())
1736                     {
1737                         return gl::error(GL_INVALID_ENUM);
1738                     }
1739                     break;
1740                   default:
1741                     return gl::error(GL_INVALID_ENUM);
1742                 }
1743
1744                 gl::TransformFeedback *curTransformFeedback = context->getCurrentTransformFeedback();
1745                 if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused())
1746                 {
1747                     // It is an invalid operation to call DrawElements, DrawRangeElements or DrawElementsInstanced
1748                     // while transform feedback is active, (3.0.2, section 2.14, pg 86)
1749                     return gl::error(GL_INVALID_OPERATION);
1750                 }
1751
1752                 // Check for mapped buffers
1753                 if (context->hasMappedBuffer(GL_ARRAY_BUFFER) || context->hasMappedBuffer(GL_ELEMENT_ARRAY_BUFFER))
1754                 {
1755                     return gl::error(GL_INVALID_OPERATION);
1756                 }
1757
1758                 context->drawElements(mode, count, type, indices, primcount);
1759             }
1760         }
1761     }
1762     catch (...)
1763     {
1764         return gl::error(GL_OUT_OF_MEMORY);
1765     }
1766 }
1767
1768 void __stdcall glEnable(GLenum cap)
1769 {
1770     EVENT("(GLenum cap = 0x%X)", cap);
1771
1772     try
1773     {
1774         gl::Context *context = gl::getNonLostContext();
1775
1776         if (context)
1777         {
1778             if (!ValidCap(context, cap))
1779             {
1780                 return gl::error(GL_INVALID_ENUM);
1781             }
1782
1783             context->setCap(cap, true);
1784         }
1785     }
1786     catch (...)
1787     {
1788         return gl::error(GL_OUT_OF_MEMORY);
1789     }
1790 }
1791
1792 void __stdcall glEnableVertexAttribArray(GLuint index)
1793 {
1794     EVENT("(GLuint index = %d)", index);
1795
1796     try
1797     {
1798         if (index >= gl::MAX_VERTEX_ATTRIBS)
1799         {
1800             return gl::error(GL_INVALID_VALUE);
1801         }
1802
1803         gl::Context *context = gl::getNonLostContext();
1804
1805         if (context)
1806         {
1807             context->setEnableVertexAttribArray(index, true);
1808         }
1809     }
1810     catch (...)
1811     {
1812         return gl::error(GL_OUT_OF_MEMORY);
1813     }
1814 }
1815
1816 void __stdcall glEndQueryEXT(GLenum target)
1817 {
1818     EVENT("GLenum target = 0x%X)", target);
1819
1820     try
1821     {
1822         gl::Context *context = gl::getNonLostContext();
1823
1824         if (context)
1825         {
1826             if (!ValidateEndQuery(context, target))
1827             {
1828                 return;
1829             }
1830
1831             context->endQuery(target);
1832         }
1833     }
1834     catch (...)
1835     {
1836         return gl::error(GL_OUT_OF_MEMORY);
1837     }
1838 }
1839
1840 void __stdcall glFinishFenceNV(GLuint fence)
1841 {
1842     EVENT("(GLuint fence = %d)", fence);
1843
1844     try
1845     {
1846         gl::Context *context = gl::getNonLostContext();
1847
1848         if (context)
1849         {
1850             gl::FenceNV *fenceObject = context->getFenceNV(fence);
1851
1852             if (fenceObject == NULL)
1853             {
1854                 return gl::error(GL_INVALID_OPERATION);
1855             }
1856
1857             if (fenceObject->isFence() != GL_TRUE)
1858             {
1859                 return gl::error(GL_INVALID_OPERATION);
1860             }
1861
1862             fenceObject->finishFence();
1863         }
1864     }
1865     catch (...)
1866     {
1867         return gl::error(GL_OUT_OF_MEMORY);
1868     }
1869 }
1870
1871 void __stdcall glFinish(void)
1872 {
1873     EVENT("()");
1874
1875     try
1876     {
1877         gl::Context *context = gl::getNonLostContext();
1878
1879         if (context)
1880         {
1881             context->sync(true);
1882         }
1883     }
1884     catch (...)
1885     {
1886         return gl::error(GL_OUT_OF_MEMORY);
1887     }
1888 }
1889
1890 void __stdcall glFlush(void)
1891 {
1892     EVENT("()");
1893
1894     try
1895     {
1896         gl::Context *context = gl::getNonLostContext();
1897
1898         if (context)
1899         {
1900             context->sync(false);
1901         }
1902     }
1903     catch (...)
1904     {
1905         return gl::error(GL_OUT_OF_MEMORY);
1906     }
1907 }
1908
1909 void __stdcall glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1910 {
1911     EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, "
1912           "GLuint renderbuffer = %d)", target, attachment, renderbuffertarget, renderbuffer);
1913
1914     try
1915     {
1916         if (!gl::ValidFramebufferTarget(target) || (renderbuffertarget != GL_RENDERBUFFER && renderbuffer != 0))
1917         {
1918             return gl::error(GL_INVALID_ENUM);
1919         }
1920
1921         gl::Context *context = gl::getNonLostContext();
1922
1923         if (context)
1924         {
1925             if (!gl::ValidateFramebufferRenderbufferParameters(context, target, attachment, renderbuffertarget, renderbuffer))
1926             {
1927                 return;
1928             }
1929
1930             gl::Framebuffer *framebuffer = context->getTargetFramebuffer(target);
1931             ASSERT(framebuffer);
1932
1933             if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
1934             {
1935                 unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
1936                 framebuffer->setColorbuffer(colorAttachment, GL_RENDERBUFFER, renderbuffer, 0, 0);
1937             }
1938             else
1939             {
1940                 switch (attachment)
1941                 {
1942                   case GL_DEPTH_ATTACHMENT:
1943                     framebuffer->setDepthbuffer(GL_RENDERBUFFER, renderbuffer, 0, 0);
1944                     break;
1945                   case GL_STENCIL_ATTACHMENT:
1946                     framebuffer->setStencilbuffer(GL_RENDERBUFFER, renderbuffer, 0, 0);
1947                     break;
1948                   case GL_DEPTH_STENCIL_ATTACHMENT:
1949                     framebuffer->setDepthStencilBuffer(GL_RENDERBUFFER, renderbuffer, 0, 0);
1950                     break;
1951                   default:
1952                     UNREACHABLE();
1953                     break;
1954                 }
1955             }
1956         }
1957     }
1958     catch (...)
1959     {
1960         return gl::error(GL_OUT_OF_MEMORY);
1961     }
1962 }
1963
1964 void __stdcall glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1965 {
1966     EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, "
1967           "GLuint texture = %d, GLint level = %d)", target, attachment, textarget, texture, level);
1968
1969     try
1970     {
1971         gl::Context *context = gl::getNonLostContext();
1972         if (context)
1973         {
1974             if (context->getClientVersion() < 3 &&
1975                 !ValidateES2FramebufferTextureParameters(context, target, attachment, textarget, texture, level))
1976             {
1977                 return;
1978             }
1979
1980             if (context->getClientVersion() >= 3 &&
1981                 !ValidateES3FramebufferTextureParameters(context, target, attachment, textarget, texture, level, 0, false))
1982             {
1983                 return;
1984             }
1985
1986             if (texture == 0)
1987             {
1988                 textarget = GL_NONE;
1989             }
1990
1991             gl::Framebuffer *framebuffer = context->getTargetFramebuffer(target);
1992
1993             if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
1994             {
1995                 const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
1996                 framebuffer->setColorbuffer(colorAttachment, textarget, texture, level, 0);
1997             }
1998             else
1999             {
2000                 switch (attachment)
2001                 {
2002                   case GL_DEPTH_ATTACHMENT:         framebuffer->setDepthbuffer(textarget, texture, level, 0);        break;
2003                   case GL_STENCIL_ATTACHMENT:       framebuffer->setStencilbuffer(textarget, texture, level, 0);      break;
2004                   case GL_DEPTH_STENCIL_ATTACHMENT: framebuffer->setDepthStencilBuffer(textarget, texture, level, 0); break;
2005                 }
2006             }
2007         }
2008     }
2009     catch (...)
2010     {
2011         return gl::error(GL_OUT_OF_MEMORY);
2012     }
2013 }
2014
2015 void __stdcall glFrontFace(GLenum mode)
2016 {
2017     EVENT("(GLenum mode = 0x%X)", mode);
2018
2019     try
2020     {
2021         switch (mode)
2022         {
2023           case GL_CW:
2024           case GL_CCW:
2025             {
2026                 gl::Context *context = gl::getNonLostContext();
2027
2028                 if (context)
2029                 {
2030                     context->setFrontFace(mode);
2031                 }
2032             }
2033             break;
2034           default:
2035             return gl::error(GL_INVALID_ENUM);
2036         }
2037     }
2038     catch (...)
2039     {
2040         return gl::error(GL_OUT_OF_MEMORY);
2041     }
2042 }
2043
2044 void __stdcall glGenBuffers(GLsizei n, GLuint* buffers)
2045 {
2046     EVENT("(GLsizei n = %d, GLuint* buffers = 0x%0.8p)", n, buffers);
2047
2048     try
2049     {
2050         if (n < 0)
2051         {
2052             return gl::error(GL_INVALID_VALUE);
2053         }
2054
2055         gl::Context *context = gl::getNonLostContext();
2056
2057         if (context)
2058         {
2059             for (int i = 0; i < n; i++)
2060             {
2061                 buffers[i] = context->createBuffer();
2062             }
2063         }
2064     }
2065     catch (...)
2066     {
2067         return gl::error(GL_OUT_OF_MEMORY);
2068     }
2069 }
2070
2071 void __stdcall glGenerateMipmap(GLenum target)
2072 {
2073     EVENT("(GLenum target = 0x%X)", target);
2074
2075     try
2076     {
2077         gl::Context *context = gl::getNonLostContext();
2078
2079         if (context)
2080         {
2081             if (!ValidTextureTarget(context, target))
2082             {
2083                 return gl::error(GL_INVALID_ENUM);
2084             }
2085
2086             gl::Texture *texture = context->getTargetTexture(target);
2087
2088             if (texture == NULL)
2089             {
2090                 return gl::error(GL_INVALID_OPERATION);
2091             }
2092
2093             GLenum internalFormat = texture->getBaseLevelInternalFormat();
2094
2095             // Internally, all texture formats are sized so checking if the format
2096             // is color renderable and filterable will not fail.
2097
2098             bool validRenderable = (gl::IsColorRenderingSupported(internalFormat, context) ||
2099                                     gl::IsSizedInternalFormat(internalFormat, context->getClientVersion()));
2100
2101             if (gl::IsDepthRenderingSupported(internalFormat, context) ||
2102                 gl::IsFormatCompressed(internalFormat, context->getClientVersion()) ||
2103                 !gl::IsTextureFilteringSupported(internalFormat, context) ||
2104                 !validRenderable)
2105             {
2106                 return gl::error(GL_INVALID_OPERATION);
2107             }
2108
2109             // Non-power of 2 ES2 check
2110             if (!context->supportsNonPower2Texture() && (!gl::isPow2(texture->getBaseLevelWidth()) || !gl::isPow2(texture->getBaseLevelHeight())))
2111             {
2112                 ASSERT(context->getClientVersion() <= 2 && (target == GL_TEXTURE_2D || target == GL_TEXTURE_CUBE_MAP));
2113                 return gl::error(GL_INVALID_OPERATION);
2114             }
2115
2116             // Cube completeness check
2117             if (target == GL_TEXTURE_CUBE_MAP)
2118             {
2119                 gl::TextureCubeMap *textureCube = static_cast<gl::TextureCubeMap *>(texture);
2120                 if (!textureCube->isCubeComplete())
2121                 {
2122                     return gl::error(GL_INVALID_OPERATION);
2123                 }
2124             }
2125
2126             texture->generateMipmaps();
2127         }
2128     }
2129     catch (...)
2130     {
2131         return gl::error(GL_OUT_OF_MEMORY);
2132     }
2133 }
2134
2135 void __stdcall glGenFencesNV(GLsizei n, GLuint* fences)
2136 {
2137     EVENT("(GLsizei n = %d, GLuint* fences = 0x%0.8p)", n, fences);
2138
2139     try
2140     {
2141         if (n < 0)
2142         {
2143             return gl::error(GL_INVALID_VALUE);
2144         }
2145
2146         gl::Context *context = gl::getNonLostContext();
2147
2148         if (context)
2149         {
2150             for (int i = 0; i < n; i++)
2151             {
2152                 fences[i] = context->createFenceNV();
2153             }
2154         }
2155     }
2156     catch (...)
2157     {
2158         return gl::error(GL_OUT_OF_MEMORY);
2159     }
2160 }
2161
2162 void __stdcall glGenFramebuffers(GLsizei n, GLuint* framebuffers)
2163 {
2164     EVENT("(GLsizei n = %d, GLuint* framebuffers = 0x%0.8p)", n, framebuffers);
2165
2166     try
2167     {
2168         if (n < 0)
2169         {
2170             return gl::error(GL_INVALID_VALUE);
2171         }
2172
2173         gl::Context *context = gl::getNonLostContext();
2174
2175         if (context)
2176         {
2177             for (int i = 0; i < n; i++)
2178             {
2179                 framebuffers[i] = context->createFramebuffer();
2180             }
2181         }
2182     }
2183     catch (...)
2184     {
2185         return gl::error(GL_OUT_OF_MEMORY);
2186     }
2187 }
2188
2189 void __stdcall glGenQueriesEXT(GLsizei n, GLuint* ids)
2190 {
2191     EVENT("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);
2192
2193     try
2194     {
2195         gl::Context *context = gl::getNonLostContext();
2196
2197         if (context)
2198         {
2199             if (n < 0)
2200             {
2201                 return gl::error(GL_INVALID_VALUE);
2202             }
2203
2204             for (GLsizei i = 0; i < n; i++)
2205             {
2206                 ids[i] = context->createQuery();
2207             }
2208         }
2209     }
2210     catch (...)
2211     {
2212         return gl::error(GL_OUT_OF_MEMORY);
2213     }
2214 }
2215
2216 void __stdcall glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
2217 {
2218     EVENT("(GLsizei n = %d, GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);
2219
2220     try
2221     {
2222         if (n < 0)
2223         {
2224             return gl::error(GL_INVALID_VALUE);
2225         }
2226
2227         gl::Context *context = gl::getNonLostContext();
2228
2229         if (context)
2230         {
2231             for (int i = 0; i < n; i++)
2232             {
2233                 renderbuffers[i] = context->createRenderbuffer();
2234             }
2235         }
2236     }
2237     catch (...)
2238     {
2239         return gl::error(GL_OUT_OF_MEMORY);
2240     }
2241 }
2242
2243 void __stdcall glGenTextures(GLsizei n, GLuint* textures)
2244 {
2245     EVENT("(GLsizei n = %d, GLuint* textures = 0x%0.8p)", n, textures);
2246
2247     try
2248     {
2249         if (n < 0)
2250         {
2251             return gl::error(GL_INVALID_VALUE);
2252         }
2253
2254         gl::Context *context = gl::getNonLostContext();
2255
2256         if (context)
2257         {
2258             for (int i = 0; i < n; i++)
2259             {
2260                 textures[i] = context->createTexture();
2261             }
2262         }
2263     }
2264     catch (...)
2265     {
2266         return gl::error(GL_OUT_OF_MEMORY);
2267     }
2268 }
2269
2270 void __stdcall glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
2271 {
2272     EVENT("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, GLsizei *length = 0x%0.8p, "
2273           "GLint *size = 0x%0.8p, GLenum *type = %0.8p, GLchar *name = %0.8p)",
2274           program, index, bufsize, length, size, type, name);
2275
2276     try
2277     {
2278         if (bufsize < 0)
2279         {
2280             return gl::error(GL_INVALID_VALUE);
2281         }
2282
2283         gl::Context *context = gl::getNonLostContext();
2284
2285         if (context)
2286         {
2287             gl::Program *programObject = context->getProgram(program);
2288
2289             if (!programObject)
2290             {
2291                 if (context->getShader(program))
2292                 {
2293                     return gl::error(GL_INVALID_OPERATION);
2294                 }
2295                 else
2296                 {
2297                     return gl::error(GL_INVALID_VALUE);
2298                 }
2299             }
2300
2301             if (index >= (GLuint)programObject->getActiveAttributeCount())
2302             {
2303                 return gl::error(GL_INVALID_VALUE);
2304             }
2305
2306             programObject->getActiveAttribute(index, bufsize, length, size, type, name);
2307         }
2308     }
2309     catch (...)
2310     {
2311         return gl::error(GL_OUT_OF_MEMORY);
2312     }
2313 }
2314
2315 void __stdcall glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
2316 {
2317     EVENT("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, "
2318           "GLsizei* length = 0x%0.8p, GLint* size = 0x%0.8p, GLenum* type = 0x%0.8p, GLchar* name = 0x%0.8p)",
2319           program, index, bufsize, length, size, type, name);
2320
2321     try
2322     {
2323         if (bufsize < 0)
2324         {
2325             return gl::error(GL_INVALID_VALUE);
2326         }
2327
2328         gl::Context *context = gl::getNonLostContext();
2329
2330         if (context)
2331         {
2332             gl::Program *programObject = context->getProgram(program);
2333
2334             if (!programObject)
2335             {
2336                 if (context->getShader(program))
2337                 {
2338                     return gl::error(GL_INVALID_OPERATION);
2339                 }
2340                 else
2341                 {
2342                     return gl::error(GL_INVALID_VALUE);
2343                 }
2344             }
2345
2346             if (index >= (GLuint)programObject->getActiveUniformCount())
2347             {
2348                 return gl::error(GL_INVALID_VALUE);
2349             }
2350
2351             programObject->getActiveUniform(index, bufsize, length, size, type, name);
2352         }
2353     }
2354     catch (...)
2355     {
2356         return gl::error(GL_OUT_OF_MEMORY);
2357     }
2358 }
2359
2360 void __stdcall glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
2361 {
2362     EVENT("(GLuint program = %d, GLsizei maxcount = %d, GLsizei* count = 0x%0.8p, GLuint* shaders = 0x%0.8p)",
2363           program, maxcount, count, shaders);
2364
2365     try
2366     {
2367         if (maxcount < 0)
2368         {
2369             return gl::error(GL_INVALID_VALUE);
2370         }
2371
2372         gl::Context *context = gl::getNonLostContext();
2373
2374         if (context)
2375         {
2376             gl::Program *programObject = context->getProgram(program);
2377
2378             if (!programObject)
2379             {
2380                 if (context->getShader(program))
2381                 {
2382                     return gl::error(GL_INVALID_OPERATION);
2383                 }
2384                 else
2385                 {
2386                     return gl::error(GL_INVALID_VALUE);
2387                 }
2388             }
2389
2390             return programObject->getAttachedShaders(maxcount, count, shaders);
2391         }
2392     }
2393     catch (...)
2394     {
2395         return gl::error(GL_OUT_OF_MEMORY);
2396     }
2397 }
2398
2399 int __stdcall glGetAttribLocation(GLuint program, const GLchar* name)
2400 {
2401     EVENT("(GLuint program = %d, const GLchar* name = %s)", program, name);
2402
2403     try
2404     {
2405         gl::Context *context = gl::getNonLostContext();
2406
2407         if (context)
2408         {
2409
2410             gl::Program *programObject = context->getProgram(program);
2411
2412             if (!programObject)
2413             {
2414                 if (context->getShader(program))
2415                 {
2416                     return gl::error(GL_INVALID_OPERATION, -1);
2417                 }
2418                 else
2419                 {
2420                     return gl::error(GL_INVALID_VALUE, -1);
2421                 }
2422             }
2423
2424             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
2425             if (!programObject->isLinked() || !programBinary)
2426             {
2427                 return gl::error(GL_INVALID_OPERATION, -1);
2428             }
2429
2430             return programBinary->getAttributeLocation(name);
2431         }
2432     }
2433     catch (...)
2434     {
2435         return gl::error(GL_OUT_OF_MEMORY, -1);
2436     }
2437
2438     return -1;
2439 }
2440
2441 void __stdcall glGetBooleanv(GLenum pname, GLboolean* params)
2442 {
2443     EVENT("(GLenum pname = 0x%X, GLboolean* params = 0x%0.8p)",  pname, params);
2444
2445     try
2446     {
2447         gl::Context *context = gl::getNonLostContext();
2448
2449         if (context)
2450         {
2451             GLenum nativeType;
2452             unsigned int numParams = 0;
2453             if (!ValidateStateQuery(context, pname, &nativeType, &numParams))
2454             {
2455                 return;
2456             }
2457
2458             if (nativeType == GL_BOOL)
2459             {
2460                 context->getBooleanv(pname, params);
2461             }
2462             else
2463             {
2464                 CastStateValues(context, nativeType, pname, numParams, params);
2465             }
2466         }
2467     }
2468     catch (...)
2469     {
2470         return gl::error(GL_OUT_OF_MEMORY);
2471     }
2472 }
2473
2474 void __stdcall glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
2475 {
2476     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
2477
2478     try
2479     {
2480         gl::Context *context = gl::getNonLostContext();
2481
2482         if (context)
2483         {
2484             if (!gl::ValidBufferTarget(context, target))
2485             {
2486                 return gl::error(GL_INVALID_ENUM);
2487             }
2488
2489             if (!gl::ValidBufferParameter(context, pname))
2490             {
2491                 return gl::error(GL_INVALID_ENUM);
2492             }
2493
2494             gl::Buffer *buffer = context->getTargetBuffer(target);
2495
2496             if (!buffer)
2497             {
2498                 // A null buffer means that "0" is bound to the requested buffer target
2499                 return gl::error(GL_INVALID_OPERATION);
2500             }
2501
2502             switch (pname)
2503             {
2504               case GL_BUFFER_USAGE:
2505                 *params = static_cast<GLint>(buffer->usage());
2506                 break;
2507               case GL_BUFFER_SIZE:
2508                 *params = gl::clampCast<GLint>(buffer->size());
2509                 break;
2510               case GL_BUFFER_ACCESS_FLAGS:
2511                 *params = buffer->accessFlags();
2512                 break;
2513               case GL_BUFFER_MAPPED:
2514                 *params = static_cast<GLint>(buffer->mapped());
2515                 break;
2516               case GL_BUFFER_MAP_OFFSET:
2517                 *params = gl::clampCast<GLint>(buffer->mapOffset());
2518                 break;
2519               case GL_BUFFER_MAP_LENGTH:
2520                 *params = gl::clampCast<GLint>(buffer->mapLength());
2521                 break;
2522               default: UNREACHABLE(); break;
2523             }
2524         }
2525     }
2526     catch (...)
2527     {
2528         return gl::error(GL_OUT_OF_MEMORY);
2529     }
2530 }
2531
2532 GLenum __stdcall glGetError(void)
2533 {
2534     EVENT("()");
2535
2536     gl::Context *context = gl::getContext();
2537
2538     if (context)
2539     {
2540         return context->getError();
2541     }
2542
2543     return GL_NO_ERROR;
2544 }
2545
2546 void __stdcall glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
2547 {
2548     EVENT("(GLuint fence = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", fence, pname, params);
2549
2550     try
2551     {
2552
2553         gl::Context *context = gl::getNonLostContext();
2554
2555         if (context)
2556         {
2557             gl::FenceNV *fenceObject = context->getFenceNV(fence);
2558
2559             if (fenceObject == NULL)
2560             {
2561                 return gl::error(GL_INVALID_OPERATION);
2562             }
2563
2564             if (fenceObject->isFence() != GL_TRUE)
2565             {
2566                 return gl::error(GL_INVALID_OPERATION);
2567             }
2568
2569             switch (pname)
2570             {
2571               case GL_FENCE_STATUS_NV:
2572               case GL_FENCE_CONDITION_NV:
2573                 break;
2574
2575               default: return gl::error(GL_INVALID_ENUM);
2576             }
2577
2578             params[0] = fenceObject->getFencei(pname);
2579         }
2580     }
2581     catch (...)
2582     {
2583         return gl::error(GL_OUT_OF_MEMORY);
2584     }
2585 }
2586
2587 void __stdcall glGetFloatv(GLenum pname, GLfloat* params)
2588 {
2589     EVENT("(GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", pname, params);
2590
2591     try
2592     {
2593         gl::Context *context = gl::getNonLostContext();
2594
2595         if (context)
2596         {
2597             GLenum nativeType;
2598             unsigned int numParams = 0;
2599             if (!ValidateStateQuery(context, pname, &nativeType, &numParams))
2600             {
2601                 return;
2602             }
2603
2604             if (nativeType == GL_FLOAT)
2605             {
2606                 context->getFloatv(pname, params);
2607             }
2608             else
2609             {
2610                 CastStateValues(context, nativeType, pname, numParams, params);
2611             }
2612         }
2613     }
2614     catch (...)
2615     {
2616         return gl::error(GL_OUT_OF_MEMORY);
2617     }
2618 }
2619
2620 void __stdcall glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
2621 {
2622     EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)",
2623           target, attachment, pname, params);
2624
2625     try
2626     {
2627         gl::Context *context = gl::getNonLostContext();
2628
2629         if (context)
2630         {
2631             if (!gl::ValidFramebufferTarget(target))
2632             {
2633                 return gl::error(GL_INVALID_ENUM);
2634             }
2635
2636             switch (pname)
2637             {
2638               case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
2639               case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
2640               case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
2641               case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
2642                 break;
2643               case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
2644               case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
2645               case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
2646               case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
2647               case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
2648               case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
2649               case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
2650               case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
2651               case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
2652                 if (context->getClientVersion() >= 3)
2653                 {
2654                     break;
2655                 }
2656               default:
2657                 return gl::error(GL_INVALID_ENUM);
2658             }
2659
2660             // Determine if the attachment is a valid enum
2661             switch (attachment)
2662             {
2663               case GL_BACK:
2664               case GL_FRONT:
2665               case GL_DEPTH:
2666               case GL_STENCIL:
2667               case GL_DEPTH_STENCIL_ATTACHMENT:
2668                 if (context->getClientVersion() < 3)
2669                 {
2670                     return gl::error(GL_INVALID_ENUM);
2671                 }
2672                 break;
2673
2674               case GL_DEPTH_ATTACHMENT:
2675               case GL_STENCIL_ATTACHMENT:
2676                 break;
2677
2678               default:
2679                 if (attachment < GL_COLOR_ATTACHMENT0_EXT ||
2680                     (attachment - GL_COLOR_ATTACHMENT0_EXT) >= context->getMaximumRenderTargets())
2681                 {
2682                     return gl::error(GL_INVALID_ENUM);
2683                 }
2684                 break;
2685             }
2686
2687             GLuint framebufferHandle = context->getTargetFramebufferHandle(target);
2688             ASSERT(framebufferHandle != GL_INVALID_INDEX);
2689             gl::Framebuffer *framebuffer = context->getFramebuffer(framebufferHandle);
2690
2691             GLenum attachmentType;
2692             GLuint attachmentHandle;
2693             GLuint attachmentLevel;
2694             GLuint attachmentLayer;
2695             gl::FramebufferAttachment *attachmentObject;
2696
2697             if (framebufferHandle == 0)
2698             {
2699                 if (context->getClientVersion() < 3)
2700                 {
2701                     return gl::error(GL_INVALID_OPERATION);
2702                 }
2703
2704                 switch (attachment)
2705                 {
2706                   case GL_BACK:
2707                     attachmentType = framebuffer->getColorbufferType(0);
2708                     attachmentHandle = framebuffer->getColorbufferHandle(0);
2709                     attachmentLevel = framebuffer->getColorbufferMipLevel(0);
2710                     attachmentLayer = framebuffer->getColorbufferLayer(0);
2711                     attachmentObject = framebuffer->getColorbuffer(0);
2712                     break;
2713                   case GL_DEPTH:
2714                     attachmentType = framebuffer->getDepthbufferType();
2715                     attachmentHandle = framebuffer->getDepthbufferHandle();
2716                     attachmentLevel = framebuffer->getDepthbufferMipLevel();
2717                     attachmentLayer = framebuffer->getDepthbufferLayer();
2718                     attachmentObject = framebuffer->getDepthbuffer();
2719                     break;
2720                   case GL_STENCIL:
2721                     attachmentType = framebuffer->getStencilbufferType();
2722                     attachmentHandle = framebuffer->getStencilbufferHandle();
2723                     attachmentLevel = framebuffer->getStencilbufferMipLevel();
2724                     attachmentLayer = framebuffer->getStencilbufferLayer();
2725                     attachmentObject = framebuffer->getStencilbuffer();
2726                     break;
2727                   default:
2728                     return gl::error(GL_INVALID_OPERATION);
2729                 }
2730             }
2731             else
2732             {
2733                 if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
2734                 {
2735                     const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
2736                     attachmentType = framebuffer->getColorbufferType(colorAttachment);
2737                     attachmentHandle = framebuffer->getColorbufferHandle(colorAttachment);
2738                     attachmentLevel = framebuffer->getColorbufferMipLevel(colorAttachment);
2739                     attachmentLayer = framebuffer->getColorbufferLayer(colorAttachment);
2740                     attachmentObject = framebuffer->getColorbuffer(colorAttachment);
2741                 }
2742                 else
2743                 {
2744                     switch (attachment)
2745                     {
2746                       case GL_DEPTH_ATTACHMENT:
2747                         attachmentType = framebuffer->getDepthbufferType();
2748                         attachmentHandle = framebuffer->getDepthbufferHandle();
2749                         attachmentLevel = framebuffer->getDepthbufferMipLevel();
2750                         attachmentLayer = framebuffer->getDepthbufferLayer();
2751                         attachmentObject = framebuffer->getDepthbuffer();
2752                         break;
2753                       case GL_STENCIL_ATTACHMENT:
2754                         attachmentType = framebuffer->getStencilbufferType();
2755                         attachmentHandle = framebuffer->getStencilbufferHandle();
2756                         attachmentLevel = framebuffer->getStencilbufferMipLevel();
2757                         attachmentLayer = framebuffer->getStencilbufferLayer();
2758                         attachmentObject = framebuffer->getStencilbuffer();
2759                         break;
2760                       case GL_DEPTH_STENCIL_ATTACHMENT:
2761                         if (framebuffer->getDepthbufferHandle() != framebuffer->getStencilbufferHandle())
2762                         {
2763                             return gl::error(GL_INVALID_OPERATION);
2764                         }
2765                         attachmentType = framebuffer->getDepthStencilbufferType();
2766                         attachmentHandle = framebuffer->getDepthStencilbufferHandle();
2767                         attachmentLevel = framebuffer->getDepthStencilbufferMipLevel();
2768                         attachmentLayer = framebuffer->getDepthStencilbufferLayer();
2769                         attachmentObject = framebuffer->getDepthStencilBuffer();
2770                         break;
2771                       default:
2772                         return gl::error(GL_INVALID_OPERATION);
2773                     }
2774                 }
2775             }
2776
2777             GLenum attachmentObjectType;   // Type category
2778             if (framebufferHandle == 0)
2779             {
2780                 attachmentObjectType = GL_FRAMEBUFFER_DEFAULT;
2781             }
2782             else if (attachmentType == GL_NONE || attachmentType == GL_RENDERBUFFER)
2783             {
2784                 attachmentObjectType = attachmentType;
2785             }
2786             else if (gl::IsInternalTextureTarget(attachmentType, context->getClientVersion()))
2787             {
2788                 attachmentObjectType = GL_TEXTURE;
2789             }
2790             else
2791             {
2792                 UNREACHABLE();
2793                 return;
2794             }
2795
2796             if (attachmentObjectType == GL_NONE)
2797             {
2798                 // ES 2.0.25 spec pg 127 states that if the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
2799                 // is NONE, then querying any other pname will generate INVALID_ENUM.
2800
2801                 // ES 3.0.2 spec pg 235 states that if the attachment type is none,
2802                 // GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME will return zero and be an
2803                 // INVALID_OPERATION for all other pnames
2804
2805                 switch (pname)
2806                 {
2807                   case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
2808                     *params = attachmentObjectType;
2809                     break;
2810
2811                   case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
2812                     if (context->getClientVersion() < 3)
2813                     {
2814                         return gl::error(GL_INVALID_ENUM);
2815                     }
2816                     *params = 0;
2817                     break;
2818
2819                   default:
2820                     if (context->getClientVersion() < 3)
2821                     {
2822                         return gl::error(GL_INVALID_ENUM);
2823                     }
2824                     else
2825                     {
2826                         gl::error(GL_INVALID_OPERATION);
2827                     }
2828                 }
2829             }
2830             else
2831             {
2832                 ASSERT(attachmentObjectType == GL_RENDERBUFFER || attachmentObjectType == GL_TEXTURE ||
2833                        attachmentObjectType == GL_FRAMEBUFFER_DEFAULT);
2834                 ASSERT(attachmentObject != NULL);
2835
2836                 switch (pname)
2837                 {
2838                   case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
2839                     *params = attachmentObjectType;
2840                     break;
2841
2842                   case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
2843                     if (attachmentObjectType != GL_RENDERBUFFER && attachmentObjectType != GL_TEXTURE)
2844                     {
2845                         return gl::error(GL_INVALID_ENUM);
2846                     }
2847                     *params = attachmentHandle;
2848                     break;
2849
2850                   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
2851                     if (attachmentObjectType != GL_TEXTURE)
2852                     {
2853                         return gl::error(GL_INVALID_ENUM);
2854                     }
2855                     *params = attachmentLevel;
2856                     break;
2857
2858                   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
2859                     if (attachmentObjectType != GL_TEXTURE)
2860                     {
2861                         return gl::error(GL_INVALID_ENUM);
2862                     }
2863                     *params = gl::IsCubemapTextureTarget(attachmentType) ? attachmentType : 0;
2864                     break;
2865
2866                   case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
2867                     *params = attachmentObject->getRedSize();
2868                     break;
2869
2870                   case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
2871                     *params = attachmentObject->getGreenSize();
2872                     break;
2873
2874                   case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
2875                     *params = attachmentObject->getBlueSize();
2876                     break;
2877
2878                   case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
2879                     *params = attachmentObject->getAlphaSize();
2880                     break;
2881
2882                   case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
2883                     *params = attachmentObject->getDepthSize();
2884                     break;
2885
2886                   case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
2887                     *params = attachmentObject->getStencilSize();
2888                     break;
2889
2890                   case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
2891                     if (attachment == GL_DEPTH_STENCIL)
2892                     {
2893                         gl::error(GL_INVALID_OPERATION);
2894                     }
2895                     *params = attachmentObject->getComponentType();
2896                     break;
2897
2898                   case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
2899                     *params = attachmentObject->getColorEncoding();
2900                     break;
2901
2902                   case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
2903                     if (attachmentObjectType != GL_TEXTURE)
2904                     {
2905                         return gl::error(GL_INVALID_ENUM);
2906                     }
2907                     *params = attachmentLayer;
2908                     break;
2909
2910                   default:
2911                     UNREACHABLE();
2912                     break;
2913                 }
2914             }
2915         }
2916     }
2917     catch (...)
2918     {
2919         return gl::error(GL_OUT_OF_MEMORY);
2920     }
2921 }
2922
2923 GLenum __stdcall glGetGraphicsResetStatusEXT(void)
2924 {
2925     EVENT("()");
2926
2927     try
2928     {
2929         gl::Context *context = gl::getContext();
2930
2931         if (context)
2932         {
2933             return context->getResetStatus();
2934         }
2935
2936         return GL_NO_ERROR;
2937     }
2938     catch (...)
2939     {
2940         return GL_OUT_OF_MEMORY;
2941     }
2942 }
2943
2944 void __stdcall glGetIntegerv(GLenum pname, GLint* params)
2945 {
2946     EVENT("(GLenum pname = 0x%X, GLint* params = 0x%0.8p)", pname, params);
2947
2948     try
2949     {
2950         gl::Context *context = gl::getNonLostContext();
2951
2952         if (context)
2953         {
2954             GLenum nativeType;
2955             unsigned int numParams = 0;
2956
2957             if (!ValidateStateQuery(context, pname, &nativeType, &numParams))
2958             {
2959                 return;
2960             }
2961
2962             if (nativeType == GL_INT)
2963             {
2964                 context->getIntegerv(pname, params);
2965             }
2966             else
2967             {
2968                 CastStateValues(context, nativeType, pname, numParams, params);
2969             }
2970         }
2971     }
2972     catch (...)
2973     {
2974         return gl::error(GL_OUT_OF_MEMORY);
2975     }
2976 }
2977
2978 void __stdcall glGetProgramiv(GLuint program, GLenum pname, GLint* params)
2979 {
2980     EVENT("(GLuint program = %d, GLenum pname = %d, GLint* params = 0x%0.8p)", program, pname, params);
2981
2982     try
2983     {
2984         gl::Context *context = gl::getNonLostContext();
2985
2986         if (context)
2987         {
2988             gl::Program *programObject = context->getProgram(program);
2989
2990             if (!programObject)
2991             {
2992                 return gl::error(GL_INVALID_VALUE);
2993             }
2994
2995             if (context->getClientVersion() < 3)
2996             {
2997                 switch (pname)
2998                 {
2999                   case GL_ACTIVE_UNIFORM_BLOCKS:
3000                   case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH:
3001                   case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
3002                   case GL_TRANSFORM_FEEDBACK_VARYINGS:
3003                   case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
3004                     return gl::error(GL_INVALID_ENUM);
3005                 }
3006             }
3007
3008             switch (pname)
3009             {
3010               case GL_DELETE_STATUS:
3011                 *params = programObject->isFlaggedForDeletion();
3012                 return;
3013               case GL_LINK_STATUS:
3014                 *params = programObject->isLinked();
3015                 return;
3016               case GL_VALIDATE_STATUS:
3017                 *params = programObject->isValidated();
3018                 return;
3019               case GL_INFO_LOG_LENGTH:
3020                 *params = programObject->getInfoLogLength();
3021                 return;
3022               case GL_ATTACHED_SHADERS:
3023                 *params = programObject->getAttachedShadersCount();
3024                 return;
3025               case GL_ACTIVE_ATTRIBUTES:
3026                 *params = programObject->getActiveAttributeCount();
3027                 return;
3028               case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
3029                 *params = programObject->getActiveAttributeMaxLength();
3030                 return;
3031               case GL_ACTIVE_UNIFORMS:
3032                 *params = programObject->getActiveUniformCount();
3033                 return;
3034               case GL_ACTIVE_UNIFORM_MAX_LENGTH:
3035                 *params = programObject->getActiveUniformMaxLength();
3036                 return;
3037               case GL_PROGRAM_BINARY_LENGTH_OES:
3038                 *params = programObject->getProgramBinaryLength();
3039                 return;
3040               case GL_ACTIVE_UNIFORM_BLOCKS:
3041                 *params = programObject->getActiveUniformBlockCount();
3042                 return;
3043               case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH:
3044                 *params = programObject->getActiveUniformBlockMaxLength();
3045                 break;
3046               case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
3047                 *params = programObject->getTransformFeedbackBufferMode();
3048                 break;
3049               case GL_TRANSFORM_FEEDBACK_VARYINGS:
3050                 *params = programObject->getTransformFeedbackVaryingCount();
3051                 break;
3052               case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
3053                 *params = programObject->getTransformFeedbackVaryingMaxLength();
3054                 break;
3055               default:
3056                 return gl::error(GL_INVALID_ENUM);
3057             }
3058         }
3059     }
3060     catch (...)
3061     {
3062         return gl::error(GL_OUT_OF_MEMORY);
3063     }
3064 }
3065
3066 void __stdcall glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
3067 {
3068     EVENT("(GLuint program = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* infolog = 0x%0.8p)",
3069           program, bufsize, length, infolog);
3070
3071     try
3072     {
3073         if (bufsize < 0)
3074         {
3075             return gl::error(GL_INVALID_VALUE);
3076         }
3077
3078         gl::Context *context = gl::getNonLostContext();
3079
3080         if (context)
3081         {
3082             gl::Program *programObject = context->getProgram(program);
3083
3084             if (!programObject)
3085             {
3086                 return gl::error(GL_INVALID_VALUE);
3087             }
3088
3089             programObject->getInfoLog(bufsize, length, infolog);
3090         }
3091     }
3092     catch (...)
3093     {
3094         return gl::error(GL_OUT_OF_MEMORY);
3095     }
3096 }
3097
3098 void __stdcall glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
3099 {
3100     EVENT("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname, params);
3101
3102     try
3103     {
3104         gl::Context *context = gl::getNonLostContext();
3105
3106         if (context)
3107         {
3108             if (!ValidQueryType(context, target))
3109             {
3110                 return gl::error(GL_INVALID_ENUM);
3111             }
3112
3113             switch (pname)
3114             {
3115               case GL_CURRENT_QUERY_EXT:
3116                 params[0] = context->getActiveQueryId(target);
3117                 break;
3118
3119               default:
3120                 return gl::error(GL_INVALID_ENUM);
3121             }
3122         }
3123     }
3124     catch (...)
3125     {
3126         return gl::error(GL_OUT_OF_MEMORY);
3127     }
3128 }
3129
3130 void __stdcall glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
3131 {
3132     EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params);
3133
3134     try
3135     {
3136         gl::Context *context = gl::getNonLostContext();
3137
3138         if (context)
3139         {
3140             gl::Query *queryObject = context->getQuery(id, false, GL_NONE);
3141
3142             if (!queryObject)
3143             {
3144                 return gl::error(GL_INVALID_OPERATION);
3145             }
3146
3147             if (context->getActiveQueryId(queryObject->getType()) == id)
3148             {
3149                 return gl::error(GL_INVALID_OPERATION);
3150             }
3151
3152             switch(pname)
3153             {
3154               case GL_QUERY_RESULT_EXT:
3155                 params[0] = queryObject->getResult();
3156                 break;
3157               case GL_QUERY_RESULT_AVAILABLE_EXT:
3158                 params[0] = queryObject->isResultAvailable();
3159                 break;
3160               default:
3161                 return gl::error(GL_INVALID_ENUM);
3162             }
3163         }
3164     }
3165     catch (...)
3166     {
3167         return gl::error(GL_OUT_OF_MEMORY);
3168     }
3169 }
3170
3171 void __stdcall glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
3172 {
3173     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
3174
3175     try
3176     {
3177         gl::Context *context = gl::getNonLostContext();
3178
3179         if (context)
3180         {
3181             if (target != GL_RENDERBUFFER)
3182             {
3183                 return gl::error(GL_INVALID_ENUM);
3184             }
3185
3186             if (context->getRenderbufferHandle() == 0)
3187             {
3188                 return gl::error(GL_INVALID_OPERATION);
3189             }
3190
3191             gl::FramebufferAttachment *attachment = context->getRenderbuffer(context->getRenderbufferHandle());
3192
3193             switch (pname)
3194             {
3195               case GL_RENDERBUFFER_WIDTH:           *params = attachment->getWidth();          break;
3196               case GL_RENDERBUFFER_HEIGHT:          *params = attachment->getHeight();         break;
3197               case GL_RENDERBUFFER_INTERNAL_FORMAT: *params = attachment->getInternalFormat(); break;
3198               case GL_RENDERBUFFER_RED_SIZE:        *params = attachment->getRedSize();        break;
3199               case GL_RENDERBUFFER_GREEN_SIZE:      *params = attachment->getGreenSize();      break;
3200               case GL_RENDERBUFFER_BLUE_SIZE:       *params = attachment->getBlueSize();       break;
3201               case GL_RENDERBUFFER_ALPHA_SIZE:      *params = attachment->getAlphaSize();      break;
3202               case GL_RENDERBUFFER_DEPTH_SIZE:      *params = attachment->getDepthSize();      break;
3203               case GL_RENDERBUFFER_STENCIL_SIZE:    *params = attachment->getStencilSize();    break;
3204               case GL_RENDERBUFFER_SAMPLES_ANGLE:
3205                 if (context->getMaxSupportedSamples() != 0)
3206                 {
3207                     *params = attachment->getSamples();
3208                 }
3209                 else
3210                 {
3211                     return gl::error(GL_INVALID_ENUM);
3212                 }
3213                 break;
3214               default:
3215                 return gl::error(GL_INVALID_ENUM);
3216             }
3217         }
3218     }
3219     catch (...)
3220     {
3221         return gl::error(GL_OUT_OF_MEMORY);
3222     }
3223 }
3224
3225 void __stdcall glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
3226 {
3227     EVENT("(GLuint shader = %d, GLenum pname = %d, GLint* params = 0x%0.8p)", shader, pname, params);
3228
3229     try
3230     {
3231         gl::Context *context = gl::getNonLostContext();
3232
3233         if (context)
3234         {
3235             gl::Shader *shaderObject = context->getShader(shader);
3236
3237             if (!shaderObject)
3238             {
3239                 return gl::error(GL_INVALID_VALUE);
3240             }
3241
3242             switch (pname)
3243             {
3244               case GL_SHADER_TYPE:
3245                 *params = shaderObject->getType();
3246                 return;
3247               case GL_DELETE_STATUS:
3248                 *params = shaderObject->isFlaggedForDeletion();
3249                 return;
3250               case GL_COMPILE_STATUS:
3251                 *params = shaderObject->isCompiled() ? GL_TRUE : GL_FALSE;
3252                 return;
3253               case GL_INFO_LOG_LENGTH:
3254                 *params = shaderObject->getInfoLogLength();
3255                 return;
3256               case GL_SHADER_SOURCE_LENGTH:
3257                 *params = shaderObject->getSourceLength();
3258                 return;
3259               case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
3260                 *params = shaderObject->getTranslatedSourceLength();
3261                 return;
3262               default:
3263                 return gl::error(GL_INVALID_ENUM);
3264             }
3265         }
3266     }
3267     catch (...)
3268     {
3269         return gl::error(GL_OUT_OF_MEMORY);
3270     }
3271 }
3272
3273 void __stdcall glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
3274 {
3275     EVENT("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* infolog = 0x%0.8p)",
3276           shader, bufsize, length, infolog);
3277
3278     try
3279     {
3280         if (bufsize < 0)
3281         {
3282             return gl::error(GL_INVALID_VALUE);
3283         }
3284
3285         gl::Context *context = gl::getNonLostContext();
3286
3287         if (context)
3288         {
3289             gl::Shader *shaderObject = context->getShader(shader);
3290
3291             if (!shaderObject)
3292             {
3293                 return gl::error(GL_INVALID_VALUE);
3294             }
3295
3296             shaderObject->getInfoLog(bufsize, length, infolog);
3297         }
3298     }
3299     catch (...)
3300     {
3301         return gl::error(GL_OUT_OF_MEMORY);
3302     }
3303 }
3304
3305 void __stdcall glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
3306 {
3307     EVENT("(GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint* range = 0x%0.8p, GLint* precision = 0x%0.8p)",
3308           shadertype, precisiontype, range, precision);
3309
3310     try
3311     {
3312         switch (shadertype)
3313         {
3314           case GL_VERTEX_SHADER:
3315           case GL_FRAGMENT_SHADER:
3316             break;
3317           default:
3318             return gl::error(GL_INVALID_ENUM);
3319         }
3320
3321         switch (precisiontype)
3322         {
3323           case GL_LOW_FLOAT:
3324           case GL_MEDIUM_FLOAT:
3325           case GL_HIGH_FLOAT:
3326             // Assume IEEE 754 precision
3327             range[0] = 127;
3328             range[1] = 127;
3329             *precision = 23;
3330             break;
3331           case GL_LOW_INT:
3332           case GL_MEDIUM_INT:
3333           case GL_HIGH_INT:
3334             // Some (most) hardware only supports single-precision floating-point numbers,
3335             // which can accurately represent integers up to +/-16777216
3336             range[0] = 24;
3337             range[1] = 24;
3338             *precision = 0;
3339             break;
3340           default:
3341             return gl::error(GL_INVALID_ENUM);
3342         }
3343     }
3344     catch (...)
3345     {
3346         return gl::error(GL_OUT_OF_MEMORY);
3347     }
3348 }
3349
3350 void __stdcall glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
3351 {
3352     EVENT("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* source = 0x%0.8p)",
3353           shader, bufsize, length, source);
3354
3355     try
3356     {
3357         if (bufsize < 0)
3358         {
3359             return gl::error(GL_INVALID_VALUE);
3360         }
3361
3362         gl::Context *context = gl::getNonLostContext();
3363
3364         if (context)
3365         {
3366             gl::Shader *shaderObject = context->getShader(shader);
3367
3368             if (!shaderObject)
3369             {
3370                 return gl::error(GL_INVALID_OPERATION);
3371             }
3372
3373             shaderObject->getSource(bufsize, length, source);
3374         }
3375     }
3376     catch (...)
3377     {
3378         return gl::error(GL_OUT_OF_MEMORY);
3379     }
3380 }
3381
3382 void __stdcall glGetTranslatedShaderSourceANGLE(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
3383 {
3384     EVENT("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* source = 0x%0.8p)",
3385           shader, bufsize, length, source);
3386
3387     try
3388     {
3389         if (bufsize < 0)
3390         {
3391             return gl::error(GL_INVALID_VALUE);
3392         }
3393
3394         gl::Context *context = gl::getNonLostContext();
3395
3396         if (context)
3397         {
3398             gl::Shader *shaderObject = context->getShader(shader);
3399
3400             if (!shaderObject)
3401             {
3402                 return gl::error(GL_INVALID_OPERATION);
3403             }
3404
3405             shaderObject->getTranslatedSource(bufsize, length, source);
3406         }
3407     }
3408     catch (...)
3409     {
3410         return gl::error(GL_OUT_OF_MEMORY);
3411     }
3412 }
3413
3414 const GLubyte* __stdcall glGetString(GLenum name)
3415 {
3416     EVENT("(GLenum name = 0x%X)", name);
3417
3418     try
3419     {
3420         gl::Context *context = gl::getNonLostContext();
3421
3422         switch (name)
3423         {
3424           case GL_VENDOR:
3425             return (GLubyte*)"Google Inc.";
3426           case GL_RENDERER:
3427             return (GLubyte*)((context != NULL) ? context->getRendererString() : "ANGLE");
3428           case GL_VERSION:
3429             if (context->getClientVersion() == 2)
3430             {
3431                 return (GLubyte*)"OpenGL ES 2.0 (ANGLE " ANGLE_VERSION_STRING ")";
3432             }
3433             else
3434             {
3435                 return (GLubyte*)"OpenGL ES 3.0 (ANGLE " ANGLE_VERSION_STRING ")";
3436             }
3437           case GL_SHADING_LANGUAGE_VERSION:
3438             if (context->getClientVersion() == 2)
3439             {
3440                 return (GLubyte*)"OpenGL ES GLSL ES 1.00 (ANGLE " ANGLE_VERSION_STRING ")";
3441             }
3442             else
3443             {
3444                 return (GLubyte*)"OpenGL ES GLSL ES 3.00 (ANGLE " ANGLE_VERSION_STRING ")";
3445             }
3446           case GL_EXTENSIONS:
3447             return (GLubyte*)((context != NULL) ? context->getCombinedExtensionsString() : "");
3448           default:
3449             return gl::error(GL_INVALID_ENUM, (GLubyte*)NULL);
3450         }
3451     }
3452     catch (...)
3453     {
3454         return gl::error(GL_OUT_OF_MEMORY, (GLubyte*)NULL);
3455     }
3456 }
3457
3458 void __stdcall glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
3459 {
3460     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", target, pname, params);
3461
3462     try
3463     {
3464         gl::Context *context = gl::getNonLostContext();
3465
3466         if (context)
3467         {
3468             gl::Texture *texture = context->getTargetTexture(target);
3469
3470             if (!texture)
3471             {
3472                 return gl::error(GL_INVALID_ENUM);
3473             }
3474
3475             switch (pname)
3476             {
3477               case GL_TEXTURE_MAG_FILTER:
3478                 *params = (GLfloat)texture->getMagFilter();
3479                 break;
3480               case GL_TEXTURE_MIN_FILTER:
3481                 *params = (GLfloat)texture->getMinFilter();
3482                 break;
3483               case GL_TEXTURE_WRAP_S:
3484                 *params = (GLfloat)texture->getWrapS();
3485                 break;
3486               case GL_TEXTURE_WRAP_T:
3487                 *params = (GLfloat)texture->getWrapT();
3488                 break;
3489               case GL_TEXTURE_WRAP_R:
3490                 if (context->getClientVersion() < 3)
3491                 {
3492                     return gl::error(GL_INVALID_ENUM);
3493                 }
3494                 *params = (GLfloat)texture->getWrapR();
3495                 break;
3496               case GL_TEXTURE_IMMUTABLE_FORMAT:
3497                 // Exposed to ES2.0 through EXT_texture_storage, no client version validation.
3498                 *params = (GLfloat)(texture->isImmutable() ? GL_TRUE : GL_FALSE);
3499                 break;
3500               case GL_TEXTURE_IMMUTABLE_LEVELS:
3501                 if (context->getClientVersion() < 3)
3502                 {
3503                     return gl::error(GL_INVALID_ENUM);
3504                 }
3505                 *params = (GLfloat)texture->immutableLevelCount();
3506                 break;
3507               case GL_TEXTURE_USAGE_ANGLE:
3508                 *params = (GLfloat)texture->getUsage();
3509                 break;
3510               case GL_TEXTURE_MAX_ANISOTROPY_EXT:
3511                 if (!context->supportsTextureFilterAnisotropy())
3512                 {
3513                     return gl::error(GL_INVALID_ENUM);
3514                 }
3515                 *params = (GLfloat)texture->getMaxAnisotropy();
3516                 break;
3517               case GL_TEXTURE_SWIZZLE_R:
3518                 if (context->getClientVersion() < 3)
3519                 {
3520                     return gl::error(GL_INVALID_ENUM);
3521                 }
3522                 *params = (GLfloat)texture->getSwizzleRed();
3523                 break;
3524               case GL_TEXTURE_SWIZZLE_G:
3525                 if (context->getClientVersion() < 3)
3526                 {
3527                     return gl::error(GL_INVALID_ENUM);
3528                 }
3529                 *params = (GLfloat)texture->getSwizzleGreen();
3530                 break;
3531               case GL_TEXTURE_SWIZZLE_B:
3532                 if (context->getClientVersion() < 3)
3533                 {
3534                     return gl::error(GL_INVALID_ENUM);
3535                 }
3536                 *params = (GLfloat)texture->getSwizzleBlue();
3537                 break;
3538               case GL_TEXTURE_SWIZZLE_A:
3539                 if (context->getClientVersion() < 3)
3540                 {
3541                     return gl::error(GL_INVALID_ENUM);
3542                 }
3543                 *params = (GLfloat)texture->getSwizzleAlpha();
3544                 break;
3545               case GL_TEXTURE_BASE_LEVEL:
3546                 if (context->getClientVersion() < 3)
3547                 {
3548                     return gl::error(GL_INVALID_ENUM);
3549                 }
3550                 *params = (GLfloat)texture->getBaseLevel();
3551                 break;
3552               case GL_TEXTURE_MAX_LEVEL:
3553                 if (context->getClientVersion() < 3)
3554                 {
3555                     return gl::error(GL_INVALID_ENUM);
3556                 }
3557                 *params = (GLfloat)texture->getMaxLevel();
3558                 break;
3559               case GL_TEXTURE_MIN_LOD:
3560                 if (context->getClientVersion() < 3)
3561                 {
3562                     return gl::error(GL_INVALID_ENUM);
3563                 }
3564                 *params = texture->getMinLod();
3565                 break;
3566               case GL_TEXTURE_MAX_LOD:
3567                 if (context->getClientVersion() < 3)
3568                 {
3569                     return gl::error(GL_INVALID_ENUM);
3570                 }
3571                 *params = texture->getMaxLod();
3572                 break;
3573               default:
3574                 return gl::error(GL_INVALID_ENUM);
3575             }
3576         }
3577     }
3578     catch (...)
3579     {
3580         return gl::error(GL_OUT_OF_MEMORY);
3581     }
3582 }
3583
3584 void __stdcall glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
3585 {
3586     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
3587
3588     try
3589     {
3590         gl::Context *context = gl::getNonLostContext();
3591
3592         if (context)
3593         {
3594             gl::Texture *texture = context->getTargetTexture(target);
3595
3596             if (!texture)
3597             {
3598                 return gl::error(GL_INVALID_ENUM);
3599             }
3600
3601             switch (pname)
3602             {
3603               case GL_TEXTURE_MAG_FILTER:
3604                 *params = texture->getMagFilter();
3605                 break;
3606               case GL_TEXTURE_MIN_FILTER:
3607                 *params = texture->getMinFilter();
3608                 break;
3609               case GL_TEXTURE_WRAP_S:
3610                 *params = texture->getWrapS();
3611                 break;
3612               case GL_TEXTURE_WRAP_T:
3613                 *params = texture->getWrapT();
3614                 break;
3615               case GL_TEXTURE_WRAP_R:
3616                 if (context->getClientVersion() < 3)
3617                 {
3618                     return gl::error(GL_INVALID_ENUM);
3619                 }
3620                 *params = texture->getWrapR();
3621                 break;
3622               case GL_TEXTURE_IMMUTABLE_FORMAT:
3623                 // Exposed to ES2.0 through EXT_texture_storage, no client version validation.
3624                 *params = texture->isImmutable() ? GL_TRUE : GL_FALSE;
3625                 break;
3626               case GL_TEXTURE_IMMUTABLE_LEVELS:
3627                 if (context->getClientVersion() < 3)
3628                 {
3629                     return gl::error(GL_INVALID_ENUM);
3630                 }
3631                 *params = texture->immutableLevelCount();
3632                 break;
3633               case GL_TEXTURE_USAGE_ANGLE:
3634                 *params = texture->getUsage();
3635                 break;
3636               case GL_TEXTURE_MAX_ANISOTROPY_EXT:
3637                 if (!context->supportsTextureFilterAnisotropy())
3638                 {
3639                     return gl::error(GL_INVALID_ENUM);
3640                 }
3641                 *params = (GLint)texture->getMaxAnisotropy();
3642                 break;
3643               case GL_TEXTURE_SWIZZLE_R:
3644                 if (context->getClientVersion() < 3)
3645                 {
3646                     return gl::error(GL_INVALID_ENUM);
3647                 }
3648                 *params = texture->getSwizzleRed();
3649                 break;
3650               case GL_TEXTURE_SWIZZLE_G:
3651                 if (context->getClientVersion() < 3)
3652                 {
3653                     return gl::error(GL_INVALID_ENUM);
3654                 }
3655                 *params = texture->getSwizzleGreen();
3656                 break;
3657               case GL_TEXTURE_SWIZZLE_B:
3658                 if (context->getClientVersion() < 3)
3659                 {
3660                     return gl::error(GL_INVALID_ENUM);
3661                 }
3662                 *params = texture->getSwizzleBlue();
3663                 break;
3664               case GL_TEXTURE_SWIZZLE_A:
3665                 if (context->getClientVersion() < 3)
3666                 {
3667                     return gl::error(GL_INVALID_ENUM);
3668                 }
3669                 *params = texture->getSwizzleAlpha();
3670                 break;
3671               case GL_TEXTURE_BASE_LEVEL:
3672                 if (context->getClientVersion() < 3)
3673                 {
3674                     return gl::error(GL_INVALID_ENUM);
3675                 }
3676                 *params = texture->getBaseLevel();
3677                 break;
3678               case GL_TEXTURE_MAX_LEVEL:
3679                 if (context->getClientVersion() < 3)
3680                 {
3681                     return gl::error(GL_INVALID_ENUM);
3682                 }
3683                 *params = texture->getMaxLevel();
3684                 break;
3685               case GL_TEXTURE_MIN_LOD:
3686                 if (context->getClientVersion() < 3)
3687                 {
3688                     return gl::error(GL_INVALID_ENUM);
3689                 }
3690                 *params = (GLint)texture->getMinLod();
3691                 break;
3692               case GL_TEXTURE_MAX_LOD:
3693                 if (context->getClientVersion() < 3)
3694                 {
3695                     return gl::error(GL_INVALID_ENUM);
3696                 }
3697                 *params = (GLint)texture->getMaxLod();
3698                 break;
3699               default:
3700                 return gl::error(GL_INVALID_ENUM);
3701             }
3702         }
3703     }
3704     catch (...)
3705     {
3706         return gl::error(GL_OUT_OF_MEMORY);
3707     }
3708 }
3709
3710 void __stdcall glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params)
3711 {
3712     EVENT("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLfloat* params = 0x%0.8p)",
3713           program, location, bufSize, params);
3714
3715     try
3716     {
3717         if (bufSize < 0)
3718         {
3719             return gl::error(GL_INVALID_VALUE);
3720         }
3721
3722         gl::Context *context = gl::getNonLostContext();
3723
3724         if (context)
3725         {
3726             if (program == 0)
3727             {
3728                 return gl::error(GL_INVALID_VALUE);
3729             }
3730
3731             gl::Program *programObject = context->getProgram(program);
3732
3733             if (!programObject || !programObject->isLinked())
3734             {
3735                 return gl::error(GL_INVALID_OPERATION);
3736             }
3737
3738             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
3739             if (!programBinary)
3740             {
3741                 return gl::error(GL_INVALID_OPERATION);
3742             }
3743
3744             if (!programBinary->getUniformfv(location, &bufSize, params))
3745             {
3746                 return gl::error(GL_INVALID_OPERATION);
3747             }
3748         }
3749     }
3750     catch (...)
3751     {
3752         return gl::error(GL_OUT_OF_MEMORY);
3753     }
3754 }
3755
3756 void __stdcall glGetUniformfv(GLuint program, GLint location, GLfloat* params)
3757 {
3758     EVENT("(GLuint program = %d, GLint location = %d, GLfloat* params = 0x%0.8p)", program, location, params);
3759
3760     try
3761     {
3762         gl::Context *context = gl::getNonLostContext();
3763
3764         if (context)
3765         {
3766             if (program == 0)
3767             {
3768                 return gl::error(GL_INVALID_VALUE);
3769             }
3770
3771             gl::Program *programObject = context->getProgram(program);
3772
3773             if (!programObject || !programObject->isLinked())
3774             {
3775                 return gl::error(GL_INVALID_OPERATION);
3776             }
3777
3778             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
3779             if (!programBinary)
3780             {
3781                 return gl::error(GL_INVALID_OPERATION);
3782             }
3783
3784             if (!programBinary->getUniformfv(location, NULL, params))
3785             {
3786                 return gl::error(GL_INVALID_OPERATION);
3787             }
3788         }
3789     }
3790     catch (...)
3791     {
3792         return gl::error(GL_OUT_OF_MEMORY);
3793     }
3794 }
3795
3796 void __stdcall glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params)
3797 {
3798     EVENT("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLint* params = 0x%0.8p)",
3799           program, location, bufSize, params);
3800
3801     try
3802     {
3803         if (bufSize < 0)
3804         {
3805             return gl::error(GL_INVALID_VALUE);
3806         }
3807
3808         gl::Context *context = gl::getNonLostContext();
3809
3810         if (context)
3811         {
3812             if (program == 0)
3813             {
3814                 return gl::error(GL_INVALID_VALUE);
3815             }
3816
3817             gl::Program *programObject = context->getProgram(program);
3818
3819             if (!programObject || !programObject->isLinked())
3820             {
3821                 return gl::error(GL_INVALID_OPERATION);
3822             }
3823
3824             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
3825             if (!programBinary)
3826             {
3827                 return gl::error(GL_INVALID_OPERATION);
3828             }
3829
3830             if (!programBinary->getUniformiv(location, &bufSize, params))
3831             {
3832                 return gl::error(GL_INVALID_OPERATION);
3833             }
3834         }
3835     }
3836     catch (...)
3837     {
3838         return gl::error(GL_OUT_OF_MEMORY);
3839     }
3840 }
3841
3842 void __stdcall glGetUniformiv(GLuint program, GLint location, GLint* params)
3843 {
3844     EVENT("(GLuint program = %d, GLint location = %d, GLint* params = 0x%0.8p)", program, location, params);
3845
3846     try
3847     {
3848         gl::Context *context = gl::getNonLostContext();
3849
3850         if (context)
3851         {
3852             if (program == 0)
3853             {
3854                 return gl::error(GL_INVALID_VALUE);
3855             }
3856
3857             gl::Program *programObject = context->getProgram(program);
3858
3859             if (!programObject || !programObject->isLinked())
3860             {
3861                 return gl::error(GL_INVALID_OPERATION);
3862             }
3863
3864             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
3865             if (!programBinary)
3866             {
3867                 return gl::error(GL_INVALID_OPERATION);
3868             }
3869
3870             if (!programBinary->getUniformiv(location, NULL, params))
3871             {
3872                 return gl::error(GL_INVALID_OPERATION);
3873             }
3874         }
3875     }
3876     catch (...)
3877     {
3878         return gl::error(GL_OUT_OF_MEMORY);
3879     }
3880 }
3881
3882 int __stdcall glGetUniformLocation(GLuint program, const GLchar* name)
3883 {
3884     EVENT("(GLuint program = %d, const GLchar* name = 0x%0.8p)", program, name);
3885
3886     try
3887     {
3888         gl::Context *context = gl::getNonLostContext();
3889
3890         if (strstr(name, "gl_") == name)
3891         {
3892             return -1;
3893         }
3894
3895         if (context)
3896         {
3897             gl::Program *programObject = context->getProgram(program);
3898
3899             if (!programObject)
3900             {
3901                 if (context->getShader(program))
3902                 {
3903                     return gl::error(GL_INVALID_OPERATION, -1);
3904                 }
3905                 else
3906                 {
3907                     return gl::error(GL_INVALID_VALUE, -1);
3908                 }
3909             }
3910
3911             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
3912             if (!programObject->isLinked() || !programBinary)
3913             {
3914                 return gl::error(GL_INVALID_OPERATION, -1);
3915             }
3916
3917             return programBinary->getUniformLocation(name);
3918         }
3919     }
3920     catch (...)
3921     {
3922         return gl::error(GL_OUT_OF_MEMORY, -1);
3923     }
3924
3925     return -1;
3926 }
3927
3928 void __stdcall glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
3929 {
3930     EVENT("(GLuint index = %d, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", index, pname, params);
3931
3932     try
3933     {
3934         gl::Context *context = gl::getNonLostContext();
3935
3936         if (context)
3937         {
3938             if (index >= gl::MAX_VERTEX_ATTRIBS)
3939             {
3940                 return gl::error(GL_INVALID_VALUE);
3941             }
3942
3943             const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
3944
3945             if (!gl::ValidateGetVertexAttribParameters(pname, context->getClientVersion()))
3946             {
3947                 return;
3948             }
3949
3950             if (pname == GL_CURRENT_VERTEX_ATTRIB)
3951             {
3952                 const gl::VertexAttribCurrentValueData &currentValueData = context->getVertexAttribCurrentValue(index);
3953                 for (int i = 0; i < 4; ++i)
3954                 {
3955                     params[i] = currentValueData.FloatValues[i];
3956                 }
3957             }
3958             else
3959             {
3960                 *params = attribState.querySingleParameter<GLfloat>(pname);
3961             }
3962         }
3963     }
3964     catch (...)
3965     {
3966         return gl::error(GL_OUT_OF_MEMORY);
3967     }
3968 }
3969
3970 void __stdcall glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
3971 {
3972     EVENT("(GLuint index = %d, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", index, pname, params);
3973
3974     try
3975     {
3976         gl::Context *context = gl::getNonLostContext();
3977
3978         if (context)
3979         {
3980             if (index >= gl::MAX_VERTEX_ATTRIBS)
3981             {
3982                 return gl::error(GL_INVALID_VALUE);
3983             }
3984
3985             const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
3986
3987             if (!gl::ValidateGetVertexAttribParameters(pname, context->getClientVersion()))
3988             {
3989                 return;
3990             }
3991
3992             if (pname == GL_CURRENT_VERTEX_ATTRIB)
3993             {
3994                 const gl::VertexAttribCurrentValueData &currentValueData = context->getVertexAttribCurrentValue(index);
3995                 for (int i = 0; i < 4; ++i)
3996                 {
3997                     float currentValue = currentValueData.FloatValues[i];
3998                     params[i] = gl::iround<GLint>(currentValue);
3999                 }
4000             }
4001             else
4002             {
4003                 *params = attribState.querySingleParameter<GLint>(pname);
4004             }
4005         }
4006     }
4007     catch (...)
4008     {
4009         return gl::error(GL_OUT_OF_MEMORY);
4010     }
4011 }
4012
4013 void __stdcall glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
4014 {
4015     EVENT("(GLuint index = %d, GLenum pname = 0x%X, GLvoid** pointer = 0x%0.8p)", index, pname, pointer);
4016
4017     try
4018     {
4019         gl::Context *context = gl::getNonLostContext();
4020
4021         if (context)
4022         {
4023             if (index >= gl::MAX_VERTEX_ATTRIBS)
4024             {
4025                 return gl::error(GL_INVALID_VALUE);
4026             }
4027
4028             if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
4029             {
4030                 return gl::error(GL_INVALID_ENUM);
4031             }
4032
4033             *pointer = const_cast<GLvoid*>(context->getVertexAttribPointer(index));
4034         }
4035     }
4036     catch (...)
4037     {
4038         return gl::error(GL_OUT_OF_MEMORY);
4039     }
4040 }
4041
4042 void __stdcall glHint(GLenum target, GLenum mode)
4043 {
4044     EVENT("(GLenum target = 0x%X, GLenum mode = 0x%X)", target, mode);
4045
4046     try
4047     {
4048         switch (mode)
4049         {
4050           case GL_FASTEST:
4051           case GL_NICEST:
4052           case GL_DONT_CARE:
4053             break;
4054           default:
4055             return gl::error(GL_INVALID_ENUM);
4056         }
4057
4058         gl::Context *context = gl::getNonLostContext();
4059         switch (target)
4060         {
4061           case GL_GENERATE_MIPMAP_HINT:
4062             if (context) context->setGenerateMipmapHint(mode);
4063             break;
4064           case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
4065             if (context) context->setFragmentShaderDerivativeHint(mode);
4066             break;
4067           default:
4068             return gl::error(GL_INVALID_ENUM);
4069         }
4070     }
4071     catch (...)
4072     {
4073         return gl::error(GL_OUT_OF_MEMORY);
4074     }
4075 }
4076
4077 GLboolean __stdcall glIsBuffer(GLuint buffer)
4078 {
4079     EVENT("(GLuint buffer = %d)", buffer);
4080
4081     try
4082     {
4083         gl::Context *context = gl::getNonLostContext();
4084
4085         if (context && buffer)
4086         {
4087             gl::Buffer *bufferObject = context->getBuffer(buffer);
4088
4089             if (bufferObject)
4090             {
4091                 return GL_TRUE;
4092             }
4093         }
4094     }
4095     catch (...)
4096     {
4097         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
4098     }
4099
4100     return GL_FALSE;
4101 }
4102
4103 GLboolean __stdcall glIsEnabled(GLenum cap)
4104 {
4105     EVENT("(GLenum cap = 0x%X)", cap);
4106
4107     try
4108     {
4109         gl::Context *context = gl::getNonLostContext();
4110
4111         if (context)
4112         {
4113             if (!ValidCap(context, cap))
4114             {
4115                 return gl::error(GL_INVALID_ENUM, false);
4116             }
4117
4118             return context->getCap(cap);
4119         }
4120     }
4121     catch (...)
4122     {
4123         return gl::error(GL_OUT_OF_MEMORY, false);
4124     }
4125
4126     return false;
4127 }
4128
4129 GLboolean __stdcall glIsFenceNV(GLuint fence)
4130 {
4131     EVENT("(GLuint fence = %d)", fence);
4132
4133     try
4134     {
4135         gl::Context *context = gl::getNonLostContext();
4136
4137         if (context)
4138         {
4139             gl::FenceNV *fenceObject = context->getFenceNV(fence);
4140
4141             if (fenceObject == NULL)
4142             {
4143                 return GL_FALSE;
4144             }
4145
4146             return fenceObject->isFence();
4147         }
4148     }
4149     catch (...)
4150     {
4151         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
4152     }
4153
4154     return GL_FALSE;
4155 }
4156
4157 GLboolean __stdcall glIsFramebuffer(GLuint framebuffer)
4158 {
4159     EVENT("(GLuint framebuffer = %d)", framebuffer);
4160
4161     try
4162     {
4163         gl::Context *context = gl::getNonLostContext();
4164
4165         if (context && framebuffer)
4166         {
4167             gl::Framebuffer *framebufferObject = context->getFramebuffer(framebuffer);
4168
4169             if (framebufferObject)
4170             {
4171                 return GL_TRUE;
4172             }
4173         }
4174     }
4175     catch (...)
4176     {
4177         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
4178     }
4179
4180     return GL_FALSE;
4181 }
4182
4183 GLboolean __stdcall glIsProgram(GLuint program)
4184 {
4185     EVENT("(GLuint program = %d)", program);
4186
4187     try
4188     {
4189         gl::Context *context = gl::getNonLostContext();
4190
4191         if (context && program)
4192         {
4193             gl::Program *programObject = context->getProgram(program);
4194
4195             if (programObject)
4196             {
4197                 return GL_TRUE;
4198             }
4199         }
4200     }
4201     catch (...)
4202     {
4203         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
4204     }
4205
4206     return GL_FALSE;
4207 }
4208
4209 GLboolean __stdcall glIsQueryEXT(GLuint id)
4210 {
4211     EVENT("(GLuint id = %d)", id);
4212
4213     try
4214     {
4215         gl::Context *context = gl::getNonLostContext();
4216
4217         if (context)
4218         {
4219             return (context->getQuery(id, false, GL_NONE) != NULL) ? GL_TRUE : GL_FALSE;
4220         }
4221     }
4222     catch (...)
4223     {
4224         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
4225     }
4226
4227     return GL_FALSE;
4228 }
4229
4230 GLboolean __stdcall glIsRenderbuffer(GLuint renderbuffer)
4231 {
4232     EVENT("(GLuint renderbuffer = %d)", renderbuffer);
4233
4234     try
4235     {
4236         gl::Context *context = gl::getNonLostContext();
4237
4238         if (context && renderbuffer)
4239         {
4240             gl::FramebufferAttachment *renderbufferObject = context->getRenderbuffer(renderbuffer);
4241
4242             if (renderbufferObject)
4243             {
4244                 return GL_TRUE;
4245             }
4246         }
4247     }
4248     catch (...)
4249     {
4250         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
4251     }
4252
4253     return GL_FALSE;
4254 }
4255
4256 GLboolean __stdcall glIsShader(GLuint shader)
4257 {
4258     EVENT("(GLuint shader = %d)", shader);
4259
4260     try
4261     {
4262         gl::Context *context = gl::getNonLostContext();
4263
4264         if (context && shader)
4265         {
4266             gl::Shader *shaderObject = context->getShader(shader);
4267
4268             if (shaderObject)
4269             {
4270                 return GL_TRUE;
4271             }
4272         }
4273     }
4274     catch (...)
4275     {
4276         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
4277     }
4278
4279     return GL_FALSE;
4280 }
4281
4282 GLboolean __stdcall glIsTexture(GLuint texture)
4283 {
4284     EVENT("(GLuint texture = %d)", texture);
4285
4286     try
4287     {
4288         gl::Context *context = gl::getNonLostContext();
4289
4290         if (context && texture)
4291         {
4292             gl::Texture *textureObject = context->getTexture(texture);
4293
4294             if (textureObject)
4295             {
4296                 return GL_TRUE;
4297             }
4298         }
4299     }
4300     catch (...)
4301     {
4302         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
4303     }
4304
4305     return GL_FALSE;
4306 }
4307
4308 void __stdcall glLineWidth(GLfloat width)
4309 {
4310     EVENT("(GLfloat width = %f)", width);
4311
4312     try
4313     {
4314         if (width <= 0.0f)
4315         {
4316             return gl::error(GL_INVALID_VALUE);
4317         }
4318
4319         gl::Context *context = gl::getNonLostContext();
4320
4321         if (context)
4322         {
4323             context->setLineWidth(width);
4324         }
4325     }
4326     catch (...)
4327     {
4328         return gl::error(GL_OUT_OF_MEMORY);
4329     }
4330 }
4331
4332 void __stdcall glLinkProgram(GLuint program)
4333 {
4334     EVENT("(GLuint program = %d)", program);
4335
4336     try
4337     {
4338         gl::Context *context = gl::getNonLostContext();
4339
4340         if (context)
4341         {
4342             gl::Program *programObject = context->getProgram(program);
4343
4344             if (!programObject)
4345             {
4346                 if (context->getShader(program))
4347                 {
4348                     return gl::error(GL_INVALID_OPERATION);
4349                 }
4350                 else
4351                 {
4352                     return gl::error(GL_INVALID_VALUE);
4353                 }
4354             }
4355
4356             context->linkProgram(program);
4357         }
4358     }
4359     catch (...)
4360     {
4361         return gl::error(GL_OUT_OF_MEMORY);
4362     }
4363 }
4364
4365 void __stdcall glPixelStorei(GLenum pname, GLint param)
4366 {
4367     EVENT("(GLenum pname = 0x%X, GLint param = %d)", pname, param);
4368
4369     try
4370     {
4371         gl::Context *context = gl::getNonLostContext();
4372
4373         if (context)
4374         {
4375             switch (pname)
4376             {
4377               case GL_UNPACK_ALIGNMENT:
4378                 if (param != 1 && param != 2 && param != 4 && param != 8)
4379                 {
4380                     return gl::error(GL_INVALID_VALUE);
4381                 }
4382
4383                 context->setUnpackAlignment(param);
4384                 break;
4385
4386               case GL_PACK_ALIGNMENT:
4387                 if (param != 1 && param != 2 && param != 4 && param != 8)
4388                 {
4389                     return gl::error(GL_INVALID_VALUE);
4390                 }
4391
4392                 context->setPackAlignment(param);
4393                 break;
4394
4395               case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
4396                 context->setPackReverseRowOrder(param != 0);
4397                 break;
4398
4399               case GL_UNPACK_IMAGE_HEIGHT:
4400               case GL_UNPACK_SKIP_IMAGES:
4401               case GL_UNPACK_ROW_LENGTH:
4402               case GL_UNPACK_SKIP_ROWS:
4403               case GL_UNPACK_SKIP_PIXELS:
4404               case GL_PACK_ROW_LENGTH:
4405               case GL_PACK_SKIP_ROWS:
4406               case GL_PACK_SKIP_PIXELS:
4407                 if (context->getClientVersion() < 3)
4408                 {
4409                     return gl::error(GL_INVALID_ENUM);
4410                 }
4411                 UNIMPLEMENTED();
4412                 break;
4413
4414               default:
4415                 return gl::error(GL_INVALID_ENUM);
4416             }
4417         }
4418     }
4419     catch (...)
4420     {
4421         return gl::error(GL_OUT_OF_MEMORY);
4422     }
4423 }
4424
4425 void __stdcall glPolygonOffset(GLfloat factor, GLfloat units)
4426 {
4427     EVENT("(GLfloat factor = %f, GLfloat units = %f)", factor, units);
4428
4429     try
4430     {
4431         gl::Context *context = gl::getNonLostContext();
4432
4433         if (context)
4434         {
4435             context->setPolygonOffsetParams(factor, units);
4436         }
4437     }
4438     catch (...)
4439     {
4440         return gl::error(GL_OUT_OF_MEMORY);
4441     }
4442 }
4443
4444 void __stdcall glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,
4445                                 GLenum format, GLenum type, GLsizei bufSize,
4446                                 GLvoid *data)
4447 {
4448     EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
4449           "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufSize = 0x%d, GLvoid *data = 0x%0.8p)",
4450           x, y, width, height, format, type, bufSize, data);
4451
4452     try
4453     {
4454         if (width < 0 || height < 0 || bufSize < 0)
4455         {
4456             return gl::error(GL_INVALID_VALUE);
4457         }
4458
4459         gl::Context *context = gl::getNonLostContext();
4460
4461         if (context)
4462         {
4463             if (!gl::ValidateReadPixelsParameters(context, x, y, width, height,
4464                                                   format, type, &bufSize, data))
4465             {
4466                 return;
4467             }
4468
4469             context->readPixels(x, y, width, height, format, type, &bufSize, data);
4470         }
4471     }
4472     catch (...)
4473     {
4474         return gl::error(GL_OUT_OF_MEMORY);
4475     }
4476 }
4477
4478 void __stdcall glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
4479                             GLenum format, GLenum type, GLvoid* pixels)
4480 {
4481     EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
4482           "GLenum format = 0x%X, GLenum type = 0x%X, GLvoid* pixels = 0x%0.8p)",
4483           x, y, width, height, format, type,  pixels);
4484
4485     try
4486     {
4487         if (width < 0 || height < 0)
4488         {
4489             return gl::error(GL_INVALID_VALUE);
4490         }
4491
4492         gl::Context *context = gl::getNonLostContext();
4493
4494         if (context)
4495         {
4496             if (!gl::ValidateReadPixelsParameters(context, x, y, width, height,
4497                                                   format, type, NULL, pixels))
4498             {
4499                 return;
4500             }
4501
4502             context->readPixels(x, y, width, height, format, type, NULL, pixels);
4503         }
4504     }
4505     catch (...)
4506     {
4507         return gl::error(GL_OUT_OF_MEMORY);
4508     }
4509 }
4510
4511 void __stdcall glReleaseShaderCompiler(void)
4512 {
4513     EVENT("()");
4514
4515     try
4516     {
4517         gl::Shader::releaseCompiler();
4518     }
4519     catch (...)
4520     {
4521         return gl::error(GL_OUT_OF_MEMORY);
4522     }
4523 }
4524
4525 void __stdcall glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
4526 {
4527     EVENT("(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
4528           target, samples, internalformat, width, height);
4529
4530     try
4531     {
4532         gl::Context *context = gl::getNonLostContext();
4533
4534         if (context)
4535         {
4536             if (!ValidateRenderbufferStorageParameters(context, target, samples, internalformat,
4537                                                        width, height, true))
4538             {
4539                 return;
4540             }
4541
4542             context->setRenderbufferStorage(width, height, internalformat, samples);
4543         }
4544     }
4545     catch (...)
4546     {
4547         return gl::error(GL_OUT_OF_MEMORY);
4548     }
4549 }
4550
4551 void __stdcall glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
4552 {
4553     glRenderbufferStorageMultisampleANGLE(target, 0, internalformat, width, height);
4554 }
4555
4556 void __stdcall glSampleCoverage(GLclampf value, GLboolean invert)
4557 {
4558     EVENT("(GLclampf value = %f, GLboolean invert = %u)", value, invert);
4559
4560     try
4561     {
4562         gl::Context* context = gl::getNonLostContext();
4563
4564         if (context)
4565         {
4566             context->setSampleCoverageParams(gl::clamp01(value), invert == GL_TRUE);
4567         }
4568     }
4569     catch (...)
4570     {
4571         return gl::error(GL_OUT_OF_MEMORY);
4572     }
4573 }
4574
4575 void __stdcall glSetFenceNV(GLuint fence, GLenum condition)
4576 {
4577     EVENT("(GLuint fence = %d, GLenum condition = 0x%X)", fence, condition);
4578
4579     try
4580     {
4581         if (condition != GL_ALL_COMPLETED_NV)
4582         {
4583             return gl::error(GL_INVALID_ENUM);
4584         }
4585
4586         gl::Context *context = gl::getNonLostContext();
4587
4588         if (context)
4589         {
4590             gl::FenceNV *fenceObject = context->getFenceNV(fence);
4591
4592             if (fenceObject == NULL)
4593             {
4594                 return gl::error(GL_INVALID_OPERATION);
4595             }
4596
4597             fenceObject->setFence(condition);
4598         }
4599     }
4600     catch (...)
4601     {
4602         return gl::error(GL_OUT_OF_MEMORY);
4603     }
4604 }
4605
4606 void __stdcall glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
4607 {
4608     EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);
4609
4610     try
4611     {
4612         if (width < 0 || height < 0)
4613         {
4614             return gl::error(GL_INVALID_VALUE);
4615         }
4616
4617         gl::Context* context = gl::getNonLostContext();
4618
4619         if (context)
4620         {
4621             context->setScissorParams(x, y, width, height);
4622         }
4623     }
4624     catch (...)
4625     {
4626         return gl::error(GL_OUT_OF_MEMORY);
4627     }
4628 }
4629
4630 void __stdcall glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
4631 {
4632     EVENT("(GLsizei n = %d, const GLuint* shaders = 0x%0.8p, GLenum binaryformat = 0x%X, "
4633           "const GLvoid* binary = 0x%0.8p, GLsizei length = %d)",
4634           n, shaders, binaryformat, binary, length);
4635
4636     try
4637     {
4638         // No binary shader formats are supported.
4639         return gl::error(GL_INVALID_ENUM);
4640     }
4641     catch (...)
4642     {
4643         return gl::error(GL_OUT_OF_MEMORY);
4644     }
4645 }
4646
4647 void __stdcall glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length)
4648 {
4649     EVENT("(GLuint shader = %d, GLsizei count = %d, const GLchar** string = 0x%0.8p, const GLint* length = 0x%0.8p)",
4650           shader, count, string, length);
4651
4652     try
4653     {
4654         if (count < 0)
4655         {
4656             return gl::error(GL_INVALID_VALUE);
4657         }
4658
4659         gl::Context *context = gl::getNonLostContext();
4660
4661         if (context)
4662         {
4663             gl::Shader *shaderObject = context->getShader(shader);
4664
4665             if (!shaderObject)
4666             {
4667                 if (context->getProgram(shader))
4668                 {
4669                     return gl::error(GL_INVALID_OPERATION);
4670                 }
4671                 else
4672                 {
4673                     return gl::error(GL_INVALID_VALUE);
4674                 }
4675             }
4676
4677             shaderObject->setSource(count, string, length);
4678         }
4679     }
4680     catch (...)
4681     {
4682         return gl::error(GL_OUT_OF_MEMORY);
4683     }
4684 }
4685
4686 void __stdcall glStencilFunc(GLenum func, GLint ref, GLuint mask)
4687 {
4688     glStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
4689 }
4690
4691 void __stdcall glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
4692 {
4693     EVENT("(GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %d)", face, func, ref, mask);
4694
4695     try
4696     {
4697         switch (face)
4698         {
4699           case GL_FRONT:
4700           case GL_BACK:
4701           case GL_FRONT_AND_BACK:
4702             break;
4703           default:
4704             return gl::error(GL_INVALID_ENUM);
4705         }
4706
4707         switch (func)
4708         {
4709           case GL_NEVER:
4710           case GL_ALWAYS:
4711           case GL_LESS:
4712           case GL_LEQUAL:
4713           case GL_EQUAL:
4714           case GL_GEQUAL:
4715           case GL_GREATER:
4716           case GL_NOTEQUAL:
4717             break;
4718           default:
4719             return gl::error(GL_INVALID_ENUM);
4720         }
4721
4722         gl::Context *context = gl::getNonLostContext();
4723
4724         if (context)
4725         {
4726             if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
4727             {
4728                 context->setStencilParams(func, ref, mask);
4729             }
4730
4731             if (face == GL_BACK || face == GL_FRONT_AND_BACK)
4732             {
4733                 context->setStencilBackParams(func, ref, mask);
4734             }
4735         }
4736     }
4737     catch (...)
4738     {
4739         return gl::error(GL_OUT_OF_MEMORY);
4740     }
4741 }
4742
4743 void __stdcall glStencilMask(GLuint mask)
4744 {
4745     glStencilMaskSeparate(GL_FRONT_AND_BACK, mask);
4746 }
4747
4748 void __stdcall glStencilMaskSeparate(GLenum face, GLuint mask)
4749 {
4750     EVENT("(GLenum face = 0x%X, GLuint mask = %d)", face, mask);
4751
4752     try
4753     {
4754         switch (face)
4755         {
4756           case GL_FRONT:
4757           case GL_BACK:
4758           case GL_FRONT_AND_BACK:
4759             break;
4760           default:
4761             return gl::error(GL_INVALID_ENUM);
4762         }
4763
4764         gl::Context *context = gl::getNonLostContext();
4765
4766         if (context)
4767         {
4768             if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
4769             {
4770                 context->setStencilWritemask(mask);
4771             }
4772
4773             if (face == GL_BACK || face == GL_FRONT_AND_BACK)
4774             {
4775                 context->setStencilBackWritemask(mask);
4776             }
4777         }
4778     }
4779     catch (...)
4780     {
4781         return gl::error(GL_OUT_OF_MEMORY);
4782     }
4783 }
4784
4785 void __stdcall glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
4786 {
4787     glStencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);
4788 }
4789
4790 void __stdcall glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
4791 {
4792     EVENT("(GLenum face = 0x%X, GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpas = 0x%Xs)",
4793           face, fail, zfail, zpass);
4794
4795     try
4796     {
4797         switch (face)
4798         {
4799           case GL_FRONT:
4800           case GL_BACK:
4801           case GL_FRONT_AND_BACK:
4802             break;
4803           default:
4804             return gl::error(GL_INVALID_ENUM);
4805         }
4806
4807         switch (fail)
4808         {
4809           case GL_ZERO:
4810           case GL_KEEP:
4811           case GL_REPLACE:
4812           case GL_INCR:
4813           case GL_DECR:
4814           case GL_INVERT:
4815           case GL_INCR_WRAP:
4816           case GL_DECR_WRAP:
4817             break;
4818           default:
4819             return gl::error(GL_INVALID_ENUM);
4820         }
4821
4822         switch (zfail)
4823         {
4824           case GL_ZERO:
4825           case GL_KEEP:
4826           case GL_REPLACE:
4827           case GL_INCR:
4828           case GL_DECR:
4829           case GL_INVERT:
4830           case GL_INCR_WRAP:
4831           case GL_DECR_WRAP:
4832             break;
4833           default:
4834             return gl::error(GL_INVALID_ENUM);
4835         }
4836
4837         switch (zpass)
4838         {
4839           case GL_ZERO:
4840           case GL_KEEP:
4841           case GL_REPLACE:
4842           case GL_INCR:
4843           case GL_DECR:
4844           case GL_INVERT:
4845           case GL_INCR_WRAP:
4846           case GL_DECR_WRAP:
4847             break;
4848           default:
4849             return gl::error(GL_INVALID_ENUM);
4850         }
4851
4852         gl::Context *context = gl::getNonLostContext();
4853
4854         if (context)
4855         {
4856             if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
4857             {
4858                 context->setStencilOperations(fail, zfail, zpass);
4859             }
4860
4861             if (face == GL_BACK || face == GL_FRONT_AND_BACK)
4862             {
4863                 context->setStencilBackOperations(fail, zfail, zpass);
4864             }
4865         }
4866     }
4867     catch (...)
4868     {
4869         return gl::error(GL_OUT_OF_MEMORY);
4870     }
4871 }
4872
4873 GLboolean __stdcall glTestFenceNV(GLuint fence)
4874 {
4875     EVENT("(GLuint fence = %d)", fence);
4876
4877     try
4878     {
4879         gl::Context *context = gl::getNonLostContext();
4880
4881         if (context)
4882         {
4883             gl::FenceNV *fenceObject = context->getFenceNV(fence);
4884
4885             if (fenceObject == NULL)
4886             {
4887                 return gl::error(GL_INVALID_OPERATION, GL_TRUE);
4888             }
4889
4890             if (fenceObject->isFence() != GL_TRUE)
4891             {
4892                 return gl::error(GL_INVALID_OPERATION, GL_TRUE);
4893             }
4894
4895             return fenceObject->testFence();
4896         }
4897     }
4898     catch (...)
4899     {
4900         gl::error(GL_OUT_OF_MEMORY);
4901     }
4902
4903     return GL_TRUE;
4904 }
4905
4906 void __stdcall glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
4907                             GLint border, GLenum format, GLenum type, const GLvoid* pixels)
4908 {
4909     EVENT("(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, GLsizei height = %d, "
4910           "GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const GLvoid* pixels = 0x%0.8p)",
4911           target, level, internalformat, width, height, border, format, type, pixels);
4912
4913     try
4914     {
4915         gl::Context *context = gl::getNonLostContext();
4916
4917         if (context)
4918         {
4919             if (context->getClientVersion() < 3 &&
4920                 !ValidateES2TexImageParameters(context, target, level, internalformat, false, false,
4921                                                0, 0, width, height, border, format, type, pixels))
4922             {
4923                 return;
4924             }
4925
4926             if (context->getClientVersion() >= 3 &&
4927                 !ValidateES3TexImageParameters(context, target, level, internalformat, false, false,
4928                                                0, 0, 0, width, height, 1, border, format, type, pixels))
4929             {
4930                 return;
4931             }
4932
4933             switch (target)
4934             {
4935               case GL_TEXTURE_2D:
4936                 {
4937                     gl::Texture2D *texture = context->getTexture2D();
4938                     texture->setImage(level, width, height, internalformat, format, type, context->getUnpackState(), pixels);
4939                 }
4940                 break;
4941               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
4942                 {
4943                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
4944                     texture->setImagePosX(level, width, height, internalformat, format, type, context->getUnpackState(), pixels);
4945                 }
4946                 break;
4947               case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
4948                 {
4949                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
4950                     texture->setImageNegX(level, width, height, internalformat, format, type, context->getUnpackState(), pixels);
4951                 }
4952                 break;
4953               case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
4954                 {
4955                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
4956                     texture->setImagePosY(level, width, height, internalformat, format, type, context->getUnpackState(), pixels);
4957                 }
4958                 break;
4959               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
4960                 {
4961                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
4962                     texture->setImageNegY(level, width, height, internalformat, format, type, context->getUnpackState(), pixels);
4963                 }
4964                 break;
4965               case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
4966                 {
4967                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
4968                     texture->setImagePosZ(level, width, height, internalformat, format, type, context->getUnpackState(), pixels);
4969                 }
4970                 break;
4971               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
4972                 {
4973                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
4974                     texture->setImageNegZ(level, width, height, internalformat, format, type, context->getUnpackState(), pixels);
4975                 }
4976                 break;
4977               default: UNREACHABLE();
4978             }
4979         }
4980     }
4981     catch (...)
4982     {
4983         return gl::error(GL_OUT_OF_MEMORY);
4984     }
4985 }
4986
4987 void __stdcall glTexParameterf(GLenum target, GLenum pname, GLfloat param)
4988 {
4989     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %f)", target, pname, param);
4990
4991     try
4992     {
4993         gl::Context *context = gl::getNonLostContext();
4994
4995         if (context)
4996         {
4997             if (!ValidateTexParamParameters(context, pname, static_cast<GLint>(param)))
4998             {
4999                 return;
5000             }
5001
5002             gl::Texture *texture = context->getTargetTexture(target);
5003
5004             if (!texture)
5005             {
5006                 return gl::error(GL_INVALID_ENUM);
5007             }
5008
5009             switch (pname)
5010             {
5011               case GL_TEXTURE_WRAP_S:               texture->setWrapS(gl::uiround<GLenum>(param));       break;
5012               case GL_TEXTURE_WRAP_T:               texture->setWrapT(gl::uiround<GLenum>(param));       break;
5013               case GL_TEXTURE_WRAP_R:               texture->setWrapR(gl::uiround<GLenum>(param));       break;
5014               case GL_TEXTURE_MIN_FILTER:           texture->setMinFilter(gl::uiround<GLenum>(param));   break;
5015               case GL_TEXTURE_MAG_FILTER:           texture->setMagFilter(gl::uiround<GLenum>(param));   break;
5016               case GL_TEXTURE_USAGE_ANGLE:          texture->setUsage(gl::uiround<GLenum>(param));       break;
5017               case GL_TEXTURE_MAX_ANISOTROPY_EXT:   texture->setMaxAnisotropy(param, context->getTextureMaxAnisotropy()); break;
5018               case GL_TEXTURE_COMPARE_MODE:         texture->setCompareMode(gl::uiround<GLenum>(param)); break;
5019               case GL_TEXTURE_COMPARE_FUNC:         texture->setCompareFunc(gl::uiround<GLenum>(param)); break;
5020               case GL_TEXTURE_SWIZZLE_R:            texture->setSwizzleRed(gl::uiround<GLenum>(param));   break;
5021               case GL_TEXTURE_SWIZZLE_G:            texture->setSwizzleGreen(gl::uiround<GLenum>(param)); break;
5022               case GL_TEXTURE_SWIZZLE_B:            texture->setSwizzleBlue(gl::uiround<GLenum>(param));  break;
5023               case GL_TEXTURE_SWIZZLE_A:            texture->setSwizzleAlpha(gl::uiround<GLenum>(param)); break;
5024               case GL_TEXTURE_BASE_LEVEL:           texture->setBaseLevel(gl::iround<GLint>(param));      break;
5025               case GL_TEXTURE_MAX_LEVEL:            texture->setMaxLevel(gl::iround<GLint>(param));       break;
5026               case GL_TEXTURE_MIN_LOD:              texture->setMinLod(param);                            break;
5027               case GL_TEXTURE_MAX_LOD:              texture->setMaxLod(param);                            break;
5028               default: UNREACHABLE(); break;
5029             }
5030         }
5031     }
5032     catch (...)
5033     {
5034         return gl::error(GL_OUT_OF_MEMORY);
5035     }
5036 }
5037
5038 void __stdcall glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
5039 {
5040     glTexParameterf(target, pname, (GLfloat)*params);
5041 }
5042
5043 void __stdcall glTexParameteri(GLenum target, GLenum pname, GLint param)
5044 {
5045     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
5046
5047     try
5048     {
5049         gl::Context *context = gl::getNonLostContext();
5050
5051         if (context)
5052         {
5053             if (!ValidateTexParamParameters(context, pname, param))
5054             {
5055                 return;
5056             }
5057
5058             gl::Texture *texture = context->getTargetTexture(target);
5059
5060             if (!texture)
5061             {
5062                 return gl::error(GL_INVALID_ENUM);
5063             }
5064
5065             switch (pname)
5066             {
5067               case GL_TEXTURE_WRAP_S:               texture->setWrapS((GLenum)param);       break;
5068               case GL_TEXTURE_WRAP_T:               texture->setWrapT((GLenum)param);       break;
5069               case GL_TEXTURE_WRAP_R:               texture->setWrapR((GLenum)param);       break;
5070               case GL_TEXTURE_MIN_FILTER:           texture->setMinFilter((GLenum)param);   break;
5071               case GL_TEXTURE_MAG_FILTER:           texture->setMagFilter((GLenum)param);   break;
5072               case GL_TEXTURE_USAGE_ANGLE:          texture->setUsage((GLenum)param);       break;
5073               case GL_TEXTURE_MAX_ANISOTROPY_EXT:   texture->setMaxAnisotropy((float)param, context->getTextureMaxAnisotropy()); break;
5074               case GL_TEXTURE_COMPARE_MODE:         texture->setCompareMode((GLenum)param); break;
5075               case GL_TEXTURE_COMPARE_FUNC:         texture->setCompareFunc((GLenum)param); break;
5076               case GL_TEXTURE_SWIZZLE_R:            texture->setSwizzleRed((GLenum)param);   break;
5077               case GL_TEXTURE_SWIZZLE_G:            texture->setSwizzleGreen((GLenum)param); break;
5078               case GL_TEXTURE_SWIZZLE_B:            texture->setSwizzleBlue((GLenum)param);  break;
5079               case GL_TEXTURE_SWIZZLE_A:            texture->setSwizzleAlpha((GLenum)param); break;
5080               case GL_TEXTURE_BASE_LEVEL:           texture->setBaseLevel(param);            break;
5081               case GL_TEXTURE_MAX_LEVEL:            texture->setMaxLevel(param);             break;
5082               case GL_TEXTURE_MIN_LOD:              texture->setMinLod((GLfloat)param);      break;
5083               case GL_TEXTURE_MAX_LOD:              texture->setMaxLod((GLfloat)param);      break;
5084               default: UNREACHABLE(); break;
5085             }
5086         }
5087     }
5088     catch (...)
5089     {
5090         return gl::error(GL_OUT_OF_MEMORY);
5091     }
5092 }
5093
5094 void __stdcall glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
5095 {
5096     glTexParameteri(target, pname, *params);
5097 }
5098
5099 void __stdcall glTexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
5100 {
5101     EVENT("(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
5102            target, levels, internalformat, width, height);
5103
5104     try
5105     {
5106         gl::Context *context = gl::getNonLostContext();
5107
5108         if (context)
5109         {
5110             if (context->getClientVersion() < 3 &&
5111                 !ValidateES2TexStorageParameters(context, target, levels, internalformat, width, height))
5112             {
5113                 return;
5114             }
5115
5116             if (context->getClientVersion() >= 3 &&
5117                 !ValidateES3TexStorageParameters(context, target, levels, internalformat, width, height, 1))
5118             {
5119                 return;
5120             }
5121
5122             switch (target)
5123             {
5124               case GL_TEXTURE_2D:
5125                 {
5126                     gl::Texture2D *texture2d = context->getTexture2D();
5127                     texture2d->storage(levels, internalformat, width, height);
5128                 }
5129                 break;
5130
5131               case GL_TEXTURE_CUBE_MAP:
5132                 {
5133                     gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
5134                     textureCube->storage(levels, internalformat, width);
5135                 }
5136                 break;
5137
5138               default:
5139                 return gl::error(GL_INVALID_ENUM);
5140             }
5141         }
5142     }
5143     catch (...)
5144     {
5145         return gl::error(GL_OUT_OF_MEMORY);
5146     }
5147 }
5148
5149 void __stdcall glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
5150                                GLenum format, GLenum type, const GLvoid* pixels)
5151 {
5152     EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
5153           "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, "
5154           "const GLvoid* pixels = 0x%0.8p)",
5155            target, level, xoffset, yoffset, width, height, format, type, pixels);
5156
5157     try
5158     {
5159         gl::Context *context = gl::getNonLostContext();
5160
5161         if (context)
5162         {
5163             if (context->getClientVersion() < 3 &&
5164                 !ValidateES2TexImageParameters(context, target, level, GL_NONE, false, true,
5165                                                xoffset, yoffset, width, height, 0, format, type, pixels))
5166             {
5167                 return;
5168             }
5169
5170             if (context->getClientVersion() >= 3 &&
5171                 !ValidateES3TexImageParameters(context, target, level, GL_NONE, false, true,
5172                                                xoffset, yoffset, 0, width, height, 1, 0, format, type, pixels))
5173             {
5174                 return;
5175             }
5176
5177             // Zero sized uploads are valid but no-ops
5178             if (width == 0 || height == 0)
5179             {
5180                 return;
5181             }
5182
5183             switch (target)
5184             {
5185               case GL_TEXTURE_2D:
5186                 {
5187                     gl::Texture2D *texture = context->getTexture2D();
5188                     texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackState(), pixels);
5189                 }
5190                 break;
5191
5192               case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
5193               case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
5194               case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
5195               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
5196               case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
5197               case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
5198                 {
5199                     gl::TextureCubeMap *texture = context->getTextureCubeMap();
5200                     texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackState(), pixels);
5201                 }
5202                 break;
5203
5204               default:
5205                 UNREACHABLE();
5206             }
5207         }
5208     }
5209     catch (...)
5210     {
5211         return gl::error(GL_OUT_OF_MEMORY);
5212     }
5213 }
5214
5215 void __stdcall glUniform1f(GLint location, GLfloat x)
5216 {
5217     glUniform1fv(location, 1, &x);
5218 }
5219
5220 void __stdcall glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
5221 {
5222     EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);
5223
5224     try
5225     {
5226         gl::Context *context = gl::getNonLostContext();
5227
5228         if (context)
5229         {
5230             if (!ValidateUniform(context, GL_FLOAT, location, count))
5231             {
5232                 return;
5233             }
5234
5235             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5236             programBinary->setUniform1fv(location, count, v);
5237         }
5238     }
5239     catch (...)
5240     {
5241         return gl::error(GL_OUT_OF_MEMORY);
5242     }
5243 }
5244
5245 void __stdcall glUniform1i(GLint location, GLint x)
5246 {
5247     glUniform1iv(location, 1, &x);
5248 }
5249
5250 void __stdcall glUniform1iv(GLint location, GLsizei count, const GLint* v)
5251 {
5252     EVENT("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);
5253
5254     try
5255     {
5256         gl::Context *context = gl::getNonLostContext();
5257
5258         if (context)
5259         {
5260             if (!ValidateUniform(context, GL_INT, location, count))
5261             {
5262                 return;
5263             }
5264
5265             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5266             programBinary->setUniform1iv(location, count, v);
5267         }
5268     }
5269     catch (...)
5270     {
5271         return gl::error(GL_OUT_OF_MEMORY);
5272     }
5273 }
5274
5275 void __stdcall glUniform2f(GLint location, GLfloat x, GLfloat y)
5276 {
5277     GLfloat xy[2] = {x, y};
5278
5279     glUniform2fv(location, 1, xy);
5280 }
5281
5282 void __stdcall glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
5283 {
5284     EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);
5285
5286     try
5287     {
5288         gl::Context *context = gl::getNonLostContext();
5289
5290         if (context)
5291         {
5292             if (!ValidateUniform(context, GL_FLOAT_VEC2, location, count))
5293             {
5294                 return;
5295             }
5296
5297             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5298             programBinary->setUniform2fv(location, count, v);
5299         }
5300     }
5301     catch (...)
5302     {
5303         return gl::error(GL_OUT_OF_MEMORY);
5304     }
5305 }
5306
5307 void __stdcall glUniform2i(GLint location, GLint x, GLint y)
5308 {
5309     GLint xy[2] = {x, y};
5310
5311     glUniform2iv(location, 1, xy);
5312 }
5313
5314 void __stdcall glUniform2iv(GLint location, GLsizei count, const GLint* v)
5315 {
5316     EVENT("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);
5317
5318     try
5319     {
5320         gl::Context *context = gl::getNonLostContext();
5321
5322         if (context)
5323         {
5324             if (!ValidateUniform(context, GL_INT_VEC2, location, count))
5325             {
5326                 return;
5327             }
5328
5329             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5330             programBinary->setUniform2iv(location, count, v);
5331         }
5332     }
5333     catch (...)
5334     {
5335         return gl::error(GL_OUT_OF_MEMORY);
5336     }
5337 }
5338
5339 void __stdcall glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
5340 {
5341     GLfloat xyz[3] = {x, y, z};
5342
5343     glUniform3fv(location, 1, xyz);
5344 }
5345
5346 void __stdcall glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
5347 {
5348     EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);
5349
5350     try
5351     {
5352         gl::Context *context = gl::getNonLostContext();
5353
5354         if (context)
5355         {
5356             if (!ValidateUniform(context, GL_FLOAT_VEC3, location, count))
5357             {
5358                 return;
5359             }
5360
5361             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5362             programBinary->setUniform3fv(location, count, v);
5363         }
5364     }
5365     catch (...)
5366     {
5367         return gl::error(GL_OUT_OF_MEMORY);
5368     }
5369 }
5370
5371 void __stdcall glUniform3i(GLint location, GLint x, GLint y, GLint z)
5372 {
5373     GLint xyz[3] = {x, y, z};
5374
5375     glUniform3iv(location, 1, xyz);
5376 }
5377
5378 void __stdcall glUniform3iv(GLint location, GLsizei count, const GLint* v)
5379 {
5380     EVENT("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);
5381
5382     try
5383     {
5384         gl::Context *context = gl::getNonLostContext();
5385
5386         if (context)
5387         {
5388             if (!ValidateUniform(context, GL_INT_VEC3, location, count))
5389             {
5390                 return;
5391             }
5392
5393             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5394             programBinary->setUniform3iv(location, count, v);
5395         }
5396     }
5397     catch (...)
5398     {
5399         return gl::error(GL_OUT_OF_MEMORY);
5400     }
5401 }
5402
5403 void __stdcall glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5404 {
5405     GLfloat xyzw[4] = {x, y, z, w};
5406
5407     glUniform4fv(location, 1, xyzw);
5408 }
5409
5410 void __stdcall glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
5411 {
5412     EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);
5413
5414     try
5415     {
5416         gl::Context *context = gl::getNonLostContext();
5417
5418         if (context)
5419         {
5420             if (!ValidateUniform(context, GL_FLOAT_VEC4, location, count))
5421             {
5422                 return;
5423             }
5424
5425             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5426             programBinary->setUniform4fv(location, count, v);
5427         }
5428     }
5429     catch (...)
5430     {
5431         return gl::error(GL_OUT_OF_MEMORY);
5432     }
5433 }
5434
5435 void __stdcall glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
5436 {
5437     GLint xyzw[4] = {x, y, z, w};
5438
5439     glUniform4iv(location, 1, xyzw);
5440 }
5441
5442 void __stdcall glUniform4iv(GLint location, GLsizei count, const GLint* v)
5443 {
5444     EVENT("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);
5445
5446     try
5447     {
5448         gl::Context *context = gl::getNonLostContext();
5449
5450         if (context)
5451         {
5452             if (!ValidateUniform(context, GL_INT_VEC4, location, count))
5453             {
5454                 return;
5455             }
5456
5457             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5458             programBinary->setUniform4iv(location, count, v);
5459         }
5460     }
5461     catch (...)
5462     {
5463         return gl::error(GL_OUT_OF_MEMORY);
5464     }
5465 }
5466
5467 void __stdcall glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
5468 {
5469     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
5470           location, count, transpose, value);
5471
5472     try
5473     {
5474         gl::Context *context = gl::getNonLostContext();
5475
5476         if (context)
5477         {
5478             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT2, location, count, transpose))
5479             {
5480                 return;
5481             }
5482
5483             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5484             programBinary->setUniformMatrix2fv(location, count, transpose, value);
5485         }
5486     }
5487     catch (...)
5488     {
5489         return gl::error(GL_OUT_OF_MEMORY);
5490     }
5491 }
5492
5493 void __stdcall glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
5494 {
5495     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
5496           location, count, transpose, value);
5497
5498     try
5499     {
5500         gl::Context *context = gl::getNonLostContext();
5501
5502         if (context)
5503         {
5504             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT3, location, count, transpose))
5505             {
5506                 return;
5507             }
5508
5509             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5510             programBinary->setUniformMatrix3fv(location, count, transpose, value);
5511         }
5512     }
5513     catch (...)
5514     {
5515         return gl::error(GL_OUT_OF_MEMORY);
5516     }
5517 }
5518
5519 void __stdcall glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
5520 {
5521     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
5522           location, count, transpose, value);
5523
5524     try
5525     {
5526         gl::Context *context = gl::getNonLostContext();
5527
5528         if (context)
5529         {
5530             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT4, location, count, transpose))
5531             {
5532                 return;
5533             }
5534
5535             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
5536             programBinary->setUniformMatrix4fv(location, count, transpose, value);
5537         }
5538     }
5539     catch (...)
5540     {
5541         return gl::error(GL_OUT_OF_MEMORY);
5542     }
5543 }
5544
5545 void __stdcall glUseProgram(GLuint program)
5546 {
5547     EVENT("(GLuint program = %d)", program);
5548
5549     try
5550     {
5551         gl::Context *context = gl::getNonLostContext();
5552
5553         if (context)
5554         {
5555             gl::Program *programObject = context->getProgram(program);
5556
5557             if (!programObject && program != 0)
5558             {
5559                 if (context->getShader(program))
5560                 {
5561                     return gl::error(GL_INVALID_OPERATION);
5562                 }
5563                 else
5564                 {
5565                     return gl::error(GL_INVALID_VALUE);
5566                 }
5567             }
5568
5569             if (program != 0 && !programObject->isLinked())
5570             {
5571                 return gl::error(GL_INVALID_OPERATION);
5572             }
5573
5574             context->useProgram(program);
5575         }
5576     }
5577     catch (...)
5578     {
5579         return gl::error(GL_OUT_OF_MEMORY);
5580     }
5581 }
5582
5583 void __stdcall glValidateProgram(GLuint program)
5584 {
5585     EVENT("(GLuint program = %d)", program);
5586
5587     try
5588     {
5589         gl::Context *context = gl::getNonLostContext();
5590
5591         if (context)
5592         {
5593             gl::Program *programObject = context->getProgram(program);
5594
5595             if (!programObject)
5596             {
5597                 if (context->getShader(program))
5598                 {
5599                     return gl::error(GL_INVALID_OPERATION);
5600                 }
5601                 else
5602                 {
5603                     return gl::error(GL_INVALID_VALUE);
5604                 }
5605             }
5606
5607             programObject->validate();
5608         }
5609     }
5610     catch (...)
5611     {
5612         return gl::error(GL_OUT_OF_MEMORY);
5613     }
5614 }
5615
5616 void __stdcall glVertexAttrib1f(GLuint index, GLfloat x)
5617 {
5618     EVENT("(GLuint index = %d, GLfloat x = %f)", index, x);
5619
5620     try
5621     {
5622         if (index >= gl::MAX_VERTEX_ATTRIBS)
5623         {
5624             return gl::error(GL_INVALID_VALUE);
5625         }
5626
5627         gl::Context *context = gl::getNonLostContext();
5628
5629         if (context)
5630         {
5631             GLfloat vals[4] = { x, 0, 0, 1 };
5632             context->setVertexAttribf(index, vals);
5633         }
5634     }
5635     catch (...)
5636     {
5637         return gl::error(GL_OUT_OF_MEMORY);
5638     }
5639 }
5640
5641 void __stdcall glVertexAttrib1fv(GLuint index, const GLfloat* values)
5642 {
5643     EVENT("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);
5644
5645     try
5646     {
5647         if (index >= gl::MAX_VERTEX_ATTRIBS)
5648         {
5649             return gl::error(GL_INVALID_VALUE);
5650         }
5651
5652         gl::Context *context = gl::getNonLostContext();
5653
5654         if (context)
5655         {
5656             GLfloat vals[4] = { values[0], 0, 0, 1 };
5657             context->setVertexAttribf(index, vals);
5658         }
5659     }
5660     catch (...)
5661     {
5662         return gl::error(GL_OUT_OF_MEMORY);
5663     }
5664 }
5665
5666 void __stdcall glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
5667 {
5668     EVENT("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f)", index, x, y);
5669
5670     try
5671     {
5672         if (index >= gl::MAX_VERTEX_ATTRIBS)
5673         {
5674             return gl::error(GL_INVALID_VALUE);
5675         }
5676
5677         gl::Context *context = gl::getNonLostContext();
5678
5679         if (context)
5680         {
5681             GLfloat vals[4] = { x, y, 0, 1 };
5682             context->setVertexAttribf(index, vals);
5683         }
5684     }
5685     catch (...)
5686     {
5687         return gl::error(GL_OUT_OF_MEMORY);
5688     }
5689 }
5690
5691 void __stdcall glVertexAttrib2fv(GLuint index, const GLfloat* values)
5692 {
5693     EVENT("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);
5694
5695     try
5696     {
5697         if (index >= gl::MAX_VERTEX_ATTRIBS)
5698         {
5699             return gl::error(GL_INVALID_VALUE);
5700         }
5701
5702         gl::Context *context = gl::getNonLostContext();
5703
5704         if (context)
5705         {
5706             GLfloat vals[4] = { values[0], values[1], 0, 1 };
5707             context->setVertexAttribf(index, vals);
5708         }
5709     }
5710     catch (...)
5711     {
5712         return gl::error(GL_OUT_OF_MEMORY);
5713     }
5714 }
5715
5716 void __stdcall glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
5717 {
5718     EVENT("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", index, x, y, z);
5719
5720     try
5721     {
5722         if (index >= gl::MAX_VERTEX_ATTRIBS)
5723         {
5724             return gl::error(GL_INVALID_VALUE);
5725         }
5726
5727         gl::Context *context = gl::getNonLostContext();
5728
5729         if (context)
5730         {
5731             GLfloat vals[4] = { x, y, z, 1 };
5732             context->setVertexAttribf(index, vals);
5733         }
5734     }
5735     catch (...)
5736     {
5737         return gl::error(GL_OUT_OF_MEMORY);
5738     }
5739 }
5740
5741 void __stdcall glVertexAttrib3fv(GLuint index, const GLfloat* values)
5742 {
5743     EVENT("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);
5744
5745     try
5746     {
5747         if (index >= gl::MAX_VERTEX_ATTRIBS)
5748         {
5749             return gl::error(GL_INVALID_VALUE);
5750         }
5751
5752         gl::Context *context = gl::getNonLostContext();
5753
5754         if (context)
5755         {
5756             GLfloat vals[4] = { values[0], values[1], values[2], 1 };
5757             context->setVertexAttribf(index, vals);
5758         }
5759     }
5760     catch (...)
5761     {
5762         return gl::error(GL_OUT_OF_MEMORY);
5763     }
5764 }
5765
5766 void __stdcall glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5767 {
5768     EVENT("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)", index, x, y, z, w);
5769
5770     try
5771     {
5772         if (index >= gl::MAX_VERTEX_ATTRIBS)
5773         {
5774             return gl::error(GL_INVALID_VALUE);
5775         }
5776
5777         gl::Context *context = gl::getNonLostContext();
5778
5779         if (context)
5780         {
5781             GLfloat vals[4] = { x, y, z, w };
5782             context->setVertexAttribf(index, vals);
5783         }
5784     }
5785     catch (...)
5786     {
5787         return gl::error(GL_OUT_OF_MEMORY);
5788     }
5789 }
5790
5791 void __stdcall glVertexAttrib4fv(GLuint index, const GLfloat* values)
5792 {
5793     EVENT("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);
5794
5795     try
5796     {
5797         if (index >= gl::MAX_VERTEX_ATTRIBS)
5798         {
5799             return gl::error(GL_INVALID_VALUE);
5800         }
5801
5802         gl::Context *context = gl::getNonLostContext();
5803
5804         if (context)
5805         {
5806             context->setVertexAttribf(index, values);
5807         }
5808     }
5809     catch (...)
5810     {
5811         return gl::error(GL_OUT_OF_MEMORY);
5812     }
5813 }
5814
5815 void __stdcall glVertexAttribDivisorANGLE(GLuint index, GLuint divisor)
5816 {
5817     EVENT("(GLuint index = %d, GLuint divisor = %d)", index, divisor);
5818
5819     try
5820     {
5821         if (index >= gl::MAX_VERTEX_ATTRIBS)
5822         {
5823             return gl::error(GL_INVALID_VALUE);
5824         }
5825
5826         gl::Context *context = gl::getNonLostContext();
5827
5828         if (context)
5829         {
5830             context->setVertexAttribDivisor(index, divisor);
5831         }
5832     }
5833     catch (...)
5834     {
5835         return gl::error(GL_OUT_OF_MEMORY);
5836     }
5837 }
5838
5839 void __stdcall glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
5840 {
5841     EVENT("(GLuint index = %d, GLint size = %d, GLenum type = 0x%X, "
5842           "GLboolean normalized = %u, GLsizei stride = %d, const GLvoid* ptr = 0x%0.8p)",
5843           index, size, type, normalized, stride, ptr);
5844
5845     try
5846     {
5847         if (index >= gl::MAX_VERTEX_ATTRIBS)
5848         {
5849             return gl::error(GL_INVALID_VALUE);
5850         }
5851
5852         if (size < 1 || size > 4)
5853         {
5854             return gl::error(GL_INVALID_VALUE);
5855         }
5856
5857         gl::Context *context = gl::getNonLostContext();
5858
5859         switch (type)
5860         {
5861           case GL_BYTE:
5862           case GL_UNSIGNED_BYTE:
5863           case GL_SHORT:
5864           case GL_UNSIGNED_SHORT:
5865           case GL_FIXED:
5866           case GL_FLOAT:
5867             break;
5868           case GL_HALF_FLOAT:
5869           case GL_INT:
5870           case GL_UNSIGNED_INT:
5871           case GL_INT_2_10_10_10_REV:
5872           case GL_UNSIGNED_INT_2_10_10_10_REV:
5873             if (context && context->getClientVersion() < 3)
5874             {
5875                 return gl::error(GL_INVALID_ENUM);
5876             }
5877             else
5878             {
5879                 break;
5880             }
5881           default:
5882             return gl::error(GL_INVALID_ENUM);
5883         }
5884
5885         if (stride < 0)
5886         {
5887             return gl::error(GL_INVALID_VALUE);
5888         }
5889
5890         if ((type == GL_INT_2_10_10_10_REV || type == GL_UNSIGNED_INT_2_10_10_10_REV) && size != 4)
5891         {
5892             return gl::error(GL_INVALID_OPERATION);
5893         }
5894
5895         if (context)
5896         {
5897             // [OpenGL ES 3.0.2] Section 2.8 page 24:
5898             // An INVALID_OPERATION error is generated when a non-zero vertex array object
5899             // is bound, zero is bound to the ARRAY_BUFFER buffer object binding point,
5900             // and the pointer argument is not NULL.
5901             if (context->getVertexArrayHandle() != 0 && context->getArrayBufferHandle() == 0 && ptr != NULL)
5902             {
5903                 return gl::error(GL_INVALID_OPERATION);
5904             }
5905
5906             context->setVertexAttribState(index, context->getArrayBuffer(), size, type,
5907                                           normalized == GL_TRUE, false, stride, ptr);
5908         }
5909     }
5910     catch (...)
5911     {
5912         return gl::error(GL_OUT_OF_MEMORY);
5913     }
5914 }
5915
5916 void __stdcall glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
5917 {
5918     EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);
5919
5920     try
5921     {
5922         if (width < 0 || height < 0)
5923         {
5924             return gl::error(GL_INVALID_VALUE);
5925         }
5926
5927         gl::Context *context = gl::getNonLostContext();
5928
5929         if (context)
5930         {
5931             context->setViewportParams(x, y, width, height);
5932         }
5933     }
5934     catch (...)
5935     {
5936         return gl::error(GL_OUT_OF_MEMORY);
5937     }
5938 }
5939
5940 // OpenGL ES 3.0 functions
5941
5942 void __stdcall glReadBuffer(GLenum mode)
5943 {
5944     EVENT("(GLenum mode = 0x%X)", mode);
5945
5946     try
5947     {
5948         gl::Context *context = gl::getNonLostContext();
5949
5950         if (context)
5951         {
5952             if (context->getClientVersion() < 3)
5953             {
5954                 return gl::error(GL_INVALID_OPERATION);
5955             }
5956
5957             // glReadBuffer
5958             UNIMPLEMENTED();
5959         }
5960     }
5961     catch (...)
5962     {
5963         return gl::error(GL_OUT_OF_MEMORY);
5964     }
5965 }
5966
5967 void __stdcall glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
5968 {
5969     EVENT("(GLenum mode = 0x%X, GLuint start = %u, GLuint end = %u, GLsizei count = %d, GLenum type = 0x%X, "
5970           "const GLvoid* indices = 0x%0.8p)", mode, start, end, count, type, indices);
5971
5972     try
5973     {
5974         gl::Context *context = gl::getNonLostContext();
5975
5976         if (context)
5977         {
5978             if (context->getClientVersion() < 3)
5979             {
5980                 return gl::error(GL_INVALID_OPERATION);
5981             }
5982
5983             // glDrawRangeElements
5984             UNIMPLEMENTED();
5985         }
5986     }
5987     catch (...)
5988     {
5989         return gl::error(GL_OUT_OF_MEMORY);
5990     }
5991 }
5992
5993 void __stdcall glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
5994 {
5995     EVENT("(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
5996           "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, "
5997           "GLenum type = 0x%X, const GLvoid* pixels = 0x%0.8p)",
5998           target, level, internalformat, width, height, depth, border, format, type, pixels);
5999
6000     try
6001     {
6002         gl::Context *context = gl::getNonLostContext();
6003
6004         if (context)
6005         {
6006             if (context->getClientVersion() < 3)
6007             {
6008                 return gl::error(GL_INVALID_OPERATION);
6009             }
6010
6011             // validateES3TexImageFormat sets the error code if there is an error
6012             if (!ValidateES3TexImageParameters(context, target, level, internalformat, false, false,
6013                                                0, 0, 0, width, height, depth, border, format, type, pixels))
6014             {
6015                 return;
6016             }
6017
6018             switch(target)
6019             {
6020               case GL_TEXTURE_3D:
6021                 {
6022                     gl::Texture3D *texture = context->getTexture3D();
6023                     texture->setImage(level, width, height, depth, internalformat, format, type, context->getUnpackState(), pixels);
6024                 }
6025                 break;
6026
6027               case GL_TEXTURE_2D_ARRAY:
6028                 {
6029                     gl::Texture2DArray *texture = context->getTexture2DArray();
6030                     texture->setImage(level, width, height, depth, internalformat, format, type, context->getUnpackState(), pixels);
6031                 }
6032                 break;
6033
6034               default:
6035                 return gl::error(GL_INVALID_ENUM);
6036             }
6037         }
6038     }
6039     catch (...)
6040     {
6041         return gl::error(GL_OUT_OF_MEMORY);
6042     }
6043 }
6044
6045 void __stdcall glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)
6046 {
6047     EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
6048           "GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
6049           "GLenum format = 0x%X, GLenum type = 0x%X, const GLvoid* pixels = 0x%0.8p)",
6050           target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
6051
6052     try
6053     {
6054         gl::Context *context = gl::getNonLostContext();
6055
6056         if (context)
6057         {
6058             if (context->getClientVersion() < 3)
6059             {
6060                 return gl::error(GL_INVALID_OPERATION);
6061             }
6062
6063             // validateES3TexImageFormat sets the error code if there is an error
6064             if (!ValidateES3TexImageParameters(context, target, level, GL_NONE, false, true,
6065                                                xoffset, yoffset, zoffset, width, height, depth, 0,
6066                                                format, type, pixels))
6067             {
6068                 return;
6069             }
6070
6071             // Zero sized uploads are valid but no-ops
6072             if (width == 0 || height == 0 || depth == 0)
6073             {
6074                 return;
6075             }
6076
6077             switch(target)
6078             {
6079               case GL_TEXTURE_3D:
6080                 {
6081                     gl::Texture3D *texture = context->getTexture3D();
6082                     texture->subImage(level, xoffset, yoffset, zoffset, width, height, depth, format, type, context->getUnpackState(), pixels);
6083                 }
6084                 break;
6085
6086               case GL_TEXTURE_2D_ARRAY:
6087                 {
6088                     gl::Texture2DArray *texture = context->getTexture2DArray();
6089                     texture->subImage(level, xoffset, yoffset, zoffset, width, height, depth, format, type, context->getUnpackState(), pixels);
6090                 }
6091                 break;
6092
6093               default:
6094                 return gl::error(GL_INVALID_ENUM);
6095             }
6096         }
6097     }
6098     catch (...)
6099     {
6100         return gl::error(GL_OUT_OF_MEMORY);
6101     }
6102 }
6103
6104 void __stdcall glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
6105 {
6106     EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
6107           "GLint zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
6108           target, level, xoffset, yoffset, zoffset, x, y, width, height);
6109
6110     try
6111     {
6112         gl::Context *context = gl::getNonLostContext();
6113
6114         if (context)
6115         {
6116             if (context->getClientVersion() < 3)
6117             {
6118                 return gl::error(GL_INVALID_OPERATION);
6119             }
6120
6121             if (!ValidateES3CopyTexImageParameters(context, target, level, GL_NONE, true, xoffset, yoffset, zoffset,
6122                                                    x, y, width, height, 0))
6123             {
6124                 return;
6125             }
6126
6127             gl::Framebuffer *framebuffer = context->getReadFramebuffer();
6128             gl::Texture *texture = NULL;
6129             switch (target)
6130             {
6131               case GL_TEXTURE_3D:
6132                 texture = context->getTexture3D();
6133                 break;
6134
6135               case GL_TEXTURE_2D_ARRAY:
6136                 texture = context->getTexture2DArray();
6137                 break;
6138
6139               default:
6140                 return gl::error(GL_INVALID_ENUM);
6141             }
6142
6143             texture->copySubImage(target, level, xoffset, yoffset, zoffset, x, y, width, height, framebuffer);
6144         }
6145     }
6146     catch (...)
6147     {
6148         return gl::error(GL_OUT_OF_MEMORY);
6149     }
6150 }
6151
6152 void __stdcall glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
6153 {
6154     EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = %d, "
6155           "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, "
6156           "const GLvoid* data = 0x%0.8p)",
6157           target, level, internalformat, width, height, depth, border, imageSize, data);
6158
6159     try
6160     {
6161         gl::Context *context = gl::getNonLostContext();
6162
6163         if (context)
6164         {
6165             if (context->getClientVersion() < 3)
6166             {
6167                 return gl::error(GL_INVALID_OPERATION);
6168             }
6169
6170             if (imageSize < 0 || imageSize != (GLsizei)gl::GetBlockSize(internalformat, GL_UNSIGNED_BYTE, context->getClientVersion(), width, height))
6171             {
6172                 return gl::error(GL_INVALID_VALUE);
6173             }
6174
6175             // validateES3TexImageFormat sets the error code if there is an error
6176             if (!ValidateES3TexImageParameters(context, target, level, internalformat, true, false,
6177                                                0, 0, 0, width, height, depth, border, GL_NONE, GL_NONE, data))
6178             {
6179                 return;
6180             }
6181
6182             switch(target)
6183             {
6184               case GL_TEXTURE_3D:
6185                 {
6186                     gl::Texture3D *texture = context->getTexture3D();
6187                     texture->setCompressedImage(level, internalformat, width, height, depth, imageSize, data);
6188                 }
6189                 break;
6190
6191               case GL_TEXTURE_2D_ARRAY:
6192                 {
6193                     gl::Texture2DArray *texture = context->getTexture2DArray();
6194                     texture->setCompressedImage(level, internalformat, width, height, depth, imageSize, data);
6195                 }
6196                 break;
6197
6198               default:
6199                 return gl::error(GL_INVALID_ENUM);
6200             }
6201         }
6202     }
6203     catch (...)
6204     {
6205         return gl::error(GL_OUT_OF_MEMORY);
6206     }
6207 }
6208
6209 void __stdcall glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data)
6210 {
6211     EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
6212         "GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, "
6213         "GLenum format = 0x%X, GLsizei imageSize = %d, const GLvoid* data = 0x%0.8p)",
6214         target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
6215
6216     try
6217     {
6218         gl::Context *context = gl::getNonLostContext();
6219
6220         if (context)
6221         {
6222             if (context->getClientVersion() < 3)
6223             {
6224                 return gl::error(GL_INVALID_OPERATION);
6225             }
6226
6227             if (imageSize < 0 || imageSize != (GLsizei)gl::GetBlockSize(format, GL_UNSIGNED_BYTE, context->getClientVersion(), width, height))
6228             {
6229                 return gl::error(GL_INVALID_VALUE);
6230             }
6231
6232             if (!data)
6233             {
6234                 return gl::error(GL_INVALID_VALUE);
6235             }
6236
6237             // validateES3TexImageFormat sets the error code if there is an error
6238             if (!ValidateES3TexImageParameters(context, target, level, GL_NONE, true, true,
6239                                                0, 0, 0, width, height, depth, 0, GL_NONE, GL_NONE, data))
6240             {
6241                 return;
6242             }
6243
6244             // Zero sized uploads are valid but no-ops
6245             if (width == 0 || height == 0)
6246             {
6247                 return;
6248             }
6249
6250             switch(target)
6251             {
6252               case GL_TEXTURE_3D:
6253                 {
6254                     gl::Texture3D *texture = context->getTexture3D();
6255                     texture->subImageCompressed(level, xoffset, yoffset, zoffset, width, height, depth,
6256                                                 format, imageSize, data);
6257                 }
6258                 break;
6259
6260               case GL_TEXTURE_2D_ARRAY:
6261                 {
6262                     gl::Texture2DArray *texture = context->getTexture2DArray();
6263                     texture->subImageCompressed(level, xoffset, yoffset, zoffset, width, height, depth,
6264                                                 format, imageSize, data);
6265                 }
6266                 break;
6267
6268             default:
6269                 return gl::error(GL_INVALID_ENUM);
6270             }
6271         }
6272     }
6273     catch (...)
6274     {
6275         return gl::error(GL_OUT_OF_MEMORY);
6276     }
6277 }
6278
6279 void __stdcall glGenQueries(GLsizei n, GLuint* ids)
6280 {
6281     EVENT("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);
6282
6283     try
6284     {
6285         gl::Context *context = gl::getNonLostContext();
6286
6287         if (context)
6288         {
6289             if (context->getClientVersion() < 3)
6290             {
6291                 return gl::error(GL_INVALID_OPERATION);
6292             }
6293
6294             if (n < 0)
6295             {
6296                 return gl::error(GL_INVALID_VALUE);
6297             }
6298
6299             for (GLsizei i = 0; i < n; i++)
6300             {
6301                 ids[i] = context->createQuery();
6302             }
6303         }
6304     }
6305     catch (...)
6306     {
6307         return gl::error(GL_OUT_OF_MEMORY);
6308     }
6309 }
6310
6311 void __stdcall glDeleteQueries(GLsizei n, const GLuint* ids)
6312 {
6313     EVENT("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);
6314
6315     try
6316     {
6317         gl::Context *context = gl::getNonLostContext();
6318
6319         if (context)
6320         {
6321             if (context->getClientVersion() < 3)
6322             {
6323                 return gl::error(GL_INVALID_OPERATION);
6324             }
6325
6326             if (n < 0)
6327             {
6328                 return gl::error(GL_INVALID_VALUE);
6329             }
6330
6331             for (GLsizei i = 0; i < n; i++)
6332             {
6333                 context->deleteQuery(ids[i]);
6334             }
6335         }
6336     }
6337     catch (...)
6338     {
6339         return gl::error(GL_OUT_OF_MEMORY);
6340     }
6341 }
6342
6343 GLboolean __stdcall glIsQuery(GLuint id)
6344 {
6345     EVENT("(GLuint id = %u)", id);
6346
6347     try
6348     {
6349         gl::Context *context = gl::getNonLostContext();
6350
6351         if (context)
6352         {
6353             if (context->getClientVersion() < 3)
6354             {
6355                 return gl::error(GL_INVALID_OPERATION, GL_FALSE);
6356             }
6357
6358             return (context->getQuery(id, false, GL_NONE) != NULL) ? GL_TRUE : GL_FALSE;
6359         }
6360     }
6361     catch (...)
6362     {
6363         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
6364     }
6365
6366     return GL_FALSE;
6367 }
6368
6369 void __stdcall glBeginQuery(GLenum target, GLuint id)
6370 {
6371     EVENT("(GLenum target = 0x%X, GLuint id = %u)", target, id);
6372
6373     try
6374     {
6375         gl::Context *context = gl::getNonLostContext();
6376
6377         if (context)
6378         {
6379             if (context->getClientVersion() < 3)
6380             {
6381                 return gl::error(GL_INVALID_OPERATION);
6382             }
6383
6384             if (!ValidateBeginQuery(context, target, id))
6385             {
6386                 return;
6387             }
6388             context->beginQuery(target, id);
6389         }
6390     }
6391     catch (...)
6392     {
6393         return gl::error(GL_OUT_OF_MEMORY);
6394     }
6395 }
6396
6397 void __stdcall glEndQuery(GLenum target)
6398 {
6399     EVENT("(GLenum target = 0x%X)", target);
6400
6401     try
6402     {
6403         gl::Context *context = gl::getNonLostContext();
6404
6405         if (context)
6406         {
6407             if (context->getClientVersion() < 3)
6408             {
6409                 return gl::error(GL_INVALID_OPERATION);
6410             }
6411
6412             if (!ValidateEndQuery(context, target))
6413             {
6414                 return;
6415             }
6416
6417             context->endQuery(target);
6418         }
6419     }
6420     catch (...)
6421     {
6422         return gl::error(GL_OUT_OF_MEMORY);
6423     }
6424 }
6425
6426 void __stdcall glGetQueryiv(GLenum target, GLenum pname, GLint* params)
6427 {
6428     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
6429
6430     try
6431     {
6432         gl::Context *context = gl::getNonLostContext();
6433
6434         if (context)
6435         {
6436             if (context->getClientVersion() < 3)
6437             {
6438                 return gl::error(GL_INVALID_OPERATION);
6439             }
6440
6441             if (!ValidQueryType(context, target))
6442             {
6443                 return gl::error(GL_INVALID_ENUM);
6444             }
6445
6446             switch (pname)
6447             {
6448               case GL_CURRENT_QUERY:
6449                 params[0] = static_cast<GLint>(context->getActiveQueryId(target));
6450                 break;
6451
6452               default:
6453                 return gl::error(GL_INVALID_ENUM);
6454             }
6455         }
6456     }
6457     catch (...)
6458     {
6459         return gl::error(GL_OUT_OF_MEMORY);
6460     }
6461 }
6462
6463 void __stdcall glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
6464 {
6465     EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", id, pname, params);
6466
6467     try
6468     {
6469         gl::Context *context = gl::getNonLostContext();
6470
6471         if (context)
6472         {
6473             if (context->getClientVersion() < 3)
6474             {
6475                 return gl::error(GL_INVALID_OPERATION);
6476             }
6477
6478             gl::Query *queryObject = context->getQuery(id, false, GL_NONE);
6479
6480             if (!queryObject)
6481             {
6482                 return gl::error(GL_INVALID_OPERATION);
6483             }
6484
6485             if (context->getActiveQueryId(queryObject->getType()) == id)
6486             {
6487                 return gl::error(GL_INVALID_OPERATION);
6488             }
6489
6490             switch(pname)
6491             {
6492               case GL_QUERY_RESULT:
6493                 params[0] = queryObject->getResult();
6494                 break;
6495               case GL_QUERY_RESULT_AVAILABLE:
6496                 params[0] = queryObject->isResultAvailable();
6497                 break;
6498               default:
6499                 return gl::error(GL_INVALID_ENUM);
6500             }
6501         }
6502     }
6503     catch (...)
6504     {
6505         return gl::error(GL_OUT_OF_MEMORY);
6506     }
6507 }
6508
6509 GLboolean __stdcall glUnmapBuffer(GLenum target)
6510 {
6511     EVENT("(GLenum target = 0x%X)", target);
6512
6513     try
6514     {
6515         gl::Context *context = gl::getNonLostContext();
6516
6517         if (context)
6518         {
6519             if (context->getClientVersion() < 3)
6520             {
6521                 return gl::error(GL_INVALID_OPERATION, GL_FALSE);
6522             }
6523
6524             return glUnmapBufferOES(target);
6525         }
6526     }
6527     catch (...)
6528     {
6529         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
6530     }
6531
6532     return GL_FALSE;
6533 }
6534
6535 void __stdcall glGetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
6536 {
6537     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLvoid** params = 0x%0.8p)", target, pname, params);
6538
6539     try
6540     {
6541         gl::Context *context = gl::getNonLostContext();
6542
6543         if (context)
6544         {
6545             if (context->getClientVersion() < 3)
6546             {
6547                 return gl::error(GL_INVALID_OPERATION);
6548             }
6549
6550             glGetBufferPointervOES(target, pname, params);
6551         }
6552     }
6553     catch (...)
6554     {
6555         return gl::error(GL_OUT_OF_MEMORY);
6556     }
6557 }
6558
6559 void __stdcall glDrawBuffers(GLsizei n, const GLenum* bufs)
6560 {
6561     try
6562     {
6563         gl::Context *context = gl::getNonLostContext();
6564
6565         if (context)
6566         {
6567             if (context->getClientVersion() < 3)
6568             {
6569                 return gl::error(GL_INVALID_OPERATION);
6570             }
6571
6572             glDrawBuffersEXT(n, bufs);
6573         }
6574     }
6575     catch (...)
6576     {
6577         return gl::error(GL_OUT_OF_MEMORY);
6578     }
6579 }
6580
6581 void __stdcall glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6582 {
6583     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
6584           location, count, transpose, value);
6585
6586     try
6587     {
6588         gl::Context *context = gl::getNonLostContext();
6589
6590         if (context)
6591         {
6592             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT2x3, location, count, transpose))
6593             {
6594                 return;
6595             }
6596
6597             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
6598             programBinary->setUniformMatrix2x3fv(location, count, transpose, value);
6599         }
6600     }
6601     catch (...)
6602     {
6603         return gl::error(GL_OUT_OF_MEMORY);
6604     }
6605 }
6606
6607 void __stdcall glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6608 {
6609     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
6610           location, count, transpose, value);
6611
6612     try
6613     {
6614         gl::Context *context = gl::getNonLostContext();
6615
6616         if (context)
6617         {
6618             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT3x2, location, count, transpose))
6619             {
6620                 return;
6621             }
6622
6623             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
6624             programBinary->setUniformMatrix3x2fv(location, count, transpose, value);
6625         }
6626     }
6627     catch (...)
6628     {
6629         return gl::error(GL_OUT_OF_MEMORY);
6630     }
6631 }
6632
6633 void __stdcall glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6634 {
6635     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
6636           location, count, transpose, value);
6637
6638     try
6639     {
6640         gl::Context *context = gl::getNonLostContext();
6641
6642         if (context)
6643         {
6644             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT2x4, location, count, transpose))
6645             {
6646                 return;
6647             }
6648
6649             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
6650             programBinary->setUniformMatrix2x4fv(location, count, transpose, value);
6651         }
6652     }
6653     catch (...)
6654     {
6655         return gl::error(GL_OUT_OF_MEMORY);
6656     }
6657 }
6658
6659 void __stdcall glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6660 {
6661     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
6662           location, count, transpose, value);
6663
6664     try
6665     {
6666         gl::Context *context = gl::getNonLostContext();
6667
6668         if (context)
6669         {
6670             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT4x2, location, count, transpose))
6671             {
6672                 return;
6673             }
6674
6675             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
6676             programBinary->setUniformMatrix4x2fv(location, count, transpose, value);
6677         }
6678     }
6679     catch (...)
6680     {
6681         return gl::error(GL_OUT_OF_MEMORY);
6682     }
6683 }
6684
6685 void __stdcall glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6686 {
6687     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
6688           location, count, transpose, value);
6689
6690     try
6691     {
6692         gl::Context *context = gl::getNonLostContext();
6693
6694         if (context)
6695         {
6696             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT3x4, location, count, transpose))
6697             {
6698                 return;
6699             }
6700
6701             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
6702             programBinary->setUniformMatrix3x4fv(location, count, transpose, value);
6703         }
6704     }
6705     catch (...)
6706     {
6707         return gl::error(GL_OUT_OF_MEMORY);
6708     }
6709 }
6710
6711 void __stdcall glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
6712 {
6713     EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat* value = 0x%0.8p)",
6714           location, count, transpose, value);
6715
6716     try
6717     {
6718         gl::Context *context = gl::getNonLostContext();
6719
6720         if (context)
6721         {
6722             if (!ValidateUniformMatrix(context, GL_FLOAT_MAT4x3, location, count, transpose))
6723             {
6724                 return;
6725             }
6726
6727             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
6728             programBinary->setUniformMatrix4x3fv(location, count, transpose, value);
6729         }
6730     }
6731     catch (...)
6732     {
6733         return gl::error(GL_OUT_OF_MEMORY);
6734     }
6735 }
6736
6737 void __stdcall glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
6738 {
6739     EVENT("(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, GLint dstX0 = %d, "
6740           "GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask = 0x%X, GLenum filter = 0x%X)",
6741           srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
6742
6743     try
6744     {
6745         gl::Context *context = gl::getNonLostContext();
6746         if (context)
6747         {
6748             if (context->getClientVersion() < 3)
6749             {
6750                 return gl::error(GL_INVALID_OPERATION);
6751             }
6752
6753             if (!ValidateBlitFramebufferParameters(context, srcX0, srcY0, srcX1, srcY1,
6754                                                    dstX0, dstY0, dstX1, dstY1, mask, filter,
6755                                                    false))
6756             {
6757                 return;
6758             }
6759
6760             context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
6761                                      mask, filter);
6762         }
6763     }
6764     catch (...)
6765     {
6766         return gl::error(GL_OUT_OF_MEMORY);
6767     }
6768 }
6769
6770 void __stdcall glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
6771 {
6772     EVENT("(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
6773         target, samples, internalformat, width, height);
6774
6775     try
6776     {
6777         gl::Context *context = gl::getNonLostContext();
6778
6779         if (context)
6780         {
6781             if (context->getClientVersion() < 3)
6782             {
6783                 return gl::error(GL_INVALID_OPERATION);
6784             }
6785
6786             if (!ValidateRenderbufferStorageParameters(context, target, samples, internalformat,
6787                                                        width, height, false))
6788             {
6789                 return;
6790             }
6791
6792             context->setRenderbufferStorage(width, height, internalformat, samples);
6793         }
6794     }
6795     catch (...)
6796     {
6797         return gl::error(GL_OUT_OF_MEMORY);
6798     }
6799 }
6800
6801 void __stdcall glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
6802 {
6803     EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d, GLint layer = %d)",
6804         target, attachment, texture, level, layer);
6805
6806     try
6807     {
6808         gl::Context *context = gl::getNonLostContext();
6809
6810         if (context)
6811         {
6812             if (context->getClientVersion() < 3)
6813             {
6814                 return gl::error(GL_INVALID_OPERATION);
6815             }
6816
6817             if (!ValidateES3FramebufferTextureParameters(context, target, attachment, GL_NONE, texture, level, layer, true))
6818             {
6819                 return;
6820             }
6821
6822             gl::Framebuffer *framebuffer = context->getTargetFramebuffer(target);
6823             ASSERT(framebuffer);
6824
6825             gl::Texture *textureObject = context->getTexture(texture);
6826             GLenum textarget = textureObject ? textureObject->getTarget() : GL_NONE;
6827
6828             if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
6829             {
6830                 const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
6831                 framebuffer->setColorbuffer(colorAttachment, textarget, texture, level, layer);
6832             }
6833             else
6834             {
6835                 switch (attachment)
6836                 {
6837                 case GL_DEPTH_ATTACHMENT:         framebuffer->setDepthbuffer(textarget, texture, level, layer);        break;
6838                 case GL_STENCIL_ATTACHMENT:       framebuffer->setStencilbuffer(textarget, texture, level, layer);      break;
6839                 case GL_DEPTH_STENCIL_ATTACHMENT: framebuffer->setDepthStencilBuffer(textarget, texture, level, layer); break;
6840                 }
6841             }
6842         }
6843     }
6844     catch (...)
6845     {
6846         return gl::error(GL_OUT_OF_MEMORY);
6847     }
6848 }
6849
6850 GLvoid* __stdcall glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
6851 {
6852     EVENT("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr length = %d, GLbitfield access = 0x%X)",
6853           target, offset, length, access);
6854
6855     try
6856     {
6857         gl::Context *context = gl::getNonLostContext();
6858
6859         if (context)
6860         {
6861             if (context->getClientVersion() < 3)
6862             {
6863                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLvoid*>(NULL));
6864             }
6865
6866             return glMapBufferRangeEXT(target, offset, length, access);
6867         }
6868     }
6869     catch (...)
6870     {
6871         return gl::error(GL_OUT_OF_MEMORY, reinterpret_cast<GLvoid*>(NULL));
6872     }
6873
6874     return NULL;
6875 }
6876
6877 void __stdcall glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
6878 {
6879     EVENT("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr length = %d)", target, offset, length);
6880
6881     try
6882     {
6883         gl::Context *context = gl::getNonLostContext();
6884
6885         if (context)
6886         {
6887             if (context->getClientVersion() < 3)
6888             {
6889                 return gl::error(GL_INVALID_OPERATION);
6890             }
6891
6892             glFlushMappedBufferRangeEXT(target, offset, length);
6893         }
6894     }
6895     catch (...)
6896     {
6897         return gl::error(GL_OUT_OF_MEMORY);
6898     }
6899 }
6900
6901 void __stdcall glBindVertexArray(GLuint array)
6902 {
6903     EVENT("(GLuint array = %u)", array);
6904
6905     try
6906     {
6907         gl::Context *context = gl::getNonLostContext();
6908
6909         if (context)
6910         {
6911             if (context->getClientVersion() < 3)
6912             {
6913                 return gl::error(GL_INVALID_OPERATION);
6914             }
6915
6916             gl::VertexArray *vao = context->getVertexArray(array);
6917
6918             if (!vao)
6919             {
6920                 // The default VAO should always exist
6921                 ASSERT(array != 0);
6922                 return gl::error(GL_INVALID_OPERATION);
6923             }
6924
6925             context->bindVertexArray(array);
6926         }
6927     }
6928     catch (...)
6929     {
6930         return gl::error(GL_OUT_OF_MEMORY);
6931     }
6932 }
6933
6934 void __stdcall glDeleteVertexArrays(GLsizei n, const GLuint* arrays)
6935 {
6936     EVENT("(GLsizei n = %d, const GLuint* arrays = 0x%0.8p)", n, arrays);
6937
6938     try
6939     {
6940         gl::Context *context = gl::getNonLostContext();
6941
6942         if (context)
6943         {
6944             if (context->getClientVersion() < 3)
6945             {
6946                 return gl::error(GL_INVALID_OPERATION);
6947             }
6948
6949             if (n < 0)
6950             {
6951                 return gl::error(GL_INVALID_VALUE);
6952             }
6953
6954             for (int arrayIndex = 0; arrayIndex < n; arrayIndex++)
6955             {
6956                 if (arrays[arrayIndex] != 0)
6957                 {
6958                     context->deleteVertexArray(arrays[arrayIndex]);
6959                 }
6960             }
6961         }
6962     }
6963     catch (...)
6964     {
6965         return gl::error(GL_OUT_OF_MEMORY);
6966     }
6967 }
6968
6969 void __stdcall glGenVertexArrays(GLsizei n, GLuint* arrays)
6970 {
6971     EVENT("(GLsizei n = %d, GLuint* arrays = 0x%0.8p)", n, arrays);
6972
6973     try
6974     {
6975         gl::Context *context = gl::getNonLostContext();
6976
6977         if (context)
6978         {
6979             if (context->getClientVersion() < 3)
6980             {
6981                 return gl::error(GL_INVALID_OPERATION);
6982             }
6983
6984             if (n < 0)
6985             {
6986                 return gl::error(GL_INVALID_VALUE);
6987             }
6988
6989             for (int arrayIndex = 0; arrayIndex < n; arrayIndex++)
6990             {
6991                 arrays[arrayIndex] = context->createVertexArray();
6992             }
6993         }
6994     }
6995     catch (...)
6996     {
6997         return gl::error(GL_OUT_OF_MEMORY);
6998     }
6999 }
7000
7001 GLboolean __stdcall glIsVertexArray(GLuint array)
7002 {
7003     EVENT("(GLuint array = %u)", array);
7004
7005     try
7006     {
7007         gl::Context *context = gl::getNonLostContext();
7008
7009         if (context)
7010         {
7011             if (context->getClientVersion() < 3)
7012             {
7013                 return gl::error(GL_INVALID_OPERATION, GL_FALSE);
7014             }
7015
7016             if (array == 0)
7017             {
7018                 return GL_FALSE;
7019             }
7020
7021             gl::VertexArray *vao = context->getVertexArray(array);
7022
7023             return (vao != NULL ? GL_TRUE : GL_FALSE);
7024         }
7025     }
7026     catch (...)
7027     {
7028         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
7029     }
7030
7031     return GL_FALSE;
7032 }
7033
7034 void __stdcall glGetIntegeri_v(GLenum target, GLuint index, GLint* data)
7035 {
7036     EVENT("(GLenum target = 0x%X, GLuint index = %u, GLint* data = 0x%0.8p)",
7037           target, index, data);
7038
7039     try
7040     {
7041         gl::Context *context = gl::getNonLostContext();
7042
7043         if (context)
7044         {
7045             if (context->getClientVersion() < 3)
7046             {
7047                 return gl::error(GL_INVALID_OPERATION);
7048             }
7049
7050             switch (target)
7051             {
7052               case GL_TRANSFORM_FEEDBACK_BUFFER_START:
7053               case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
7054               case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
7055                 if (index >= context->getMaxTransformFeedbackBufferBindings())
7056                     return gl::error(GL_INVALID_VALUE);
7057                 break;
7058               case GL_UNIFORM_BUFFER_START:
7059               case GL_UNIFORM_BUFFER_SIZE:
7060               case GL_UNIFORM_BUFFER_BINDING:
7061                 if (index >= context->getMaximumCombinedUniformBufferBindings())
7062                     return gl::error(GL_INVALID_VALUE);
7063                 break;
7064               default:
7065                 return gl::error(GL_INVALID_ENUM);
7066             }
7067
7068             if (!(context->getIndexedIntegerv(target, index, data)))
7069             {
7070                 GLenum nativeType;
7071                 unsigned int numParams = 0;
7072                 if (!context->getIndexedQueryParameterInfo(target, &nativeType, &numParams))
7073                     return gl::error(GL_INVALID_ENUM);
7074
7075                 if (numParams == 0)
7076                     return; // it is known that pname is valid, but there are no parameters to return
7077
7078                 if (nativeType == GL_INT_64_ANGLEX)
7079                 {
7080                     GLint64 minIntValue = static_cast<GLint64>(std::numeric_limits<int>::min());
7081                     GLint64 maxIntValue = static_cast<GLint64>(std::numeric_limits<int>::max());
7082                     GLint64 *int64Params = new GLint64[numParams];
7083
7084                     context->getIndexedInteger64v(target, index, int64Params);
7085
7086                     for (unsigned int i = 0; i < numParams; ++i)
7087                     {
7088                         GLint64 clampedValue = std::max(std::min(int64Params[i], maxIntValue), minIntValue);
7089                         data[i] = static_cast<GLint>(clampedValue);
7090                     }
7091
7092                     delete [] int64Params;
7093                 }
7094                 else
7095                 {
7096                     UNREACHABLE();
7097                 }
7098             }
7099         }
7100     }
7101     catch (...)
7102     {
7103         return gl::error(GL_OUT_OF_MEMORY);
7104     }
7105 }
7106
7107 void __stdcall glBeginTransformFeedback(GLenum primitiveMode)
7108 {
7109     EVENT("(GLenum primitiveMode = 0x%X)", primitiveMode);
7110
7111     try
7112     {
7113         gl::Context *context = gl::getNonLostContext();
7114
7115         if (context)
7116         {
7117             if (context->getClientVersion() < 3)
7118             {
7119                 return gl::error(GL_INVALID_OPERATION);
7120             }
7121
7122             switch (primitiveMode)
7123             {
7124               case GL_TRIANGLES:
7125               case GL_LINES:
7126               case GL_POINTS:
7127                 break;
7128               default:
7129                 return gl::error(GL_INVALID_ENUM);
7130             }
7131
7132             gl::TransformFeedback *transformFeedback = context->getCurrentTransformFeedback();
7133             ASSERT(transformFeedback != NULL);
7134
7135             if (transformFeedback->isStarted())
7136             {
7137                 return gl::error(GL_INVALID_OPERATION);
7138             }
7139
7140             if (transformFeedback->isPaused())
7141             {
7142                 transformFeedback->resume();
7143             }
7144             else
7145             {
7146                 transformFeedback->start(primitiveMode);
7147             }
7148         }
7149     }
7150     catch (...)
7151     {
7152         return gl::error(GL_OUT_OF_MEMORY);
7153     }
7154 }
7155
7156 void __stdcall glEndTransformFeedback(void)
7157 {
7158     EVENT("(void)");
7159
7160     try
7161     {
7162         gl::Context *context = gl::getNonLostContext();
7163
7164         if (context)
7165         {
7166             if (context->getClientVersion() < 3)
7167             {
7168                 return gl::error(GL_INVALID_OPERATION);
7169             }
7170
7171             gl::TransformFeedback *transformFeedback = context->getCurrentTransformFeedback();
7172             ASSERT(transformFeedback != NULL);
7173
7174             if (!transformFeedback->isStarted())
7175             {
7176                 return gl::error(GL_INVALID_OPERATION);
7177             }
7178
7179             transformFeedback->stop();
7180         }
7181     }
7182     catch (...)
7183     {
7184         return gl::error(GL_OUT_OF_MEMORY);
7185     }
7186 }
7187
7188 void __stdcall glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
7189 {
7190     EVENT("(GLenum target = 0x%X, GLuint index = %u, GLuint buffer = %u, GLintptr offset = %d, GLsizeiptr size = %d)",
7191           target, index, buffer, offset, size);
7192
7193     try
7194     {
7195         gl::Context *context = gl::getNonLostContext();
7196
7197         if (context)
7198         {
7199             if (context->getClientVersion() < 3)
7200             {
7201                 return gl::error(GL_INVALID_OPERATION);
7202             }
7203
7204             switch (target)
7205             {
7206               case GL_TRANSFORM_FEEDBACK_BUFFER:
7207                 if (index >= context->getMaxTransformFeedbackBufferBindings())
7208                 {
7209                     return gl::error(GL_INVALID_VALUE);
7210                 }
7211                 break;
7212
7213               case GL_UNIFORM_BUFFER:
7214                 if (index >= context->getMaximumCombinedUniformBufferBindings())
7215                 {
7216                     return gl::error(GL_INVALID_VALUE);
7217                 }
7218                 break;
7219
7220               default:
7221                 return gl::error(GL_INVALID_ENUM);
7222             }
7223
7224             if (buffer != 0 && size <= 0)
7225             {
7226                 return gl::error(GL_INVALID_VALUE);
7227             }
7228
7229             switch (target)
7230             {
7231               case GL_TRANSFORM_FEEDBACK_BUFFER:
7232
7233                 // size and offset must be a multiple of 4
7234                 if (buffer != 0 && ((offset % 4) != 0 || (size % 4) != 0))
7235                 {
7236                     return gl::error(GL_INVALID_VALUE);
7237                 }
7238
7239                 context->bindIndexedTransformFeedbackBuffer(buffer, index, offset, size);
7240                 context->bindGenericTransformFeedbackBuffer(buffer);
7241                 break;
7242
7243               case GL_UNIFORM_BUFFER:
7244
7245                 // it is an error to bind an offset not a multiple of the alignment
7246                 if (buffer != 0 && (offset % context->getUniformBufferOffsetAlignment()) != 0)
7247                 {
7248                     return gl::error(GL_INVALID_VALUE);
7249                 }
7250
7251                 context->bindIndexedUniformBuffer(buffer, index, offset, size);
7252                 context->bindGenericUniformBuffer(buffer);
7253                 break;
7254
7255               default:
7256                 UNREACHABLE();
7257             }
7258         }
7259     }
7260     catch (...)
7261     {
7262         return gl::error(GL_OUT_OF_MEMORY);
7263     }
7264 }
7265
7266 void __stdcall glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
7267 {
7268     EVENT("(GLenum target = 0x%X, GLuint index = %u, GLuint buffer = %u)",
7269           target, index, buffer);
7270
7271     try
7272     {
7273         gl::Context *context = gl::getNonLostContext();
7274
7275         if (context)
7276         {
7277             if (context->getClientVersion() < 3)
7278             {
7279                 return gl::error(GL_INVALID_OPERATION);
7280             }
7281
7282             switch (target)
7283             {
7284               case GL_TRANSFORM_FEEDBACK_BUFFER:
7285                 if (index >= context->getMaxTransformFeedbackBufferBindings())
7286                 {
7287                     return gl::error(GL_INVALID_VALUE);
7288                 }
7289                 break;
7290
7291               case GL_UNIFORM_BUFFER:
7292                 if (index >= context->getMaximumCombinedUniformBufferBindings())
7293                 {
7294                     return gl::error(GL_INVALID_VALUE);
7295                 }
7296                 break;
7297
7298               default:
7299                 return gl::error(GL_INVALID_ENUM);
7300             }
7301
7302             switch (target)
7303             {
7304               case GL_TRANSFORM_FEEDBACK_BUFFER:
7305                 context->bindIndexedTransformFeedbackBuffer(buffer, index, 0, 0);
7306                 context->bindGenericTransformFeedbackBuffer(buffer);
7307                 break;
7308
7309               case GL_UNIFORM_BUFFER:
7310                 context->bindIndexedUniformBuffer(buffer, index, 0, 0);
7311                 context->bindGenericUniformBuffer(buffer);
7312                 break;
7313
7314               default:
7315                 UNREACHABLE();
7316             }
7317         }
7318     }
7319     catch (...)
7320     {
7321         return gl::error(GL_OUT_OF_MEMORY);
7322     }
7323 }
7324
7325 void __stdcall glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
7326 {
7327     EVENT("(GLuint program = %u, GLsizei count = %d, const GLchar* const* varyings = 0x%0.8p, GLenum bufferMode = 0x%X)",
7328           program, count, varyings, bufferMode);
7329
7330     try
7331     {
7332         gl::Context *context = gl::getNonLostContext();
7333
7334         if (context)
7335         {
7336             if (context->getClientVersion() < 3)
7337             {
7338                 return gl::error(GL_INVALID_OPERATION);
7339             }
7340
7341             if (count < 0)
7342             {
7343                 return gl::error(GL_INVALID_VALUE);
7344             }
7345
7346             switch (bufferMode)
7347             {
7348               case GL_INTERLEAVED_ATTRIBS:
7349                 break;
7350               case GL_SEPARATE_ATTRIBS:
7351                 if (static_cast<GLuint>(count) > context->getMaxTransformFeedbackBufferBindings())
7352                 {
7353                     return gl::error(GL_INVALID_VALUE);
7354                 }
7355                 break;
7356               default:
7357                 return gl::error(GL_INVALID_ENUM);
7358             }
7359
7360             if (!gl::ValidProgram(context, program))
7361             {
7362                 return;
7363             }
7364
7365             gl::Program *programObject = context->getProgram(program);
7366             ASSERT(programObject);
7367
7368             programObject->setTransformFeedbackVaryings(count, varyings, bufferMode);
7369         }
7370     }
7371     catch (...)
7372     {
7373         return gl::error(GL_OUT_OF_MEMORY);
7374     }
7375 }
7376
7377 void __stdcall glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
7378 {
7379     EVENT("(GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei* length = 0x%0.8p, "
7380           "GLsizei* size = 0x%0.8p, GLenum* type = 0x%0.8p, GLchar* name = 0x%0.8p)",
7381           program, index, bufSize, length, size, type, name);
7382
7383     try
7384     {
7385         gl::Context *context = gl::getNonLostContext();
7386
7387         if (context)
7388         {
7389             if (context->getClientVersion() < 3)
7390             {
7391                 return gl::error(GL_INVALID_OPERATION);
7392             }
7393
7394             if (bufSize < 0)
7395             {
7396                 return gl::error(GL_INVALID_VALUE);
7397             }
7398
7399             if (!gl::ValidProgram(context, program))
7400             {
7401                 return;
7402             }
7403
7404             gl::Program *programObject = context->getProgram(program);
7405             ASSERT(programObject);
7406
7407             if (index >= static_cast<GLuint>(programObject->getTransformFeedbackVaryingCount()))
7408             {
7409                 return gl::error(GL_INVALID_VALUE);
7410             }
7411
7412             programObject->getTransformFeedbackVarying(index, bufSize, length, size, type, name);
7413         }
7414     }
7415     catch (...)
7416     {
7417         return gl::error(GL_OUT_OF_MEMORY);
7418     }
7419 }
7420
7421 void __stdcall glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
7422 {
7423     EVENT("(GLuint index = %u, GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const GLvoid* pointer = 0x%0.8p)",
7424           index, size, type, stride, pointer);
7425
7426     try
7427     {
7428         gl::Context *context = gl::getNonLostContext();
7429
7430         if (context)
7431         {
7432             if (context->getClientVersion() < 3)
7433             {
7434                 return gl::error(GL_INVALID_OPERATION);
7435             }
7436         }
7437
7438         if (index >= gl::MAX_VERTEX_ATTRIBS)
7439         {
7440             return gl::error(GL_INVALID_VALUE);
7441         }
7442
7443         if (size < 1 || size > 4)
7444         {
7445             return gl::error(GL_INVALID_VALUE);
7446         }
7447
7448         switch (type)
7449         {
7450           case GL_BYTE:
7451           case GL_UNSIGNED_BYTE:
7452           case GL_SHORT:
7453           case GL_UNSIGNED_SHORT:
7454           case GL_INT:
7455           case GL_UNSIGNED_INT:
7456           case GL_INT_2_10_10_10_REV:
7457           case GL_UNSIGNED_INT_2_10_10_10_REV:
7458             break;
7459           default:
7460             return gl::error(GL_INVALID_ENUM);
7461         }
7462
7463         if (stride < 0)
7464         {
7465             return gl::error(GL_INVALID_VALUE);
7466         }
7467
7468         if ((type == GL_INT_2_10_10_10_REV || type == GL_UNSIGNED_INT_2_10_10_10_REV) && size != 4)
7469         {
7470             return gl::error(GL_INVALID_OPERATION);
7471         }
7472
7473         if (context)
7474         {
7475             // [OpenGL ES 3.0.2] Section 2.8 page 24:
7476             // An INVALID_OPERATION error is generated when a non-zero vertex array object
7477             // is bound, zero is bound to the ARRAY_BUFFER buffer object binding point,
7478             // and the pointer argument is not NULL.
7479             if (context->getVertexArrayHandle() != 0 && context->getArrayBufferHandle() == 0 && pointer != NULL)
7480             {
7481                 return gl::error(GL_INVALID_OPERATION);
7482             }
7483
7484             context->setVertexAttribState(index, context->getArrayBuffer(), size, type, false, true,
7485                                           stride, pointer);
7486         }
7487     }
7488     catch (...)
7489     {
7490         return gl::error(GL_OUT_OF_MEMORY);
7491     }
7492 }
7493
7494 void __stdcall glGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
7495 {
7496     EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLint* params = 0x%0.8p)",
7497           index, pname, params);
7498
7499     try
7500     {
7501         gl::Context *context = gl::getNonLostContext();
7502
7503         if (context)
7504         {
7505             if (context->getClientVersion() < 3)
7506             {
7507                 return gl::error(GL_INVALID_OPERATION);
7508             }
7509
7510             if (index >= gl::MAX_VERTEX_ATTRIBS)
7511             {
7512                 return gl::error(GL_INVALID_VALUE);
7513             }
7514
7515             const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
7516
7517             if (!gl::ValidateGetVertexAttribParameters(pname, context->getClientVersion()))
7518             {
7519                 return;
7520             }
7521
7522             if (pname == GL_CURRENT_VERTEX_ATTRIB)
7523             {
7524                 const gl::VertexAttribCurrentValueData &currentValueData = context->getVertexAttribCurrentValue(index);
7525                 for (int i = 0; i < 4; ++i)
7526                 {
7527                     params[i] = currentValueData.IntValues[i];
7528                 }
7529             }
7530             else
7531             {
7532                 *params = attribState.querySingleParameter<GLint>(pname);
7533             }
7534         }
7535     }
7536     catch (...)
7537     {
7538         return gl::error(GL_OUT_OF_MEMORY);
7539     }
7540 }
7541
7542 void __stdcall glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
7543 {
7544     EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLuint* params = 0x%0.8p)",
7545           index, pname, params);
7546
7547     try
7548     {
7549         gl::Context *context = gl::getNonLostContext();
7550
7551         if (context)
7552         {
7553             if (context->getClientVersion() < 3)
7554             {
7555                 return gl::error(GL_INVALID_OPERATION);
7556             }
7557
7558             if (index >= gl::MAX_VERTEX_ATTRIBS)
7559             {
7560                 return gl::error(GL_INVALID_VALUE);
7561             }
7562
7563             const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
7564
7565             if (!gl::ValidateGetVertexAttribParameters(pname, context->getClientVersion()))
7566             {
7567                 return;
7568             }
7569
7570             if (pname == GL_CURRENT_VERTEX_ATTRIB)
7571             {
7572                 const gl::VertexAttribCurrentValueData &currentValueData = context->getVertexAttribCurrentValue(index);
7573                 for (int i = 0; i < 4; ++i)
7574                 {
7575                     params[i] = currentValueData.UnsignedIntValues[i];
7576                 }
7577             }
7578             else
7579             {
7580                 *params = attribState.querySingleParameter<GLuint>(pname);
7581             }
7582         }
7583     }
7584     catch (...)
7585     {
7586         return gl::error(GL_OUT_OF_MEMORY);
7587     }
7588 }
7589
7590 void __stdcall glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
7591 {
7592     EVENT("(GLuint index = %u, GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d)",
7593           index, x, y, z, w);
7594
7595     try
7596     {
7597         gl::Context *context = gl::getNonLostContext();
7598
7599         if (context)
7600         {
7601             if (context->getClientVersion() < 3)
7602             {
7603                 return gl::error(GL_INVALID_OPERATION);
7604             }
7605
7606             if (index >= gl::MAX_VERTEX_ATTRIBS)
7607             {
7608                 return gl::error(GL_INVALID_VALUE);
7609             }
7610
7611             GLint vals[4] = { x, y, z, w };
7612             context->setVertexAttribi(index, vals);
7613         }
7614     }
7615     catch (...)
7616     {
7617         return gl::error(GL_OUT_OF_MEMORY);
7618     }
7619 }
7620
7621 void __stdcall glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
7622 {
7623     EVENT("(GLuint index = %u, GLuint x = %u, GLuint y = %u, GLuint z = %u, GLuint w = %u)",
7624           index, x, y, z, w);
7625
7626     try
7627     {
7628         gl::Context *context = gl::getNonLostContext();
7629
7630         if (context)
7631         {
7632             if (context->getClientVersion() < 3)
7633             {
7634                 return gl::error(GL_INVALID_OPERATION);
7635             }
7636
7637             if (index >= gl::MAX_VERTEX_ATTRIBS)
7638             {
7639                 return gl::error(GL_INVALID_VALUE);
7640             }
7641
7642             GLuint vals[4] = { x, y, z, w };
7643             context->setVertexAttribu(index, vals);
7644         }
7645     }
7646     catch (...)
7647     {
7648         return gl::error(GL_OUT_OF_MEMORY);
7649     }
7650 }
7651
7652 void __stdcall glVertexAttribI4iv(GLuint index, const GLint* v)
7653 {
7654     EVENT("(GLuint index = %u, const GLint* v = 0x%0.8p)", index, v);
7655
7656     try
7657     {
7658         gl::Context *context = gl::getNonLostContext();
7659
7660         if (context)
7661         {
7662             if (context->getClientVersion() < 3)
7663             {
7664                 return gl::error(GL_INVALID_OPERATION);
7665             }
7666
7667             if (index >= gl::MAX_VERTEX_ATTRIBS)
7668             {
7669                 return gl::error(GL_INVALID_VALUE);
7670             }
7671
7672             context->setVertexAttribi(index, v);
7673         }
7674     }
7675     catch (...)
7676     {
7677         return gl::error(GL_OUT_OF_MEMORY);
7678     }
7679 }
7680
7681 void __stdcall glVertexAttribI4uiv(GLuint index, const GLuint* v)
7682 {
7683     EVENT("(GLuint index = %u, const GLuint* v = 0x%0.8p)", index, v);
7684
7685     try
7686     {
7687         gl::Context *context = gl::getNonLostContext();
7688
7689         if (context)
7690         {
7691             if (context->getClientVersion() < 3)
7692             {
7693                 return gl::error(GL_INVALID_OPERATION);
7694             }
7695
7696             if (index >= gl::MAX_VERTEX_ATTRIBS)
7697             {
7698                 return gl::error(GL_INVALID_VALUE);
7699             }
7700
7701             context->setVertexAttribu(index, v);
7702         }
7703     }
7704     catch (...)
7705     {
7706         return gl::error(GL_OUT_OF_MEMORY);
7707     }
7708 }
7709
7710 void __stdcall glGetUniformuiv(GLuint program, GLint location, GLuint* params)
7711 {
7712     EVENT("(GLuint program = %u, GLint location = %d, GLuint* params = 0x%0.8p)",
7713           program, location, params);
7714
7715     try
7716     {
7717         gl::Context *context = gl::getNonLostContext();
7718
7719         if (context)
7720         {
7721             if (context->getClientVersion() < 3)
7722             {
7723                 return gl::error(GL_INVALID_OPERATION);
7724             }
7725
7726             if (program == 0)
7727             {
7728                 return gl::error(GL_INVALID_VALUE);
7729             }
7730
7731             gl::Program *programObject = context->getProgram(program);
7732
7733             if (!programObject || !programObject->isLinked())
7734             {
7735                 return gl::error(GL_INVALID_OPERATION);
7736             }
7737
7738             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
7739             if (!programBinary)
7740             {
7741                 return gl::error(GL_INVALID_OPERATION);
7742             }
7743
7744             if (!programBinary->getUniformuiv(location, NULL, params))
7745             {
7746                 return gl::error(GL_INVALID_OPERATION);
7747             }
7748         }
7749     }
7750     catch (...)
7751     {
7752         return gl::error(GL_OUT_OF_MEMORY);
7753     }
7754 }
7755
7756 GLint __stdcall glGetFragDataLocation(GLuint program, const GLchar *name)
7757 {
7758     EVENT("(GLuint program = %u, const GLchar *name = 0x%0.8p)",
7759           program, name);
7760
7761     try
7762     {
7763         gl::Context *context = gl::getNonLostContext();
7764
7765         if (context)
7766         {
7767             if (context->getClientVersion() < 3)
7768             {
7769                 return gl::error(GL_INVALID_OPERATION, -1);
7770             }
7771
7772             if (program == 0)
7773             {
7774                 return gl::error(GL_INVALID_VALUE, -1);
7775             }
7776
7777             gl::Program *programObject = context->getProgram(program);
7778
7779             if (!programObject || !programObject->isLinked())
7780             {
7781                 return gl::error(GL_INVALID_OPERATION, -1);
7782             }
7783
7784             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
7785             if (!programBinary)
7786             {
7787                 return gl::error(GL_INVALID_OPERATION, -1);
7788             }
7789
7790             return programBinary->getFragDataLocation(name);
7791         }
7792     }
7793     catch (...)
7794     {
7795         return gl::error(GL_OUT_OF_MEMORY, 0);
7796     }
7797
7798     return 0;
7799 }
7800
7801 void __stdcall glUniform1ui(GLint location, GLuint v0)
7802 {
7803     glUniform1uiv(location, 1, &v0);
7804 }
7805
7806 void __stdcall glUniform2ui(GLint location, GLuint v0, GLuint v1)
7807 {
7808     const GLuint xy[] = { v0, v1 };
7809     glUniform2uiv(location, 1, xy);
7810 }
7811
7812 void __stdcall glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
7813 {
7814     const GLuint xyz[] = { v0, v1, v2 };
7815     glUniform3uiv(location, 1, xyz);
7816 }
7817
7818 void __stdcall glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
7819 {
7820     const GLuint xyzw[] = { v0, v1, v2, v3 };
7821     glUniform4uiv(location, 1, xyzw);
7822 }
7823
7824 void __stdcall glUniform1uiv(GLint location, GLsizei count, const GLuint* value)
7825 {
7826     EVENT("(GLint location = %d, GLsizei count = %d, const GLuint* value = 0x%0.8p)",
7827           location, count, value);
7828
7829     try
7830     {
7831         gl::Context *context = gl::getNonLostContext();
7832
7833         if (context)
7834         {
7835             if (!ValidateUniform(context, GL_UNSIGNED_INT, location, count))
7836             {
7837                 return;
7838             }
7839
7840             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
7841             programBinary->setUniform1uiv(location, count, value);
7842         }
7843     }
7844     catch (...)
7845     {
7846         return gl::error(GL_OUT_OF_MEMORY);
7847     }
7848 }
7849
7850 void __stdcall glUniform2uiv(GLint location, GLsizei count, const GLuint* value)
7851 {
7852     EVENT("(GLint location = %d, GLsizei count = %d, const GLuint* value = 0x%0.8p)",
7853           location, count, value);
7854
7855     try
7856     {
7857         gl::Context *context = gl::getNonLostContext();
7858
7859         if (context)
7860         {
7861             if (!ValidateUniform(context, GL_UNSIGNED_INT_VEC2, location, count))
7862             {
7863                 return;
7864             }
7865
7866             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
7867             programBinary->setUniform2uiv(location, count, value);
7868         }
7869     }
7870     catch (...)
7871     {
7872         return gl::error(GL_OUT_OF_MEMORY);
7873     }
7874 }
7875
7876 void __stdcall glUniform3uiv(GLint location, GLsizei count, const GLuint* value)
7877 {
7878     EVENT("(GLint location = %d, GLsizei count = %d, const GLuint* value)",
7879           location, count, value);
7880
7881     try
7882     {
7883         gl::Context *context = gl::getNonLostContext();
7884
7885         if (context)
7886         {
7887             if (!ValidateUniform(context, GL_UNSIGNED_INT_VEC3, location, count))
7888             {
7889                 return;
7890             }
7891
7892             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
7893             programBinary->setUniform3uiv(location, count, value);
7894         }
7895     }
7896     catch (...)
7897     {
7898         return gl::error(GL_OUT_OF_MEMORY);
7899     }
7900 }
7901
7902 void __stdcall glUniform4uiv(GLint location, GLsizei count, const GLuint* value)
7903 {
7904     EVENT("(GLint location = %d, GLsizei count = %d, const GLuint* value = 0x%0.8p)",
7905           location, count, value);
7906
7907     try
7908     {
7909         gl::Context *context = gl::getNonLostContext();
7910
7911         if (context)
7912         {
7913             if (!ValidateUniform(context, GL_UNSIGNED_INT_VEC4, location, count))
7914             {
7915                 return;
7916             }
7917
7918             gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
7919             programBinary->setUniform4uiv(location, count, value);
7920         }
7921     }
7922     catch (...)
7923     {
7924         return gl::error(GL_OUT_OF_MEMORY);
7925     }
7926 }
7927
7928 void __stdcall glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
7929 {
7930     EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLint* value = 0x%0.8p)",
7931           buffer, drawbuffer, value);
7932
7933     try
7934     {
7935         gl::Context *context = gl::getNonLostContext();
7936
7937         if (context)
7938         {
7939             if (context->getClientVersion() < 3)
7940             {
7941                 return gl::error(GL_INVALID_OPERATION);
7942             }
7943
7944             switch (buffer)
7945             {
7946               case GL_COLOR:
7947                 if (drawbuffer < 0 || drawbuffer >= static_cast<GLint>(context->getMaximumRenderTargets()))
7948                 {
7949                     return gl::error(GL_INVALID_VALUE);
7950                 }
7951                 break;
7952               case GL_STENCIL:
7953                 if (drawbuffer != 0)
7954                 {
7955                     return gl::error(GL_INVALID_VALUE);
7956                 }
7957                 break;
7958               default:
7959                 return gl::error(GL_INVALID_ENUM);
7960             }
7961
7962             context->clearBufferiv(buffer, drawbuffer, value);
7963         }
7964     }
7965     catch (...)
7966     {
7967         return gl::error(GL_OUT_OF_MEMORY);
7968     }
7969 }
7970
7971 void __stdcall glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
7972 {
7973     EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLuint* value = 0x%0.8p)",
7974           buffer, drawbuffer, value);
7975
7976     try
7977     {
7978         gl::Context *context = gl::getNonLostContext();
7979
7980         if (context)
7981         {
7982             if (context->getClientVersion() < 3)
7983             {
7984                 return gl::error(GL_INVALID_OPERATION);
7985             }
7986
7987             switch (buffer)
7988             {
7989               case GL_COLOR:
7990                 if (drawbuffer < 0 || drawbuffer >= static_cast<GLint>(context->getMaximumRenderTargets()))
7991                 {
7992                     return gl::error(GL_INVALID_VALUE);
7993                 }
7994                 break;
7995               default:
7996                 return gl::error(GL_INVALID_ENUM);
7997             }
7998
7999             context->clearBufferuiv(buffer, drawbuffer, value);
8000         }
8001     }
8002     catch (...)
8003     {
8004         return gl::error(GL_OUT_OF_MEMORY);
8005     }
8006 }
8007
8008 void __stdcall glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
8009 {
8010     EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLfloat* value = 0x%0.8p)",
8011           buffer, drawbuffer, value);
8012
8013     try
8014     {
8015         gl::Context *context = gl::getNonLostContext();
8016
8017         if (context)
8018         {
8019             if (context->getClientVersion() < 3)
8020             {
8021                 return gl::error(GL_INVALID_OPERATION);
8022             }
8023
8024             switch (buffer)
8025             {
8026               case GL_COLOR:
8027                 if (drawbuffer < 0 || drawbuffer >= static_cast<GLint>(context->getMaximumRenderTargets()))
8028                 {
8029                     return gl::error(GL_INVALID_VALUE);
8030                 }
8031                 break;
8032               case GL_DEPTH:
8033                 if (drawbuffer != 0)
8034                 {
8035                     return gl::error(GL_INVALID_VALUE);
8036                 }
8037                 break;
8038               default:
8039                 return gl::error(GL_INVALID_ENUM);
8040             }
8041
8042             context->clearBufferfv(buffer, drawbuffer, value);
8043         }
8044     }
8045     catch (...)
8046     {
8047         return gl::error(GL_OUT_OF_MEMORY);
8048     }
8049 }
8050
8051 void __stdcall glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
8052 {
8053     EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, GLfloat depth, GLint stencil = %d)",
8054           buffer, drawbuffer, depth, stencil);
8055
8056     try
8057     {
8058         gl::Context *context = gl::getNonLostContext();
8059
8060         if (context)
8061         {
8062             if (context->getClientVersion() < 3)
8063             {
8064                 return gl::error(GL_INVALID_OPERATION);
8065             }
8066
8067             switch (buffer)
8068             {
8069               case GL_DEPTH_STENCIL:
8070                 if (drawbuffer != 0)
8071                 {
8072                     return gl::error(GL_INVALID_VALUE);
8073                 }
8074                 break;
8075               default:
8076                 return gl::error(GL_INVALID_ENUM);
8077             }
8078
8079             context->clearBufferfi(buffer, drawbuffer, depth, stencil);
8080         }
8081     }
8082     catch (...)
8083     {
8084         return gl::error(GL_OUT_OF_MEMORY);
8085     }
8086 }
8087
8088 const GLubyte* __stdcall glGetStringi(GLenum name, GLuint index)
8089 {
8090     EVENT("(GLenum name = 0x%X, GLuint index = %u)", name, index);
8091
8092     try
8093     {
8094         gl::Context *context = gl::getNonLostContext();
8095
8096         if (context)
8097         {
8098             if (context->getClientVersion() < 3)
8099             {
8100                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLubyte*>(NULL));
8101             }
8102
8103             if (name != GL_EXTENSIONS)
8104             {
8105                 return gl::error(GL_INVALID_ENUM, reinterpret_cast<GLubyte*>(NULL));
8106             }
8107
8108             if (index >= context->getNumExtensions())
8109             {
8110                 return gl::error(GL_INVALID_VALUE, reinterpret_cast<GLubyte*>(NULL));
8111             }
8112
8113             return reinterpret_cast<const GLubyte*>(context->getExtensionString(index));
8114         }
8115     }
8116     catch (...)
8117     {
8118         return gl::error(GL_OUT_OF_MEMORY, reinterpret_cast<GLubyte*>(NULL));
8119     }
8120
8121     return NULL;
8122 }
8123
8124 void __stdcall glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
8125 {
8126     EVENT("(GLenum readTarget = 0x%X, GLenum writeTarget = 0x%X, GLintptr readOffset = %d, GLintptr writeOffset = %d, GLsizeiptr size = %d)",
8127           readTarget, writeTarget, readOffset, writeOffset, size);
8128
8129     try
8130     {
8131         gl::Context *context = gl::getNonLostContext();
8132
8133         if (context)
8134         {
8135             if (context->getClientVersion() < 3)
8136             {
8137                 return gl::error(GL_INVALID_OPERATION);
8138             }
8139
8140             if (!gl::ValidBufferTarget(context, readTarget) || !gl::ValidBufferTarget(context, readTarget))
8141             {
8142                 return gl::error(GL_INVALID_ENUM);
8143             }
8144
8145             gl::Buffer *readBuffer = context->getTargetBuffer(readTarget);
8146             gl::Buffer *writeBuffer = context->getTargetBuffer(writeTarget);
8147
8148             if (!readBuffer || !writeBuffer)
8149             {
8150                 return gl::error(GL_INVALID_OPERATION);
8151             }
8152
8153             if (readBuffer->mapped() || writeBuffer->mapped())
8154             {
8155                 return gl::error(GL_INVALID_OPERATION);
8156             }
8157
8158             if (readOffset < 0 || writeOffset < 0 || size < 0 ||
8159                 static_cast<unsigned int>(readOffset + size) > readBuffer->size() ||
8160                 static_cast<unsigned int>(writeOffset + size) > writeBuffer->size())
8161             {
8162                 return gl::error(GL_INVALID_VALUE);
8163             }
8164
8165             if (readBuffer == writeBuffer && abs(readOffset - writeOffset) < size)
8166             {
8167                 return gl::error(GL_INVALID_VALUE);
8168             }
8169
8170             // TODO: Verify that readBuffer and writeBuffer are not currently mapped (GL_INVALID_OPERATION)
8171
8172             // if size is zero, the copy is a successful no-op
8173             if (size > 0)
8174             {
8175                 writeBuffer->copyBufferSubData(readBuffer, readOffset, writeOffset, size);
8176             }
8177         }
8178     }
8179     catch (...)
8180     {
8181         return gl::error(GL_OUT_OF_MEMORY);
8182     }
8183 }
8184
8185 void __stdcall glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
8186 {
8187     EVENT("(GLuint program = %u, GLsizei uniformCount = %d, const GLchar* const* uniformNames = 0x%0.8p, GLuint* uniformIndices = 0x%0.8p)",
8188           program, uniformCount, uniformNames, uniformIndices);
8189
8190     try
8191     {
8192         gl::Context *context = gl::getNonLostContext();
8193
8194         if (context)
8195         {
8196             if (context->getClientVersion() < 3)
8197             {
8198                 return gl::error(GL_INVALID_OPERATION);
8199             }
8200
8201             if (uniformCount < 0)
8202             {
8203                 return gl::error(GL_INVALID_VALUE);
8204             }
8205
8206             gl::Program *programObject = context->getProgram(program);
8207
8208             if (!programObject)
8209             {
8210                 if (context->getShader(program))
8211                 {
8212                     return gl::error(GL_INVALID_OPERATION);
8213                 }
8214                 else
8215                 {
8216                     return gl::error(GL_INVALID_VALUE);
8217                 }
8218             }
8219
8220             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
8221             if (!programObject->isLinked() || !programBinary)
8222             {
8223                 for (int uniformId = 0; uniformId < uniformCount; uniformId++)
8224                 {
8225                     uniformIndices[uniformId] = GL_INVALID_INDEX;
8226                 }
8227             }
8228             else
8229             {
8230                 for (int uniformId = 0; uniformId < uniformCount; uniformId++)
8231                 {
8232                     uniformIndices[uniformId] = programBinary->getUniformIndex(uniformNames[uniformId]);
8233                 }
8234             }
8235         }
8236     }
8237     catch (...)
8238     {
8239         return gl::error(GL_OUT_OF_MEMORY);
8240     }
8241 }
8242
8243 void __stdcall glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
8244 {
8245     EVENT("(GLuint program = %u, GLsizei uniformCount = %d, const GLuint* uniformIndices = 0x%0.8p, GLenum pname = 0x%X, GLint* params = 0x%0.8p)",
8246           program, uniformCount, uniformIndices, pname, params);
8247
8248     try
8249     {
8250         gl::Context *context = gl::getNonLostContext();
8251
8252         if (context)
8253         {
8254             if (context->getClientVersion() < 3)
8255             {
8256                 return gl::error(GL_INVALID_OPERATION);
8257             }
8258
8259             if (uniformCount < 0)
8260             {
8261                 return gl::error(GL_INVALID_VALUE);
8262             }
8263
8264             gl::Program *programObject = context->getProgram(program);
8265
8266             if (!programObject)
8267             {
8268                 if (context->getShader(program))
8269                 {
8270                     return gl::error(GL_INVALID_OPERATION);
8271                 }
8272                 else
8273                 {
8274                     return gl::error(GL_INVALID_VALUE);
8275                 }
8276             }
8277
8278             switch (pname)
8279             {
8280               case GL_UNIFORM_TYPE:
8281               case GL_UNIFORM_SIZE:
8282               case GL_UNIFORM_NAME_LENGTH:
8283               case GL_UNIFORM_BLOCK_INDEX:
8284               case GL_UNIFORM_OFFSET:
8285               case GL_UNIFORM_ARRAY_STRIDE:
8286               case GL_UNIFORM_MATRIX_STRIDE:
8287               case GL_UNIFORM_IS_ROW_MAJOR:
8288                 break;
8289               default:
8290                 return gl::error(GL_INVALID_ENUM);
8291             }
8292
8293             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
8294
8295             if (!programBinary && uniformCount > 0)
8296             {
8297                 return gl::error(GL_INVALID_VALUE);
8298             }
8299
8300             for (int uniformId = 0; uniformId < uniformCount; uniformId++)
8301             {
8302                 const GLuint index = uniformIndices[uniformId];
8303
8304                 if (index >= (GLuint)programBinary->getActiveUniformCount())
8305                 {
8306                     return gl::error(GL_INVALID_VALUE);
8307                 }
8308             }
8309
8310             for (int uniformId = 0; uniformId < uniformCount; uniformId++)
8311             {
8312                 const GLuint index = uniformIndices[uniformId];
8313                 params[uniformId] = programBinary->getActiveUniformi(index, pname);
8314             }
8315         }
8316     }
8317     catch (...)
8318     {
8319         return gl::error(GL_OUT_OF_MEMORY);
8320     }
8321 }
8322
8323 GLuint __stdcall glGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
8324 {
8325     EVENT("(GLuint program = %u, const GLchar* uniformBlockName = 0x%0.8p)", program, uniformBlockName);
8326
8327     try
8328     {
8329         gl::Context *context = gl::getNonLostContext();
8330
8331         if (context)
8332         {
8333             if (context->getClientVersion() < 3)
8334             {
8335                 return gl::error(GL_INVALID_OPERATION, GL_INVALID_INDEX);
8336             }
8337
8338             gl::Program *programObject = context->getProgram(program);
8339
8340             if (!programObject)
8341             {
8342                 if (context->getShader(program))
8343                 {
8344                     return gl::error(GL_INVALID_OPERATION, GL_INVALID_INDEX);
8345                 }
8346                 else
8347                 {
8348                     return gl::error(GL_INVALID_VALUE, GL_INVALID_INDEX);
8349                 }
8350             }
8351
8352             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
8353             if (!programBinary)
8354             {
8355                 return GL_INVALID_INDEX;
8356             }
8357
8358             return programBinary->getUniformBlockIndex(uniformBlockName);
8359         }
8360     }
8361     catch (...)
8362     {
8363         return gl::error(GL_OUT_OF_MEMORY, 0);
8364     }
8365
8366     return 0;
8367 }
8368
8369 void __stdcall glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
8370 {
8371     EVENT("(GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = 0x%X, GLint* params = 0x%0.8p)",
8372           program, uniformBlockIndex, pname, params);
8373
8374     try
8375     {
8376         gl::Context *context = gl::getNonLostContext();
8377
8378         if (context)
8379         {
8380             if (context->getClientVersion() < 3)
8381             {
8382                 return gl::error(GL_INVALID_OPERATION);
8383             }
8384             gl::Program *programObject = context->getProgram(program);
8385
8386             if (!programObject)
8387             {
8388                 if (context->getShader(program))
8389                 {
8390                     return gl::error(GL_INVALID_OPERATION);
8391                 }
8392                 else
8393                 {
8394                     return gl::error(GL_INVALID_VALUE);
8395                 }
8396             }
8397
8398             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
8399
8400             if (!programBinary || uniformBlockIndex >= programBinary->getActiveUniformBlockCount())
8401             {
8402                 return gl::error(GL_INVALID_VALUE);
8403             }
8404
8405             switch (pname)
8406             {
8407               case GL_UNIFORM_BLOCK_BINDING:
8408                 *params = static_cast<GLint>(programObject->getUniformBlockBinding(uniformBlockIndex));
8409                 break;
8410
8411               case GL_UNIFORM_BLOCK_DATA_SIZE:
8412               case GL_UNIFORM_BLOCK_NAME_LENGTH:
8413               case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
8414               case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
8415               case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
8416               case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
8417                 programBinary->getActiveUniformBlockiv(uniformBlockIndex, pname, params);
8418                 break;
8419
8420               default:
8421                 return gl::error(GL_INVALID_ENUM);
8422             }
8423         }
8424     }
8425     catch (...)
8426     {
8427         return gl::error(GL_OUT_OF_MEMORY);
8428     }
8429 }
8430
8431 void __stdcall glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
8432 {
8433     EVENT("(GLuint program = %u, GLuint uniformBlockIndex = %u, GLsizei bufSize = %d, GLsizei* length = 0x%0.8p, GLchar* uniformBlockName = 0x%0.8p)",
8434           program, uniformBlockIndex, bufSize, length, uniformBlockName);
8435
8436     try
8437     {
8438         gl::Context *context = gl::getNonLostContext();
8439
8440         if (context)
8441         {
8442             if (context->getClientVersion() < 3)
8443             {
8444                 return gl::error(GL_INVALID_OPERATION);
8445             }
8446
8447             gl::Program *programObject = context->getProgram(program);
8448
8449             if (!programObject)
8450             {
8451                 if (context->getShader(program))
8452                 {
8453                     return gl::error(GL_INVALID_OPERATION);
8454                 }
8455                 else
8456                 {
8457                     return gl::error(GL_INVALID_VALUE);
8458                 }
8459             }
8460
8461             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
8462
8463             if (!programBinary || uniformBlockIndex >= programBinary->getActiveUniformBlockCount())
8464             {
8465                 return gl::error(GL_INVALID_VALUE);
8466             }
8467
8468             programBinary->getActiveUniformBlockName(uniformBlockIndex, bufSize, length, uniformBlockName);
8469         }
8470     }
8471     catch (...)
8472     {
8473         return gl::error(GL_OUT_OF_MEMORY);
8474     }
8475 }
8476
8477 void __stdcall glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
8478 {
8479     EVENT("(GLuint program = %u, GLuint uniformBlockIndex = %u, GLuint uniformBlockBinding = %u)",
8480           program, uniformBlockIndex, uniformBlockBinding);
8481
8482     try
8483     {
8484         gl::Context *context = gl::getNonLostContext();
8485
8486         if (context)
8487         {
8488             if (context->getClientVersion() < 3)
8489             {
8490                 return gl::error(GL_INVALID_OPERATION);
8491             }
8492
8493             if (uniformBlockBinding >= context->getMaximumCombinedUniformBufferBindings())
8494             {
8495                 return gl::error(GL_INVALID_VALUE);
8496             }
8497
8498             gl::Program *programObject = context->getProgram(program);
8499
8500             if (!programObject)
8501             {
8502                 if (context->getShader(program))
8503                 {
8504                     return gl::error(GL_INVALID_OPERATION);
8505                 }
8506                 else
8507                 {
8508                     return gl::error(GL_INVALID_VALUE);
8509                 }
8510             }
8511
8512             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
8513
8514             // if never linked, there won't be any uniform blocks
8515             if (!programBinary || uniformBlockIndex >= programBinary->getActiveUniformBlockCount())
8516             {
8517                 return gl::error(GL_INVALID_VALUE);
8518             }
8519
8520             programObject->bindUniformBlock(uniformBlockIndex, uniformBlockBinding);
8521         }
8522     }
8523     catch (...)
8524     {
8525         return gl::error(GL_OUT_OF_MEMORY);
8526     }
8527 }
8528
8529 void __stdcall glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
8530 {
8531     EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei instanceCount = %d)",
8532           mode, first, count, instanceCount);
8533
8534     try
8535     {
8536         gl::Context *context = gl::getNonLostContext();
8537
8538         if (context)
8539         {
8540             if (context->getClientVersion() < 3)
8541             {
8542                 return gl::error(GL_INVALID_OPERATION);
8543             }
8544
8545             // glDrawArraysInstanced
8546             UNIMPLEMENTED();
8547         }
8548     }
8549     catch (...)
8550     {
8551         return gl::error(GL_OUT_OF_MEMORY);
8552     }
8553 }
8554
8555 void __stdcall glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount)
8556 {
8557     EVENT("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = 0x%0.8p, GLsizei instanceCount = %d)",
8558           mode, count, type, indices, instanceCount);
8559
8560     try
8561     {
8562         gl::Context *context = gl::getNonLostContext();
8563
8564         if (context)
8565         {
8566             if (context->getClientVersion() < 3)
8567             {
8568                 return gl::error(GL_INVALID_OPERATION);
8569             }
8570
8571             // glDrawElementsInstanced
8572             UNIMPLEMENTED();
8573         }
8574     }
8575     catch (...)
8576     {
8577         return gl::error(GL_OUT_OF_MEMORY);
8578     }
8579 }
8580
8581 GLsync __stdcall glFenceSync(GLenum condition, GLbitfield flags)
8582 {
8583     EVENT("(GLenum condition = 0x%X, GLbitfield flags = 0x%X)", condition, flags);
8584
8585     try
8586     {
8587         gl::Context *context = gl::getNonLostContext();
8588
8589         if (context)
8590         {
8591             if (context->getClientVersion() < 3)
8592             {
8593                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLsync>(0));
8594             }
8595
8596             if (condition != GL_SYNC_GPU_COMMANDS_COMPLETE)
8597             {
8598                 return gl::error(GL_INVALID_ENUM, reinterpret_cast<GLsync>(0));
8599             }
8600
8601             if (flags != 0)
8602             {
8603                 return gl::error(GL_INVALID_VALUE, reinterpret_cast<GLsync>(0));
8604             }
8605
8606             return context->createFenceSync(condition);
8607         }
8608     }
8609     catch (...)
8610     {
8611         return gl::error(GL_OUT_OF_MEMORY, reinterpret_cast<GLsync>(NULL));
8612     }
8613
8614     return NULL;
8615 }
8616
8617 GLboolean __stdcall glIsSync(GLsync sync)
8618 {
8619     EVENT("(GLsync sync = 0x%0.8p)", sync);
8620
8621     try
8622     {
8623         gl::Context *context = gl::getNonLostContext();
8624
8625         if (context)
8626         {
8627             if (context->getClientVersion() < 3)
8628             {
8629                 return gl::error(GL_INVALID_OPERATION, GL_FALSE);
8630             }
8631
8632             return (context->getFenceSync(sync) != NULL);
8633         }
8634     }
8635     catch (...)
8636     {
8637         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
8638     }
8639
8640     return GL_FALSE;
8641 }
8642
8643 void __stdcall glDeleteSync(GLsync sync)
8644 {
8645     EVENT("(GLsync sync = 0x%0.8p)", sync);
8646
8647     try
8648     {
8649         gl::Context *context = gl::getNonLostContext();
8650
8651         if (context)
8652         {
8653             if (context->getClientVersion() < 3)
8654             {
8655                 return gl::error(GL_INVALID_OPERATION);
8656             }
8657
8658             if (sync != static_cast<GLsync>(0) && !context->getFenceSync(sync))
8659             {
8660                 return gl::error(GL_INVALID_VALUE);
8661             }
8662
8663             context->deleteFenceSync(sync);
8664         }
8665     }
8666     catch (...)
8667     {
8668         return gl::error(GL_OUT_OF_MEMORY);
8669     }
8670 }
8671
8672 GLenum __stdcall glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
8673 {
8674     EVENT("(GLsync sync = 0x%0.8p, GLbitfield flags = 0x%X, GLuint64 timeout = %llu)",
8675           sync, flags, timeout);
8676
8677     try
8678     {
8679         gl::Context *context = gl::getNonLostContext();
8680
8681         if (context)
8682         {
8683             if (context->getClientVersion() < 3)
8684             {
8685                 return gl::error(GL_INVALID_OPERATION, GL_WAIT_FAILED);
8686             }
8687
8688             if ((flags & ~(GL_SYNC_FLUSH_COMMANDS_BIT)) != 0)
8689             {
8690                 return gl::error(GL_INVALID_VALUE, GL_WAIT_FAILED);
8691             }
8692
8693             gl::FenceSync *fenceSync = context->getFenceSync(sync);
8694
8695             if (!fenceSync)
8696             {
8697                 return gl::error(GL_INVALID_VALUE, GL_WAIT_FAILED);
8698             }
8699
8700             return fenceSync->clientWait(flags, timeout);
8701         }
8702     }
8703     catch (...)
8704     {
8705         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
8706     }
8707
8708     return GL_FALSE;
8709 }
8710
8711 void __stdcall glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
8712 {
8713     EVENT("(GLsync sync = 0x%0.8p, GLbitfield flags = 0x%X, GLuint64 timeout = %llu)",
8714           sync, flags, timeout);
8715
8716     try
8717     {
8718         gl::Context *context = gl::getNonLostContext();
8719
8720         if (context)
8721         {
8722             if (context->getClientVersion() < 3)
8723             {
8724                 return gl::error(GL_INVALID_OPERATION);
8725             }
8726
8727             if (flags != 0)
8728             {
8729                 return gl::error(GL_INVALID_VALUE);
8730             }
8731
8732             if (timeout != GL_TIMEOUT_IGNORED)
8733             {
8734                 return gl::error(GL_INVALID_VALUE);
8735             }
8736
8737             gl::FenceSync *fenceSync = context->getFenceSync(sync);
8738
8739             if (!fenceSync)
8740             {
8741                 return gl::error(GL_INVALID_VALUE);
8742             }
8743
8744             fenceSync->serverWait();
8745         }
8746     }
8747     catch (...)
8748     {
8749         return gl::error(GL_OUT_OF_MEMORY);
8750     }
8751 }
8752
8753 void __stdcall glGetInteger64v(GLenum pname, GLint64* params)
8754 {
8755     EVENT("(GLenum pname = 0x%X, GLint64* params = 0x%0.8p)",
8756           pname, params);
8757
8758     try
8759     {
8760         gl::Context *context = gl::getNonLostContext();
8761
8762         if (context)
8763         {
8764             if (context->getClientVersion() < 3)
8765             {
8766                 return gl::error(GL_INVALID_OPERATION);
8767             }
8768
8769             GLenum nativeType;
8770             unsigned int numParams = 0;
8771             if (!ValidateStateQuery(context, pname, &nativeType, &numParams))
8772             {
8773                 return;
8774             }
8775
8776             if (nativeType == GL_INT_64_ANGLEX)
8777             {
8778                 context->getInteger64v(pname, params);
8779             }
8780             else
8781             {
8782                 CastStateValues(context, nativeType, pname, numParams, params);
8783             }
8784         }
8785     }
8786     catch (...)
8787     {
8788         return gl::error(GL_OUT_OF_MEMORY);
8789     }
8790 }
8791
8792 void __stdcall glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
8793 {
8794     EVENT("(GLsync sync = 0x%0.8p, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei* length = 0x%0.8p, GLint* values = 0x%0.8p)",
8795           sync, pname, bufSize, length, values);
8796
8797     try
8798     {
8799         gl::Context *context = gl::getNonLostContext();
8800
8801         if (context)
8802         {
8803             if (context->getClientVersion() < 3)
8804             {
8805                 return gl::error(GL_INVALID_OPERATION);
8806             }
8807
8808             if (bufSize < 0)
8809             {
8810                 return gl::error(GL_INVALID_VALUE);
8811             }
8812
8813             gl::FenceSync *fenceSync = context->getFenceSync(sync);
8814
8815             if (!fenceSync)
8816             {
8817                 return gl::error(GL_INVALID_VALUE);
8818             }
8819
8820             switch (pname)
8821             {
8822               case GL_OBJECT_TYPE:     values[0] = static_cast<GLint>(GL_SYNC_FENCE);              break;
8823               case GL_SYNC_STATUS:     values[0] = static_cast<GLint>(fenceSync->getStatus());     break;
8824               case GL_SYNC_CONDITION:  values[0] = static_cast<GLint>(fenceSync->getCondition());  break;
8825               case GL_SYNC_FLAGS:      values[0] = 0;                                              break;
8826
8827               default:
8828                 return gl::error(GL_INVALID_ENUM);
8829             }
8830         }
8831     }
8832     catch (...)
8833     {
8834         return gl::error(GL_OUT_OF_MEMORY);
8835     }
8836 }
8837
8838 void __stdcall glGetInteger64i_v(GLenum target, GLuint index, GLint64* data)
8839 {
8840     EVENT("(GLenum target = 0x%X, GLuint index = %u, GLint64* data = 0x%0.8p)",
8841           target, index, data);
8842
8843     try
8844     {
8845         gl::Context *context = gl::getNonLostContext();
8846
8847         if (context)
8848         {
8849             if (context->getClientVersion() < 3)
8850             {
8851                 return gl::error(GL_INVALID_OPERATION);
8852             }
8853
8854             switch (target)
8855             {
8856               case GL_TRANSFORM_FEEDBACK_BUFFER_START:
8857               case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
8858               case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
8859                 if (index >= context->getMaxTransformFeedbackBufferBindings())
8860                     return gl::error(GL_INVALID_VALUE);
8861                 break;
8862               case GL_UNIFORM_BUFFER_START:
8863               case GL_UNIFORM_BUFFER_SIZE:
8864               case GL_UNIFORM_BUFFER_BINDING:
8865                 if (index >= context->getMaximumCombinedUniformBufferBindings())
8866                     return gl::error(GL_INVALID_VALUE);
8867                 break;
8868               default:
8869                 return gl::error(GL_INVALID_ENUM);
8870             }
8871
8872             if (!(context->getIndexedInteger64v(target, index, data)))
8873             {
8874                 GLenum nativeType;
8875                 unsigned int numParams = 0;
8876                 if (!context->getIndexedQueryParameterInfo(target, &nativeType, &numParams))
8877                     return gl::error(GL_INVALID_ENUM);
8878
8879                 if (numParams == 0)
8880                     return; // it is known that pname is valid, but there are no parameters to return
8881
8882                 if (nativeType == GL_INT)
8883                 {
8884                     GLint *intParams = new GLint[numParams];
8885
8886                     context->getIndexedIntegerv(target, index, intParams);
8887
8888                     for (unsigned int i = 0; i < numParams; ++i)
8889                     {
8890                         data[i] = static_cast<GLint64>(intParams[i]);
8891                     }
8892
8893                     delete [] intParams;
8894                 }
8895                 else
8896                 {
8897                     UNREACHABLE();
8898                 }
8899             }
8900         }
8901     }
8902     catch (...)
8903     {
8904         return gl::error(GL_OUT_OF_MEMORY);
8905     }
8906 }
8907
8908 void __stdcall glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
8909 {
8910     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint64* params = 0x%0.8p)",
8911           target, pname, params);
8912
8913     try
8914     {
8915         gl::Context *context = gl::getNonLostContext();
8916
8917         if (context)
8918         {
8919             if (context->getClientVersion() < 3)
8920             {
8921                 return gl::error(GL_INVALID_OPERATION);
8922             }
8923
8924             if (!gl::ValidBufferTarget(context, target))
8925             {
8926                 return gl::error(GL_INVALID_ENUM);
8927             }
8928
8929             if (!gl::ValidBufferParameter(context, pname))
8930             {
8931                 return gl::error(GL_INVALID_ENUM);
8932             }
8933
8934             gl::Buffer *buffer = context->getTargetBuffer(target);
8935
8936             if (!buffer)
8937             {
8938                 // A null buffer means that "0" is bound to the requested buffer target
8939                 return gl::error(GL_INVALID_OPERATION);
8940             }
8941
8942             switch (pname)
8943             {
8944               case GL_BUFFER_USAGE:
8945                 *params = static_cast<GLint64>(buffer->usage());
8946                 break;
8947               case GL_BUFFER_SIZE:
8948                 *params = buffer->size();
8949                 break;
8950               case GL_BUFFER_ACCESS_FLAGS:
8951                 *params = static_cast<GLint64>(buffer->accessFlags());
8952                 break;
8953               case GL_BUFFER_MAPPED:
8954                 *params = static_cast<GLint64>(buffer->mapped());
8955                 break;
8956               case GL_BUFFER_MAP_OFFSET:
8957                 *params = buffer->mapOffset();
8958                 break;
8959               case GL_BUFFER_MAP_LENGTH:
8960                 *params = buffer->mapLength();
8961                 break;
8962               default: UNREACHABLE(); break;
8963             }
8964         }
8965     }
8966     catch (...)
8967     {
8968         return gl::error(GL_OUT_OF_MEMORY);
8969     }
8970 }
8971
8972 void __stdcall glGenSamplers(GLsizei count, GLuint* samplers)
8973 {
8974     EVENT("(GLsizei count = %d, GLuint* samplers = 0x%0.8p)", count, samplers);
8975
8976     try
8977     {
8978         gl::Context *context = gl::getNonLostContext();
8979
8980         if (context)
8981         {
8982             if (context->getClientVersion() < 3)
8983             {
8984                 return gl::error(GL_INVALID_OPERATION);
8985             }
8986
8987             if (count < 0)
8988             {
8989                 return gl::error(GL_INVALID_VALUE);
8990             }
8991
8992             for (int i = 0; i < count; i++)
8993             {
8994                 samplers[i] = context->createSampler();
8995             }
8996         }
8997     }
8998     catch (...)
8999     {
9000         return gl::error(GL_OUT_OF_MEMORY);
9001     }
9002 }
9003
9004 void __stdcall glDeleteSamplers(GLsizei count, const GLuint* samplers)
9005 {
9006     EVENT("(GLsizei count = %d, const GLuint* samplers = 0x%0.8p)", count, samplers);
9007
9008     try
9009     {
9010         gl::Context *context = gl::getNonLostContext();
9011
9012         if (context)
9013         {
9014             if (context->getClientVersion() < 3)
9015             {
9016                 return gl::error(GL_INVALID_OPERATION);
9017             }
9018
9019             if (count < 0)
9020             {
9021                 return gl::error(GL_INVALID_VALUE);
9022             }
9023
9024             for (int i = 0; i < count; i++)
9025             {
9026                 context->deleteSampler(samplers[i]);
9027             }
9028         }
9029     }
9030     catch (...)
9031     {
9032         return gl::error(GL_OUT_OF_MEMORY);
9033     }
9034 }
9035
9036 GLboolean __stdcall glIsSampler(GLuint sampler)
9037 {
9038     EVENT("(GLuint sampler = %u)", sampler);
9039
9040     try
9041     {
9042         gl::Context *context = gl::getNonLostContext();
9043
9044         if (context)
9045         {
9046             if (context->getClientVersion() < 3)
9047             {
9048                 return gl::error(GL_INVALID_OPERATION, GL_FALSE);
9049             }
9050
9051             return context->isSampler(sampler);
9052         }
9053     }
9054     catch (...)
9055     {
9056         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
9057     }
9058
9059     return GL_FALSE;
9060 }
9061
9062 void __stdcall glBindSampler(GLuint unit, GLuint sampler)
9063 {
9064     EVENT("(GLuint unit = %u, GLuint sampler = %u)", unit, sampler);
9065
9066     try
9067     {
9068         gl::Context *context = gl::getNonLostContext();
9069
9070         if (context)
9071         {
9072             if (context->getClientVersion() < 3)
9073             {
9074                 return gl::error(GL_INVALID_OPERATION);
9075             }
9076
9077             if (sampler != 0 && !context->isSampler(sampler))
9078             {
9079                 return gl::error(GL_INVALID_OPERATION);
9080             }
9081
9082             if (unit >= context->getMaximumCombinedTextureImageUnits())
9083             {
9084                 return gl::error(GL_INVALID_VALUE);
9085             }
9086
9087             context->bindSampler(unit, sampler);
9088         }
9089     }
9090     catch (...)
9091     {
9092         return gl::error(GL_OUT_OF_MEMORY);
9093     }
9094 }
9095
9096 void __stdcall glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
9097 {
9098     EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint param = %d)", sampler, pname, param);
9099
9100     try
9101     {
9102         gl::Context *context = gl::getNonLostContext();
9103
9104         if (context)
9105         {
9106             if (context->getClientVersion() < 3)
9107             {
9108                 return gl::error(GL_INVALID_OPERATION);
9109             }
9110
9111             if (!gl::ValidateSamplerObjectParameter(pname))
9112             {
9113                 return;
9114             }
9115
9116             if (!gl::ValidateTexParamParameters(context, pname, param))
9117             {
9118                 return;
9119             }
9120
9121             if (!context->isSampler(sampler))
9122             {
9123                 return gl::error(GL_INVALID_OPERATION);
9124             }
9125
9126             context->samplerParameteri(sampler, pname, param);
9127         }
9128     }
9129     catch (...)
9130     {
9131         return gl::error(GL_OUT_OF_MEMORY);
9132     }
9133 }
9134
9135 void __stdcall glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
9136 {
9137     glSamplerParameteri(sampler, pname, *param);
9138 }
9139
9140 void __stdcall glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
9141 {
9142     EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLfloat param = %g)", sampler, pname, param);
9143
9144     try
9145     {
9146         gl::Context *context = gl::getNonLostContext();
9147
9148         if (context)
9149         {
9150             if (context->getClientVersion() < 3)
9151             {
9152                 return gl::error(GL_INVALID_OPERATION);
9153             }
9154
9155             if (!gl::ValidateSamplerObjectParameter(pname))
9156             {
9157                 return;
9158             }
9159
9160             if (!gl::ValidateTexParamParameters(context, pname, static_cast<GLint>(param)))
9161             {
9162                 return;
9163             }
9164
9165             if (!context->isSampler(sampler))
9166             {
9167                 return gl::error(GL_INVALID_OPERATION);
9168             }
9169
9170             context->samplerParameterf(sampler, pname, param);
9171         }
9172     }
9173     catch (...)
9174     {
9175         return gl::error(GL_OUT_OF_MEMORY);
9176     }
9177 }
9178
9179 void __stdcall glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
9180 {
9181     glSamplerParameterf(sampler, pname, *param);
9182 }
9183
9184 void __stdcall glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
9185 {
9186     EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", sampler, pname, params);
9187
9188     try
9189     {
9190         gl::Context *context = gl::getNonLostContext();
9191
9192         if (context)
9193         {
9194             if (context->getClientVersion() < 3)
9195             {
9196                 return gl::error(GL_INVALID_OPERATION);
9197             }
9198
9199             if (!gl::ValidateSamplerObjectParameter(pname))
9200             {
9201                 return;
9202             }
9203
9204             if (!context->isSampler(sampler))
9205             {
9206                 return gl::error(GL_INVALID_OPERATION);
9207             }
9208
9209             *params = context->getSamplerParameteri(sampler, pname);
9210         }
9211     }
9212     catch (...)
9213     {
9214         return gl::error(GL_OUT_OF_MEMORY);
9215     }
9216 }
9217
9218 void __stdcall glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
9219 {
9220     EVENT("(GLuint sample = %ur, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", sampler, pname, params);
9221
9222     try
9223     {
9224         gl::Context *context = gl::getNonLostContext();
9225
9226         if (context)
9227         {
9228             if (context->getClientVersion() < 3)
9229             {
9230                 return gl::error(GL_INVALID_OPERATION);
9231             }
9232
9233             if (!gl::ValidateSamplerObjectParameter(pname))
9234             {
9235                 return;
9236             }
9237
9238             if (!context->isSampler(sampler))
9239             {
9240                 return gl::error(GL_INVALID_OPERATION);
9241             }
9242
9243             *params = context->getSamplerParameterf(sampler, pname);
9244         }
9245     }
9246     catch (...)
9247     {
9248         return gl::error(GL_OUT_OF_MEMORY);
9249     }
9250 }
9251
9252 void __stdcall glVertexAttribDivisor(GLuint index, GLuint divisor)
9253 {
9254     EVENT("(GLuint index = %u, GLuint divisor = %u)", index, divisor);
9255
9256     try
9257     {
9258         if (index >= gl::MAX_VERTEX_ATTRIBS)
9259         {
9260             return gl::error(GL_INVALID_VALUE);
9261         }
9262
9263         gl::Context *context = gl::getNonLostContext();
9264
9265         if (context)
9266         {
9267             if (context->getClientVersion() < 3)
9268             {
9269                 return gl::error(GL_INVALID_OPERATION);
9270             }
9271
9272             context->setVertexAttribDivisor(index, divisor);
9273         }
9274     }
9275     catch (...)
9276     {
9277         return gl::error(GL_OUT_OF_MEMORY);
9278     }
9279 }
9280
9281 void __stdcall glBindTransformFeedback(GLenum target, GLuint id)
9282 {
9283     EVENT("(GLenum target = 0x%X, GLuint id = %u)", target, id);
9284
9285     try
9286     {
9287         gl::Context *context = gl::getNonLostContext();
9288
9289         if (context)
9290         {
9291             if (context->getClientVersion() < 3)
9292             {
9293                 return gl::error(GL_INVALID_OPERATION);
9294             }
9295
9296             switch (target)
9297             {
9298               case GL_TRANSFORM_FEEDBACK:
9299                 {
9300                     // Cannot bind a transform feedback object if the current one is started and not paused (3.0.2 pg 85 section 2.14.1)
9301                     gl::TransformFeedback *curTransformFeedback = context->getCurrentTransformFeedback();
9302                     if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused())
9303                     {
9304                         return gl::error(GL_INVALID_OPERATION);
9305                     }
9306
9307                     // Cannot bind a transform feedback object that does not exist (3.0.2 pg 85 section 2.14.1)
9308                     if (context->getTransformFeedback(id) == NULL)
9309                     {
9310                         return gl::error(GL_INVALID_OPERATION);
9311                     }
9312
9313                     context->bindTransformFeedback(id);
9314                 }
9315                 break;
9316
9317               default:
9318                 return gl::error(GL_INVALID_ENUM);
9319             }
9320         }
9321     }
9322     catch (...)
9323     {
9324         return gl::error(GL_OUT_OF_MEMORY);
9325     }
9326 }
9327
9328 void __stdcall glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
9329 {
9330     EVENT("(GLsizei n = %d, const GLuint* ids = 0x%0.8p)", n, ids);
9331
9332     try
9333     {
9334         gl::Context *context = gl::getNonLostContext();
9335
9336         if (context)
9337         {
9338             if (context->getClientVersion() < 3)
9339             {
9340                 return gl::error(GL_INVALID_OPERATION);
9341             }
9342
9343             for (int i = 0; i < n; i++)
9344             {
9345                 context->deleteTransformFeedback(ids[i]);
9346             }
9347         }
9348     }
9349     catch (...)
9350     {
9351         return gl::error(GL_OUT_OF_MEMORY);
9352     }
9353 }
9354
9355 void __stdcall glGenTransformFeedbacks(GLsizei n, GLuint* ids)
9356 {
9357     EVENT("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);
9358
9359     try
9360     {
9361         gl::Context *context = gl::getNonLostContext();
9362
9363         if (context)
9364         {
9365             if (context->getClientVersion() < 3)
9366             {
9367                 return gl::error(GL_INVALID_OPERATION);
9368             }
9369
9370             for (int i = 0; i < n; i++)
9371             {
9372                 ids[i] = context->createTransformFeedback();
9373             }
9374         }
9375     }
9376     catch (...)
9377     {
9378         return gl::error(GL_OUT_OF_MEMORY);
9379     }
9380 }
9381
9382 GLboolean __stdcall glIsTransformFeedback(GLuint id)
9383 {
9384     EVENT("(GLuint id = %u)", id);
9385
9386     try
9387     {
9388         gl::Context *context = gl::getNonLostContext();
9389
9390         if (context)
9391         {
9392             if (context->getClientVersion() < 3)
9393             {
9394                 return gl::error(GL_INVALID_OPERATION, GL_FALSE);
9395             }
9396
9397             return ((context->getTransformFeedback(id) != NULL) ? GL_TRUE : GL_FALSE);
9398         }
9399     }
9400     catch (...)
9401     {
9402         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
9403     }
9404
9405     return GL_FALSE;
9406 }
9407
9408 void __stdcall glPauseTransformFeedback(void)
9409 {
9410     EVENT("(void)");
9411
9412     try
9413     {
9414         gl::Context *context = gl::getNonLostContext();
9415
9416         if (context)
9417         {
9418             if (context->getClientVersion() < 3)
9419             {
9420                 return gl::error(GL_INVALID_OPERATION);
9421             }
9422
9423             gl::TransformFeedback *transformFeedback = context->getCurrentTransformFeedback();
9424             ASSERT(transformFeedback != NULL);
9425
9426             // Current transform feedback must be started and not paused in order to pause (3.0.2 pg 86)
9427             if (!transformFeedback->isStarted() || transformFeedback->isPaused())
9428             {
9429                 return gl::error(GL_INVALID_OPERATION);
9430             }
9431
9432             transformFeedback->pause();
9433         }
9434     }
9435     catch (...)
9436     {
9437         return gl::error(GL_OUT_OF_MEMORY);
9438     }
9439 }
9440
9441 void __stdcall glResumeTransformFeedback(void)
9442 {
9443     EVENT("(void)");
9444
9445     try
9446     {
9447         gl::Context *context = gl::getNonLostContext();
9448
9449         if (context)
9450         {
9451             if (context->getClientVersion() < 3)
9452             {
9453                 return gl::error(GL_INVALID_OPERATION);
9454             }
9455
9456             gl::TransformFeedback *transformFeedback = context->getCurrentTransformFeedback();
9457             ASSERT(transformFeedback != NULL);
9458
9459             // Current transform feedback must be started and paused in order to resume (3.0.2 pg 86)
9460             if (!transformFeedback->isStarted() || !transformFeedback->isPaused())
9461             {
9462                 return gl::error(GL_INVALID_OPERATION);
9463             }
9464
9465             transformFeedback->resume();
9466         }
9467     }
9468     catch (...)
9469     {
9470         return gl::error(GL_OUT_OF_MEMORY);
9471     }
9472 }
9473
9474 void __stdcall glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
9475 {
9476     EVENT("(GLuint program = %u, GLsizei bufSize = %d, GLsizei* length = 0x%0.8p, GLenum* binaryFormat = 0x%0.8p, GLvoid* binary = 0x%0.8p)",
9477           program, bufSize, length, binaryFormat, binary);
9478
9479     try
9480     {
9481         gl::Context *context = gl::getNonLostContext();
9482
9483         if (context)
9484         {
9485             if (context->getClientVersion() < 3)
9486             {
9487                 return gl::error(GL_INVALID_OPERATION);
9488             }
9489
9490             // glGetProgramBinary
9491             UNIMPLEMENTED();
9492         }
9493     }
9494     catch (...)
9495     {
9496         return gl::error(GL_OUT_OF_MEMORY);
9497     }
9498 }
9499
9500 void __stdcall glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
9501 {
9502     EVENT("(GLuint program = %u, GLenum binaryFormat = 0x%X, const GLvoid* binary = 0x%0.8p, GLsizei length = %d)",
9503           program, binaryFormat, binary, length);
9504
9505     try
9506     {
9507         gl::Context *context = gl::getNonLostContext();
9508
9509         if (context)
9510         {
9511             if (context->getClientVersion() < 3)
9512             {
9513                 return gl::error(GL_INVALID_OPERATION);
9514             }
9515
9516             // glProgramBinary
9517             UNIMPLEMENTED();
9518         }
9519     }
9520     catch (...)
9521     {
9522         return gl::error(GL_OUT_OF_MEMORY);
9523     }
9524 }
9525
9526 void __stdcall glProgramParameteri(GLuint program, GLenum pname, GLint value)
9527 {
9528     EVENT("(GLuint program = %u, GLenum pname = 0x%X, GLint value = %d)",
9529           program, pname, value);
9530
9531     try
9532     {
9533         gl::Context *context = gl::getNonLostContext();
9534
9535         if (context)
9536         {
9537             if (context->getClientVersion() < 3)
9538             {
9539                 return gl::error(GL_INVALID_OPERATION);
9540             }
9541
9542             // glProgramParameteri
9543             UNIMPLEMENTED();
9544         }
9545     }
9546     catch (...)
9547     {
9548         return gl::error(GL_OUT_OF_MEMORY);
9549     }
9550 }
9551
9552 void __stdcall glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
9553 {
9554     EVENT("(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum* attachments = 0x%0.8p)",
9555           target, numAttachments, attachments);
9556
9557     try
9558     {
9559         gl::Context *context = gl::getNonLostContext();
9560
9561         if (context)
9562         {
9563             if (context->getClientVersion() < 3)
9564             {
9565                 return gl::error(GL_INVALID_OPERATION);
9566             }
9567
9568             if (!ValidateInvalidateFramebufferParameters(context, target, numAttachments, attachments))
9569             {
9570                 return;
9571             }
9572
9573             int maxDimension = context->getMaximumRenderbufferDimension();
9574             context->invalidateFrameBuffer(target, numAttachments, attachments, 0, 0, maxDimension, maxDimension);
9575         }
9576     }
9577     catch (...)
9578     {
9579         return gl::error(GL_OUT_OF_MEMORY);
9580     }
9581 }
9582
9583 void __stdcall glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
9584 {
9585     EVENT("(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum* attachments = 0x%0.8p, GLint x = %d, "
9586           "GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
9587           target, numAttachments, attachments, x, y, width, height);
9588
9589     try
9590     {
9591         gl::Context *context = gl::getNonLostContext();
9592
9593         if (context)
9594         {
9595             if (context->getClientVersion() < 3)
9596             {
9597                 return gl::error(GL_INVALID_OPERATION);
9598             }
9599
9600             if (!ValidateInvalidateFramebufferParameters(context, target, numAttachments, attachments))
9601             {
9602                 return;
9603             }
9604
9605             context->invalidateFrameBuffer(target, numAttachments, attachments, x, y, width, height);
9606         }
9607     }
9608     catch (...)
9609     {
9610         return gl::error(GL_OUT_OF_MEMORY);
9611     }
9612 }
9613
9614 void __stdcall glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
9615 {
9616     EVENT("(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
9617           target, levels, internalformat, width, height);
9618
9619     try
9620     {
9621         gl::Context *context = gl::getNonLostContext();
9622
9623         if (context)
9624         {
9625             if (context->getClientVersion() < 3)
9626             {
9627                 return gl::error(GL_INVALID_OPERATION);
9628             }
9629
9630             if (!ValidateES3TexStorageParameters(context, target, levels, internalformat, width, height, 1))
9631             {
9632                 return;
9633             }
9634
9635             switch (target)
9636             {
9637               case GL_TEXTURE_2D:
9638                 {
9639                     gl::Texture2D *texture2d = context->getTexture2D();
9640                     texture2d->storage(levels, internalformat, width, height);
9641                 }
9642                 break;
9643
9644               case GL_TEXTURE_CUBE_MAP:
9645                 {
9646                     gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
9647                     textureCube->storage(levels, internalformat, width);
9648                 }
9649                 break;
9650
9651               default:
9652                 return gl::error(GL_INVALID_ENUM);
9653             }
9654         }
9655     }
9656     catch (...)
9657     {
9658         return gl::error(GL_OUT_OF_MEMORY);
9659     }
9660 }
9661
9662 void __stdcall glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
9663 {
9664     EVENT("(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = %d, "
9665           "GLsizei height = %d, GLsizei depth = %d)",
9666           target, levels, internalformat, width, height, depth);
9667
9668     try
9669     {
9670         gl::Context *context = gl::getNonLostContext();
9671
9672         if (context)
9673         {
9674             if (context->getClientVersion() < 3)
9675             {
9676                 return gl::error(GL_INVALID_OPERATION);
9677             }
9678
9679             if (!ValidateES3TexStorageParameters(context, target, levels, internalformat, width, height, depth))
9680             {
9681                 return;
9682             }
9683
9684             switch (target)
9685             {
9686               case GL_TEXTURE_3D:
9687                 {
9688                     gl::Texture3D *texture3d = context->getTexture3D();
9689                     texture3d->storage(levels, internalformat, width, height, depth);
9690                 }
9691                 break;
9692
9693               case GL_TEXTURE_2D_ARRAY:
9694                 {
9695                     gl::Texture2DArray *texture2darray = context->getTexture2DArray();
9696                     texture2darray->storage(levels, internalformat, width, height, depth);
9697                 }
9698                 break;
9699
9700               default:
9701                 UNREACHABLE();
9702             }
9703         }
9704     }
9705     catch (...)
9706     {
9707         return gl::error(GL_OUT_OF_MEMORY);
9708     }
9709 }
9710
9711 void __stdcall glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
9712 {
9713     EVENT("(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, "
9714           "GLint* params = 0x%0.8p)",
9715           target, internalformat, pname, bufSize, params);
9716
9717     try
9718     {
9719         gl::Context *context = gl::getNonLostContext();
9720
9721         if (context)
9722         {
9723             if (context->getClientVersion() < 3)
9724             {
9725                 return gl::error(GL_INVALID_OPERATION);
9726             }
9727
9728             if (!gl::IsColorRenderingSupported(internalformat, context) &&
9729                 !gl::IsDepthRenderingSupported(internalformat, context) &&
9730                 !gl::IsStencilRenderingSupported(internalformat, context))
9731             {
9732                 return gl::error(GL_INVALID_ENUM);
9733             }
9734
9735             if (target != GL_RENDERBUFFER)
9736             {
9737                 return gl::error(GL_INVALID_ENUM);
9738             }
9739
9740             if (bufSize < 0)
9741             {
9742                 return gl::error(GL_INVALID_VALUE);
9743             }
9744
9745             switch (pname)
9746             {
9747               case GL_NUM_SAMPLE_COUNTS:
9748                 if (bufSize != 0)
9749                     *params = context->getNumSampleCounts(internalformat);
9750                 break;
9751               case GL_SAMPLES:
9752                 context->getSampleCounts(internalformat, bufSize, params);
9753                 break;
9754               default:
9755                 return gl::error(GL_INVALID_ENUM);
9756             }
9757         }
9758     }
9759     catch (...)
9760     {
9761         return gl::error(GL_OUT_OF_MEMORY);
9762     }
9763 }
9764
9765 // Extension functions
9766
9767 void __stdcall glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
9768                                       GLbitfield mask, GLenum filter)
9769 {
9770     EVENT("(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
9771           "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, "
9772           "GLbitfield mask = 0x%X, GLenum filter = 0x%X)",
9773           srcX0, srcY0, srcX1, srcX1, dstX0, dstY0, dstX1, dstY1, mask, filter);
9774
9775     try
9776     {
9777         gl::Context *context = gl::getNonLostContext();
9778
9779         if (context)
9780         {
9781             if (!ValidateBlitFramebufferParameters(context, srcX0, srcY0, srcX1, srcY1,
9782                                                    dstX0, dstY0, dstX1, dstY1, mask, filter,
9783                                                    true))
9784             {
9785                 return;
9786             }
9787
9788             context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
9789                                      mask, filter);
9790         }
9791     }
9792     catch (...)
9793     {
9794         return gl::error(GL_OUT_OF_MEMORY);
9795     }
9796 }
9797
9798 void __stdcall glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
9799                                GLint border, GLenum format, GLenum type, const GLvoid* pixels)
9800 {
9801     EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
9802           "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, "
9803           "GLenum format = 0x%X, GLenum type = 0x%x, const GLvoid* pixels = 0x%0.8p)",
9804           target, level, internalformat, width, height, depth, border, format, type, pixels);
9805
9806     try
9807     {
9808         UNIMPLEMENTED();   // FIXME
9809     }
9810     catch (...)
9811     {
9812         return gl::error(GL_OUT_OF_MEMORY);
9813     }
9814 }
9815
9816 void __stdcall glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length,
9817                                      GLenum *binaryFormat, void *binary)
9818 {
9819     EVENT("(GLenum program = 0x%X, bufSize = %d, length = 0x%0.8p, binaryFormat = 0x%0.8p, binary = 0x%0.8p)",
9820           program, bufSize, length, binaryFormat, binary);
9821
9822     try
9823     {
9824         gl::Context *context = gl::getNonLostContext();
9825
9826         if (context)
9827         {
9828             gl::Program *programObject = context->getProgram(program);
9829
9830             if (!programObject || !programObject->isLinked())
9831             {
9832                 return gl::error(GL_INVALID_OPERATION);
9833             }
9834
9835             gl::ProgramBinary *programBinary = programObject->getProgramBinary();
9836
9837             if (!programBinary)
9838             {
9839                 return gl::error(GL_INVALID_OPERATION);
9840             }
9841
9842             if (!programBinary->save(binary, bufSize, length))
9843             {
9844                 return gl::error(GL_INVALID_OPERATION);
9845             }
9846
9847             *binaryFormat = GL_PROGRAM_BINARY_ANGLE;
9848         }
9849     }
9850     catch (...)
9851     {
9852         return gl::error(GL_OUT_OF_MEMORY);
9853     }
9854 }
9855
9856 void __stdcall glProgramBinaryOES(GLuint program, GLenum binaryFormat,
9857                                   const void *binary, GLint length)
9858 {
9859     EVENT("(GLenum program = 0x%X, binaryFormat = 0x%x, binary = 0x%0.8p, length = %d)",
9860           program, binaryFormat, binary, length);
9861
9862     try
9863     {
9864         gl::Context *context = gl::getNonLostContext();
9865
9866         if (context)
9867         {
9868             if (binaryFormat != GL_PROGRAM_BINARY_ANGLE)
9869             {
9870                 return gl::error(GL_INVALID_ENUM);
9871             }
9872
9873             gl::Program *programObject = context->getProgram(program);
9874
9875             if (!programObject)
9876             {
9877                 return gl::error(GL_INVALID_OPERATION);
9878             }
9879
9880             context->setProgramBinary(program, binary, length);
9881         }
9882     }
9883     catch (...)
9884     {
9885         return gl::error(GL_OUT_OF_MEMORY);
9886     }
9887 }
9888
9889 void __stdcall glDrawBuffersEXT(GLsizei n, const GLenum *bufs)
9890 {
9891     EVENT("(GLenum n = %d, bufs = 0x%0.8p)", n, bufs);
9892
9893     try
9894     {
9895         gl::Context *context = gl::getNonLostContext();
9896
9897         if (context)
9898         {
9899             if (n < 0 || (unsigned int)n > context->getMaximumRenderTargets())
9900             {
9901                 return gl::error(GL_INVALID_VALUE);
9902             }
9903
9904             if (context->getDrawFramebufferHandle() == 0)
9905             {
9906                 if (n != 1)
9907                 {
9908                     return gl::error(GL_INVALID_OPERATION);
9909                 }
9910
9911                 if (bufs[0] != GL_NONE && bufs[0] != GL_BACK)
9912                 {
9913                     return gl::error(GL_INVALID_OPERATION);
9914                 }
9915             }
9916             else
9917             {
9918                 for (int colorAttachment = 0; colorAttachment < n; colorAttachment++)
9919                 {
9920                     const GLenum attachment = GL_COLOR_ATTACHMENT0_EXT + colorAttachment;
9921                     if (bufs[colorAttachment] != GL_NONE && bufs[colorAttachment] != attachment)
9922                     {
9923                         return gl::error(GL_INVALID_OPERATION);
9924                     }
9925                 }
9926             }
9927
9928             gl::Framebuffer *framebuffer = context->getDrawFramebuffer();
9929
9930             for (int colorAttachment = 0; colorAttachment < n; colorAttachment++)
9931             {
9932                 framebuffer->setDrawBufferState(colorAttachment, bufs[colorAttachment]);
9933             }
9934
9935             for (int colorAttachment = n; colorAttachment < (int)context->getMaximumRenderTargets(); colorAttachment++)
9936             {
9937                 framebuffer->setDrawBufferState(colorAttachment, GL_NONE);
9938             }
9939         }
9940     }
9941     catch (...)
9942     {
9943         return gl::error(GL_OUT_OF_MEMORY);
9944     }
9945 }
9946
9947 void __stdcall glGetBufferPointervOES(GLenum target, GLenum pname, void** params)
9948 {
9949     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLvoid** params = 0x%0.8p)", target, pname, params);
9950
9951     try
9952     {
9953         gl::Context *context = gl::getNonLostContext();
9954
9955         if (context)
9956         {
9957             if (!context->supportsPBOs())
9958             {
9959                 return gl::error(GL_INVALID_OPERATION);
9960             }
9961
9962             if (!gl::ValidBufferTarget(context, target))
9963             {
9964                 return gl::error(GL_INVALID_ENUM);
9965             }
9966
9967             if (pname != GL_BUFFER_MAP_POINTER)
9968             {
9969                 return gl::error(GL_INVALID_ENUM);
9970             }
9971
9972             gl::Buffer *buffer = context->getTargetBuffer(target);
9973
9974             if (!buffer || !buffer->mapped())
9975             {
9976                 *params = NULL;
9977             }
9978
9979             *params = buffer->mapPointer();
9980         }
9981     }
9982     catch (...)
9983     {
9984         return gl::error(GL_OUT_OF_MEMORY);
9985     }
9986 }
9987
9988 void * __stdcall glMapBufferOES(GLenum target, GLenum access)
9989 {
9990     EVENT("(GLenum target = 0x%X, GLbitfield access = 0x%X)", target, access);
9991
9992     try
9993     {
9994         gl::Context *context = gl::getNonLostContext();
9995
9996         if (context)
9997         {
9998             if (!gl::ValidBufferTarget(context, target))
9999             {
10000                 return gl::error(GL_INVALID_ENUM, reinterpret_cast<GLvoid*>(NULL));
10001             }
10002
10003             gl::Buffer *buffer = context->getTargetBuffer(target);
10004
10005             if (buffer == NULL)
10006             {
10007                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLvoid*>(NULL));
10008             }
10009
10010             if (access != GL_WRITE_ONLY_OES)
10011             {
10012                 return gl::error(GL_INVALID_ENUM, reinterpret_cast<GLvoid*>(NULL));
10013             }
10014
10015             if (buffer->mapped())
10016             {
10017                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLvoid*>(NULL));
10018             }
10019
10020             return buffer->mapRange(0, buffer->size(), GL_MAP_WRITE_BIT);
10021         }
10022     }
10023     catch (...)
10024     {
10025         return gl::error(GL_OUT_OF_MEMORY, reinterpret_cast<GLvoid*>(NULL));
10026     }
10027
10028     return NULL;
10029 }
10030
10031 GLboolean __stdcall glUnmapBufferOES(GLenum target)
10032 {
10033     EVENT("(GLenum target = 0x%X)", target);
10034
10035     try
10036     {
10037         gl::Context *context = gl::getNonLostContext();
10038
10039         if (context)
10040         {
10041             if (!gl::ValidBufferTarget(context, target))
10042             {
10043                 return gl::error(GL_INVALID_ENUM, GL_FALSE);
10044             }
10045
10046             gl::Buffer *buffer = context->getTargetBuffer(target);
10047
10048             if (buffer == NULL || !buffer->mapped())
10049             {
10050                 return gl::error(GL_INVALID_OPERATION, GL_FALSE);
10051             }
10052
10053             // TODO: detect if we had corruption. if so, throw an error and return false.
10054
10055             buffer->unmap();
10056
10057             return GL_TRUE;
10058         }
10059     }
10060     catch (...)
10061     {
10062         return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
10063     }
10064
10065     return GL_FALSE;
10066 }
10067
10068 void* __stdcall glMapBufferRangeEXT (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
10069 {
10070     EVENT("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr length = %d, GLbitfield access = 0x%X)",
10071           target, offset, length, access);
10072
10073     try
10074     {
10075         gl::Context *context = gl::getNonLostContext();
10076
10077         if (context)
10078         {
10079             if (!gl::ValidBufferTarget(context, target))
10080             {
10081                 return gl::error(GL_INVALID_ENUM, reinterpret_cast<GLvoid*>(NULL));
10082             }
10083
10084             if (offset < 0 || length < 0)
10085             {
10086                 return gl::error(GL_INVALID_VALUE, reinterpret_cast<GLvoid*>(NULL));
10087             }
10088
10089             gl::Buffer *buffer = context->getTargetBuffer(target);
10090
10091             if (buffer == NULL)
10092             {
10093                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLvoid*>(NULL));
10094             }
10095
10096             // Check for buffer overflow
10097             size_t offsetSize = static_cast<size_t>(offset);
10098             size_t lengthSize = static_cast<size_t>(length);
10099
10100             if (!rx::IsUnsignedAdditionSafe(offsetSize, lengthSize) ||
10101                 offsetSize + lengthSize > static_cast<size_t>(buffer->size()))
10102             {
10103                 return gl::error(GL_INVALID_VALUE, reinterpret_cast<GLvoid*>(NULL));
10104             }
10105
10106             // Check for invalid bits in the mask
10107             GLbitfield allAccessBits = GL_MAP_READ_BIT |
10108                                        GL_MAP_WRITE_BIT |
10109                                        GL_MAP_INVALIDATE_RANGE_BIT |
10110                                        GL_MAP_INVALIDATE_BUFFER_BIT |
10111                                        GL_MAP_FLUSH_EXPLICIT_BIT |
10112                                        GL_MAP_UNSYNCHRONIZED_BIT;
10113
10114             if (access & ~(allAccessBits))
10115             {
10116                 return gl::error(GL_INVALID_VALUE, reinterpret_cast<GLvoid*>(NULL));
10117             }
10118
10119             if (length == 0 || buffer->mapped())
10120             {
10121                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLvoid*>(NULL));
10122             }
10123
10124             // Check for invalid bit combinations
10125             if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0)
10126             {
10127                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLvoid*>(NULL));
10128             }
10129
10130             GLbitfield writeOnlyBits = GL_MAP_INVALIDATE_RANGE_BIT |
10131                                        GL_MAP_INVALIDATE_BUFFER_BIT |
10132                                        GL_MAP_UNSYNCHRONIZED_BIT;
10133
10134             if ((access & GL_MAP_READ_BIT) != 0 && (access & writeOnlyBits) != 0)
10135             {
10136                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLvoid*>(NULL));
10137             }
10138
10139             if ((access & GL_MAP_WRITE_BIT) == 0 && (access & GL_MAP_FLUSH_EXPLICIT_BIT) != 0)
10140             {
10141                 return gl::error(GL_INVALID_OPERATION, reinterpret_cast<GLvoid*>(NULL));
10142             }
10143
10144             return buffer->mapRange(offset, length, access);
10145         }
10146     }
10147     catch (...)
10148     {
10149         return gl::error(GL_OUT_OF_MEMORY, reinterpret_cast<GLvoid*>(NULL));
10150     }
10151
10152     return NULL;
10153 }
10154
10155 void __stdcall glFlushMappedBufferRangeEXT (GLenum target, GLintptr offset, GLsizeiptr length)
10156 {
10157     EVENT("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr length = %d)", target, offset, length);
10158
10159     try
10160     {
10161         gl::Context *context = gl::getNonLostContext();
10162
10163         if (context)
10164         {
10165             if (offset < 0 || length < 0)
10166             {
10167                 return gl::error(GL_INVALID_VALUE);
10168             }
10169
10170             if (!gl::ValidBufferTarget(context, target))
10171             {
10172                 return gl::error(GL_INVALID_ENUM);
10173             }
10174
10175             gl::Buffer *buffer = context->getTargetBuffer(target);
10176
10177             if (buffer == NULL)
10178             {
10179                 return gl::error(GL_INVALID_OPERATION);
10180             }
10181
10182             if (!buffer->mapped() || (buffer->accessFlags() & GL_MAP_FLUSH_EXPLICIT_BIT) == 0)
10183             {
10184                 return gl::error(GL_INVALID_OPERATION);
10185             }
10186
10187             // Check for buffer overflow
10188             size_t offsetSize = static_cast<size_t>(offset);
10189             size_t lengthSize = static_cast<size_t>(length);
10190
10191             if (!rx::IsUnsignedAdditionSafe(offsetSize, lengthSize) ||
10192                 offsetSize + lengthSize > static_cast<size_t>(buffer->mapLength()))
10193             {
10194                 return gl::error(GL_INVALID_VALUE);
10195             }
10196
10197             // We do not currently support a non-trivial implementation of FlushMappedBufferRange
10198         }
10199     }
10200     catch (...)
10201     {
10202         return gl::error(GL_OUT_OF_MEMORY);
10203     }
10204 }
10205
10206 __eglMustCastToProperFunctionPointerType __stdcall glGetProcAddress(const char *procname)
10207 {
10208     struct Extension
10209     {
10210         const char *name;
10211         __eglMustCastToProperFunctionPointerType address;
10212     };
10213
10214     static const Extension glExtensions[] =
10215     {
10216         {"glTexImage3DOES", (__eglMustCastToProperFunctionPointerType)glTexImage3DOES},
10217         {"glBlitFramebufferANGLE", (__eglMustCastToProperFunctionPointerType)glBlitFramebufferANGLE},
10218         {"glRenderbufferStorageMultisampleANGLE", (__eglMustCastToProperFunctionPointerType)glRenderbufferStorageMultisampleANGLE},
10219         {"glDeleteFencesNV", (__eglMustCastToProperFunctionPointerType)glDeleteFencesNV},
10220         {"glGenFencesNV", (__eglMustCastToProperFunctionPointerType)glGenFencesNV},
10221         {"glIsFenceNV", (__eglMustCastToProperFunctionPointerType)glIsFenceNV},
10222         {"glTestFenceNV", (__eglMustCastToProperFunctionPointerType)glTestFenceNV},
10223         {"glGetFenceivNV", (__eglMustCastToProperFunctionPointerType)glGetFenceivNV},
10224         {"glFinishFenceNV", (__eglMustCastToProperFunctionPointerType)glFinishFenceNV},
10225         {"glSetFenceNV", (__eglMustCastToProperFunctionPointerType)glSetFenceNV},
10226         {"glGetTranslatedShaderSourceANGLE", (__eglMustCastToProperFunctionPointerType)glGetTranslatedShaderSourceANGLE},
10227         {"glTexStorage2DEXT", (__eglMustCastToProperFunctionPointerType)glTexStorage2DEXT},
10228         {"glGetGraphicsResetStatusEXT", (__eglMustCastToProperFunctionPointerType)glGetGraphicsResetStatusEXT},
10229         {"glReadnPixelsEXT", (__eglMustCastToProperFunctionPointerType)glReadnPixelsEXT},
10230         {"glGetnUniformfvEXT", (__eglMustCastToProperFunctionPointerType)glGetnUniformfvEXT},
10231         {"glGetnUniformivEXT", (__eglMustCastToProperFunctionPointerType)glGetnUniformivEXT},
10232         {"glGenQueriesEXT", (__eglMustCastToProperFunctionPointerType)glGenQueriesEXT},
10233         {"glDeleteQueriesEXT", (__eglMustCastToProperFunctionPointerType)glDeleteQueriesEXT},
10234         {"glIsQueryEXT", (__eglMustCastToProperFunctionPointerType)glIsQueryEXT},
10235         {"glBeginQueryEXT", (__eglMustCastToProperFunctionPointerType)glBeginQueryEXT},
10236         {"glEndQueryEXT", (__eglMustCastToProperFunctionPointerType)glEndQueryEXT},
10237         {"glGetQueryivEXT", (__eglMustCastToProperFunctionPointerType)glGetQueryivEXT},
10238         {"glGetQueryObjectuivEXT", (__eglMustCastToProperFunctionPointerType)glGetQueryObjectuivEXT},
10239         {"glDrawBuffersEXT", (__eglMustCastToProperFunctionPointerType)glDrawBuffersEXT},
10240         {"glVertexAttribDivisorANGLE", (__eglMustCastToProperFunctionPointerType)glVertexAttribDivisorANGLE},
10241         {"glDrawArraysInstancedANGLE", (__eglMustCastToProperFunctionPointerType)glDrawArraysInstancedANGLE},
10242         {"glDrawElementsInstancedANGLE", (__eglMustCastToProperFunctionPointerType)glDrawElementsInstancedANGLE},
10243         {"glGetProgramBinaryOES", (__eglMustCastToProperFunctionPointerType)glGetProgramBinaryOES},
10244         {"glProgramBinaryOES", (__eglMustCastToProperFunctionPointerType)glProgramBinaryOES},
10245         {"glGetBufferPointervOES", (__eglMustCastToProperFunctionPointerType)glGetBufferPointervOES},
10246         {"glMapBufferOES", (__eglMustCastToProperFunctionPointerType)glMapBufferOES},
10247         {"glUnmapBufferOES", (__eglMustCastToProperFunctionPointerType)glUnmapBufferOES},
10248         {"glMapBufferRangeEXT", (__eglMustCastToProperFunctionPointerType)glMapBufferRangeEXT},
10249         {"glFlushMappedBufferRangeEXT", (__eglMustCastToProperFunctionPointerType)glFlushMappedBufferRangeEXT},    };
10250
10251     for (unsigned int ext = 0; ext < ArraySize(glExtensions); ext++)
10252     {
10253         if (strcmp(procname, glExtensions[ext].name) == 0)
10254         {
10255             return (__eglMustCastToProperFunctionPointerType)glExtensions[ext].address;
10256         }
10257     }
10258
10259     return NULL;
10260 }
10261
10262 // Non-public functions used by EGL
10263
10264 bool __stdcall glBindTexImage(egl::Surface *surface)
10265 {
10266     EVENT("(egl::Surface* surface = 0x%0.8p)",
10267           surface);
10268
10269     try
10270     {
10271         gl::Context *context = gl::getNonLostContext();
10272
10273         if (context)
10274         {
10275             gl::Texture2D *textureObject = context->getTexture2D();
10276             ASSERT(textureObject != NULL);
10277
10278             if (textureObject->isImmutable())
10279             {
10280                 return false;
10281             }
10282
10283             textureObject->bindTexImage(surface);
10284         }
10285     }
10286     catch (...)
10287     {
10288         return gl::error(GL_OUT_OF_MEMORY, false);
10289     }
10290
10291     return true;
10292 }
10293
10294 }