Source/WebCore/platform/graphics/efl/GraphicsContext3DInternal.cpp

   1 /*
   2     Copyright (C) 2011 Samsung Electronics
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Library General Public
   6     License as published by the Free Software Foundation; either
   7     version 2 of the License, or (at your option) any later version.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Library General Public License for more details.
  13
  14     You should have received a copy of the GNU Library General Public License
  15     along with this library; see the file COPYING.LIB.  If not, write to
  16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17     Boston, MA 02110-1301, USA.
  18 */
  19
  20 #include "config.h"
  21
  22 #if ENABLE(TIZEN_ACCELERATED_COMPOSITING)
  23 #if USE(ACCELERATED_COMPOSITING)
  24
  25 #include "GraphicsContext3DInternal.h"
  26
  27 #include "Extensions3DEfl.h"
  28 #if ENABLE(WEBGL)
  29 #include "GraphicsContext3DOffscreen.h"
  30 #endif
  31
  32 #if !ENABLE(TIZEN_WEBKIT2)
  33 #include "GraphicsContext3DOnscreen.h"
  34 #endif
  35
  36 #include "HostWindow.h"
  37 #include "ImageData.h"
  38 #include "NotImplemented.h"
  39 #include <wtf/text/CString.h>
  40 #include <wtf/OwnArrayPtr.h>
  41
  42 namespace WebCore {
  43
  44 PassOwnPtr<GraphicsContext3DInternal> GraphicsContext3DInternal::create(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, bool renderDirectlyToHostWindow)
  45 {
  46     if (renderDirectlyToHostWindow)
  47 #if !ENABLE(TIZEN_WEBKIT2)
  48         return GraphicsContext3DOnscreen::create(attrs, hostWindow);
  49 #else
  50         return nullptr;
  51 #endif
  52
  53 #if ENABLE(WEBGL)
  54     return GraphicsContext3DOffscreen::create(attrs, hostWindow);
  55 #else
  56     return nullptr;
  57 #endif
  58 }
  59
  60 GraphicsContext3DInternal::GraphicsContext3DInternal(GraphicsContext3D::Attributes attrs, GraphicsContext3D::RenderStyle renderStyle)
  61     : m_attributes(attrs)
  62     , m_renderStyle(renderStyle)
  63 #if ENABLE(TIZEN_WEBKIT2)
  64     , m_display(EGL_NO_DISPLAY)
  65     , m_context(EGL_NO_CONTEXT)
  66     , m_surface(EGL_NO_SURFACE)
  67 #else
  68     , m_evasGL(0)
  69     , m_context(0)
  70     , m_surface(0)
  71     , m_api(0)
  72 #if ENABLE(TIZEN_EVAS_GL_DIRECT_RENDERING)
  73     , m_config(0)
  74 #endif
  75 #endif
  76 {
  77     LOG(AcceleratedCompositing, "[%p] GraphicsContext3DInternal::%s() - CONSTRUCTOR\n", this, __func__);
  78     LOG(AcceleratedCompositing, "---> Evas_GL\n");
  79 }
  80
  81 GraphicsContext3DInternal::~GraphicsContext3DInternal()
  82 {
  83 #if ENABLE(TIZEN_WEBKIT2)\r
  84     eglDestroyContext(EGL_NO_DISPLAY, m_context);\r
  85     eglDestroySurface(EGL_NO_DISPLAY, m_surface);\r
  86 #else
  87     evas_gl_surface_destroy(m_evasGL, m_surface);
  88     evas_gl_context_destroy(m_evasGL, m_context);
  89     evas_gl_free(m_evasGL);
  90 #if ENABLE(TIZEN_EVAS_GL_DIRECT_RENDERING)
  91     evas_gl_config_free(m_config);
  92 #endif
  93 #endif
  94     m_syntheticErrors.clear();
  95     LOG(AcceleratedCompositing, "[%p] GraphicsContext3DInternal::%s() - DESTRUCTOR\n", this, __func__);
  96 }
  97
  98 #if ENABLE(TIZEN_WEBKIT2)\r
  99 #include <stdio.h>\r
 100 void HandleEGLError(const char* name)\r
 101 {\r
 102     static const char* const egErrorStrings[] =\r
 103     {\r
 104         "EGL_SUCCESS",\r
 105         "EGL_NOT_INITIALIZED",\r
 106         "EGL_BAD_ACCESS",\r
 107         "EGL_BAD_ALLOC",\r
 108         "EGL_BAD_ATTRIBUTE",\r
 109         "EGL_BAD_CONFIG",\r
 110         "EGL_BAD_CONTEXT",\r
 111         "EGL_BAD_CURRENT_SURFACE",\r
 112         "EGL_BAD_DISPLAY",\r
 113         "EGL_BAD_MATCH",\r
 114         "EGL_BAD_NATIVE_PIXMAP",\r
 115         "EGL_BAD_NATIVE_WINDOW",\r
 116         "EGL_BAD_PARAMETER",\r
 117         "EGL_BAD_SURFACE"\r
 118     };\r
 119 \r
 120     EGLint errorCode = eglGetError();\r
 121 \r
 122     printf("'%s' returned egl error '%s' (0x%x)\n",\r
 123               name,\r
 124               egErrorStrings[errorCode - EGL_SUCCESS],\r
 125               errorCode);\r
 126 }\r
 127 #endif\r
 128
 129 bool GraphicsContext3DInternal::initialize(HostWindow* hostWindow)
 130 {
 131 #if ENABLE(TIZEN_WEBKIT2)\r
 132     m_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);\r
 133     if (!m_display) {\r
 134         HandleEGLError("eglGetDisplay");\r
 135         return false;\r
 136     }\r
 137
 138     if (!eglInitialize(m_display, 0, 0)) {\r
 139         HandleEGLError("eglInitialize");\r
 140         return false;\r
 141     }\r
 142     EGLConfig configs[1];\r
 143     EGLint configCount = 0;\r
 144     EGLint configAttribs[32];\r
 145 \r
 146     int i = 0;\r
 147     configAttribs[i++] = EGL_RED_SIZE;\r
 148     configAttribs[i++] = 8;\r
 149     configAttribs[i++] = EGL_GREEN_SIZE;\r
 150     configAttribs[i++] = 8;\r
 151     configAttribs[i++] = EGL_BLUE_SIZE;\r
 152     configAttribs[i++] = 8;\r
 153     configAttribs[i++] = EGL_ALPHA_SIZE;\r
 154     configAttribs[i++] = 8;\r
 155     configAttribs[i++] = EGL_DEPTH_SIZE;\r
 156     configAttribs[i++] = 24;\r
 157     configAttribs[i++] = EGL_SURFACE_TYPE;\r
 158     configAttribs[i++] = EGL_PIXMAP_BIT;\r
 159     configAttribs[i++] = EGL_RENDERABLE_TYPE;\r
 160     configAttribs[i++] = EGL_OPENGL_ES2_BIT;\r
 161     configAttribs[i++] = EGL_NONE;\r
 162         \r
 163     if (!eglChooseConfig(m_display, configAttribs, configs, 1, &configCount))    {\r
 164         HandleEGLError("eglChooseConfig");\r
 165         return false;\r
 166     }\r
 167     EGLint surfaceAttbs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };\r
 168     m_surface = eglCreatePbufferSurface(m_display, configs[0], surfaceAttbs);\r
 169     if (m_surface == EGL_NO_SURFACE) {\r
 170         HandleEGLError("eglCreatePbufferSurface");\r
 171         return false;\r
 172     }\r
 173 \r
 174     EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};\r
 175 \r
 176     m_context = eglCreateContext(m_display, configs[0], EGL_NO_CONTEXT, contextAttribs);\r
 177     if (m_context == EGL_NO_CONTEXT) {\r
 178         HandleEGLError("eglCreateContext");\r
 179         return false;\r
 180     }\r
 181     return true;\r
 182 #else
 183     LOG(AcceleratedCompositing, "[%p] GraphicsContext3DInternal::%s()\n", this, __func__);
 184
 185     Evas_Object* view = static_cast<Evas_Object*>(hostWindow->platformPageClient());
 186
 187     Evas* evas = evas_object_evas_get(view);
 188     if (!evas)
 189         return false;
 190
 191     m_evasGL = evas_gl_new(evas);
 192     if (!m_evasGL) {
 193         LOG(AcceleratedCompositing, "---> failed to evas_gl_new()\n");
 194         return false;
 195     }
 196
 197     m_api = evas_gl_api_get(m_evasGL);
 198     if (!m_api) {
 199         evas_gl_free(m_evasGL);
 200         LOG(AcceleratedCompositing, "---> failed to evas_gl_api_get()\n");
 201         return false;
 202     }
 203     if (!createContext(view)) {
 204         evas_gl_free(m_evasGL);
 205         LOG(AcceleratedCompositing, "---> failed to create Evas_GL_Context\n");
 206         return false;
 207     }
 208     if (!createSurface(view)) {
 209         evas_gl_context_destroy(m_evasGL, m_context);
 210         evas_gl_free(m_evasGL);
 211         LOG(AcceleratedCompositing, "---> failed to create Evas_GL_Surface\n");
 212         return false;
 213     }
 214     if (!makeContextCurrent()) {
 215         evas_gl_surface_destroy(m_evasGL, m_surface);
 216         evas_gl_context_destroy(m_evasGL, m_context);
 217         evas_gl_free(m_evasGL);
 218         return false;
 219     }
 220 #endif
 221     return true;
 222 }
 223
 224 bool GraphicsContext3DInternal::makeContextCurrent()
 225 {
 226 #if ENABLE(TIZEN_WEBKIT2)
 227     if (eglMakeCurrent(m_display, m_surface, m_surface, m_context) != EGL_TRUE) {\r
 228         HandleEGLError("eglMakeCurrent");\r
 229         return false;\r
 230     }\r
 231 \r
 232     return true;
 233 #else
 234     return (evas_gl_make_current(m_evasGL, m_surface, m_context) == EINA_TRUE);
 235 #endif
 236 }
 237
 238 PassRefPtr<ImageData> GraphicsContext3DInternal::paintRenderingResultsToImageData(int width, int height)
 239 {
 240     return 0;
 241 }
 242
 243 void GraphicsContext3DInternal::synthesizeGLError(GC3Denum error)
 244 {
 245     m_syntheticErrors.add(error);
 246 }
 247
 248 Extensions3D* GraphicsContext3DInternal::getExtensions()
 249 {
 250     if (!m_extensions)
 251         m_extensions = adoptPtr(new Extensions3DEfl(this));
 252     return m_extensions.get();
 253 }
 254
 255 void GraphicsContext3DInternal::validateAttributes()
 256 {
 257     Extensions3D* extensions = getExtensions();
 258     if (m_attributes.stencil) {
 259         if (extensions->supports("GL_EXT_packed_depth_stencil")) {
 260             extensions->ensureEnabled("GL_EXT_packed_depth_stencil");
 261             // Force depth if stencil is true.
 262             m_attributes.depth = true;
 263         }
 264     }
 265     if (m_attributes.antialias) {
 266         bool isValidVendor = true;
 267         // Currently in Mac we only turn on antialias if vendor is NVIDIA.
 268         String vendor(reinterpret_cast<const char*>(GL_CMD(glGetString(GraphicsContext3D::VENDOR))));
 269
 270         if (vendor.isEmpty() || !vendor.contains("NVIDIA"))
 271             isValidVendor = false;
 272         if (!isValidVendor || !extensions->supports("GL_ANGLE_framebuffer_multisample"))
 273             m_attributes.antialias = false;
 274         else
 275             extensions->ensureEnabled("GL_ANGLE_framebuffer_multisample");
 276     }
 277 }
 278
 279 void GraphicsContext3DInternal::activeTexture(GC3Denum texture)
 280 {
 281     makeContextCurrent();
 282     GL_CMD(glActiveTexture(texture));
 283 }
 284
 285 void GraphicsContext3DInternal::attachShader(Platform3DObject program, Platform3DObject shader)
 286 {
 287     makeContextCurrent();
 288     GL_CMD(glAttachShader(program, shader));
 289 }
 290
 291 void GraphicsContext3DInternal::bindAttribLocation(Platform3DObject program, GC3Duint index, const String& name)
 292 {
 293     makeContextCurrent();
 294     GL_CMD(glBindAttribLocation(program, index, name.utf8().data()));
 295 }
 296
 297 void GraphicsContext3DInternal::bindBuffer(GC3Denum target, Platform3DObject buffer)
 298 {
 299     makeContextCurrent();
 300     GL_CMD(glBindBuffer(target, buffer));
 301 }
 302
 303 void GraphicsContext3DInternal::bindFramebuffer(GC3Denum target, Platform3DObject framebuffer)
 304 {
 305     makeContextCurrent();
 306     GL_CMD(glBindFramebuffer(target, framebuffer));
 307 }
 308
 309 void GraphicsContext3DInternal::bindRenderbuffer(GC3Denum target, Platform3DObject buffer)
 310 {
 311     makeContextCurrent();
 312     GL_CMD(glBindRenderbuffer(target, buffer));
 313 }
 314
 315 void GraphicsContext3DInternal::bindTexture(GC3Denum target, Platform3DObject texture)
 316 {
 317     makeContextCurrent();
 318     GL_CMD(glBindTexture(target, texture));
 319 }
 320
 321 void GraphicsContext3DInternal::blendColor(GC3Dclampf red, GC3Dclampf green, GC3Dclampf blue, GC3Dclampf alpha)
 322 {
 323     makeContextCurrent();
 324     GL_CMD(glBlendColor(red, green, blue, alpha));
 325 }
 326
 327 void GraphicsContext3DInternal::blendEquation(GC3Denum mode)
 328 {
 329     makeContextCurrent();
 330     GL_CMD(glBlendEquation(mode));
 331 }
 332
 333 void GraphicsContext3DInternal::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)
 334 {
 335     makeContextCurrent();
 336     GL_CMD(glBlendEquationSeparate(modeRGB, modeAlpha));
 337 }
 338
 339 void GraphicsContext3DInternal::blendFunc(GC3Denum sfactor, GC3Denum dfactor)
 340 {
 341     makeContextCurrent();
 342     GL_CMD(glBlendFunc(sfactor, dfactor));
 343 }
 344
 345 void GraphicsContext3DInternal::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)
 346 {
 347     makeContextCurrent();
 348     GL_CMD(glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha));
 349 }
 350
 351 void GraphicsContext3DInternal::bufferData(GC3Denum target, GC3Dsizeiptr size, const void* data, GC3Denum usage)
 352 {
 353     makeContextCurrent();
 354     GL_CMD(glBufferData(target, size, data, usage));
 355 }
 356
 357 void GraphicsContext3DInternal::bufferSubData(GC3Denum target, GC3Dintptr offset, GC3Dsizeiptr size, const void* data)
 358 {
 359     makeContextCurrent();
 360     GL_CMD(glBufferSubData(target, offset, size, data));
 361 }
 362
 363 GC3Denum GraphicsContext3DInternal::checkFramebufferStatus(GC3Denum target)
 364 {
 365     makeContextCurrent();
 366     return GL_CMD(glCheckFramebufferStatus(target));
 367 }
 368
 369 void GraphicsContext3DInternal::clear(GC3Dbitfield mask)
 370 {
 371     makeContextCurrent();
 372     GL_CMD(glClear(mask));
 373 }
 374
 375 void GraphicsContext3DInternal::clearColor(GC3Dclampf red, GC3Dclampf green, GC3Dclampf blue, GC3Dclampf alpha)
 376 {
 377     makeContextCurrent();
 378     GL_CMD(glClearColor(red, green, blue, alpha));
 379 }
 380
 381 void GraphicsContext3DInternal::clearDepth(GC3Dclampf depth)
 382 {
 383     makeContextCurrent();
 384     GL_CMD(glClearDepthf(depth));
 385 }
 386
 387 void GraphicsContext3DInternal::clearStencil(GC3Dint s)
 388 {
 389     makeContextCurrent();
 390     GL_CMD(glClearStencil(s));
 391 }
 392
 393 void GraphicsContext3DInternal::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)
 394 {
 395     makeContextCurrent();
 396     GL_CMD(glColorMask(red, green, blue, alpha));
 397 }
 398
 399 void GraphicsContext3DInternal::compileShader(Platform3DObject shader)
 400 {
 401     makeContextCurrent();
 402     GL_CMD(glCompileShader(shader));
 403 }
 404
 405 void GraphicsContext3DInternal::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)
 406 {
 407     makeContextCurrent();
 408     GL_CMD(glCopyTexImage2D(target, level, internalformat, x, y, width, height, border));
 409 }
 410
 411 void GraphicsContext3DInternal::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
 412 {
 413     makeContextCurrent();
 414     GL_CMD(glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height));
 415 }
 416
 417 void GraphicsContext3DInternal::cullFace(GC3Denum mode)
 418 {
 419     makeContextCurrent();
 420     GL_CMD(glCullFace(mode));
 421 }
 422
 423 void GraphicsContext3DInternal::depthFunc(GC3Denum func)
 424 {
 425     if (!m_attributes.depth)
 426         return;
 427
 428     makeContextCurrent();
 429     GL_CMD(glDepthFunc(func));
 430 }
 431
 432 void GraphicsContext3DInternal::depthMask(GC3Dboolean flag)
 433 {
 434     makeContextCurrent();
 435     GL_CMD(glDepthMask(flag));
 436 }
 437
 438 void GraphicsContext3DInternal::depthRange(GC3Dclampf zNear, GC3Dclampf zFar)
 439 {
 440     makeContextCurrent();
 441     GL_CMD(glDepthRangef(zNear, zFar));
 442 }
 443
 444 void GraphicsContext3DInternal::detachShader(Platform3DObject program, Platform3DObject shader)
 445 {
 446     makeContextCurrent();
 447     GL_CMD(glDetachShader(program, shader));
 448 }
 449
 450 void GraphicsContext3DInternal::disable(GC3Denum cap)
 451 {
 452     makeContextCurrent();
 453     GL_CMD(glDisable(cap));
 454 }
 455
 456 void GraphicsContext3DInternal::disableVertexAttribArray(GC3Duint index)
 457 {
 458     makeContextCurrent();
 459     GL_CMD(glDisableVertexAttribArray(index));
 460 }
 461
 462 void GraphicsContext3DInternal::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count)
 463 {
 464     makeContextCurrent();
 465     GL_CMD(glDrawArrays(mode, first, count));
 466 }
 467
 468 void GraphicsContext3DInternal::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset)
 469 {
 470     makeContextCurrent();
 471     GL_CMD(glDrawElements(mode, count, type, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset))));
 472 }
 473
 474 void GraphicsContext3DInternal::enable(GC3Denum cap)
 475 {
 476     makeContextCurrent();
 477     GL_CMD(glEnable(cap));
 478 }
 479
 480 void GraphicsContext3DInternal::enableVertexAttribArray(GC3Duint index)
 481 {
 482     makeContextCurrent();
 483     GL_CMD(glEnableVertexAttribArray(index));
 484 }
 485
 486 void GraphicsContext3DInternal::finish()
 487 {
 488     makeContextCurrent();
 489     GL_CMD(glFinish());
 490 }
 491
 492 void GraphicsContext3DInternal::flush()
 493 {
 494     makeContextCurrent();
 495     GL_CMD(glFlush());
 496 }
 497
 498 void GraphicsContext3DInternal::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, Platform3DObject renderbuffer)
 499 {
 500     makeContextCurrent();
 501     GL_CMD(glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer));
 502 }
 503
 504 void GraphicsContext3DInternal::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, Platform3DObject texture, GC3Dint level)
 505 {
 506     makeContextCurrent();
 507     GL_CMD(glFramebufferTexture2D(target, attachment, textarget, texture, level));
 508 }
 509
 510 void GraphicsContext3DInternal::frontFace(GC3Denum mode)
 511 {
 512     makeContextCurrent();
 513     GL_CMD(glFrontFace(mode));
 514 }
 515
 516 void GraphicsContext3DInternal::generateMipmap(GC3Denum target)
 517 {
 518     makeContextCurrent();
 519     GL_CMD(glGenerateMipmap(target));
 520 }
 521
 522 bool GraphicsContext3DInternal::getActiveAttrib(Platform3DObject program, GC3Duint index, ActiveInfo& info)
 523 {
 524     if (!program) {
 525         synthesizeGLError(GL_INVALID_VALUE);
 526         return false;
 527     }
 528
 529     makeContextCurrent();
 530
 531     int maxNameLength = -1;
 532     GL_CMD(glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxNameLength));
 533     if (maxNameLength < 0)
 534         return false;
 535
 536     OwnArrayPtr<char> name = adoptArrayPtr(new char[maxNameLength]);
 537     if (!name) {
 538         synthesizeGLError(GL_OUT_OF_MEMORY);
 539         return false;
 540     }
 541
 542     int length = 0;
 543     int size = -1;
 544     GLenum type = 0;
 545
 546     GL_CMD(glGetActiveAttrib(program, index, maxNameLength, &length, &size, &type, name.get()));
 547     if (size < 0)
 548         return false;
 549
 550     info.name = String::fromUTF8(name.get(), length);
 551     info.type = type;
 552     info.size = size;
 553     return true;
 554 }
 555
 556 bool GraphicsContext3DInternal::getActiveUniform(Platform3DObject program, GC3Duint index, ActiveInfo& info)
 557 {
 558     if (!program) {
 559         synthesizeGLError(GL_INVALID_VALUE);
 560         return false;
 561     }
 562
 563     makeContextCurrent();
 564
 565     int maxNameLength = -1;
 566     GL_CMD(glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength));
 567     if (maxNameLength < 0)
 568         return false;
 569
 570     OwnArrayPtr<char> name = adoptArrayPtr(new char[maxNameLength]);
 571     if (!name) {
 572         synthesizeGLError(GL_OUT_OF_MEMORY);
 573         return false;
 574     }
 575
 576     int length = 0;
 577     int size = -1;
 578     GLenum type = 0;
 579
 580     GL_CMD(glGetActiveUniform(program, index, maxNameLength, &length, &size, &type, name.get()));
 581     if (size < 0)
 582         return false;
 583
 584     info.name = String::fromUTF8(name.get(), length);
 585     info.type = type;
 586     info.size = size;
 587     return true;
 588 }
 589
 590 void GraphicsContext3DInternal::getAttachedShaders(Platform3DObject program, GC3Dsizei maxCount, GC3Dsizei* count, Platform3DObject* shaders)
 591 {
 592     if (!program) {
 593         synthesizeGLError(GraphicsContext3D::INVALID_VALUE);
 594         return;
 595     }
 596     makeContextCurrent();
 597     GL_CMD(glGetAttachedShaders(program, maxCount, count, shaders));
 598 }
 599
 600 int GraphicsContext3DInternal::getAttribLocation(Platform3DObject program, const String& name)
 601 {
 602     if (!program)
 603         return -1;
 604
 605     makeContextCurrent();
 606     return GL_CMD(glGetAttribLocation(program, name.utf8().data()));
 607 }
 608
 609 void GraphicsContext3DInternal::getBooleanv(GC3Denum pname, GC3Dboolean* value)
 610 {
 611     makeContextCurrent();
 612     if (pname == GraphicsContext3D::DITHER)
 613         *value = GL_CMD(glIsEnabled(pname));
 614     else
 615         GL_CMD(glGetBooleanv(pname, value));
 616 }
 617
 618 void GraphicsContext3DInternal::getBufferParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value)
 619 {
 620     makeContextCurrent();
 621     GL_CMD(glGetBufferParameteriv(target, pname, value));
 622 }
 623
 624 GraphicsContext3D::Attributes GraphicsContext3DInternal::getContextAttributes()
 625 {
 626     return m_attributes;
 627 }
 628
 629 GC3Denum GraphicsContext3DInternal::getError()
 630 {
 631     if (m_syntheticErrors.size() > 0) {
 632         ListHashSet<GC3Denum>::iterator iter = m_syntheticErrors.begin();
 633         GC3Denum err = *iter;
 634         m_syntheticErrors.remove(iter);
 635         return err;
 636     }
 637
 638     makeContextCurrent();
 639     return GL_CMD(glGetError());
 640 }
 641
 642 void GraphicsContext3DInternal::getFloatv(GC3Denum pname, GC3Dfloat* value)
 643 {
 644     makeContextCurrent();
 645     GL_CMD(glGetFloatv(pname, value));
 646 }
 647
 648 void GraphicsContext3DInternal::getFramebufferAttachmentParameteriv(GC3Denum target, GC3Denum attachment, GC3Denum pname, GC3Dint* value)
 649 {
 650     makeContextCurrent();
 651     if (attachment == GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT)
 652         attachment = GraphicsContext3D::DEPTH_ATTACHMENT; // Or STENCIL_ATTACHMENT, either works.
 653     GL_CMD(glGetFramebufferAttachmentParameteriv(target, attachment, pname, value));
 654 }
 655
 656 void GraphicsContext3DInternal::getIntegerv(GC3Denum pname, GC3Dint* value)
 657 {
 658     makeContextCurrent();
 659
 660     switch (pname) {
 661     case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS:
 662         GL_CMD(glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, value));
 663         *value /= 4;
 664         break;
 665     case GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS:
 666         GL_CMD(glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, value));
 667         *value /= 4;
 668         break;
 669     case GraphicsContext3D::MAX_VARYING_VECTORS:
 670         GL_CMD(glGetIntegerv(GL_MAX_VARYING_VECTORS, value));
 671         *value /= 4;
 672         break;
 673     default:
 674         GL_CMD(glGetIntegerv(pname, value));
 675     }
 676 }
 677
 678 void GraphicsContext3DInternal::getProgramiv(Platform3DObject program, GC3Denum pname, GC3Dint* value)
 679 {
 680     makeContextCurrent();
 681     GL_CMD(glGetProgramiv(program, pname, value));
 682 }
 683
 684 String GraphicsContext3DInternal::getProgramInfoLog(Platform3DObject program)
 685 {
 686     makeContextCurrent();
 687
 688     int logLength = 0;
 689     GL_CMD(glGetProgramiv(program, GraphicsContext3D::INFO_LOG_LENGTH, &logLength));
 690     if (!logLength)
 691         return String();
 692
 693     OwnArrayPtr<char> log = adoptArrayPtr(new char[logLength]);
 694     if (!log)
 695         return String();
 696
 697     int returnedLogLength = 0;
 698     GL_CMD(glGetProgramInfoLog(program, logLength, &returnedLogLength, log.get()));
 699     ASSERT(logLength == returnedLogLength + 1);
 700
 701     String res = String::fromUTF8(log.get(), returnedLogLength);
 702     return res;
 703 }
 704
 705 void GraphicsContext3DInternal::getRenderbufferParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value)
 706 {
 707     makeContextCurrent();
 708     GL_CMD(glGetRenderbufferParameteriv(target, pname, value));
 709 }
 710
 711 void GraphicsContext3DInternal::getShaderiv(Platform3DObject shader, GC3Denum pname, GC3Dint* value)
 712 {
 713     makeContextCurrent();
 714     GL_CMD(glGetShaderiv(shader, pname, value));
 715 }
 716
 717 String GraphicsContext3DInternal::getShaderInfoLog(Platform3DObject shader)
 718 {
 719     makeContextCurrent();
 720
 721     int logLength = 0;
 722     GL_CMD(glGetShaderiv(shader, GraphicsContext3D::INFO_LOG_LENGTH, &logLength));
 723     if (logLength <= 1)
 724         return String();
 725
 726     OwnArrayPtr<char> log = adoptArrayPtr(new char[logLength]);
 727     if (!log)
 728         return String();
 729
 730     int returnedLogLength = 0;
 731     GL_CMD(glGetShaderInfoLog(shader, logLength, &returnedLogLength, log.get()));
 732     ASSERT(logLength == returnedLogLength + 1);
 733
 734     String res = String::fromUTF8(log.get(), returnedLogLength);
 735     return res;
 736 }
 737
 738 String GraphicsContext3DInternal::getShaderSource(Platform3DObject shader)
 739 {
 740     makeContextCurrent();
 741
 742     int logLength = 0;
 743     GL_CMD(glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &logLength));
 744     if (logLength <= 1)
 745         return String();
 746
 747     OwnArrayPtr<char> log = adoptArrayPtr(new char[logLength]);
 748     if (!log)
 749         return String();
 750
 751     int returnedLogLength = 0;
 752     GL_CMD(glGetShaderSource(shader, logLength, &returnedLogLength, log.get()));
 753     ASSERT(logLength == returnedLogLength + 1);
 754
 755     String res = String::fromUTF8(log.get(), returnedLogLength);
 756     return res;
 757 }
 758
 759 String GraphicsContext3DInternal::getString(GC3Denum name)
 760 {
 761     makeContextCurrent();
 762     return String(reinterpret_cast<const char*>(GL_CMD(glGetString(name))));
 763 }
 764
 765 void GraphicsContext3DInternal::getTexParameterfv(GC3Denum target, GC3Denum pname, GC3Dfloat* value)
 766 {
 767     makeContextCurrent();
 768     GL_CMD(glGetTexParameterfv(target, pname, value));
 769 }
 770
 771 void GraphicsContext3DInternal::getTexParameteriv(GC3Denum target, GC3Denum pname, GC3Dint* value)
 772 {
 773     makeContextCurrent();
 774     GL_CMD(glGetTexParameteriv(target, pname, value));
 775 }
 776
 777 void GraphicsContext3DInternal::getUniformfv(Platform3DObject program, GC3Dint location, GC3Dfloat* value)
 778 {
 779     makeContextCurrent();
 780     GL_CMD(glGetUniformfv(program, location, value));
 781 }
 782
 783 void GraphicsContext3DInternal::getUniformiv(Platform3DObject program, GC3Dint location, GC3Dint* value)
 784 {
 785     makeContextCurrent();
 786     GL_CMD(glGetUniformiv(program, location, value));
 787 }
 788
 789 GC3Dint GraphicsContext3DInternal::getUniformLocation(Platform3DObject program, const String& name)
 790 {
 791     makeContextCurrent();
 792     return GL_CMD(glGetUniformLocation(program, name.utf8().data()));
 793 }
 794
 795 void GraphicsContext3DInternal::getVertexAttribfv(GC3Duint index, GC3Denum pname, GC3Dfloat* value)
 796 {
 797     makeContextCurrent();
 798     GL_CMD(glGetVertexAttribfv(index, pname, value));
 799 }
 800
 801 void GraphicsContext3DInternal::getVertexAttribiv(GC3Duint index, GC3Denum pname, GC3Dint* value)
 802 {
 803     makeContextCurrent();
 804     GL_CMD(glGetVertexAttribiv(index, pname, value));
 805 }
 806
 807 GC3Dsizeiptr GraphicsContext3DInternal::getVertexAttribOffset(GC3Duint index, GC3Denum pname)
 808 {
 809     makeContextCurrent();
 810     void* pointer;
 811     GL_CMD(glGetVertexAttribPointerv(index, pname, &pointer));
 812     return reinterpret_cast<GC3Dsizeiptr>(pointer);
 813 }
 814
 815 void GraphicsContext3DInternal::hint(GC3Denum target, GC3Denum mode)
 816 {
 817     makeContextCurrent();
 818     GL_CMD(glHint(target, mode));
 819 }
 820
 821 GC3Dboolean GraphicsContext3DInternal::isBuffer(Platform3DObject buffer)
 822 {
 823     if (!buffer)
 824         return GL_FALSE;
 825
 826     makeContextCurrent();
 827     return GL_CMD(glIsBuffer(buffer));
 828 }
 829
 830 GC3Dboolean GraphicsContext3DInternal::isEnabled(GC3Denum cap)
 831 {
 832     makeContextCurrent();
 833     return GL_CMD(glIsEnabled(cap));
 834 }
 835
 836 GC3Dboolean GraphicsContext3DInternal::isFramebuffer(Platform3DObject framebuffer)
 837 {
 838     if (!framebuffer)
 839         return GL_FALSE;
 840
 841     makeContextCurrent();
 842     return GL_CMD(glIsFramebuffer(framebuffer));
 843 }
 844
 845 GC3Dboolean GraphicsContext3DInternal::isProgram(Platform3DObject program)
 846 {
 847     if (!program)
 848         return GL_FALSE;
 849
 850     makeContextCurrent();
 851     return GL_CMD(glIsProgram(program));
 852 }
 853
 854 GC3Dboolean GraphicsContext3DInternal::isRenderbuffer(Platform3DObject renderbuffer)
 855 {
 856     if (!renderbuffer)
 857         return GL_FALSE;
 858
 859     makeContextCurrent();
 860     return GL_CMD(glIsRenderbuffer(renderbuffer));
 861 }
 862
 863 GC3Dboolean GraphicsContext3DInternal::isShader(Platform3DObject shader)
 864 {
 865     if (!shader)
 866         return GL_FALSE;
 867
 868     makeContextCurrent();
 869     return GL_CMD(glIsShader(shader));
 870 }
 871
 872 GC3Dboolean GraphicsContext3DInternal::isTexture(Platform3DObject texture)
 873 {
 874     if (!texture)
 875         return GL_FALSE;
 876
 877     makeContextCurrent();
 878     return GL_CMD(glIsTexture(texture));
 879 }
 880
 881 void GraphicsContext3DInternal::lineWidth(GC3Dfloat width)
 882 {
 883     makeContextCurrent();
 884     GL_CMD(glLineWidth(width));
 885 }
 886
 887 void GraphicsContext3DInternal::linkProgram(Platform3DObject program)
 888 {
 889     makeContextCurrent();
 890     GL_CMD(glLinkProgram(program));
 891 }
 892
 893 void GraphicsContext3DInternal::pixelStorei(GC3Denum pname, GC3Dint param)
 894 {
 895     makeContextCurrent();
 896     GL_CMD(glPixelStorei(pname, param));
 897 }
 898
 899 void GraphicsContext3DInternal::polygonOffset(GC3Dfloat factor, GC3Dfloat units)
 900 {
 901     makeContextCurrent();
 902     GL_CMD(glPolygonOffset(factor, units));
 903 }
 904
 905 void GraphicsContext3DInternal::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, void* data)
 906 {
 907     makeContextCurrent();
 908
 909     GL_CMD(glFlush());
 910     GL_CMD(glReadPixels(x, y, width, height, format, type, data));
 911 }
 912
 913 void GraphicsContext3DInternal::releaseShaderCompiler()
 914 {
 915     makeContextCurrent();
 916 }
 917
 918 void GraphicsContext3DInternal::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
 919 {
 920     makeContextCurrent();
 921     GL_CMD(glRenderbufferStorage(target, internalformat, width, height));
 922 }
 923
 924 void GraphicsContext3DInternal::sampleCoverage(GC3Dclampf value, GC3Dboolean invert)
 925 {
 926     makeContextCurrent();
 927     GL_CMD(glSampleCoverage(value, invert));
 928 }
 929
 930 void GraphicsContext3DInternal::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
 931 {
 932     makeContextCurrent();
 933     GL_CMD(glScissor(x, y, width, height));
 934 }
 935
 936 void GraphicsContext3DInternal::shaderSource(Platform3DObject shader, const String& string)
 937 {
 938     makeContextCurrent();
 939     CString sourceCS = string.utf8();
 940     const char* str = sourceCS.data();
 941     int length = string.length();
 942     GL_CMD(glShaderSource(shader, 1, &str, &length));
 943 }
 944
 945 void GraphicsContext3DInternal::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)
 946 {
 947     makeContextCurrent();
 948     GL_CMD(glStencilFunc(func, ref, mask));
 949 }
 950
 951 void GraphicsContext3DInternal::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)
 952 {
 953     makeContextCurrent();
 954     GL_CMD(glStencilFuncSeparate(face, func, ref, mask));
 955 }
 956
 957 void GraphicsContext3DInternal::stencilMask(GC3Duint mask)
 958 {
 959     makeContextCurrent();
 960     GL_CMD(glStencilMask(mask));
 961 }
 962
 963 void GraphicsContext3DInternal::stencilMaskSeparate(GC3Denum face, GC3Duint mask)
 964 {
 965     makeContextCurrent();
 966     GL_CMD(glStencilMaskSeparate(face, mask));
 967 }
 968
 969 void GraphicsContext3DInternal::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
 970 {
 971     makeContextCurrent();
 972     GL_CMD(glStencilOp(fail, zfail, zpass));
 973 }
 974
 975 void GraphicsContext3DInternal::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
 976 {
 977     makeContextCurrent();
 978     GL_CMD(glStencilOpSeparate(face, fail, zfail, zpass));
 979 }
 980
 981 bool GraphicsContext3DInternal::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels)
 982 {
 983     makeContextCurrent();
 984     GL_CMD(glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels));
 985     return true;
 986 }
 987
 988 void GraphicsContext3DInternal::texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param)
 989 {
 990     makeContextCurrent();
 991     GL_CMD(glTexParameterf(target, pname, param));
 992 }
 993
 994 void GraphicsContext3DInternal::texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param)
 995 {
 996     makeContextCurrent();
 997     GL_CMD(glTexParameteri(target, pname, param));
 998 }
 999
