src/ppapi/lib/gl/gles2/gles2.c

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file is auto-generated from
   6 // gpu/command_buffer/build_gles2_cmd_buffer.py
   7 // It's formatted by clang-format using chromium coding style:
   8 //    clang-format -i -style=chromium filename
   9 // DO NOT EDIT!
  10
  11 #ifndef GL_GLEXT_PROTOTYPES
  12 #define GL_GLEXT_PROTOTYPES
  13 #endif
  14 #include <GLES2/gl2.h>
  15 #include <GLES2/gl2ext.h>
  16 #include "ppapi/lib/gl/gles2/gl2ext_ppapi.h"
  17
  18 void GL_APIENTRY glActiveTexture(GLenum texture) {
  19   glGetInterfacePPAPI()->ActiveTexture(glGetCurrentContextPPAPI(), texture);
  20 }
  21
  22 void GL_APIENTRY glAttachShader(GLuint program, GLuint shader) {
  23   glGetInterfacePPAPI()->AttachShader(glGetCurrentContextPPAPI(), program,
  24                                       shader);
  25 }
  26
  27 void GL_APIENTRY
  28 glBindAttribLocation(GLuint program, GLuint index, const char* name) {
  29   glGetInterfacePPAPI()->BindAttribLocation(glGetCurrentContextPPAPI(), program,
  30                                             index, name);
  31 }
  32
  33 void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer) {
  34   glGetInterfacePPAPI()->BindBuffer(glGetCurrentContextPPAPI(), target, buffer);
  35 }
  36
  37 void GL_APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer) {
  38   glGetInterfacePPAPI()->BindFramebuffer(glGetCurrentContextPPAPI(), target,
  39                                          framebuffer);
  40 }
  41
  42 void GL_APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
  43   glGetInterfacePPAPI()->BindRenderbuffer(glGetCurrentContextPPAPI(), target,
  44                                           renderbuffer);
  45 }
  46
  47 void GL_APIENTRY glBindTexture(GLenum target, GLuint texture) {
  48   glGetInterfacePPAPI()->BindTexture(glGetCurrentContextPPAPI(), target,
  49                                      texture);
  50 }
  51
  52 void GL_APIENTRY
  53 glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
  54   glGetInterfacePPAPI()->BlendColor(glGetCurrentContextPPAPI(), red, green,
  55                                     blue, alpha);
  56 }
  57
  58 void GL_APIENTRY glBlendEquation(GLenum mode) {
  59   glGetInterfacePPAPI()->BlendEquation(glGetCurrentContextPPAPI(), mode);
  60 }
  61
  62 void GL_APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
  63   glGetInterfacePPAPI()->BlendEquationSeparate(glGetCurrentContextPPAPI(),
  64                                                modeRGB, modeAlpha);
  65 }
  66
  67 void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor) {
  68   glGetInterfacePPAPI()->BlendFunc(glGetCurrentContextPPAPI(), sfactor,
  69                                    dfactor);
  70 }
  71
  72 void GL_APIENTRY glBlendFuncSeparate(GLenum srcRGB,
  73                                      GLenum dstRGB,
  74                                      GLenum srcAlpha,
  75                                      GLenum dstAlpha) {
  76   glGetInterfacePPAPI()->BlendFuncSeparate(glGetCurrentContextPPAPI(), srcRGB,
  77                                            dstRGB, srcAlpha, dstAlpha);
  78 }
  79
  80 void GL_APIENTRY
  81 glBufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
  82   glGetInterfacePPAPI()->BufferData(glGetCurrentContextPPAPI(), target, size,
  83                                     data, usage);
  84 }
  85
  86 void GL_APIENTRY glBufferSubData(GLenum target,
  87                                  GLintptr offset,
  88                                  GLsizeiptr size,
  89                                  const void* data) {
  90   glGetInterfacePPAPI()->BufferSubData(glGetCurrentContextPPAPI(), target,
  91                                        offset, size, data);
  92 }
  93
  94 GLenum GL_APIENTRY glCheckFramebufferStatus(GLenum target) {
  95   return glGetInterfacePPAPI()->CheckFramebufferStatus(
  96       glGetCurrentContextPPAPI(), target);
  97 }
  98
  99 void GL_APIENTRY glClear(GLbitfield mask) {
 100   glGetInterfacePPAPI()->Clear(glGetCurrentContextPPAPI(), mask);
 101 }
 102
 103 void GL_APIENTRY
 104 glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
 105   glGetInterfacePPAPI()->ClearColor(glGetCurrentContextPPAPI(), red, green,
 106                                     blue, alpha);
 107 }
 108
 109 void GL_APIENTRY glClearDepthf(GLclampf depth) {
 110   glGetInterfacePPAPI()->ClearDepthf(glGetCurrentContextPPAPI(), depth);
 111 }
 112
 113 void GL_APIENTRY glClearStencil(GLint s) {
 114   glGetInterfacePPAPI()->ClearStencil(glGetCurrentContextPPAPI(), s);
 115 }
 116
 117 void GL_APIENTRY
 118 glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
 119   glGetInterfacePPAPI()->ColorMask(glGetCurrentContextPPAPI(), red, green, blue,
 120                                    alpha);
 121 }
 122
 123 void GL_APIENTRY glCompileShader(GLuint shader) {
 124   glGetInterfacePPAPI()->CompileShader(glGetCurrentContextPPAPI(), shader);
 125 }
 126
 127 void GL_APIENTRY glCompressedTexImage2D(GLenum target,
 128                                         GLint level,
 129                                         GLenum internalformat,
 130                                         GLsizei width,
 131                                         GLsizei height,
 132                                         GLint border,
 133                                         GLsizei imageSize,
 134                                         const void* data) {
 135   glGetInterfacePPAPI()->CompressedTexImage2D(
 136       glGetCurrentContextPPAPI(), target, level, internalformat, width, height,
 137       border, imageSize, data);
 138 }
 139
 140 void GL_APIENTRY glCompressedTexSubImage2D(GLenum target,
 141                                            GLint level,
 142                                            GLint xoffset,
 143                                            GLint yoffset,
 144                                            GLsizei width,
 145                                            GLsizei height,
 146                                            GLenum format,
 147                                            GLsizei imageSize,
 148                                            const void* data) {
 149   glGetInterfacePPAPI()->CompressedTexSubImage2D(
 150       glGetCurrentContextPPAPI(), target, level, xoffset, yoffset, width,
 151       height, format, imageSize, data);
 152 }
 153
 154 void GL_APIENTRY glCopyTexImage2D(GLenum target,
 155                                   GLint level,
 156                                   GLenum internalformat,
 157                                   GLint x,
 158                                   GLint y,
 159                                   GLsizei width,
 160                                   GLsizei height,
 161                                   GLint border) {
 162   glGetInterfacePPAPI()->CopyTexImage2D(glGetCurrentContextPPAPI(), target,
 163                                         level, internalformat, x, y, width,
 164                                         height, border);
 165 }
 166
 167 void GL_APIENTRY glCopyTexSubImage2D(GLenum target,
 168                                      GLint level,
 169                                      GLint xoffset,
 170                                      GLint yoffset,
 171                                      GLint x,
 172                                      GLint y,
 173                                      GLsizei width,
 174                                      GLsizei height) {
 175   glGetInterfacePPAPI()->CopyTexSubImage2D(glGetCurrentContextPPAPI(), target,
 176                                            level, xoffset, yoffset, x, y, width,
 177                                            height);
 178 }
 179
 180 GLuint GL_APIENTRY glCreateProgram() {
 181   return glGetInterfacePPAPI()->CreateProgram(glGetCurrentContextPPAPI());
 182 }
 183
 184 GLuint GL_APIENTRY glCreateShader(GLenum type) {
 185   return glGetInterfacePPAPI()->CreateShader(glGetCurrentContextPPAPI(), type);
 186 }
 187
 188 void GL_APIENTRY glCullFace(GLenum mode) {
 189   glGetInterfacePPAPI()->CullFace(glGetCurrentContextPPAPI(), mode);
 190 }
 191
 192 void GL_APIENTRY glDeleteBuffers(GLsizei n, const GLuint* buffers) {
 193   glGetInterfacePPAPI()->DeleteBuffers(glGetCurrentContextPPAPI(), n, buffers);
 194 }
 195
 196 void GL_APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
 197   glGetInterfacePPAPI()->DeleteFramebuffers(glGetCurrentContextPPAPI(), n,
 198                                             framebuffers);
 199 }
 200
 201 void GL_APIENTRY glDeleteProgram(GLuint program) {
 202   glGetInterfacePPAPI()->DeleteProgram(glGetCurrentContextPPAPI(), program);
 203 }
 204
 205 void GL_APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
 206   glGetInterfacePPAPI()->DeleteRenderbuffers(glGetCurrentContextPPAPI(), n,
 207                                              renderbuffers);
 208 }
 209
 210 void GL_APIENTRY glDeleteShader(GLuint shader) {
 211   glGetInterfacePPAPI()->DeleteShader(glGetCurrentContextPPAPI(), shader);
 212 }
 213
 214 void GL_APIENTRY glDeleteTextures(GLsizei n, const GLuint* textures) {
 215   glGetInterfacePPAPI()->DeleteTextures(glGetCurrentContextPPAPI(), n,
 216                                         textures);
 217 }
 218
 219 void GL_APIENTRY glDepthFunc(GLenum func) {
 220   glGetInterfacePPAPI()->DepthFunc(glGetCurrentContextPPAPI(), func);
 221 }
 222
 223 void GL_APIENTRY glDepthMask(GLboolean flag) {
 224   glGetInterfacePPAPI()->DepthMask(glGetCurrentContextPPAPI(), flag);
 225 }
 226
 227 void GL_APIENTRY glDepthRangef(GLclampf zNear, GLclampf zFar) {
 228   glGetInterfacePPAPI()->DepthRangef(glGetCurrentContextPPAPI(), zNear, zFar);
 229 }
 230
 231 void GL_APIENTRY glDetachShader(GLuint program, GLuint shader) {
 232   glGetInterfacePPAPI()->DetachShader(glGetCurrentContextPPAPI(), program,
 233                                       shader);
 234 }
 235
 236 void GL_APIENTRY glDisable(GLenum cap) {
 237   glGetInterfacePPAPI()->Disable(glGetCurrentContextPPAPI(), cap);
 238 }
 239
 240 void GL_APIENTRY glDisableVertexAttribArray(GLuint index) {
 241   glGetInterfacePPAPI()->DisableVertexAttribArray(glGetCurrentContextPPAPI(),
 242                                                   index);
 243 }
 244
 245 void GL_APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count) {
 246   glGetInterfacePPAPI()->DrawArrays(glGetCurrentContextPPAPI(), mode, first,
 247                                     count);
 248 }
 249
 250 void GL_APIENTRY
 251 glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) {
 252   glGetInterfacePPAPI()->DrawElements(glGetCurrentContextPPAPI(), mode, count,
 253                                       type, indices);
 254 }
 255
 256 void GL_APIENTRY glEnable(GLenum cap) {
 257   glGetInterfacePPAPI()->Enable(glGetCurrentContextPPAPI(), cap);
 258 }
 259
 260 void GL_APIENTRY glEnableVertexAttribArray(GLuint index) {
 261   glGetInterfacePPAPI()->EnableVertexAttribArray(glGetCurrentContextPPAPI(),
 262                                                  index);
 263 }
 264
 265 void GL_APIENTRY glFinish() {
 266   glGetInterfacePPAPI()->Finish(glGetCurrentContextPPAPI());
 267 }
 268
 269 void GL_APIENTRY glFlush() {
 270   glGetInterfacePPAPI()->Flush(glGetCurrentContextPPAPI());
 271 }
 272
 273 void GL_APIENTRY glFramebufferRenderbuffer(GLenum target,
 274                                            GLenum attachment,
 275                                            GLenum renderbuffertarget,
 276                                            GLuint renderbuffer) {
 277   glGetInterfacePPAPI()->FramebufferRenderbuffer(
 278       glGetCurrentContextPPAPI(), target, attachment, renderbuffertarget,
 279       renderbuffer);
 280 }
 281
 282 void GL_APIENTRY glFramebufferTexture2D(GLenum target,
 283                                         GLenum attachment,
 284                                         GLenum textarget,
 285                                         GLuint texture,
 286                                         GLint level) {
 287   glGetInterfacePPAPI()->FramebufferTexture2D(glGetCurrentContextPPAPI(),
 288                                               target, attachment, textarget,
 289                                               texture, level);
 290 }
 291
 292 void GL_APIENTRY glFrontFace(GLenum mode) {
 293   glGetInterfacePPAPI()->FrontFace(glGetCurrentContextPPAPI(), mode);
 294 }
 295
 296 void GL_APIENTRY glGenBuffers(GLsizei n, GLuint* buffers) {
 297   glGetInterfacePPAPI()->GenBuffers(glGetCurrentContextPPAPI(), n, buffers);
 298 }
 299
 300 void GL_APIENTRY glGenerateMipmap(GLenum target) {
 301   glGetInterfacePPAPI()->GenerateMipmap(glGetCurrentContextPPAPI(), target);
 302 }
 303
 304 void GL_APIENTRY glGenFramebuffers(GLsizei n, GLuint* framebuffers) {
 305   glGetInterfacePPAPI()->GenFramebuffers(glGetCurrentContextPPAPI(), n,
 306                                          framebuffers);
 307 }
 308
 309 void GL_APIENTRY glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
 310   glGetInterfacePPAPI()->GenRenderbuffers(glGetCurrentContextPPAPI(), n,
 311                                           renderbuffers);
 312 }
 313
 314 void GL_APIENTRY glGenTextures(GLsizei n, GLuint* textures) {
 315   glGetInterfacePPAPI()->GenTextures(glGetCurrentContextPPAPI(), n, textures);
 316 }
 317
 318 void GL_APIENTRY glGetActiveAttrib(GLuint program,
 319                                    GLuint index,
 320                                    GLsizei bufsize,
 321                                    GLsizei* length,
 322                                    GLint* size,
 323                                    GLenum* type,
 324                                    char* name) {
 325   glGetInterfacePPAPI()->GetActiveAttrib(glGetCurrentContextPPAPI(), program,
 326                                          index, bufsize, length, size, type,
 327                                          name);
 328 }
 329
 330 void GL_APIENTRY glGetActiveUniform(GLuint program,
 331                                     GLuint index,
 332                                     GLsizei bufsize,
 333                                     GLsizei* length,
 334                                     GLint* size,
 335                                     GLenum* type,
 336                                     char* name) {
 337   glGetInterfacePPAPI()->GetActiveUniform(glGetCurrentContextPPAPI(), program,
 338                                           index, bufsize, length, size, type,
 339                                           name);
 340 }
 341
 342 void GL_APIENTRY glGetAttachedShaders(GLuint program,
 343                                       GLsizei maxcount,
 344                                       GLsizei* count,
 345                                       GLuint* shaders) {
 346   glGetInterfacePPAPI()->GetAttachedShaders(glGetCurrentContextPPAPI(), program,
 347                                             maxcount, count, shaders);
 348 }
 349
 350 GLint GL_APIENTRY glGetAttribLocation(GLuint program, const char* name) {
 351   return glGetInterfacePPAPI()->GetAttribLocation(glGetCurrentContextPPAPI(),
 352                                                   program, name);
 353 }
 354
 355 void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean* params) {
 356   glGetInterfacePPAPI()->GetBooleanv(glGetCurrentContextPPAPI(), pname, params);
 357 }
 358
 359 void GL_APIENTRY
 360 glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
 361   glGetInterfacePPAPI()->GetBufferParameteriv(glGetCurrentContextPPAPI(),
 362                                               target, pname, params);
 363 }
 364
 365 GLenum GL_APIENTRY glGetError() {
 366   return glGetInterfacePPAPI()->GetError(glGetCurrentContextPPAPI());
 367 }
 368
 369 void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat* params) {
 370   glGetInterfacePPAPI()->GetFloatv(glGetCurrentContextPPAPI(), pname, params);
 371 }
 372
 373 void GL_APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target,
 374                                                        GLenum attachment,
 375                                                        GLenum pname,
 376                                                        GLint* params) {
 377   glGetInterfacePPAPI()->GetFramebufferAttachmentParameteriv(
 378       glGetCurrentContextPPAPI(), target, attachment, pname, params);
 379 }
 380
 381 void GL_APIENTRY glGetIntegerv(GLenum pname, GLint* params) {
 382   glGetInterfacePPAPI()->GetIntegerv(glGetCurrentContextPPAPI(), pname, params);
 383 }
 384
 385 void GL_APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint* params) {
 386   glGetInterfacePPAPI()->GetProgramiv(glGetCurrentContextPPAPI(), program,
 387                                       pname, params);
 388 }
 389
 390 void GL_APIENTRY glGetProgramInfoLog(GLuint program,
 391                                      GLsizei bufsize,
 392                                      GLsizei* length,
 393                                      char* infolog) {
 394   glGetInterfacePPAPI()->GetProgramInfoLog(glGetCurrentContextPPAPI(), program,
 395                                            bufsize, length, infolog);
 396 }
 397
 398 void GL_APIENTRY
 399 glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) {
 400   glGetInterfacePPAPI()->GetRenderbufferParameteriv(glGetCurrentContextPPAPI(),
 401                                                     target, pname, params);
 402 }
 403
 404 void GL_APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint* params) {
 405   glGetInterfacePPAPI()->GetShaderiv(glGetCurrentContextPPAPI(), shader, pname,
 406                                      params);
 407 }
 408
 409 void GL_APIENTRY glGetShaderInfoLog(GLuint shader,
 410                                     GLsizei bufsize,
 411                                     GLsizei* length,
 412                                     char* infolog) {
 413   glGetInterfacePPAPI()->GetShaderInfoLog(glGetCurrentContextPPAPI(), shader,
 414                                           bufsize, length, infolog);
 415 }
 416
 417 void GL_APIENTRY glGetShaderPrecisionFormat(GLenum shadertype,
 418                                             GLenum precisiontype,
 419                                             GLint* range,
 420                                             GLint* precision) {
 421   glGetInterfacePPAPI()->GetShaderPrecisionFormat(
 422       glGetCurrentContextPPAPI(), shadertype, precisiontype, range, precision);
 423 }
 424
 425 void GL_APIENTRY glGetShaderSource(GLuint shader,
 426                                    GLsizei bufsize,
 427                                    GLsizei* length,
 428                                    char* source) {
 429   glGetInterfacePPAPI()->GetShaderSource(glGetCurrentContextPPAPI(), shader,
 430                                          bufsize, length, source);
 431 }
 432
 433 const GLubyte* GL_APIENTRY glGetString(GLenum name) {
 434   return glGetInterfacePPAPI()->GetString(glGetCurrentContextPPAPI(), name);
 435 }
 436
 437 void GL_APIENTRY
 438 glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
 439   glGetInterfacePPAPI()->GetTexParameterfv(glGetCurrentContextPPAPI(), target,
 440                                            pname, params);
 441 }
 442
 443 void GL_APIENTRY
 444 glGetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
 445   glGetInterfacePPAPI()->GetTexParameteriv(glGetCurrentContextPPAPI(), target,
 446                                            pname, params);
 447 }
 448
 449 void GL_APIENTRY
 450 glGetUniformfv(GLuint program, GLint location, GLfloat* params) {
 451   glGetInterfacePPAPI()->GetUniformfv(glGetCurrentContextPPAPI(), program,
 452                                       location, params);
 453 }
 454
 455 void GL_APIENTRY glGetUniformiv(GLuint program, GLint location, GLint* params) {
 456   glGetInterfacePPAPI()->GetUniformiv(glGetCurrentContextPPAPI(), program,
 457                                       location, params);
 458 }
 459
 460 GLint GL_APIENTRY glGetUniformLocation(GLuint program, const char* name) {
 461   return glGetInterfacePPAPI()->GetUniformLocation(glGetCurrentContextPPAPI(),
 462                                                    program, name);
 463 }
 464
 465 void GL_APIENTRY
 466 glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) {
 467   glGetInterfacePPAPI()->GetVertexAttribfv(glGetCurrentContextPPAPI(), index,
 468                                            pname, params);
 469 }
 470
 471 void GL_APIENTRY
 472 glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params) {
 473   glGetInterfacePPAPI()->GetVertexAttribiv(glGetCurrentContextPPAPI(), index,
 474                                            pname, params);
 475 }
 476
 477 void GL_APIENTRY
 478 glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) {
 479   glGetInterfacePPAPI()->GetVertexAttribPointerv(glGetCurrentContextPPAPI(),
 480                                                  index, pname, pointer);
 481 }
 482
 483 void GL_APIENTRY glHint(GLenum target, GLenum mode) {
 484   glGetInterfacePPAPI()->Hint(glGetCurrentContextPPAPI(), target, mode);
 485 }
 486
 487 GLboolean GL_APIENTRY glIsBuffer(GLuint buffer) {
 488   return glGetInterfacePPAPI()->IsBuffer(glGetCurrentContextPPAPI(), buffer);
 489 }
 490
 491 GLboolean GL_APIENTRY glIsEnabled(GLenum cap) {
 492   return glGetInterfacePPAPI()->IsEnabled(glGetCurrentContextPPAPI(), cap);
 493 }
 494
 495 GLboolean GL_APIENTRY glIsFramebuffer(GLuint framebuffer) {
 496   return glGetInterfacePPAPI()->IsFramebuffer(glGetCurrentContextPPAPI(),
 497                                               framebuffer);
 498 }
 499
 500 GLboolean GL_APIENTRY glIsProgram(GLuint program) {
 501   return glGetInterfacePPAPI()->IsProgram(glGetCurrentContextPPAPI(), program);
 502 }
 503
 504 GLboolean GL_APIENTRY glIsRenderbuffer(GLuint renderbuffer) {
 505   return glGetInterfacePPAPI()->IsRenderbuffer(glGetCurrentContextPPAPI(),
 506                                                renderbuffer);
 507 }
 508
 509 GLboolean GL_APIENTRY glIsShader(GLuint shader) {
 510   return glGetInterfacePPAPI()->IsShader(glGetCurrentContextPPAPI(), shader);
 511 }
 512
 513 GLboolean GL_APIENTRY glIsTexture(GLuint texture) {
 514   return glGetInterfacePPAPI()->IsTexture(glGetCurrentContextPPAPI(), texture);
 515 }
 516
 517 void GL_APIENTRY glLineWidth(GLfloat width) {
 518   glGetInterfacePPAPI()->LineWidth(glGetCurrentContextPPAPI(), width);
 519 }
 520
 521 void GL_APIENTRY glLinkProgram(GLuint program) {
 522   glGetInterfacePPAPI()->LinkProgram(glGetCurrentContextPPAPI(), program);
 523 }
 524
 525 void GL_APIENTRY glPixelStorei(GLenum pname, GLint param) {
 526   glGetInterfacePPAPI()->PixelStorei(glGetCurrentContextPPAPI(), pname, param);
 527 }
 528
 529 void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units) {
 530   glGetInterfacePPAPI()->PolygonOffset(glGetCurrentContextPPAPI(), factor,
 531                                        units);
 532 }
 533
 534 void GL_APIENTRY glReadPixels(GLint x,
 535                               GLint y,
 536                               GLsizei width,
 537                               GLsizei height,
 538                               GLenum format,
 539                               GLenum type,
 540                               void* pixels) {
 541   glGetInterfacePPAPI()->ReadPixels(glGetCurrentContextPPAPI(), x, y, width,
 542                                     height, format, type, pixels);
 543 }
 544
 545 void GL_APIENTRY glReleaseShaderCompiler() {
 546   glGetInterfacePPAPI()->ReleaseShaderCompiler(glGetCurrentContextPPAPI());
 547 }
 548
 549 void GL_APIENTRY glRenderbufferStorage(GLenum target,
 550                                        GLenum internalformat,
 551                                        GLsizei width,
 552                                        GLsizei height) {
 553   glGetInterfacePPAPI()->RenderbufferStorage(glGetCurrentContextPPAPI(), target,
 554                                              internalformat, width, height);
 555 }
 556
 557 void GL_APIENTRY glSampleCoverage(GLclampf value, GLboolean invert) {
 558   glGetInterfacePPAPI()->SampleCoverage(glGetCurrentContextPPAPI(), value,
 559                                         invert);
 560 }
 561
 562 void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 563   glGetInterfacePPAPI()->Scissor(glGetCurrentContextPPAPI(), x, y, width,
 564                                  height);
 565 }
 566
 567 void GL_APIENTRY glShaderBinary(GLsizei n,
 568                                 const GLuint* shaders,
 569                                 GLenum binaryformat,
 570                                 const void* binary,
 571                                 GLsizei length) {
 572   glGetInterfacePPAPI()->ShaderBinary(glGetCurrentContextPPAPI(), n, shaders,
 573                                       binaryformat, binary, length);
 574 }
 575
 576 void GL_APIENTRY glShaderSource(GLuint shader,
 577                                 GLsizei count,
 578                                 const char** str,
 579                                 const GLint* length) {
 580   glGetInterfacePPAPI()->ShaderSource(glGetCurrentContextPPAPI(), shader, count,
 581                                       str, length);
 582 }
 583
 584 void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask) {
 585   glGetInterfacePPAPI()->StencilFunc(glGetCurrentContextPPAPI(), func, ref,
 586                                      mask);
 587 }
 588
 589 void GL_APIENTRY
 590 glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
 591   glGetInterfacePPAPI()->StencilFuncSeparate(glGetCurrentContextPPAPI(), face,
 592                                              func, ref, mask);
 593 }
 594
 595 void GL_APIENTRY glStencilMask(GLuint mask) {
 596   glGetInterfacePPAPI()->StencilMask(glGetCurrentContextPPAPI(), mask);
 597 }
 598
 599 void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask) {
 600   glGetInterfacePPAPI()->StencilMaskSeparate(glGetCurrentContextPPAPI(), face,
 601                                              mask);
 602 }
 603
 604 void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 605   glGetInterfacePPAPI()->StencilOp(glGetCurrentContextPPAPI(), fail, zfail,
 606                                    zpass);
 607 }
 608
 609 void GL_APIENTRY
 610 glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
 611   glGetInterfacePPAPI()->StencilOpSeparate(glGetCurrentContextPPAPI(), face,
 612                                            fail, zfail, zpass);
 613 }
 614
 615 void GL_APIENTRY glTexImage2D(GLenum target,
 616                               GLint level,
 617                               GLint internalformat,
 618                               GLsizei width,
 619                               GLsizei height,
 620                               GLint border,
 621                               GLenum format,
 622                               GLenum type,
 623                               const void* pixels) {
 624   glGetInterfacePPAPI()->TexImage2D(glGetCurrentContextPPAPI(), target, level,
 625                                     internalformat, width, height, border,
 626                                     format, type, pixels);
 627 }
 628
 629 void GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
 630   glGetInterfacePPAPI()->TexParameterf(glGetCurrentContextPPAPI(), target,
 631                                        pname, param);
 632 }
 633
 634 void GL_APIENTRY
 635 glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params) {
 636   glGetInterfacePPAPI()->TexParameterfv(glGetCurrentContextPPAPI(), target,
 637                                         pname, params);
 638 }
 639
 640 void GL_APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param) {
 641   glGetInterfacePPAPI()->TexParameteri(glGetCurrentContextPPAPI(), target,
 642                                        pname, param);
 643 }
 644
 645 void GL_APIENTRY
 646 glTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
 647   glGetInterfacePPAPI()->TexParameteriv(glGetCurrentContextPPAPI(), target,
 648                                         pname, params);
 649 }
 650
 651 void GL_APIENTRY glTexSubImage2D(GLenum target,
 652                                  GLint level,
 653                                  GLint xoffset,
 654                                  GLint yoffset,
 655                                  GLsizei width,
 656                                  GLsizei height,
 657                                  GLenum format,
 658                                  GLenum type,
 659                                  const void* pixels) {
 660   glGetInterfacePPAPI()->TexSubImage2D(glGetCurrentContextPPAPI(), target,
 661                                        level, xoffset, yoffset, width, height,
 662                                        format, type, pixels);
 663 }
 664
 665 void GL_APIENTRY glUniform1f(GLint location, GLfloat x) {
 666   glGetInterfacePPAPI()->Uniform1f(glGetCurrentContextPPAPI(), location, x);
 667 }
 668
 669 void GL_APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat* v) {
 670   glGetInterfacePPAPI()->Uniform1fv(glGetCurrentContextPPAPI(), location, count,
 671                                     v);
 672 }
 673
 674 void GL_APIENTRY glUniform1i(GLint location, GLint x) {
 675   glGetInterfacePPAPI()->Uniform1i(glGetCurrentContextPPAPI(), location, x);
 676 }
 677
 678 void GL_APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint* v) {
 679   glGetInterfacePPAPI()->Uniform1iv(glGetCurrentContextPPAPI(), location, count,
 680                                     v);
 681 }
 682
 683 void GL_APIENTRY glUniform2f(GLint location, GLfloat x, GLfloat y) {
 684   glGetInterfacePPAPI()->Uniform2f(glGetCurrentContextPPAPI(), location, x, y);
 685 }
 686
 687 void GL_APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat* v) {
 688   glGetInterfacePPAPI()->Uniform2fv(glGetCurrentContextPPAPI(), location, count,
 689                                     v);
 690 }
 691
 692 void GL_APIENTRY glUniform2i(GLint location, GLint x, GLint y) {
 693   glGetInterfacePPAPI()->Uniform2i(glGetCurrentContextPPAPI(), location, x, y);
 694 }
 695
 696 void GL_APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint* v) {
 697   glGetInterfacePPAPI()->Uniform2iv(glGetCurrentContextPPAPI(), location, count,
 698                                     v);
 699 }
 700
 701 void GL_APIENTRY glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
 702   glGetInterfacePPAPI()->Uniform3f(glGetCurrentContextPPAPI(), location, x, y,
 703                                    z);
 704 }
 705
 706 void GL_APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat* v) {
 707   glGetInterfacePPAPI()->Uniform3fv(glGetCurrentContextPPAPI(), location, count,
 708                                     v);
 709 }
 710
 711 void GL_APIENTRY glUniform3i(GLint location, GLint x, GLint y, GLint z) {
 712   glGetInterfacePPAPI()->Uniform3i(glGetCurrentContextPPAPI(), location, x, y,
 713                                    z);
 714 }
 715
 716 void GL_APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint* v) {
 717   glGetInterfacePPAPI()->Uniform3iv(glGetCurrentContextPPAPI(), location, count,
 718                                     v);
 719 }
 720
 721 void GL_APIENTRY
 722 glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
 723   glGetInterfacePPAPI()->Uniform4f(glGetCurrentContextPPAPI(), location, x, y,
 724                                    z, w);
 725 }
 726
 727 void GL_APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat* v) {
 728   glGetInterfacePPAPI()->Uniform4fv(glGetCurrentContextPPAPI(), location, count,
 729                                     v);
 730 }
 731
 732 void GL_APIENTRY
 733 glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
 734   glGetInterfacePPAPI()->Uniform4i(glGetCurrentContextPPAPI(), location, x, y,
 735                                    z, w);
 736 }
 737
 738 void GL_APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint* v) {
 739   glGetInterfacePPAPI()->Uniform4iv(glGetCurrentContextPPAPI(), location, count,
 740                                     v);
 741 }
 742
 743 void GL_APIENTRY glUniformMatrix2fv(GLint location,
 744                                     GLsizei count,
 745                                     GLboolean transpose,
 746                                     const GLfloat* value) {
 747   glGetInterfacePPAPI()->UniformMatrix2fv(glGetCurrentContextPPAPI(), location,
 748                                           count, transpose, value);
 749 }
 750
 751 void GL_APIENTRY glUniformMatrix3fv(GLint location,
 752                                     GLsizei count,
 753                                     GLboolean transpose,
 754                                     const GLfloat* value) {
 755   glGetInterfacePPAPI()->UniformMatrix3fv(glGetCurrentContextPPAPI(), location,
 756                                           count, transpose, value);
 757 }
 758
 759 void GL_APIENTRY glUniformMatrix4fv(GLint location,
 760                                     GLsizei count,
 761                                     GLboolean transpose,
 762                                     const GLfloat* value) {
 763   glGetInterfacePPAPI()->UniformMatrix4fv(glGetCurrentContextPPAPI(), location,
 764                                           count, transpose, value);
 765 }
 766
 767 void GL_APIENTRY glUseProgram(GLuint program) {
 768   glGetInterfacePPAPI()->UseProgram(glGetCurrentContextPPAPI(), program);
 769 }
 770
 771 void GL_APIENTRY glValidateProgram(GLuint program) {
 772   glGetInterfacePPAPI()->ValidateProgram(glGetCurrentContextPPAPI(), program);
 773 }
 774
 775 void GL_APIENTRY glVertexAttrib1f(GLuint indx, GLfloat x) {
 776   glGetInterfacePPAPI()->VertexAttrib1f(glGetCurrentContextPPAPI(), indx, x);
 777 }
 778
 779 void GL_APIENTRY glVertexAttrib1fv(GLuint indx, const GLfloat* values) {
 780   glGetInterfacePPAPI()->VertexAttrib1fv(glGetCurrentContextPPAPI(), indx,
 781                                          values);
 782 }
 783
 784 void GL_APIENTRY glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
 785   glGetInterfacePPAPI()->VertexAttrib2f(glGetCurrentContextPPAPI(), indx, x, y);
 786 }
 787
 788 void GL_APIENTRY glVertexAttrib2fv(GLuint indx, const GLfloat* values) {
 789   glGetInterfacePPAPI()->VertexAttrib2fv(glGetCurrentContextPPAPI(), indx,
 790                                          values);
 791 }
 792
 793 void GL_APIENTRY
 794 glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
 795   glGetInterfacePPAPI()->VertexAttrib3f(glGetCurrentContextPPAPI(), indx, x, y,
 796                                         z);
 797 }
 798
 799 void GL_APIENTRY glVertexAttrib3fv(GLuint indx, const GLfloat* values) {
 800   glGetInterfacePPAPI()->VertexAttrib3fv(glGetCurrentContextPPAPI(), indx,
 801                                          values);
 802 }
 803
 804 void GL_APIENTRY
 805 glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
 806   glGetInterfacePPAPI()->VertexAttrib4f(glGetCurrentContextPPAPI(), indx, x, y,
 807                                         z, w);
 808 }
 809
 810 void GL_APIENTRY glVertexAttrib4fv(GLuint indx, const GLfloat* values) {
 811   glGetInterfacePPAPI()->VertexAttrib4fv(glGetCurrentContextPPAPI(), indx,
 812                                          values);
 813 }
 814
 815 void GL_APIENTRY glVertexAttribPointer(GLuint indx,
 816                                        GLint size,
 817                                        GLenum type,
 818                                        GLboolean normalized,
 819                                        GLsizei stride,
 820                                        const void* ptr) {
 821   glGetInterfacePPAPI()->VertexAttribPointer(
 822       glGetCurrentContextPPAPI(), indx, size, type, normalized, stride, ptr);
 823 }
 824
 825 void GL_APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
 826   glGetInterfacePPAPI()->Viewport(glGetCurrentContextPPAPI(), x, y, width,
 827                                   height);
 828 }
 829
 830 void GL_APIENTRY glBlitFramebufferEXT(GLint srcX0,
 831                                       GLint srcY0,
 832                                       GLint srcX1,
 833                                       GLint srcY1,
 834                                       GLint dstX0,
 835                                       GLint dstY0,
 836                                       GLint dstX1,
 837                                       GLint dstY1,
 838                                       GLbitfield mask,
 839                                       GLenum filter) {
 840   const struct PPB_OpenGLES2FramebufferBlit* ext =
 841       glGetFramebufferBlitInterfacePPAPI();
 842   if (ext)
 843     ext->BlitFramebufferEXT(glGetCurrentContextPPAPI(), srcX0, srcY0, srcX1,
 844                             srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 845 }
 846
 847 void GL_APIENTRY glRenderbufferStorageMultisampleEXT(GLenum target,
 848                                                      GLsizei samples,
 849                                                      GLenum internalformat,
 850                                                      GLsizei width,
 851                                                      GLsizei height) {
 852   const struct PPB_OpenGLES2FramebufferMultisample* ext =
 853       glGetFramebufferMultisampleInterfacePPAPI();
 854   if (ext)
 855     ext->RenderbufferStorageMultisampleEXT(glGetCurrentContextPPAPI(), target,
 856                                            samples, internalformat, width,
 857                                            height);
 858 }
 859
 860 void GL_APIENTRY glGenQueriesEXT(GLsizei n, GLuint* queries) {
 861   const struct PPB_OpenGLES2Query* ext = glGetQueryInterfacePPAPI();
 862   if (ext)
 863     ext->GenQueriesEXT(glGetCurrentContextPPAPI(), n, queries);
 864 }
 865
 866 void GL_APIENTRY glDeleteQueriesEXT(GLsizei n, const GLuint* queries) {
 867   const struct PPB_OpenGLES2Query* ext = glGetQueryInterfacePPAPI();
 868   if (ext)
 869     ext->DeleteQueriesEXT(glGetCurrentContextPPAPI(), n, queries);
 870 }
 871
 872 GLboolean GL_APIENTRY glIsQueryEXT(GLuint id) {
 873   const struct PPB_OpenGLES2Query* ext = glGetQueryInterfacePPAPI();
 874   if (ext)
 875     return ext->IsQueryEXT(glGetCurrentContextPPAPI(), id);
 876   return 0;
 877 }
 878
 879 void GL_APIENTRY glBeginQueryEXT(GLenum target, GLuint id) {
 880   const struct PPB_OpenGLES2Query* ext = glGetQueryInterfacePPAPI();
 881   if (ext)
 882     ext->BeginQueryEXT(glGetCurrentContextPPAPI(), target, id);
 883 }
 884
 885 void GL_APIENTRY glEndQueryEXT(GLenum target) {
 886   const struct PPB_OpenGLES2Query* ext = glGetQueryInterfacePPAPI();
 887   if (ext)
 888     ext->EndQueryEXT(glGetCurrentContextPPAPI(), target);
 889 }
 890
 891 void GL_APIENTRY glGetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
 892   const struct PPB_OpenGLES2Query* ext = glGetQueryInterfacePPAPI();
 893   if (ext)
 894     ext->GetQueryivEXT(glGetCurrentContextPPAPI(), target, pname, params);
 895 }
 896
 897 void GL_APIENTRY
 898 glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* params) {
 899   const struct PPB_OpenGLES2Query* ext = glGetQueryInterfacePPAPI();
 900   if (ext)
 901     ext->GetQueryObjectuivEXT(glGetCurrentContextPPAPI(), id, pname, params);
 902 }
 903
 904 void GL_APIENTRY glGenVertexArraysOES(GLsizei n, GLuint* arrays) {
 905   const struct PPB_OpenGLES2VertexArrayObject* ext =
 906       glGetVertexArrayObjectInterfacePPAPI();
 907   if (ext)
 908     ext->GenVertexArraysOES(glGetCurrentContextPPAPI(), n, arrays);
 909 }
 910
 911 void GL_APIENTRY glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
 912   const struct PPB_OpenGLES2VertexArrayObject* ext =
 913       glGetVertexArrayObjectInterfacePPAPI();
 914   if (ext)
 915     ext->DeleteVertexArraysOES(glGetCurrentContextPPAPI(), n, arrays);
 916 }
 917
 918 GLboolean GL_APIENTRY glIsVertexArrayOES(GLuint array) {
 919   const struct PPB_OpenGLES2VertexArrayObject* ext =
 920       glGetVertexArrayObjectInterfacePPAPI();
 921   if (ext)
 922     return ext->IsVertexArrayOES(glGetCurrentContextPPAPI(), array);
 923   return 0;
 924 }
 925
 926 void GL_APIENTRY glBindVertexArrayOES(GLuint array) {
 927   const struct PPB_OpenGLES2VertexArrayObject* ext =
 928       glGetVertexArrayObjectInterfacePPAPI();
 929   if (ext)
 930     ext->BindVertexArrayOES(glGetCurrentContextPPAPI(), array);
 931 }
 932
 933 GLboolean GL_APIENTRY glEnableFeatureCHROMIUM(const char* feature) {
 934   const struct PPB_OpenGLES2ChromiumEnableFeature* ext =
 935       glGetChromiumEnableFeatureInterfacePPAPI();
 936   if (ext)
 937     return ext->EnableFeatureCHROMIUM(glGetCurrentContextPPAPI(), feature);
 938   return 0;
 939 }
 940
 941 void* GL_APIENTRY glMapBufferSubDataCHROMIUM(GLuint target,
 942                                              GLintptr offset,
 943                                              GLsizeiptr size,
 944                                              GLenum access) {
 945   const struct PPB_OpenGLES2ChromiumMapSub* ext =
 946       glGetChromiumMapSubInterfacePPAPI();
 947   if (ext)
 948     return ext->MapBufferSubDataCHROMIUM(glGetCurrentContextPPAPI(), target,
 949                                          offset, size, access);
 950   return 0;
 951 }
 952
 953 void GL_APIENTRY glUnmapBufferSubDataCHROMIUM(const void* mem) {
 954   const struct PPB_OpenGLES2ChromiumMapSub* ext =
 955       glGetChromiumMapSubInterfacePPAPI();
 956   if (ext)
 957     ext->UnmapBufferSubDataCHROMIUM(glGetCurrentContextPPAPI(), mem);
 958 }
 959
 960 void* GL_APIENTRY glMapTexSubImage2DCHROMIUM(GLenum target,
 961                                              GLint level,
 962                                              GLint xoffset,
 963                                              GLint yoffset,
 964                                              GLsizei width,
 965                                              GLsizei height,
 966                                              GLenum format,
 967                                              GLenum type,
 968                                              GLenum access) {
 969   const struct PPB_OpenGLES2ChromiumMapSub* ext =
 970       glGetChromiumMapSubInterfacePPAPI();
 971   if (ext)
 972     return ext->MapTexSubImage2DCHROMIUM(glGetCurrentContextPPAPI(), target,
 973                                          level, xoffset, yoffset, width, height,
 974                                          format, type, access);
 975   return 0;
 976 }
 977
 978 void GL_APIENTRY glUnmapTexSubImage2DCHROMIUM(const void* mem) {
 979   const struct PPB_OpenGLES2ChromiumMapSub* ext =
 980       glGetChromiumMapSubInterfacePPAPI();
 981   if (ext)
 982     ext->UnmapTexSubImage2DCHROMIUM(glGetCurrentContextPPAPI(), mem);
 983 }
 984
 985 void GL_APIENTRY glDrawArraysInstancedANGLE(GLenum mode,
 986                                             GLint first,
 987                                             GLsizei count,
 988                                             GLsizei primcount) {
 989   const struct PPB_OpenGLES2InstancedArrays* ext =
 990       glGetInstancedArraysInterfacePPAPI();
 991   if (ext)
 992     ext->DrawArraysInstancedANGLE(glGetCurrentContextPPAPI(), mode, first,
 993                                   count, primcount);
 994 }
 995
 996 void GL_APIENTRY glDrawElementsInstancedANGLE(GLenum mode,
 997                                               GLsizei count,
 998                                               GLenum type,
 999                                               const void* indices,
1000                                               GLsizei primcount) {
1001   const struct PPB_OpenGLES2InstancedArrays* ext =
1002       glGetInstancedArraysInterfacePPAPI();
1003   if (ext)
1004     ext->DrawElementsInstancedANGLE(glGetCurrentContextPPAPI(), mode, count,
1005                                     type, indices, primcount);
1006 }
1007
1008 void GL_APIENTRY glVertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1009   const struct PPB_OpenGLES2InstancedArrays* ext =
1010       glGetInstancedArraysInterfacePPAPI();
1011   if (ext)
1012     ext->VertexAttribDivisorANGLE(glGetCurrentContextPPAPI(), index, divisor);
1013 }
1014
1015 void GL_APIENTRY glDrawBuffersEXT(GLsizei count, const GLenum* bufs) {
1016   const struct PPB_OpenGLES2DrawBuffers_Dev* ext =
1017       glGetDrawBuffersInterfacePPAPI();
1018   if (ext)
1019     ext->DrawBuffersEXT(glGetCurrentContextPPAPI(), count, bufs);
1020 }