| OLD | NEW |
|---|
| (Empty) |
| 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 #include "base/logging.h" | |
| 6 #include "mojo/examples/pepper_container_app/graphics_3d_resource.h" | |
| 7 #include "mojo/examples/pepper_container_app/thunk.h" | |
| 8 #include "mojo/public/c/gles2/gles2.h" | |
| 9 #include "ppapi/thunk/enter.h" | |
| 10 #include "ppapi/thunk/ppb_graphics_3d_api.h" | |
| 11 | |
| 12 namespace mojo { | |
| 13 namespace examples { | |
| 14 | |
| 15 namespace { | |
| 16 | |
| 17 typedef ppapi::thunk::EnterResource<ppapi::thunk::PPB_Graphics3D_API> Enter3D; | |
| 18 | |
| 19 bool IsBoundGraphics(Enter3D* enter) { | |
| 20 return enter->succeeded() && | |
| 21 static_cast<Graphics3DResource*>(enter->object())->IsBoundGraphics(); | |
| 22 } | |
| 23 | |
| 24 void ActiveTexture(PP_Resource context_id, GLenum texture) { | |
| 25 Enter3D enter(context_id, true); | |
| 26 if (IsBoundGraphics(&enter)) { | |
| 27 glActiveTexture(texture); | |
| 28 } | |
| 29 } | |
| 30 | |
| 31 void AttachShader(PP_Resource context_id, GLuint program, GLuint shader) { | |
| 32 Enter3D enter(context_id, true); | |
| 33 if (IsBoundGraphics(&enter)) { | |
| 34 glAttachShader(program, shader); | |
| 35 } | |
| 36 } | |
| 37 | |
| 38 void BindAttribLocation(PP_Resource context_id, | |
| 39 GLuint program, | |
| 40 GLuint index, | |
| 41 const char* name) { | |
| 42 Enter3D enter(context_id, true); | |
| 43 if (IsBoundGraphics(&enter)) { | |
| 44 glBindAttribLocation(program, index, name); | |
| 45 } | |
| 46 } | |
| 47 | |
| 48 void BindBuffer(PP_Resource context_id, GLenum target, GLuint buffer) { | |
| 49 Enter3D enter(context_id, true); | |
| 50 if (IsBoundGraphics(&enter)) { | |
| 51 glBindBuffer(target, buffer); | |
| 52 } | |
| 53 } | |
| 54 | |
| 55 void BindFramebuffer(PP_Resource context_id, | |
| 56 GLenum target, | |
| 57 GLuint framebuffer) { | |
| 58 Enter3D enter(context_id, true); | |
| 59 if (IsBoundGraphics(&enter)) { | |
| 60 glBindFramebuffer(target, framebuffer); | |
| 61 } | |
| 62 } | |
| 63 | |
| 64 void BindRenderbuffer(PP_Resource context_id, | |
| 65 GLenum target, | |
| 66 GLuint renderbuffer) { | |
| 67 Enter3D enter(context_id, true); | |
| 68 if (IsBoundGraphics(&enter)) { | |
| 69 glBindRenderbuffer(target, renderbuffer); | |
| 70 } | |
| 71 } | |
| 72 | |
| 73 void BindTexture(PP_Resource context_id, GLenum target, GLuint texture) { | |
| 74 Enter3D enter(context_id, true); | |
| 75 if (IsBoundGraphics(&enter)) { | |
| 76 glBindTexture(target, texture); | |
| 77 } | |
| 78 } | |
| 79 | |
| 80 void BlendColor(PP_Resource context_id, | |
| 81 GLclampf red, | |
| 82 GLclampf green, | |
| 83 GLclampf blue, | |
| 84 GLclampf alpha) { | |
| 85 Enter3D enter(context_id, true); | |
| 86 if (IsBoundGraphics(&enter)) { | |
| 87 glBlendColor(red, green, blue, alpha); | |
| 88 } | |
| 89 } | |
| 90 | |
| 91 void BlendEquation(PP_Resource context_id, GLenum mode) { | |
| 92 Enter3D enter(context_id, true); | |
| 93 if (IsBoundGraphics(&enter)) { | |
| 94 glBlendEquation(mode); | |
| 95 } | |
| 96 } | |
| 97 | |
| 98 void BlendEquationSeparate(PP_Resource context_id, | |
| 99 GLenum modeRGB, | |
| 100 GLenum modeAlpha) { | |
| 101 Enter3D enter(context_id, true); | |
| 102 if (IsBoundGraphics(&enter)) { | |
| 103 glBlendEquationSeparate(modeRGB, modeAlpha); | |
| 104 } | |
| 105 } | |
| 106 | |
| 107 void BlendFunc(PP_Resource context_id, GLenum sfactor, GLenum dfactor) { | |
| 108 Enter3D enter(context_id, true); | |
| 109 if (IsBoundGraphics(&enter)) { | |
| 110 glBlendFunc(sfactor, dfactor); | |
| 111 } | |
| 112 } | |
| 113 | |
| 114 void BlendFuncSeparate(PP_Resource context_id, | |
| 115 GLenum srcRGB, | |
| 116 GLenum dstRGB, | |
| 117 GLenum srcAlpha, | |
| 118 GLenum dstAlpha) { | |
| 119 Enter3D enter(context_id, true); | |
| 120 if (IsBoundGraphics(&enter)) { | |
| 121 glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); | |
| 122 } | |
| 123 } | |
| 124 | |
| 125 void BufferData(PP_Resource context_id, | |
| 126 GLenum target, | |
| 127 GLsizeiptr size, | |
| 128 const void* data, | |
| 129 GLenum usage) { | |
| 130 Enter3D enter(context_id, true); | |
| 131 if (IsBoundGraphics(&enter)) { | |
| 132 glBufferData(target, size, data, usage); | |
| 133 } | |
| 134 } | |
| 135 | |
| 136 void BufferSubData(PP_Resource context_id, | |
| 137 GLenum target, | |
| 138 GLintptr offset, | |
| 139 GLsizeiptr size, | |
| 140 const void* data) { | |
| 141 Enter3D enter(context_id, true); | |
| 142 if (IsBoundGraphics(&enter)) { | |
| 143 glBufferSubData(target, offset, size, data); | |
| 144 } | |
| 145 } | |
| 146 | |
| 147 GLenum CheckFramebufferStatus(PP_Resource context_id, GLenum target) { | |
| 148 Enter3D enter(context_id, true); | |
| 149 if (IsBoundGraphics(&enter)) { | |
| 150 return glCheckFramebufferStatus(target); | |
| 151 } else { | |
| 152 return 0; | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 void Clear(PP_Resource context_id, GLbitfield mask) { | |
| 157 Enter3D enter(context_id, true); | |
| 158 if (IsBoundGraphics(&enter)) { | |
| 159 glClear(mask); | |
| 160 } | |
| 161 } | |
| 162 | |
| 163 void ClearColor(PP_Resource context_id, | |
| 164 GLclampf red, | |
| 165 GLclampf green, | |
| 166 GLclampf blue, | |
| 167 GLclampf alpha) { | |
| 168 Enter3D enter(context_id, true); | |
| 169 if (IsBoundGraphics(&enter)) { | |
| 170 glClearColor(red, green, blue, alpha); | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 void ClearDepthf(PP_Resource context_id, GLclampf depth) { | |
| 175 Enter3D enter(context_id, true); | |
| 176 if (IsBoundGraphics(&enter)) { | |
| 177 glClearDepthf(depth); | |
| 178 } | |
| 179 } | |
| 180 | |
| 181 void ClearStencil(PP_Resource context_id, GLint s) { | |
| 182 Enter3D enter(context_id, true); | |
| 183 if (IsBoundGraphics(&enter)) { | |
| 184 glClearStencil(s); | |
| 185 } | |
| 186 } | |
| 187 | |
| 188 void ColorMask(PP_Resource context_id, | |
| 189 GLboolean red, | |
| 190 GLboolean green, | |
| 191 GLboolean blue, | |
| 192 GLboolean alpha) { | |
| 193 Enter3D enter(context_id, true); | |
| 194 if (IsBoundGraphics(&enter)) { | |
| 195 glColorMask(red, green, blue, alpha); | |
| 196 } | |
| 197 } | |
| 198 | |
| 199 void CompileShader(PP_Resource context_id, GLuint shader) { | |
| 200 Enter3D enter(context_id, true); | |
| 201 if (IsBoundGraphics(&enter)) { | |
| 202 glCompileShader(shader); | |
| 203 } | |
| 204 } | |
| 205 | |
| 206 void CompressedTexImage2D(PP_Resource context_id, | |
| 207 GLenum target, | |
| 208 GLint level, | |
| 209 GLenum internalformat, | |
| 210 GLsizei width, | |
| 211 GLsizei height, | |
| 212 GLint border, | |
| 213 GLsizei imageSize, | |
| 214 const void* data) { | |
| 215 Enter3D enter(context_id, true); | |
| 216 if (IsBoundGraphics(&enter)) { | |
| 217 glCompressedTexImage2D( | |
| 218 target, level, internalformat, width, height, border, imageSize, data); | |
| 219 } | |
| 220 } | |
| 221 | |
| 222 void CompressedTexSubImage2D(PP_Resource context_id, | |
| 223 GLenum target, | |
| 224 GLint level, | |
| 225 GLint xoffset, | |
| 226 GLint yoffset, | |
| 227 GLsizei width, | |
| 228 GLsizei height, | |
| 229 GLenum format, | |
| 230 GLsizei imageSize, | |
| 231 const void* data) { | |
| 232 Enter3D enter(context_id, true); | |
| 233 if (IsBoundGraphics(&enter)) { | |
| 234 glCompressedTexSubImage2D(target, | |
| 235 level, | |
| 236 xoffset, | |
| 237 yoffset, | |
| 238 width, | |
| 239 height, | |
| 240 format, | |
| 241 imageSize, | |
| 242 data); | |
| 243 } | |
| 244 } | |
| 245 | |
| 246 void CopyTexImage2D(PP_Resource context_id, | |
| 247 GLenum target, | |
| 248 GLint level, | |
| 249 GLenum internalformat, | |
| 250 GLint x, | |
| 251 GLint y, | |
| 252 GLsizei width, | |
| 253 GLsizei height, | |
| 254 GLint border) { | |
| 255 Enter3D enter(context_id, true); | |
| 256 if (IsBoundGraphics(&enter)) { | |
| 257 glCopyTexImage2D( | |
| 258 target, level, internalformat, x, y, width, height, border); | |
| 259 } | |
| 260 } | |
| 261 | |
| 262 void CopyTexSubImage2D(PP_Resource context_id, | |
| 263 GLenum target, | |
| 264 GLint level, | |
| 265 GLint xoffset, | |
| 266 GLint yoffset, | |
| 267 GLint x, | |
| 268 GLint y, | |
| 269 GLsizei width, | |
| 270 GLsizei height) { | |
| 271 Enter3D enter(context_id, true); | |
| 272 if (IsBoundGraphics(&enter)) { | |
| 273 glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); | |
| 274 } | |
| 275 } | |
| 276 | |
| 277 GLuint CreateProgram(PP_Resource context_id) { | |
| 278 Enter3D enter(context_id, true); | |
| 279 if (IsBoundGraphics(&enter)) { | |
| 280 return glCreateProgram(); | |
| 281 } else { | |
| 282 return 0; | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 GLuint CreateShader(PP_Resource context_id, GLenum type) { | |
| 287 Enter3D enter(context_id, true); | |
| 288 if (IsBoundGraphics(&enter)) { | |
| 289 return glCreateShader(type); | |
| 290 } else { | |
| 291 return 0; | |
| 292 } | |
| 293 } | |
| 294 | |
| 295 void CullFace(PP_Resource context_id, GLenum mode) { | |
| 296 Enter3D enter(context_id, true); | |
| 297 if (IsBoundGraphics(&enter)) { | |
| 298 glCullFace(mode); | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 void DeleteBuffers(PP_Resource context_id, GLsizei n, const GLuint* buffers) { | |
| 303 Enter3D enter(context_id, true); | |
| 304 if (IsBoundGraphics(&enter)) { | |
| 305 glDeleteBuffers(n, buffers); | |
| 306 } | |
| 307 } | |
| 308 | |
| 309 void DeleteFramebuffers(PP_Resource context_id, | |
| 310 GLsizei n, | |
| 311 const GLuint* framebuffers) { | |
| 312 Enter3D enter(context_id, true); | |
| 313 if (IsBoundGraphics(&enter)) { | |
| 314 glDeleteFramebuffers(n, framebuffers); | |
| 315 } | |
| 316 } | |
| 317 | |
| 318 void DeleteProgram(PP_Resource context_id, GLuint program) { | |
| 319 Enter3D enter(context_id, true); | |
| 320 if (IsBoundGraphics(&enter)) { | |
| 321 glDeleteProgram(program); | |
| 322 } | |
| 323 } | |
| 324 | |
| 325 void DeleteRenderbuffers(PP_Resource context_id, | |
| 326 GLsizei n, | |
| 327 const GLuint* renderbuffers) { | |
| 328 Enter3D enter(context_id, true); | |
| 329 if (IsBoundGraphics(&enter)) { | |
| 330 glDeleteRenderbuffers(n, renderbuffers); | |
| 331 } | |
| 332 } | |
| 333 | |
| 334 void DeleteShader(PP_Resource context_id, GLuint shader) { | |
| 335 Enter3D enter(context_id, true); | |
| 336 if (IsBoundGraphics(&enter)) { | |
| 337 glDeleteShader(shader); | |
| 338 } | |
| 339 } | |
| 340 | |
| 341 void DeleteTextures(PP_Resource context_id, GLsizei n, const GLuint* textures) { | |
| 342 Enter3D enter(context_id, true); | |
| 343 if (IsBoundGraphics(&enter)) { | |
| 344 glDeleteTextures(n, textures); | |
| 345 } | |
| 346 } | |
| 347 | |
| 348 void DepthFunc(PP_Resource context_id, GLenum func) { | |
| 349 Enter3D enter(context_id, true); | |
| 350 if (IsBoundGraphics(&enter)) { | |
| 351 glDepthFunc(func); | |
| 352 } | |
| 353 } | |
| 354 | |
| 355 void DepthMask(PP_Resource context_id, GLboolean flag) { | |
| 356 Enter3D enter(context_id, true); | |
| 357 if (IsBoundGraphics(&enter)) { | |
| 358 glDepthMask(flag); | |
| 359 } | |
| 360 } | |
| 361 | |
| 362 void DepthRangef(PP_Resource context_id, GLclampf zNear, GLclampf zFar) { | |
| 363 Enter3D enter(context_id, true); | |
| 364 if (IsBoundGraphics(&enter)) { | |
| 365 glDepthRangef(zNear, zFar); | |
| 366 } | |
| 367 } | |
| 368 | |
| 369 void DetachShader(PP_Resource context_id, GLuint program, GLuint shader) { | |
| 370 Enter3D enter(context_id, true); | |
| 371 if (IsBoundGraphics(&enter)) { | |
| 372 glDetachShader(program, shader); | |
| 373 } | |
| 374 } | |
| 375 | |
| 376 void Disable(PP_Resource context_id, GLenum cap) { | |
| 377 Enter3D enter(context_id, true); | |
| 378 if (IsBoundGraphics(&enter)) { | |
| 379 glDisable(cap); | |
| 380 } | |
| 381 } | |
| 382 | |
| 383 void DisableVertexAttribArray(PP_Resource context_id, GLuint index) { | |
| 384 Enter3D enter(context_id, true); | |
| 385 if (IsBoundGraphics(&enter)) { | |
| 386 glDisableVertexAttribArray(index); | |
| 387 } | |
| 388 } | |
| 389 | |
| 390 void DrawArrays(PP_Resource context_id, | |
| 391 GLenum mode, | |
| 392 GLint first, | |
| 393 GLsizei count) { | |
| 394 Enter3D enter(context_id, true); | |
| 395 if (IsBoundGraphics(&enter)) { | |
| 396 glDrawArrays(mode, first, count); | |
| 397 } | |
| 398 } | |
| 399 | |
| 400 void DrawElements(PP_Resource context_id, | |
| 401 GLenum mode, | |
| 402 GLsizei count, | |
| 403 GLenum type, | |
| 404 const void* indices) { | |
| 405 Enter3D enter(context_id, true); | |
| 406 if (IsBoundGraphics(&enter)) { | |
| 407 glDrawElements(mode, count, type, indices); | |
| 408 } | |
| 409 } | |
| 410 | |
| 411 void Enable(PP_Resource context_id, GLenum cap) { | |
| 412 Enter3D enter(context_id, true); | |
| 413 if (IsBoundGraphics(&enter)) { | |
| 414 glEnable(cap); | |
| 415 } | |
| 416 } | |
| 417 | |
| 418 void EnableVertexAttribArray(PP_Resource context_id, GLuint index) { | |
| 419 Enter3D enter(context_id, true); | |
| 420 if (IsBoundGraphics(&enter)) { | |
| 421 glEnableVertexAttribArray(index); | |
| 422 } | |
| 423 } | |
| 424 | |
| 425 void Finish(PP_Resource context_id) { | |
| 426 Enter3D enter(context_id, true); | |
| 427 if (IsBoundGraphics(&enter)) { | |
| 428 glFinish(); | |
| 429 } | |
| 430 } | |
| 431 | |
| 432 void Flush(PP_Resource context_id) { | |
| 433 Enter3D enter(context_id, true); | |
| 434 if (IsBoundGraphics(&enter)) { | |
| 435 glFlush(); | |
| 436 } | |
| 437 } | |
| 438 | |
| 439 void FramebufferRenderbuffer(PP_Resource context_id, | |
| 440 GLenum target, | |
| 441 GLenum attachment, | |
| 442 GLenum renderbuffertarget, | |
| 443 GLuint renderbuffer) { | |
| 444 Enter3D enter(context_id, true); | |
| 445 if (IsBoundGraphics(&enter)) { | |
| 446 glFramebufferRenderbuffer( | |
| 447 target, attachment, renderbuffertarget, renderbuffer); | |
| 448 } | |
| 449 } | |
| 450 | |
| 451 void FramebufferTexture2D(PP_Resource context_id, | |
| 452 GLenum target, | |
| 453 GLenum attachment, | |
| 454 GLenum textarget, | |
| 455 GLuint texture, | |
| 456 GLint level) { | |
| 457 Enter3D enter(context_id, true); | |
| 458 if (IsBoundGraphics(&enter)) { | |
| 459 glFramebufferTexture2D(target, attachment, textarget, texture, level); | |
| 460 } | |
| 461 } | |
| 462 | |
| 463 void FrontFace(PP_Resource context_id, GLenum mode) { | |
| 464 Enter3D enter(context_id, true); | |
| 465 if (IsBoundGraphics(&enter)) { | |
| 466 glFrontFace(mode); | |
| 467 } | |
| 468 } | |
| 469 | |
| 470 void GenBuffers(PP_Resource context_id, GLsizei n, GLuint* buffers) { | |
| 471 Enter3D enter(context_id, true); | |
| 472 if (IsBoundGraphics(&enter)) { | |
| 473 glGenBuffers(n, buffers); | |
| 474 } | |
| 475 } | |
| 476 | |
| 477 void GenerateMipmap(PP_Resource context_id, GLenum target) { | |
| 478 Enter3D enter(context_id, true); | |
| 479 if (IsBoundGraphics(&enter)) { | |
| 480 glGenerateMipmap(target); | |
| 481 } | |
| 482 } | |
| 483 | |
| 484 void GenFramebuffers(PP_Resource context_id, GLsizei n, GLuint* framebuffers) { | |
| 485 Enter3D enter(context_id, true); | |
| 486 if (IsBoundGraphics(&enter)) { | |
| 487 glGenFramebuffers(n, framebuffers); | |
| 488 } | |
| 489 } | |
| 490 | |
| 491 void GenRenderbuffers(PP_Resource context_id, | |
| 492 GLsizei n, | |
| 493 GLuint* renderbuffers) { | |
| 494 Enter3D enter(context_id, true); | |
| 495 if (IsBoundGraphics(&enter)) { | |
| 496 glGenRenderbuffers(n, renderbuffers); | |
| 497 } | |
| 498 } | |
| 499 | |
| 500 void GenTextures(PP_Resource context_id, GLsizei n, GLuint* textures) { | |
| 501 Enter3D enter(context_id, true); | |
| 502 if (IsBoundGraphics(&enter)) { | |
| 503 glGenTextures(n, textures); | |
| 504 } | |
| 505 } | |
| 506 | |
| 507 void GetActiveAttrib(PP_Resource context_id, | |
| 508 GLuint program, | |
| 509 GLuint index, | |
| 510 GLsizei bufsize, | |
| 511 GLsizei* length, | |
| 512 GLint* size, | |
| 513 GLenum* type, | |
| 514 char* name) { | |
| 515 Enter3D enter(context_id, true); | |
| 516 if (IsBoundGraphics(&enter)) { | |
| 517 glGetActiveAttrib(program, index, bufsize, length, size, type, name); | |
| 518 } | |
| 519 } | |
| 520 | |
| 521 void GetActiveUniform(PP_Resource context_id, | |
| 522 GLuint program, | |
| 523 GLuint index, | |
| 524 GLsizei bufsize, | |
| 525 GLsizei* length, | |
| 526 GLint* size, | |
| 527 GLenum* type, | |
| 528 char* name) { | |
| 529 Enter3D enter(context_id, true); | |
| 530 if (IsBoundGraphics(&enter)) { | |
| 531 glGetActiveUniform(program, index, bufsize, length, size, type, name); | |
| 532 } | |
| 533 } | |
| 534 | |
| 535 void GetAttachedShaders(PP_Resource context_id, | |
| 536 GLuint program, | |
| 537 GLsizei maxcount, | |
| 538 GLsizei* count, | |
| 539 GLuint* shaders) { | |
| 540 Enter3D enter(context_id, true); | |
| 541 if (IsBoundGraphics(&enter)) { | |
| 542 glGetAttachedShaders(program, maxcount, count, shaders); | |
| 543 } | |
| 544 } | |
| 545 | |
| 546 GLint GetAttribLocation(PP_Resource context_id, | |
| 547 GLuint program, | |
| 548 const char* name) { | |
| 549 Enter3D enter(context_id, true); | |
| 550 if (IsBoundGraphics(&enter)) { | |
| 551 return glGetAttribLocation(program, name); | |
| 552 } else { | |
| 553 return -1; | |
| 554 } | |
| 555 } | |
| 556 | |
| 557 void GetBooleanv(PP_Resource context_id, GLenum pname, GLboolean* params) { | |
| 558 Enter3D enter(context_id, true); | |
| 559 if (IsBoundGraphics(&enter)) { | |
| 560 glGetBooleanv(pname, params); | |
| 561 } | |
| 562 } | |
| 563 | |
| 564 void GetBufferParameteriv(PP_Resource context_id, | |
| 565 GLenum target, | |
| 566 GLenum pname, | |
| 567 GLint* params) { | |
| 568 Enter3D enter(context_id, true); | |
| 569 if (IsBoundGraphics(&enter)) { | |
| 570 glGetBufferParameteriv(target, pname, params); | |
| 571 } | |
| 572 } | |
| 573 | |
| 574 GLenum GetError(PP_Resource context_id) { | |
| 575 Enter3D enter(context_id, true); | |
| 576 if (IsBoundGraphics(&enter)) { | |
| 577 return glGetError(); | |
| 578 } else { | |
| 579 return 0; | |
| 580 } | |
| 581 } | |
| 582 | |
| 583 void GetFloatv(PP_Resource context_id, GLenum pname, GLfloat* params) { | |
| 584 Enter3D enter(context_id, true); | |
| 585 if (IsBoundGraphics(&enter)) { | |
| 586 glGetFloatv(pname, params); | |
| 587 } | |
| 588 } | |
| 589 | |
| 590 void GetFramebufferAttachmentParameteriv(PP_Resource context_id, | |
| 591 GLenum target, | |
| 592 GLenum attachment, | |
| 593 GLenum pname, | |
| 594 GLint* params) { | |
| 595 Enter3D enter(context_id, true); | |
| 596 if (IsBoundGraphics(&enter)) { | |
| 597 glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); | |
| 598 } | |
| 599 } | |
| 600 | |
| 601 void GetIntegerv(PP_Resource context_id, GLenum pname, GLint* params) { | |
| 602 Enter3D enter(context_id, true); | |
| 603 if (IsBoundGraphics(&enter)) { | |
| 604 glGetIntegerv(pname, params); | |
| 605 } | |
| 606 } | |
| 607 | |
| 608 void GetProgramiv(PP_Resource context_id, | |
| 609 GLuint program, | |
| 610 GLenum pname, | |
| 611 GLint* params) { | |
| 612 Enter3D enter(context_id, true); | |
| 613 if (IsBoundGraphics(&enter)) { | |
| 614 glGetProgramiv(program, pname, params); | |
| 615 } | |
| 616 } | |
| 617 | |
| 618 void GetProgramInfoLog(PP_Resource context_id, | |
| 619 GLuint program, | |
| 620 GLsizei bufsize, | |
| 621 GLsizei* length, | |
| 622 char* infolog) { | |
| 623 Enter3D enter(context_id, true); | |
| 624 if (IsBoundGraphics(&enter)) { | |
| 625 glGetProgramInfoLog(program, bufsize, length, infolog); | |
| 626 } | |
| 627 } | |
| 628 | |
| 629 void GetRenderbufferParameteriv(PP_Resource context_id, | |
| 630 GLenum target, | |
| 631 GLenum pname, | |
| 632 GLint* params) { | |
| 633 Enter3D enter(context_id, true); | |
| 634 if (IsBoundGraphics(&enter)) { | |
| 635 glGetRenderbufferParameteriv(target, pname, params); | |
| 636 } | |
| 637 } | |
| 638 | |
| 639 void GetShaderiv(PP_Resource context_id, | |
| 640 GLuint shader, | |
| 641 GLenum pname, | |
| 642 GLint* params) { | |
| 643 Enter3D enter(context_id, true); | |
| 644 if (IsBoundGraphics(&enter)) { | |
| 645 glGetShaderiv(shader, pname, params); | |
| 646 } | |
| 647 } | |
| 648 | |
| 649 void GetShaderInfoLog(PP_Resource context_id, | |
| 650 GLuint shader, | |
| 651 GLsizei bufsize, | |
| 652 GLsizei* length, | |
| 653 char* infolog) { | |
| 654 Enter3D enter(context_id, true); | |
| 655 if (IsBoundGraphics(&enter)) { | |
| 656 glGetShaderInfoLog(shader, bufsize, length, infolog); | |
| 657 } | |
| 658 } | |
| 659 | |
| 660 void GetShaderPrecisionFormat(PP_Resource context_id, | |
| 661 GLenum shadertype, | |
| 662 GLenum precisiontype, | |
| 663 GLint* range, | |
| 664 GLint* precision) { | |
| 665 Enter3D enter(context_id, true); | |
| 666 if (IsBoundGraphics(&enter)) { | |
| 667 glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); | |
| 668 } | |
| 669 } | |
| 670 | |
| 671 void GetShaderSource(PP_Resource context_id, | |
| 672 GLuint shader, | |
| 673 GLsizei bufsize, | |
| 674 GLsizei* length, | |
| 675 char* source) { | |
| 676 Enter3D enter(context_id, true); | |
| 677 if (IsBoundGraphics(&enter)) { | |
| 678 glGetShaderSource(shader, bufsize, length, source); | |
| 679 } | |
| 680 } | |
| 681 | |
| 682 const GLubyte* GetString(PP_Resource context_id, GLenum name) { | |
| 683 Enter3D enter(context_id, true); | |
| 684 if (IsBoundGraphics(&enter)) { | |
| 685 return glGetString(name); | |
| 686 } else { | |
| 687 return NULL; | |
| 688 } | |
| 689 } | |
| 690 | |
| 691 void GetTexParameterfv(PP_Resource context_id, | |
| 692 GLenum target, | |
| 693 GLenum pname, | |
| 694 GLfloat* params) { | |
| 695 Enter3D enter(context_id, true); | |
| 696 if (IsBoundGraphics(&enter)) { | |
| 697 glGetTexParameterfv(target, pname, params); | |
| 698 } | |
| 699 } | |
| 700 | |
| 701 void GetTexParameteriv(PP_Resource context_id, | |
| 702 GLenum target, | |
| 703 GLenum pname, | |
| 704 GLint* params) { | |
| 705 Enter3D enter(context_id, true); | |
| 706 if (IsBoundGraphics(&enter)) { | |
| 707 glGetTexParameteriv(target, pname, params); | |
| 708 } | |
| 709 } | |
| 710 | |
| 711 void GetUniformfv(PP_Resource context_id, | |
| 712 GLuint program, | |
| 713 GLint location, | |
| 714 GLfloat* params) { | |
| 715 Enter3D enter(context_id, true); | |
| 716 if (IsBoundGraphics(&enter)) { | |
| 717 glGetUniformfv(program, location, params); | |
| 718 } | |
| 719 } | |
| 720 | |
| 721 void GetUniformiv(PP_Resource context_id, | |
| 722 GLuint program, | |
| 723 GLint location, | |
| 724 GLint* params) { | |
| 725 Enter3D enter(context_id, true); | |
| 726 if (IsBoundGraphics(&enter)) { | |
| 727 glGetUniformiv(program, location, params); | |
| 728 } | |
| 729 } | |
| 730 | |
| 731 GLint GetUniformLocation(PP_Resource context_id, | |
| 732 GLuint program, | |
| 733 const char* name) { | |
| 734 Enter3D enter(context_id, true); | |
| 735 if (IsBoundGraphics(&enter)) { | |
| 736 return glGetUniformLocation(program, name); | |
| 737 } else { | |
| 738 return -1; | |
| 739 } | |
| 740 } | |
| 741 | |
| 742 void GetVertexAttribfv(PP_Resource context_id, | |
| 743 GLuint index, | |
| 744 GLenum pname, | |
| 745 GLfloat* params) { | |
| 746 Enter3D enter(context_id, true); | |
| 747 if (IsBoundGraphics(&enter)) { | |
| 748 glGetVertexAttribfv(index, pname, params); | |
| 749 } | |
| 750 } | |
| 751 | |
| 752 void GetVertexAttribiv(PP_Resource context_id, | |
| 753 GLuint index, | |
| 754 GLenum pname, | |
| 755 GLint* params) { | |
| 756 Enter3D enter(context_id, true); | |
| 757 if (IsBoundGraphics(&enter)) { | |
| 758 glGetVertexAttribiv(index, pname, params); | |
| 759 } | |
| 760 } | |
| 761 | |
| 762 void GetVertexAttribPointerv(PP_Resource context_id, | |
| 763 GLuint index, | |
| 764 GLenum pname, | |
| 765 void** pointer) { | |
| 766 Enter3D enter(context_id, true); | |
| 767 if (IsBoundGraphics(&enter)) { | |
| 768 glGetVertexAttribPointerv(index, pname, pointer); | |
| 769 } | |
| 770 } | |
| 771 | |
| 772 void Hint(PP_Resource context_id, GLenum target, GLenum mode) { | |
| 773 Enter3D enter(context_id, true); | |
| 774 if (IsBoundGraphics(&enter)) { | |
| 775 glHint(target, mode); | |
| 776 } | |
| 777 } | |
| 778 | |
| 779 GLboolean IsBuffer(PP_Resource context_id, GLuint buffer) { | |
| 780 Enter3D enter(context_id, true); | |
| 781 if (IsBoundGraphics(&enter)) { | |
| 782 return glIsBuffer(buffer); | |
| 783 } else { | |
| 784 return GL_FALSE; | |
| 785 } | |
| 786 } | |
| 787 | |
| 788 GLboolean IsEnabled(PP_Resource context_id, GLenum cap) { | |
| 789 Enter3D enter(context_id, true); | |
| 790 if (IsBoundGraphics(&enter)) { | |
| 791 return glIsEnabled(cap); | |
| 792 } else { | |
| 793 return GL_FALSE; | |
| 794 } | |
| 795 } | |
| 796 | |
| 797 GLboolean IsFramebuffer(PP_Resource context_id, GLuint framebuffer) { | |
| 798 Enter3D enter(context_id, true); | |
| 799 if (IsBoundGraphics(&enter)) { | |
| 800 return glIsFramebuffer(framebuffer); | |
| 801 } else { | |
| 802 return GL_FALSE; | |
| 803 } | |
| 804 } | |
| 805 | |
| 806 GLboolean IsProgram(PP_Resource context_id, GLuint program) { | |
| 807 Enter3D enter(context_id, true); | |
| 808 if (IsBoundGraphics(&enter)) { | |
| 809 return glIsProgram(program); | |
| 810 } else { | |
| 811 return GL_FALSE; | |
| 812 } | |
| 813 } | |
| 814 | |
| 815 GLboolean IsRenderbuffer(PP_Resource context_id, GLuint renderbuffer) { | |
| 816 Enter3D enter(context_id, true); | |
| 817 if (IsBoundGraphics(&enter)) { | |
| 818 return glIsRenderbuffer(renderbuffer); | |
| 819 } else { | |
| 820 return GL_FALSE; | |
| 821 } | |
| 822 } | |
| 823 | |
| 824 GLboolean IsShader(PP_Resource context_id, GLuint shader) { | |
| 825 Enter3D enter(context_id, true); | |
| 826 if (IsBoundGraphics(&enter)) { | |
| 827 return glIsShader(shader); | |
| 828 } else { | |
| 829 return GL_FALSE; | |
| 830 } | |
| 831 } | |
| 832 | |
| 833 GLboolean IsTexture(PP_Resource context_id, GLuint texture) { | |
| 834 Enter3D enter(context_id, true); | |
| 835 if (IsBoundGraphics(&enter)) { | |
| 836 return glIsTexture(texture); | |
| 837 } else { | |
| 838 return GL_FALSE; | |
| 839 } | |
| 840 } | |
| 841 | |
| 842 void LineWidth(PP_Resource context_id, GLfloat width) { | |
| 843 Enter3D enter(context_id, true); | |
| 844 if (IsBoundGraphics(&enter)) { | |
| 845 glLineWidth(width); | |
| 846 } | |
| 847 } | |
| 848 | |
| 849 void LinkProgram(PP_Resource context_id, GLuint program) { | |
| 850 Enter3D enter(context_id, true); | |
| 851 if (IsBoundGraphics(&enter)) { | |
| 852 glLinkProgram(program); | |
| 853 } | |
| 854 } | |
| 855 | |
| 856 void PixelStorei(PP_Resource context_id, GLenum pname, GLint param) { | |
| 857 Enter3D enter(context_id, true); | |
| 858 if (IsBoundGraphics(&enter)) { | |
| 859 glPixelStorei(pname, param); | |
| 860 } | |
| 861 } | |
| 862 | |
| 863 void PolygonOffset(PP_Resource context_id, GLfloat factor, GLfloat units) { | |
| 864 Enter3D enter(context_id, true); | |
| 865 if (IsBoundGraphics(&enter)) { | |
| 866 glPolygonOffset(factor, units); | |
| 867 } | |
| 868 } | |
| 869 | |
| 870 void ReadPixels(PP_Resource context_id, | |
| 871 GLint x, | |
| 872 GLint y, | |
| 873 GLsizei width, | |
| 874 GLsizei height, | |
| 875 GLenum format, | |
| 876 GLenum type, | |
| 877 void* pixels) { | |
| 878 Enter3D enter(context_id, true); | |
| 879 if (IsBoundGraphics(&enter)) { | |
| 880 glReadPixels(x, y, width, height, format, type, pixels); | |
| 881 } | |
| 882 } | |
| 883 | |
| 884 void ReleaseShaderCompiler(PP_Resource context_id) { | |
| 885 Enter3D enter(context_id, true); | |
| 886 if (IsBoundGraphics(&enter)) { | |
| 887 glReleaseShaderCompiler(); | |
| 888 } | |
| 889 } | |
| 890 | |
| 891 void RenderbufferStorage(PP_Resource context_id, | |
| 892 GLenum target, | |
| 893 GLenum internalformat, | |
| 894 GLsizei width, | |
| 895 GLsizei height) { | |
| 896 Enter3D enter(context_id, true); | |
| 897 if (IsBoundGraphics(&enter)) { | |
| 898 glRenderbufferStorage(target, internalformat, width, height); | |
| 899 } | |
| 900 } | |
| 901 | |
| 902 void SampleCoverage(PP_Resource context_id, GLclampf value, GLboolean invert) { | |
| 903 Enter3D enter(context_id, true); | |
| 904 if (IsBoundGraphics(&enter)) { | |
| 905 glSampleCoverage(value, invert); | |
| 906 } | |
| 907 } | |
| 908 | |
| 909 void Scissor(PP_Resource context_id, | |
| 910 GLint x, | |
| 911 GLint y, | |
| 912 GLsizei width, | |
| 913 GLsizei height) { | |
| 914 Enter3D enter(context_id, true); | |
| 915 if (IsBoundGraphics(&enter)) { | |
| 916 glScissor(x, y, width, height); | |
| 917 } | |
| 918 } | |
| 919 | |
| 920 void ShaderBinary(PP_Resource context_id, | |
| 921 GLsizei n, | |
| 922 const GLuint* shaders, | |
| 923 GLenum binaryformat, | |
| 924 const void* binary, | |
| 925 GLsizei length) { | |
| 926 Enter3D enter(context_id, true); | |
| 927 if (IsBoundGraphics(&enter)) { | |
| 928 glShaderBinary(n, shaders, binaryformat, binary, length); | |
| 929 } | |
| 930 } | |
| 931 | |
| 932 void ShaderSource(PP_Resource context_id, | |
| 933 GLuint shader, | |
| 934 GLsizei count, | |
| 935 const char** str, | |
| 936 const GLint* length) { | |
| 937 Enter3D enter(context_id, true); | |
| 938 if (IsBoundGraphics(&enter)) { | |
| 939 glShaderSource(shader, count, str, length); | |
| 940 } | |
| 941 } | |
| 942 | |
| 943 void StencilFunc(PP_Resource context_id, GLenum func, GLint ref, GLuint mask) { | |
| 944 Enter3D enter(context_id, true); | |
| 945 if (IsBoundGraphics(&enter)) { | |
| 946 glStencilFunc(func, ref, mask); | |
| 947 } | |
| 948 } | |
| 949 | |
| 950 void StencilFuncSeparate(PP_Resource context_id, | |
| 951 GLenum face, | |
| 952 GLenum func, | |
| 953 GLint ref, | |
| 954 GLuint mask) { | |
| 955 Enter3D enter(context_id, true); | |
| 956 if (IsBoundGraphics(&enter)) { | |
| 957 glStencilFuncSeparate(face, func, ref, mask); | |
| 958 } | |
| 959 } | |
| 960 | |
| 961 void StencilMask(PP_Resource context_id, GLuint mask) { | |
| 962 Enter3D enter(context_id, true); | |
| 963 if (IsBoundGraphics(&enter)) { | |
| 964 glStencilMask(mask); | |
| 965 } | |
| 966 } | |
| 967 | |
| 968 void StencilMaskSeparate(PP_Resource context_id, GLenum face, GLuint mask) { | |
| 969 Enter3D enter(context_id, true); | |
| 970 if (IsBoundGraphics(&enter)) { | |
| 971 glStencilMaskSeparate(face, mask); | |
| 972 } | |
| 973 } | |
| 974 | |
| 975 void StencilOp(PP_Resource context_id, | |
| 976 GLenum fail, | |
| 977 GLenum zfail, | |
| 978 GLenum zpass) { | |
| 979 Enter3D enter(context_id, true); | |
| 980 if (IsBoundGraphics(&enter)) { | |
| 981 glStencilOp(fail, zfail, zpass); | |
| 982 } | |
| 983 } | |
| 984 | |
| 985 void StencilOpSeparate(PP_Resource context_id, | |
| 986 GLenum face, | |
| 987 GLenum fail, | |
| 988 GLenum zfail, | |
| 989 GLenum zpass) { | |
| 990 Enter3D enter(context_id, true); | |
| 991 if (IsBoundGraphics(&enter)) { | |
| 992 glStencilOpSeparate(face, fail, zfail, zpass); | |
| 993 } | |
| 994 } | |
| 995 | |
| 996 void TexImage2D(PP_Resource context_id, | |
| 997 GLenum target, | |
| 998 GLint level, | |
| 999 GLint internalformat, | |
| 1000 GLsizei width, | |
| 1001 GLsizei height, | |
| 1002 GLint border, | |
| 1003 GLenum format, | |
| 1004 GLenum type, | |
| 1005 const void* pixels) { | |
| 1006 Enter3D enter(context_id, true); | |
| 1007 if (IsBoundGraphics(&enter)) { | |
| 1008 glTexImage2D(target, | |
| 1009 level, | |
| 1010 internalformat, | |
| 1011 width, | |
| 1012 height, | |
| 1013 border, | |
| 1014 format, | |
| 1015 type, | |
| 1016 pixels); | |
| 1017 } | |
| 1018 } | |
| 1019 | |
| 1020 void TexParameterf(PP_Resource context_id, | |
| 1021 GLenum target, | |
| 1022 GLenum pname, | |
| 1023 GLfloat param) { | |
| 1024 Enter3D enter(context_id, true); | |
| 1025 if (IsBoundGraphics(&enter)) { | |
| 1026 glTexParameterf(target, pname, param); | |
| 1027 } | |
| 1028 } | |
| 1029 | |
| 1030 void TexParameterfv(PP_Resource context_id, | |
| 1031 GLenum target, | |
| 1032 GLenum pname, | |
| 1033 const GLfloat* params) { | |
| 1034 Enter3D enter(context_id, true); | |
| 1035 if (IsBoundGraphics(&enter)) { | |
| 1036 glTexParameterfv(target, pname, params); | |
| 1037 } | |
| 1038 } | |
| 1039 | |
| 1040 void TexParameteri(PP_Resource context_id, | |
| 1041 GLenum target, | |
| 1042 GLenum pname, | |
| 1043 GLint param) { | |
| 1044 Enter3D enter(context_id, true); | |
| 1045 if (IsBoundGraphics(&enter)) { | |
| 1046 glTexParameteri(target, pname, param); | |
| 1047 } | |
| 1048 } | |
| 1049 | |
| 1050 void TexParameteriv(PP_Resource context_id, | |
| 1051 GLenum target, | |
| 1052 GLenum pname, | |
| 1053 const GLint* params) { | |
| 1054 Enter3D enter(context_id, true); | |
| 1055 if (IsBoundGraphics(&enter)) { | |
| 1056 glTexParameteriv(target, pname, params); | |
| 1057 } | |
| 1058 } | |
| 1059 | |
| 1060 void TexSubImage2D(PP_Resource context_id, | |
| 1061 GLenum target, | |
| 1062 GLint level, | |
| 1063 GLint xoffset, | |
| 1064 GLint yoffset, | |
| 1065 GLsizei width, | |
| 1066 GLsizei height, | |
| 1067 GLenum format, | |
| 1068 GLenum type, | |
| 1069 const void* pixels) { | |
| 1070 Enter3D enter(context_id, true); | |
| 1071 if (IsBoundGraphics(&enter)) { | |
| 1072 glTexSubImage2D( | |
| 1073 target, level, xoffset, yoffset, width, height, format, type, pixels); | |
| 1074 } | |
| 1075 } | |
| 1076 | |
| 1077 void Uniform1f(PP_Resource context_id, GLint location, GLfloat x) { | |
| 1078 Enter3D enter(context_id, true); | |
| 1079 if (IsBoundGraphics(&enter)) { | |
| 1080 glUniform1f(location, x); | |
| 1081 } | |
| 1082 } | |
| 1083 | |
| 1084 void Uniform1fv(PP_Resource context_id, | |
| 1085 GLint location, | |
| 1086 GLsizei count, | |
| 1087 const GLfloat* v) { | |
| 1088 Enter3D enter(context_id, true); | |
| 1089 if (IsBoundGraphics(&enter)) { | |
| 1090 glUniform1fv(location, count, v); | |
| 1091 } | |
| 1092 } | |
| 1093 | |
| 1094 void Uniform1i(PP_Resource context_id, GLint location, GLint x) { | |
| 1095 Enter3D enter(context_id, true); | |
| 1096 if (IsBoundGraphics(&enter)) { | |
| 1097 glUniform1i(location, x); | |
| 1098 } | |
| 1099 } | |
| 1100 | |
| 1101 void Uniform1iv(PP_Resource context_id, | |
| 1102 GLint location, | |
| 1103 GLsizei count, | |
| 1104 const GLint* v) { | |
| 1105 Enter3D enter(context_id, true); | |
| 1106 if (IsBoundGraphics(&enter)) { | |
| 1107 glUniform1iv(location, count, v); | |
| 1108 } | |
| 1109 } | |
| 1110 | |
| 1111 void Uniform2f(PP_Resource context_id, GLint location, GLfloat x, GLfloat y) { | |
| 1112 Enter3D enter(context_id, true); | |
| 1113 if (IsBoundGraphics(&enter)) { | |
| 1114 glUniform2f(location, x, y); | |
| 1115 } | |
| 1116 } | |
| 1117 | |
| 1118 void Uniform2fv(PP_Resource context_id, | |
| 1119 GLint location, | |
| 1120 GLsizei count, | |
| 1121 const GLfloat* v) { | |
| 1122 Enter3D enter(context_id, true); | |
| 1123 if (IsBoundGraphics(&enter)) { | |
| 1124 glUniform2fv(location, count, v); | |
| 1125 } | |
| 1126 } | |
| 1127 | |
| 1128 void Uniform2i(PP_Resource context_id, GLint location, GLint x, GLint y) { | |
| 1129 Enter3D enter(context_id, true); | |
| 1130 if (IsBoundGraphics(&enter)) { | |
| 1131 glUniform2i(location, x, y); | |
| 1132 } | |
| 1133 } | |
| 1134 | |
| 1135 void Uniform2iv(PP_Resource context_id, | |
| 1136 GLint location, | |
| 1137 GLsizei count, | |
| 1138 const GLint* v) { | |
| 1139 Enter3D enter(context_id, true); | |
| 1140 if (IsBoundGraphics(&enter)) { | |
| 1141 glUniform2iv(location, count, v); | |
| 1142 } | |
| 1143 } | |
| 1144 | |
| 1145 void Uniform3f(PP_Resource context_id, | |
| 1146 GLint location, | |
| 1147 GLfloat x, | |
| 1148 GLfloat y, | |
| 1149 GLfloat z) { | |
| 1150 Enter3D enter(context_id, true); | |
| 1151 if (IsBoundGraphics(&enter)) { | |
| 1152 glUniform3f(location, x, y, z); | |
| 1153 } | |
| 1154 } | |
| 1155 | |
| 1156 void Uniform3fv(PP_Resource context_id, | |
| 1157 GLint location, | |
| 1158 GLsizei count, | |
| 1159 const GLfloat* v) { | |
| 1160 Enter3D enter(context_id, true); | |
| 1161 if (IsBoundGraphics(&enter)) { | |
| 1162 glUniform3fv(location, count, v); | |
| 1163 } | |
| 1164 } | |
| 1165 | |
| 1166 void Uniform3i(PP_Resource context_id, | |
| 1167 GLint location, | |
| 1168 GLint x, | |
| 1169 GLint y, | |
| 1170 GLint z) { | |
| 1171 Enter3D enter(context_id, true); | |
| 1172 if (IsBoundGraphics(&enter)) { | |
| 1173 glUniform3i(location, x, y, z); | |
| 1174 } | |
| 1175 } | |
| 1176 | |
| 1177 void Uniform3iv(PP_Resource context_id, | |
| 1178 GLint location, | |
| 1179 GLsizei count, | |
| 1180 const GLint* v) { | |
| 1181 Enter3D enter(context_id, true); | |
| 1182 if (IsBoundGraphics(&enter)) { | |
| 1183 glUniform3iv(location, count, v); | |
| 1184 } | |
| 1185 } | |
| 1186 | |
| 1187 void Uniform4f(PP_Resource context_id, | |
| 1188 GLint location, | |
| 1189 GLfloat x, | |
| 1190 GLfloat y, | |
| 1191 GLfloat z, | |
| 1192 GLfloat w) { | |
| 1193 Enter3D enter(context_id, true); | |
| 1194 if (IsBoundGraphics(&enter)) { | |
| 1195 glUniform4f(location, x, y, z, w); | |
| 1196 } | |
| 1197 } | |
| 1198 | |
| 1199 void Uniform4fv(PP_Resource context_id, | |
| 1200 GLint location, | |
| 1201 GLsizei count, | |
| 1202 const GLfloat* v) { | |
| 1203 Enter3D enter(context_id, true); | |
| 1204 if (IsBoundGraphics(&enter)) { | |
| 1205 glUniform4fv(location, count, v); | |
| 1206 } | |
| 1207 } | |
| 1208 | |
| 1209 void Uniform4i(PP_Resource context_id, | |
| 1210 GLint location, | |
| 1211 GLint x, | |
| 1212 GLint y, | |
| 1213 GLint z, | |
| 1214 GLint w) { | |
| 1215 Enter3D enter(context_id, true); | |
| 1216 if (IsBoundGraphics(&enter)) { | |
| 1217 glUniform4i(location, x, y, z, w); | |
| 1218 } | |
| 1219 } | |
| 1220 | |
| 1221 void Uniform4iv(PP_Resource context_id, | |
| 1222 GLint location, | |
| 1223 GLsizei count, | |
| 1224 const GLint* v) { | |
| 1225 Enter3D enter(context_id, true); | |
| 1226 if (IsBoundGraphics(&enter)) { | |
| 1227 glUniform4iv(location, count, v); | |
| 1228 } | |
| 1229 } | |
| 1230 | |
| 1231 void UniformMatrix2fv(PP_Resource context_id, | |
| 1232 GLint location, | |
| 1233 GLsizei count, | |
| 1234 GLboolean transpose, | |
| 1235 const GLfloat* value) { | |
| 1236 Enter3D enter(context_id, true); | |
| 1237 if (IsBoundGraphics(&enter)) { | |
| 1238 glUniformMatrix2fv(location, count, transpose, value); | |
| 1239 } | |
| 1240 } | |
| 1241 | |
| 1242 void UniformMatrix3fv(PP_Resource context_id, | |
| 1243 GLint location, | |
| 1244 GLsizei count, | |
| 1245 GLboolean transpose, | |
| 1246 const GLfloat* value) { | |
| 1247 Enter3D enter(context_id, true); | |
| 1248 if (IsBoundGraphics(&enter)) { | |
| 1249 glUniformMatrix3fv(location, count, transpose, value); | |
| 1250 } | |
| 1251 } | |
| 1252 | |
| 1253 void UniformMatrix4fv(PP_Resource context_id, | |
| 1254 GLint location, | |
| 1255 GLsizei count, | |
| 1256 GLboolean transpose, | |
| 1257 const GLfloat* value) { | |
| 1258 Enter3D enter(context_id, true); | |
| 1259 if (IsBoundGraphics(&enter)) { | |
| 1260 glUniformMatrix4fv(location, count, transpose, value); | |
| 1261 } | |
| 1262 } | |
| 1263 | |
| 1264 void UseProgram(PP_Resource context_id, GLuint program) { | |
| 1265 Enter3D enter(context_id, true); | |
| 1266 if (IsBoundGraphics(&enter)) { | |
| 1267 glUseProgram(program); | |
| 1268 } | |
| 1269 } | |
| 1270 | |
| 1271 void ValidateProgram(PP_Resource context_id, GLuint program) { | |
| 1272 Enter3D enter(context_id, true); | |
| 1273 if (IsBoundGraphics(&enter)) { | |
| 1274 glValidateProgram(program); | |
| 1275 } | |
| 1276 } | |
| 1277 | |
| 1278 void VertexAttrib1f(PP_Resource context_id, GLuint indx, GLfloat x) { | |
| 1279 Enter3D enter(context_id, true); | |
| 1280 if (IsBoundGraphics(&enter)) { | |
| 1281 glVertexAttrib1f(indx, x); | |
| 1282 } | |
| 1283 } | |
| 1284 | |
| 1285 void VertexAttrib1fv(PP_Resource context_id, | |
| 1286 GLuint indx, | |
| 1287 const GLfloat* values) { | |
| 1288 Enter3D enter(context_id, true); | |
| 1289 if (IsBoundGraphics(&enter)) { | |
| 1290 glVertexAttrib1fv(indx, values); | |
| 1291 } | |
| 1292 } | |
| 1293 | |
| 1294 void VertexAttrib2f(PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y) { | |
| 1295 Enter3D enter(context_id, true); | |
| 1296 if (IsBoundGraphics(&enter)) { | |
| 1297 glVertexAttrib2f(indx, x, y); | |
| 1298 } | |
| 1299 } | |
| 1300 | |
| 1301 void VertexAttrib2fv(PP_Resource context_id, | |
| 1302 GLuint indx, | |
| 1303 const GLfloat* values) { | |
| 1304 Enter3D enter(context_id, true); | |
| 1305 if (IsBoundGraphics(&enter)) { | |
| 1306 glVertexAttrib2fv(indx, values); | |
| 1307 } | |
| 1308 } | |
| 1309 | |
| 1310 void VertexAttrib3f(PP_Resource context_id, | |
| 1311 GLuint indx, | |
| 1312 GLfloat x, | |
| 1313 GLfloat y, | |
| 1314 GLfloat z) { | |
| 1315 Enter3D enter(context_id, true); | |
| 1316 if (IsBoundGraphics(&enter)) { | |
| 1317 glVertexAttrib3f(indx, x, y, z); | |
| 1318 } | |
| 1319 } | |
| 1320 | |
| 1321 void VertexAttrib3fv(PP_Resource context_id, | |
| 1322 GLuint indx, | |
| 1323 const GLfloat* values) { | |
| 1324 Enter3D enter(context_id, true); | |
| 1325 if (IsBoundGraphics(&enter)) { | |
| 1326 glVertexAttrib3fv(indx, values); | |
| 1327 } | |
| 1328 } | |
| 1329 | |
| 1330 void VertexAttrib4f(PP_Resource context_id, | |
| 1331 GLuint indx, | |
| 1332 GLfloat x, | |
| 1333 GLfloat y, | |
| 1334 GLfloat z, | |
| 1335 GLfloat w) { | |
| 1336 Enter3D enter(context_id, true); | |
| 1337 if (IsBoundGraphics(&enter)) { | |
| 1338 glVertexAttrib4f(indx, x, y, z, w); | |
| 1339 } | |
| 1340 } | |
| 1341 | |
| 1342 void VertexAttrib4fv(PP_Resource context_id, | |
| 1343 GLuint indx, | |
| 1344 const GLfloat* values) { | |
| 1345 Enter3D enter(context_id, true); | |
| 1346 if (IsBoundGraphics(&enter)) { | |
| 1347 glVertexAttrib4fv(indx, values); | |
| 1348 } | |
| 1349 } | |
| 1350 | |
| 1351 void VertexAttribPointer(PP_Resource context_id, | |
| 1352 GLuint indx, | |
| 1353 GLint size, | |
| 1354 GLenum type, | |
| 1355 GLboolean normalized, | |
| 1356 GLsizei stride, | |
| 1357 const void* ptr) { | |
| 1358 Enter3D enter(context_id, true); | |
| 1359 if (IsBoundGraphics(&enter)) { | |
| 1360 glVertexAttribPointer(indx, size, type, normalized, stride, ptr); | |
| 1361 } | |
| 1362 } | |
| 1363 | |
| 1364 void Viewport(PP_Resource context_id, | |
| 1365 GLint x, | |
| 1366 GLint y, | |
| 1367 GLsizei width, | |
| 1368 GLsizei height) { | |
| 1369 Enter3D enter(context_id, true); | |
| 1370 if (IsBoundGraphics(&enter)) { | |
| 1371 glViewport(x, y, width, height); | |
| 1372 } | |
| 1373 } | |
| 1374 | |
| 1375 } // namespace | |
| 1376 | |
| 1377 const PPB_OpenGLES2* GetPPB_OpenGLES2_Thunk() { | |
| 1378 static const struct PPB_OpenGLES2 ppb_opengles2 = { | |
| 1379 &ActiveTexture, &AttachShader, | |
| 1380 &BindAttribLocation, &BindBuffer, | |
| 1381 &BindFramebuffer, &BindRenderbuffer, | |
| 1382 &BindTexture, &BlendColor, | |
| 1383 &BlendEquation, &BlendEquationSeparate, | |
| 1384 &BlendFunc, &BlendFuncSeparate, | |
| 1385 &BufferData, &BufferSubData, | |
| 1386 &CheckFramebufferStatus, &Clear, | |
| 1387 &ClearColor, &ClearDepthf, | |
| 1388 &ClearStencil, &ColorMask, | |
| 1389 &CompileShader, &CompressedTexImage2D, | |
| 1390 &CompressedTexSubImage2D, &CopyTexImage2D, | |
| 1391 &CopyTexSubImage2D, &CreateProgram, | |
| 1392 &CreateShader, &CullFace, | |
| 1393 &DeleteBuffers, &DeleteFramebuffers, | |
| 1394 &DeleteProgram, &DeleteRenderbuffers, | |
| 1395 &DeleteShader, &DeleteTextures, | |
| 1396 &DepthFunc, &DepthMask, | |
| 1397 &DepthRangef, &DetachShader, | |
| 1398 &Disable, &DisableVertexAttribArray, | |
| 1399 &DrawArrays, &DrawElements, | |
| 1400 &Enable, &EnableVertexAttribArray, | |
| 1401 &Finish, &Flush, | |
| 1402 &FramebufferRenderbuffer, &FramebufferTexture2D, | |
| 1403 &FrontFace, &GenBuffers, | |
| 1404 &GenerateMipmap, &GenFramebuffers, | |
| 1405 &GenRenderbuffers, &GenTextures, | |
| 1406 &GetActiveAttrib, &GetActiveUniform, | |
| 1407 &GetAttachedShaders, &GetAttribLocation, | |
| 1408 &GetBooleanv, &GetBufferParameteriv, | |
| 1409 &GetError, &GetFloatv, | |
| 1410 &GetFramebufferAttachmentParameteriv, &GetIntegerv, | |
| 1411 &GetProgramiv, &GetProgramInfoLog, | |
| 1412 &GetRenderbufferParameteriv, &GetShaderiv, | |
| 1413 &GetShaderInfoLog, &GetShaderPrecisionFormat, | |
| 1414 &GetShaderSource, &GetString, | |
| 1415 &GetTexParameterfv, &GetTexParameteriv, | |
| 1416 &GetUniformfv, &GetUniformiv, | |
| 1417 &GetUniformLocation, &GetVertexAttribfv, | |
| 1418 &GetVertexAttribiv, &GetVertexAttribPointerv, | |
| 1419 &Hint, &IsBuffer, | |
| 1420 &IsEnabled, &IsFramebuffer, | |
| 1421 &IsProgram, &IsRenderbuffer, | |
| 1422 &IsShader, &IsTexture, | |
| 1423 &LineWidth, &LinkProgram, | |
| 1424 &PixelStorei, &PolygonOffset, | |
| 1425 &ReadPixels, &ReleaseShaderCompiler, | |
| 1426 &RenderbufferStorage, &SampleCoverage, | |
| 1427 &Scissor, &ShaderBinary, | |
| 1428 &ShaderSource, &StencilFunc, | |
| 1429 &StencilFuncSeparate, &StencilMask, | |
| 1430 &StencilMaskSeparate, &StencilOp, | |
| 1431 &StencilOpSeparate, &TexImage2D, | |
| 1432 &TexParameterf, &TexParameterfv, | |
| 1433 &TexParameteri, &TexParameteriv, | |
| 1434 &TexSubImage2D, &Uniform1f, | |
| 1435 &Uniform1fv, &Uniform1i, | |
| 1436 &Uniform1iv, &Uniform2f, | |
| 1437 &Uniform2fv, &Uniform2i, | |
| 1438 &Uniform2iv, &Uniform3f, | |
| 1439 &Uniform3fv, &Uniform3i, | |
| 1440 &Uniform3iv, &Uniform4f, | |
| 1441 &Uniform4fv, &Uniform4i, | |
| 1442 &Uniform4iv, &UniformMatrix2fv, | |
| 1443 &UniformMatrix3fv, &UniformMatrix4fv, | |
| 1444 &UseProgram, &ValidateProgram, | |
| 1445 &VertexAttrib1f, &VertexAttrib1fv, | |
| 1446 &VertexAttrib2f, &VertexAttrib2fv, | |
| 1447 &VertexAttrib3f, &VertexAttrib3fv, | |
| 1448 &VertexAttrib4f, &VertexAttrib4fv, | |
| 1449 &VertexAttribPointer, &Viewport}; | |
| 1450 return &ppb_opengles2; | |
| 1451 } | |
| 1452 | |
| 1453 } // namespace examples | |
| 1454 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 681203002:
Remove mojo/examples/pepper_container_app (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master