1000 void GraphicsContext3DInternal::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels)
1001 {
1002     makeContextCurrent();
1003     GL_CMD(glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels));
1004 }
1005
1006 void GraphicsContext3DInternal::uniform1f(GC3Dint location, GC3Dfloat x)
1007 {
1008     makeContextCurrent();
1009     GL_CMD(glUniform1f(location, x));
1010 }
1011
1012 void GraphicsContext3DInternal::uniform1fv(GC3Dint location, GC3Dsizei size, GC3Dfloat* v)
1013 {
1014     makeContextCurrent();
1015     GL_CMD(glUniform1fv(location, size, v));
1016 }
1017
1018 void GraphicsContext3DInternal::uniform1i(GC3Dint location, GC3Dint x)
1019 {
1020     makeContextCurrent();
1021     GL_CMD(glUniform1i(location, x));
1022 }
1023
1024 void GraphicsContext3DInternal::uniform1iv(GC3Dint location, GC3Dsizei size, GC3Dint* v)
1025 {
1026     makeContextCurrent();
1027     GL_CMD(glUniform1iv(location, size, v));
1028 }
1029
1030 void GraphicsContext3DInternal::uniform2f(GC3Dint location, GC3Dfloat x, GC3Dfloat y)
1031 {
1032     makeContextCurrent();
1033     GL_CMD(glUniform2f(location, x, y));
1034 }
1035
1036 void GraphicsContext3DInternal::uniform2fv(GC3Dint location, GC3Dsizei size, GC3Dfloat* v)
1037 {
1038     makeContextCurrent();
1039     GL_CMD(glUniform2fv(location, size, v));
1040 }
1041
1042 void GraphicsContext3DInternal::uniform2i(GC3Dint location, GC3Dint x, GC3Dint y)
1043 {
1044     makeContextCurrent();
1045     GL_CMD(glUniform2i(location, x, y));
1046 }
1047
1048 void GraphicsContext3DInternal::uniform2iv(GC3Dint location, GC3Dsizei size, GC3Dint* v)
1049 {
1050     makeContextCurrent();
1051     GL_CMD(glUniform2iv(location, size, v));
1052 }
1053
1054 void GraphicsContext3DInternal::uniform3f(GC3Dint location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z)
1055 {
1056     makeContextCurrent();
1057     GL_CMD(glUniform3f(location, x, y, z));
1058 }
1059
1060 void GraphicsContext3DInternal::uniform3fv(GC3Dint location, GC3Dsizei size, GC3Dfloat* v)
1061 {
1062     makeContextCurrent();
1063     GL_CMD(glUniform3fv(location, size, v));
1064 }
1065
1066 void GraphicsContext3DInternal::uniform3i(GC3Dint location, GC3Dint x, GC3Dint y, GC3Dint z)
1067 {
1068     makeContextCurrent();
1069     GL_CMD(glUniform3i(location, x, y, z));
1070 }
1071
1072 void GraphicsContext3DInternal::uniform3iv(GC3Dint location, GC3Dsizei size, GC3Dint* v)
1073 {
1074     makeContextCurrent();
1075     GL_CMD(glUniform3iv(location, size, v));
1076 }
1077
1078 void GraphicsContext3DInternal::uniform4f(GC3Dint location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w)
1079 {
1080     makeContextCurrent();
1081     GL_CMD(glUniform4f(location, x, y, z, w));
1082 }
1083
1084 void GraphicsContext3DInternal::uniform4fv(GC3Dint location, GC3Dsizei size, GC3Dfloat* v)
1085 {
1086     makeContextCurrent();
1087     GL_CMD(glUniform4fv(location, size, v));
1088 }
1089
1090 void GraphicsContext3DInternal::uniform4i(GC3Dint location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w)
1091 {
1092     makeContextCurrent();
1093     GL_CMD(glUniform4i(location, x, y, z, w));
1094 }
1095
1096 void GraphicsContext3DInternal::uniform4iv(GC3Dint location, GC3Dsizei size, GC3Dint* v)
1097 {
1098     makeContextCurrent();
1099     GL_CMD(glUniform4iv(location, size, v));
1100 }
1101
1102 void GraphicsContext3DInternal::uniformMatrix2fv(GC3Dint location, GC3Dsizei size, GC3Dboolean transpose, GC3Dfloat* value)
1103 {
1104     makeContextCurrent();
1105     GL_CMD(glUniformMatrix2fv(location, size, transpose, value));
1106 }
1107
1108 void GraphicsContext3DInternal::uniformMatrix3fv(GC3Dint location, GC3Dsizei size, GC3Dboolean transpose, GC3Dfloat* value)
1109 {
1110     makeContextCurrent();
1111     GL_CMD(glUniformMatrix3fv(location, size, transpose, value));
1112 }
1113
1114 void GraphicsContext3DInternal::uniformMatrix4fv(GC3Dint location, GC3Dsizei size, GC3Dboolean transpose, GC3Dfloat* value)
1115 {
1116     makeContextCurrent();
1117     GL_CMD(glUniformMatrix4fv(location, size, transpose, value));
1118 }
1119
1120 void GraphicsContext3DInternal::useProgram(Platform3DObject program)
1121 {
1122     makeContextCurrent();
1123     GL_CMD(glUseProgram(program));
1124 }
1125
1126 void GraphicsContext3DInternal::validateProgram(Platform3DObject program)
1127 {
1128     makeContextCurrent();
1129     GL_CMD(glValidateProgram(program));
1130 }
1131
1132 void GraphicsContext3DInternal::vertexAttrib1f(GC3Duint index, GC3Dfloat x)
1133 {
1134     makeContextCurrent();
1135     GL_CMD(glVertexAttrib1f(index, x));
1136 }
1137
1138 void GraphicsContext3DInternal::vertexAttrib1fv(GC3Duint index, GC3Dfloat* values)
1139 {
1140     makeContextCurrent();
1141     GL_CMD(glVertexAttrib1fv(index, values));
1142 }
1143
1144 void GraphicsContext3DInternal::vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y)
1145 {
1146     makeContextCurrent();
1147     GL_CMD(glVertexAttrib2f(index, x, y));
1148 }
1149
1150 void GraphicsContext3DInternal::vertexAttrib2fv(GC3Duint index, GC3Dfloat* values)
1151 {
1152     makeContextCurrent();
1153     GL_CMD(glVertexAttrib2fv(index, values));
1154 }
1155
1156 void GraphicsContext3DInternal::vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z)
1157 {
1158     makeContextCurrent();
1159     GL_CMD(glVertexAttrib3f(index, x, y, z));
1160 }
1161
1162 void GraphicsContext3DInternal::vertexAttrib3fv(GC3Duint index, GC3Dfloat* values)
1163 {
1164     makeContextCurrent();
1165     GL_CMD(glVertexAttrib3fv(index, values));
1166 }
1167
1168 void GraphicsContext3DInternal::vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w)
1169 {
1170     makeContextCurrent();
1171     GL_CMD(glVertexAttrib4f(index, x, y, z, w));
1172 }
1173
1174 void GraphicsContext3DInternal::vertexAttrib4fv(GC3Duint index, GC3Dfloat* values)
1175 {
1176     makeContextCurrent();
1177     GL_CMD(glVertexAttrib4fv(index, values));
1178 }
1179
1180 void GraphicsContext3DInternal::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, GC3Dintptr offset)
1181 {
1182     makeContextCurrent();
1183     GL_CMD(glVertexAttribPointer(index, size, type, normalized, stride, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset))));
1184 }
1185
1186 void GraphicsContext3DInternal::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
1187 {
1188     makeContextCurrent();
1189     GL_CMD(glViewport(x, y, width, height));
1190 }
1191
1192 Platform3DObject GraphicsContext3DInternal::createBuffer()
1193 {
1194     makeContextCurrent();
1195     Platform3DObject o = 0;
1196     GL_CMD(glGenBuffers(1, &o));
1197     return o;
1198 }
1199
1200 Platform3DObject GraphicsContext3DInternal::createFramebuffer()
1201 {
1202     makeContextCurrent();
1203     Platform3DObject o = 0;
1204     GL_CMD(glGenFramebuffers(1, &o));
1205     return o;
1206 }
1207
1208 Platform3DObject GraphicsContext3DInternal::createProgram()
1209 {
1210     makeContextCurrent();
1211     return GL_CMD(glCreateProgram());
1212 }
1213
1214 Platform3DObject GraphicsContext3DInternal::createRenderbuffer()
1215 {
1216     makeContextCurrent();
1217     Platform3DObject o;
1218     GL_CMD(glGenRenderbuffers(1, &o));
1219     return o;
1220 }
1221
1222 Platform3DObject GraphicsContext3DInternal::createShader(GC3Denum shaderType)
1223 {
1224     makeContextCurrent();
1225     return GL_CMD(glCreateShader(shaderType));
1226 }
1227
1228 Platform3DObject GraphicsContext3DInternal::createTexture()
1229 {
1230     makeContextCurrent();
1231     Platform3DObject o;
1232     GL_CMD(glGenTextures(1, &o));
1233     return o;
1234 }
1235
1236 void GraphicsContext3DInternal::deleteBuffer(Platform3DObject buffer)
1237 {
1238     makeContextCurrent();
1239     GL_CMD(glDeleteBuffers(1, &buffer));
1240 }
1241
1242 void GraphicsContext3DInternal::deleteFramebuffer(Platform3DObject framebuffer)
1243 {
1244     makeContextCurrent();
1245     GL_CMD(glDeleteFramebuffers(1, &framebuffer));
1246 }
1247
1248 void GraphicsContext3DInternal::deleteProgram(Platform3DObject program)
1249 {
1250     makeContextCurrent();
1251     GL_CMD(glDeleteProgram(program));
1252 }
1253
1254 void GraphicsContext3DInternal::deleteRenderbuffer(Platform3DObject renderbuffer)
1255 {
1256     makeContextCurrent();
1257     GL_CMD(glDeleteRenderbuffers(1, &renderbuffer));
1258 }
1259
1260 void GraphicsContext3DInternal::deleteShader(Platform3DObject shader)
1261 {
1262     makeContextCurrent();
1263     GL_CMD(glDeleteShader(shader));
1264 }
1265
1266 void GraphicsContext3DInternal::deleteTexture(Platform3DObject texture)
1267 {
1268     makeContextCurrent();
1269     GL_CMD(glDeleteTextures(1, &texture));
1270 }
1271
1272 } // namespace WebCore
1273
1274
1275 #endif
1276 #endif