Source/WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp

   1 /*
   2     Copyright (C) 2010 Tieto Corporation.
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Lesser General Public
   6     License as published by the Free Software Foundation; either
   7     version 2.1 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     Lesser General Public License for more details.
  13
  14     You should have received a copy of the GNU Lesser General Public
  15     License along with this library; if not, write to the Free Software
  16     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18
  19 #include "config.h"
  20
  21 #include "GraphicsContext3D.h"
  22
  23 #include "WebGLObject.h"
  24 #include "CanvasRenderingContext.h"
  25 #include "Extensions3DQt.h"
  26 #include "GraphicsContext.h"
  27 #include "HTMLCanvasElement.h"
  28 #include "HostWindow.h"
  29 #include "ImageBuffer.h"
  30 #include "NotImplemented.h"
  31 #include "QWebPageClient.h"
  32 #include <QAbstractScrollArea>
  33 #include <QGLContext>
  34 #include <wtf/UnusedParam.h>
  35 #include <wtf/text/CString.h>
  36
  37 #if ENABLE(WEBGL)
  38
  39 namespace WebCore {
  40
  41 #if !defined(GLchar)
  42 typedef char GLchar;
  43 #endif
  44
  45 #if !defined(APIENTRY)
  46 #define APIENTRY
  47 #endif
  48
  49 #ifdef QT_OPENGL_ES_2
  50 typedef GLsizeiptr GLsizeiptrType;
  51 typedef GLintptr GLintptrType;
  52 #else
  53 typedef ptrdiff_t GLsizeiptrType;
  54 typedef ptrdiff_t GLintptrType;
  55 #endif
  56
  57 typedef void (APIENTRY* glActiveTextureType) (GLenum);
  58 typedef void (APIENTRY* glAttachShaderType) (GLuint, GLuint);
  59 typedef void (APIENTRY* glBindAttribLocationType) (GLuint, GLuint, const char*);
  60 typedef void (APIENTRY* glBindBufferType) (GLenum, GLuint);
  61 typedef void (APIENTRY* glBindFramebufferType) (GLenum, GLuint);
  62 typedef void (APIENTRY* glBindRenderbufferType) (GLenum, GLuint);
  63 typedef void (APIENTRY* glBlendColorType) (GLclampf, GLclampf, GLclampf, GLclampf);
  64 typedef void (APIENTRY* glBlendEquationType) (GLenum);
  65 typedef void (APIENTRY* glBlendEquationSeparateType)(GLenum, GLenum);
  66 typedef void (APIENTRY* glBlendFuncSeparateType)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
  67 typedef void (APIENTRY* glBufferDataType) (GLenum, GLsizeiptrType, const GLvoid*, GLenum);
  68 typedef void (APIENTRY* glBufferSubDataType) (GLenum, GLintptrType, GLsizeiptrType, const GLvoid*);
  69 typedef GLenum (APIENTRY* glCheckFramebufferStatusType) (GLenum);
  70 typedef void (APIENTRY* glCompileShaderType) (GLuint);
  71 typedef GLuint (APIENTRY* glCreateProgramType) ();
  72 typedef GLuint (APIENTRY* glCreateShaderType) (GLenum);
  73 typedef void (APIENTRY* glDeleteBuffersType) (GLsizei, const GLuint*);
  74 typedef void (APIENTRY* glDeleteFramebuffersType) (GLsizei n, const GLuint*);
  75 typedef void (APIENTRY* glDeleteProgramType) (GLuint);
  76 typedef void (APIENTRY* glDeleteRenderbuffersType) (GLsizei n, const GLuint*);
  77 typedef void (APIENTRY* glDeleteShaderType) (GLuint);
  78 typedef void (APIENTRY* glDetachShaderType) (GLuint, GLuint);
  79 typedef void (APIENTRY* glDisableVertexAttribArrayType) (GLuint);
  80 typedef void (APIENTRY* glEnableVertexAttribArrayType) (GLuint);
  81 typedef void (APIENTRY* glFramebufferRenderbufferType) (GLenum, GLenum, GLenum, GLuint);
  82 typedef void (APIENTRY* glFramebufferTexture2DType) (GLenum, GLenum, GLenum, GLuint, GLint);
  83 typedef void (APIENTRY* glGenBuffersType) (GLsizei, GLuint*);
  84 typedef void (APIENTRY* glGenerateMipmapType) (GLenum target);
  85 typedef void (APIENTRY* glGenFramebuffersType) (GLsizei, GLuint*);
  86 typedef void (APIENTRY* glGenRenderbuffersType) (GLsizei, GLuint*);
  87 typedef void (APIENTRY* glGetActiveAttribType) (GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*);
  88 typedef void (APIENTRY* glGetActiveUniformType) (GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*);
  89 typedef void (APIENTRY* glGetAttachedShadersType) (GLuint, GLsizei, GLsizei*, GLuint*);
  90 typedef GLint (APIENTRY* glGetAttribLocationType) (GLuint, const char*);
  91 typedef void (APIENTRY* glGetBufferParameterivType) (GLenum, GLenum, GLint*);
  92 typedef void (APIENTRY* glGetFramebufferAttachmentParameterivType) (GLenum, GLenum, GLenum, GLint* params);
  93 typedef void (APIENTRY* glGetProgramInfoLogType) (GLuint, GLsizei, GLsizei*, char*);
  94 typedef void (APIENTRY* glGetProgramivType) (GLuint, GLenum, GLint*);
  95 typedef void (APIENTRY* glGetRenderbufferParameterivType) (GLenum, GLenum, GLint*);
  96 typedef void (APIENTRY* glGetShaderInfoLogType) (GLuint, GLsizei, GLsizei*, char*);
  97 typedef void (APIENTRY* glGetShaderivType) (GLuint, GLenum, GLint*);
  98 typedef void (APIENTRY* glGetShaderSourceType) (GLuint, GLsizei, GLsizei*, char*);
  99 typedef GLint (APIENTRY* glGetUniformLocationType) (GLuint, const char*);
 100 typedef void (APIENTRY* glGetUniformfvType) (GLuint, GLint, GLfloat*);
 101 typedef void (APIENTRY* glGetUniformivType) (GLuint, GLint, GLint*);
 102 typedef void (APIENTRY* glGetVertexAttribfvType) (GLuint, GLenum, GLfloat*);
 103 typedef void (APIENTRY* glGetVertexAttribivType) (GLuint, GLenum, GLint*);
 104 typedef void (APIENTRY* glGetVertexAttribPointervType) (GLuint, GLenum, GLvoid**);
 105 typedef GLboolean (APIENTRY* glIsBufferType) (GLuint);
 106 typedef GLboolean (APIENTRY* glIsFramebufferType) (GLuint);
 107 typedef GLboolean (APIENTRY* glIsProgramType) (GLuint);
 108 typedef GLboolean (APIENTRY* glIsRenderbufferType) (GLuint);
 109 typedef GLboolean (APIENTRY* glIsShaderType) (GLuint);
 110 typedef void (APIENTRY* glLinkProgramType) (GLuint);
 111 typedef void (APIENTRY* glRenderbufferStorageType) (GLenum, GLenum, GLsizei, GLsizei);
 112 typedef void (APIENTRY* glSampleCoverageType) (GLclampf, GLboolean);
 113 typedef void (APIENTRY* glShaderSourceType) (GLuint, GLsizei, const char**, const GLint*);
 114 typedef void (APIENTRY* glStencilFuncSeparateType) (GLenum, GLenum, GLint, GLuint);
 115 typedef void (APIENTRY* glStencilMaskSeparateType) (GLenum, GLuint);
 116 typedef void (APIENTRY* glStencilOpSeparateType) (GLenum, GLenum, GLenum, GLenum);
 117 typedef void (APIENTRY* glUniform1fType) (GLint, GLfloat);
 118 typedef void (APIENTRY* glUniform1fvType) (GLint, GLsizei, const GLfloat*);
 119 typedef void (APIENTRY* glUniform1iType) (GLint, GLint);
 120 typedef void (APIENTRY* glUniform1ivType) (GLint, GLsizei, const GLint*);
 121 typedef void (APIENTRY* glUniform2fType) (GLint, GLfloat, GLfloat);
 122 typedef void (APIENTRY* glUniform2fvType) (GLint, GLsizei, const GLfloat*);
 123 typedef void (APIENTRY* glUniform2iType) (GLint, GLint, GLint);
 124 typedef void (APIENTRY* glUniform2ivType) (GLint, GLsizei, const GLint*);
 125 typedef void (APIENTRY* glUniform3fType) (GLint, GLfloat, GLfloat, GLfloat);
 126 typedef void (APIENTRY* glUniform3fvType) (GLint, GLsizei, const GLfloat*);
 127 typedef void (APIENTRY* glUniform3iType) (GLint, GLint, GLint, GLint);
 128 typedef void (APIENTRY* glUniform3ivType) (GLint, GLsizei, const GLint*);
 129 typedef void (APIENTRY* glUniform4fType) (GLint, GLfloat, GLfloat, GLfloat, GLfloat);
 130 typedef void (APIENTRY* glUniform4fvType) (GLint, GLsizei, const GLfloat*);
 131 typedef void (APIENTRY* glUniform4iType) (GLint, GLint, GLint, GLint, GLint);
 132 typedef void (APIENTRY* glUniform4ivType) (GLint, GLsizei, const GLint*);
 133 typedef void (APIENTRY* glUniformMatrix2fvType) (GLint, GLsizei, GLboolean, const GLfloat*);
 134 typedef void (APIENTRY* glUniformMatrix3fvType) (GLint, GLsizei, GLboolean, const GLfloat*);
 135 typedef void (APIENTRY* glUniformMatrix4fvType) (GLint, GLsizei, GLboolean, const GLfloat*);
 136 typedef void (APIENTRY* glUseProgramType) (GLuint);
 137 typedef void (APIENTRY* glValidateProgramType) (GLuint);
 138 typedef void (APIENTRY* glVertexAttrib1fType) (GLuint, const GLfloat);
 139 typedef void (APIENTRY* glVertexAttrib1fvType) (GLuint, const GLfloat*);
 140 typedef void (APIENTRY* glVertexAttrib2fType) (GLuint, const GLfloat, const GLfloat);
 141 typedef void (APIENTRY* glVertexAttrib2fvType) (GLuint, const GLfloat*);
 142 typedef void (APIENTRY* glVertexAttrib3fType) (GLuint, const GLfloat, const GLfloat, const GLfloat);
 143 typedef void (APIENTRY* glVertexAttrib3fvType) (GLuint, const GLfloat*);
 144 typedef void (APIENTRY* glVertexAttrib4fType) (GLuint, const GLfloat, const GLfloat, const GLfloat, const GLfloat);
 145 typedef void (APIENTRY* glVertexAttrib4fvType) (GLuint, const GLfloat*);
 146 typedef void (APIENTRY* glVertexAttribPointerType) (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid*);
 147
 148 class GraphicsContext3DInternal {
 149 public:
 150     GraphicsContext3DInternal(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow);
 151     ~GraphicsContext3DInternal();
 152
 153     bool isContextValid() { return m_contextValid; }
 154     QGLWidget* getOwnerGLWidget(QWebPageClient* webPageClient);
 155
 156     glActiveTextureType activeTexture;
 157     glAttachShaderType attachShader;
 158     glBindAttribLocationType bindAttribLocation;
 159     glBindBufferType bindBuffer;
 160     glBindFramebufferType bindFramebuffer;
 161     glBindRenderbufferType bindRenderbuffer;
 162     glBlendColorType blendColor;
 163     glBlendEquationType blendEquation;
 164     glBlendEquationSeparateType blendEquationSeparate;
 165     glBlendFuncSeparateType blendFuncSeparate;
 166     glBufferDataType bufferData;
 167     glBufferSubDataType bufferSubData;
 168     glCheckFramebufferStatusType checkFramebufferStatus;
 169     glCompileShaderType compileShader;
 170     glCreateProgramType createProgram;
 171     glCreateShaderType createShader;
 172     glDeleteBuffersType deleteBuffers;
 173     glDeleteFramebuffersType deleteFramebuffers;
 174     glDeleteProgramType deleteProgram;
 175     glDeleteRenderbuffersType deleteRenderbuffers;
 176     glDeleteShaderType deleteShader;
 177     glDetachShaderType detachShader;
 178     glDisableVertexAttribArrayType disableVertexAttribArray;
 179     glEnableVertexAttribArrayType enableVertexAttribArray;
 180     glFramebufferRenderbufferType framebufferRenderbuffer;
 181     glFramebufferTexture2DType framebufferTexture2D;
 182     glGenBuffersType genBuffers;
 183     glGenerateMipmapType generateMipmap;
 184     glGenFramebuffersType genFramebuffers;
 185     glGenRenderbuffersType genRenderbuffers;
 186     glGetActiveAttribType getActiveAttrib;
 187     glGetActiveUniformType getActiveUniform;
 188     glGetAttachedShadersType getAttachedShaders;
 189     glGetAttribLocationType getAttribLocation;
 190     glGetBufferParameterivType getBufferParameteriv;
 191     glGetFramebufferAttachmentParameterivType getFramebufferAttachmentParameteriv;
 192     glGetProgramInfoLogType getProgramInfoLog;
 193     glGetProgramivType getProgramiv;
 194     glGetRenderbufferParameterivType getRenderbufferParameteriv;
 195     glGetShaderInfoLogType getShaderInfoLog;
 196     glGetShaderivType getShaderiv;
 197     glGetShaderSourceType getShaderSource;
 198     glGetUniformfvType getUniformfv;
 199     glGetUniformivType getUniformiv;
 200     glGetUniformLocationType getUniformLocation;
 201     glGetVertexAttribfvType getVertexAttribfv;
 202     glGetVertexAttribivType getVertexAttribiv;
 203     glGetVertexAttribPointervType getVertexAttribPointerv;
 204     glIsBufferType isBuffer;
 205     glIsFramebufferType isFramebuffer;
 206     glIsProgramType isProgram;
 207     glIsRenderbufferType isRenderbuffer;
 208     glIsShaderType isShader;
 209     glLinkProgramType linkProgram;
 210     glRenderbufferStorageType renderbufferStorage;
 211     glSampleCoverageType sampleCoverage;
 212     glShaderSourceType shaderSource;
 213     glStencilFuncSeparateType stencilFuncSeparate;
 214     glStencilMaskSeparateType stencilMaskSeparate;
 215     glStencilOpSeparateType stencilOpSeparate;
 216     glUniform1fType uniform1f;
 217     glUniform1fvType uniform1fv;
 218     glUniform1iType uniform1i;
 219     glUniform1ivType uniform1iv;
 220     glUniform2fType uniform2f;
 221     glUniform2fvType uniform2fv;
 222     glUniform2iType uniform2i;
 223     glUniform2ivType uniform2iv;
 224     glUniform3fType uniform3f;
 225     glUniform3fvType uniform3fv;
 226     glUniform3iType uniform3i;
 227     glUniform3ivType uniform3iv;
 228     glUniform4fType uniform4f;
 229     glUniform4fvType uniform4fv;
 230     glUniform4iType uniform4i;
 231     glUniform4ivType uniform4iv;
 232     glUniformMatrix2fvType uniformMatrix2fv;
 233     glUniformMatrix3fvType uniformMatrix3fv;
 234     glUniformMatrix4fvType uniformMatrix4fv;
 235     glUseProgramType useProgram;
 236     glValidateProgramType validateProgram;
 237     glVertexAttrib1fType vertexAttrib1f;
 238     glVertexAttrib1fvType vertexAttrib1fv;
 239     glVertexAttrib2fType vertexAttrib2f;
 240     glVertexAttrib2fvType vertexAttrib2fv;
 241     glVertexAttrib3fType vertexAttrib3f;
 242     glVertexAttrib3fvType vertexAttrib3fv;
 243     glVertexAttrib4fType vertexAttrib4f;
 244     glVertexAttrib4fvType vertexAttrib4fv;
 245     glVertexAttribPointerType vertexAttribPointer;
 246
 247     GraphicsContext3D::Attributes m_attrs;
 248     HostWindow* m_hostWindow;
 249     QGLWidget* m_glWidget;
 250     GLuint m_texture;
 251     GLuint m_mainFbo;
 252     GLuint m_currentFbo;
 253     GLuint m_depthBuffer;
 254     QImage m_pixels;
 255     ListHashSet<unsigned long> m_syntheticErrors;
 256
 257     OwnPtr<Extensions3DQt> m_extensions;
 258
 259 private:
 260
 261     void* getProcAddress(const String& proc);
 262     bool m_contextValid;
 263 };
 264
 265 #if defined (QT_OPENGL_ES_2)
 266 #define GET_PROC_ADDRESS(Proc) Proc
 267 #else
 268 #define GET_PROC_ADDRESS(Proc) reinterpret_cast<Proc##Type>(getProcAddress(#Proc));
 269 #endif
 270
 271 bool GraphicsContext3D::isGLES2Compliant() const
 272 {
 273 #if defined (QT_OPENGL_ES_2)
 274     return true;
 275 #else
 276     return false;
 277 #endif
 278 }
 279
 280 // Even with underlying GLES2 driver, the below flags should still be set to
 281 // false if extentions exist (and they almost always do).
 282 bool GraphicsContext3D::isGLES2NPOTStrict() const
 283 {
 284     return false;
 285 }
 286
 287 bool GraphicsContext3D::isErrorGeneratedOnOutOfBoundsAccesses() const
 288 {
 289     return false;
 290 }
 291
 292 int GraphicsContext3D::getGraphicsResetStatusARB()
 293 {
 294     return NO_ERROR;
 295 }
 296
 297
 298 GraphicsContext3DInternal::GraphicsContext3DInternal(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow)
 299     : m_attrs(attrs)
 300     , m_hostWindow(hostWindow)
 301     , m_glWidget(0)
 302     , m_texture(0)
 303     , m_mainFbo(0)
 304     , m_currentFbo(0)
 305     , m_depthBuffer(0)
 306     , m_contextValid(true)
 307 {
 308     QWebPageClient* webPageClient = hostWindow->platformPageClient();
 309     QGLWidget* ownerGLWidget  = getOwnerGLWidget(webPageClient);
 310
 311     if (ownerGLWidget)
 312         m_glWidget = new QGLWidget(0, ownerGLWidget);
 313     else {
 314         QGLFormat format;
 315         format.setDepth(true);
 316         format.setSampleBuffers(true);
 317         format.setStencil(false);
 318
 319         m_glWidget = new QGLWidget(format);
 320     }
 321
 322     if (!m_glWidget->isValid()) {
 323         LOG_ERROR("GraphicsContext3D: QGLWidget does not have a valid context");
 324         m_contextValid = false;
 325         return;
 326     }
 327
 328     QGLFormat format = m_glWidget->format();
 329
 330     m_attrs.alpha = format.alpha();
 331     m_attrs.depth = format.depth();
 332     m_attrs.stencil = format.stencil();
 333     m_attrs.antialias = false;
 334     m_attrs.premultipliedAlpha = true;
 335
 336     m_glWidget->makeCurrent();
 337
 338     activeTexture = GET_PROC_ADDRESS(glActiveTexture);
 339     attachShader = GET_PROC_ADDRESS(glAttachShader);
 340     bindAttribLocation = GET_PROC_ADDRESS(glBindAttribLocation);
 341     bindBuffer = GET_PROC_ADDRESS(glBindBuffer);
 342     bindFramebuffer = GET_PROC_ADDRESS(glBindFramebuffer);
 343     bindRenderbuffer = GET_PROC_ADDRESS(glBindRenderbuffer);
 344     blendColor = GET_PROC_ADDRESS(glBlendColor);
 345     blendEquation = GET_PROC_ADDRESS(glBlendEquation);
 346     blendEquationSeparate = GET_PROC_ADDRESS(glBlendEquationSeparate);
 347     blendFuncSeparate = GET_PROC_ADDRESS(glBlendFuncSeparate);
 348     bufferData = GET_PROC_ADDRESS(glBufferData);
 349     bufferSubData = GET_PROC_ADDRESS(glBufferSubData);
 350     checkFramebufferStatus = GET_PROC_ADDRESS(glCheckFramebufferStatus);
 351     compileShader = GET_PROC_ADDRESS(glCompileShader);
 352     createProgram = GET_PROC_ADDRESS(glCreateProgram);
 353     createShader = GET_PROC_ADDRESS(glCreateShader);
 354     deleteBuffers = GET_PROC_ADDRESS(glDeleteBuffers);
 355     deleteFramebuffers = GET_PROC_ADDRESS(glDeleteFramebuffers);
 356     deleteProgram = GET_PROC_ADDRESS(glDeleteProgram);
 357     deleteRenderbuffers = GET_PROC_ADDRESS(glDeleteRenderbuffers);
 358     deleteShader = GET_PROC_ADDRESS(glDeleteShader);
 359     detachShader = GET_PROC_ADDRESS(glDetachShader);
 360     disableVertexAttribArray = GET_PROC_ADDRESS(glDisableVertexAttribArray);
 361     enableVertexAttribArray = GET_PROC_ADDRESS(glEnableVertexAttribArray);
 362     framebufferRenderbuffer = GET_PROC_ADDRESS(glFramebufferRenderbuffer);
 363     framebufferTexture2D = GET_PROC_ADDRESS(glFramebufferTexture2D);
 364     genBuffers = GET_PROC_ADDRESS(glGenBuffers);
 365     generateMipmap = GET_PROC_ADDRESS(glGenerateMipmap);
 366     genFramebuffers = GET_PROC_ADDRESS(glGenFramebuffers);
 367     genRenderbuffers = GET_PROC_ADDRESS(glGenRenderbuffers);
 368     getActiveAttrib = GET_PROC_ADDRESS(glGetActiveAttrib);
 369     getActiveUniform = GET_PROC_ADDRESS(glGetActiveUniform);
 370     getAttachedShaders = GET_PROC_ADDRESS(glGetAttachedShaders);
 371     getAttribLocation = GET_PROC_ADDRESS(glGetAttribLocation);
 372     getBufferParameteriv = GET_PROC_ADDRESS(glGetBufferParameteriv);
 373     getFramebufferAttachmentParameteriv = GET_PROC_ADDRESS(glGetFramebufferAttachmentParameteriv);
 374     getProgramInfoLog = GET_PROC_ADDRESS(glGetProgramInfoLog);
 375     getProgramiv = GET_PROC_ADDRESS(glGetProgramiv);
 376     getRenderbufferParameteriv = GET_PROC_ADDRESS(glGetRenderbufferParameteriv);
 377     getShaderInfoLog = GET_PROC_ADDRESS(glGetShaderInfoLog);
 378     getShaderiv = GET_PROC_ADDRESS(glGetShaderiv);
 379     getShaderSource = GET_PROC_ADDRESS(glGetShaderSource);
 380     getUniformfv = GET_PROC_ADDRESS(glGetUniformfv);
 381     getUniformiv = GET_PROC_ADDRESS(glGetUniformiv);
 382     getUniformLocation = GET_PROC_ADDRESS(glGetUniformLocation);
 383     getVertexAttribfv = GET_PROC_ADDRESS(glGetVertexAttribfv);
 384     getVertexAttribiv = GET_PROC_ADDRESS(glGetVertexAttribiv);
 385     getVertexAttribPointerv = GET_PROC_ADDRESS(glGetVertexAttribPointerv);
 386     isBuffer = GET_PROC_ADDRESS(glIsBuffer);
 387     isFramebuffer = GET_PROC_ADDRESS(glIsFramebuffer);
 388     isProgram = GET_PROC_ADDRESS(glIsProgram);
 389     isRenderbuffer = GET_PROC_ADDRESS(glIsRenderbuffer);
 390     isShader = GET_PROC_ADDRESS(glIsShader);
 391     linkProgram = GET_PROC_ADDRESS(glLinkProgram);
 392     renderbufferStorage = GET_PROC_ADDRESS(glRenderbufferStorage);
 393     sampleCoverage = GET_PROC_ADDRESS(glSampleCoverage);
 394     shaderSource = GET_PROC_ADDRESS(glShaderSource);
 395     stencilFuncSeparate = GET_PROC_ADDRESS(glStencilFuncSeparate);
 396     stencilMaskSeparate = GET_PROC_ADDRESS(glStencilMaskSeparate);
 397     stencilOpSeparate = GET_PROC_ADDRESS(glStencilOpSeparate);
 398     uniform1f = GET_PROC_ADDRESS(glUniform1f);
 399     uniform1fv = GET_PROC_ADDRESS(glUniform1fv);
 400     uniform1i = GET_PROC_ADDRESS(glUniform1i);
 401     uniform1iv = GET_PROC_ADDRESS(glUniform1iv);
 402     uniform2f = GET_PROC_ADDRESS(glUniform2f);
 403     uniform2fv = GET_PROC_ADDRESS(glUniform2fv);
 404     uniform2i = GET_PROC_ADDRESS(glUniform2i);
 405     uniform2iv = GET_PROC_ADDRESS(glUniform2iv);
 406     uniform3f = GET_PROC_ADDRESS(glUniform3f);
 407     uniform3fv = GET_PROC_ADDRESS(glUniform3fv);
 408     uniform3i = GET_PROC_ADDRESS(glUniform3i);
 409     uniform3iv = GET_PROC_ADDRESS(glUniform3iv);
 410     uniform4f = GET_PROC_ADDRESS(glUniform4f);
 411     uniform4fv = GET_PROC_ADDRESS(glUniform4fv);
 412     uniform4i = GET_PROC_ADDRESS(glUniform4i);
 413     uniform4iv = GET_PROC_ADDRESS(glUniform4iv);
 414     uniformMatrix2fv = GET_PROC_ADDRESS(glUniformMatrix2fv);
 415     uniformMatrix3fv = GET_PROC_ADDRESS(glUniformMatrix3fv);
 416     uniformMatrix4fv = GET_PROC_ADDRESS(glUniformMatrix4fv);
 417     useProgram = GET_PROC_ADDRESS(glUseProgram);
 418     validateProgram = GET_PROC_ADDRESS(glValidateProgram);
 419     vertexAttrib1f = GET_PROC_ADDRESS(glVertexAttrib1f);
 420     vertexAttrib1fv = GET_PROC_ADDRESS(glVertexAttrib1fv);
 421     vertexAttrib2f = GET_PROC_ADDRESS(glVertexAttrib2f);
 422     vertexAttrib2fv = GET_PROC_ADDRESS(glVertexAttrib2fv);
 423     vertexAttrib3f = GET_PROC_ADDRESS(glVertexAttrib3f);
 424     vertexAttrib3fv = GET_PROC_ADDRESS(glVertexAttrib3fv);
 425     vertexAttrib4f = GET_PROC_ADDRESS(glVertexAttrib4f);
 426     vertexAttrib4fv = GET_PROC_ADDRESS(glVertexAttrib4fv);
 427     vertexAttribPointer = GET_PROC_ADDRESS(glVertexAttribPointer);
 428
 429     if (!m_contextValid) {
 430         LOG_ERROR("GraphicsContext3D: All needed OpenGL extensions are not available");
 431         m_contextValid = false;
 432         return;
 433     }
 434
 435     glGenTextures(1, &m_texture);
 436     glBindTexture(GraphicsContext3D::TEXTURE_2D, m_texture);
 437     glTexParameterf(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
 438     glTexParameterf(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
 439     glTexParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE);
 440     glTexParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE);
 441     glTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, 1, 1, 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, 0);
 442     glBindTexture(GraphicsContext3D::TEXTURE_2D, 0);
 443
 444     genFramebuffers(/* count */ 1, &m_mainFbo);
 445     m_currentFbo = m_mainFbo;
 446
 447     bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_mainFbo);
 448
 449     genRenderbuffers(/* count */ 1, &m_depthBuffer);
 450     bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_depthBuffer);
 451 #if defined(QT_OPENGL_ES_2)
 452     renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT16, /* width */ 1, /* height */ 1);
 453 #else
 454     renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT, /* width */ 1, /* height */ 1);
 455 #endif
 456
 457     bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
 458
 459     framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, m_texture, 0);
 460     framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_depthBuffer);
 461     glClearColor(/* red */ 0, /* green */ 0, /* blue */ 0, /* alpha */ 0);
 462
 463     if (checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
 464         LOG_ERROR("GraphicsContext3D: Wasn't able to create the main framebuffer");
 465         m_contextValid = false;
 466     }
 467 }
 468
 469 GraphicsContext3DInternal::~GraphicsContext3DInternal()
 470 {
 471     delete m_glWidget;
 472     m_glWidget = 0;
 473 }
 474
 475 QGLWidget* GraphicsContext3DInternal::getOwnerGLWidget(QWebPageClient* webPageClient)
 476 {
 477     QAbstractScrollArea* scrollArea = qobject_cast<QAbstractScrollArea*>(webPageClient->ownerWidget());
 478
 479     if (scrollArea)
 480         return qobject_cast<QGLWidget*>(scrollArea->viewport());
 481
 482     return 0;
 483 }
 484
 485 void* GraphicsContext3DInternal::getProcAddress(const String& proc)
 486 {
 487     String ext[3] = { "", "ARB", "EXT" };
 488
 489     for (int i = 0; i < 3; i++) {
 490         String nameWithExt = proc + ext[i];
 491
 492         void* addr = m_glWidget->context()->getProcAddress(nameWithExt.utf8().data());
 493         if (addr)
 494             return addr;
 495     }
 496
 497     LOG_ERROR("GraphicsContext3D: Did not find GL function %s", proc.utf8().data());
 498     m_contextValid = false;
 499     return 0;
 500 }
 501
 502 PassOwnPtr<GraphicsContext3D> GraphicsContext3D::create(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, GraphicsContext3D::RenderStyle renderStyle)
 503 {
 504     // This implementation doesn't currently support rendering directly to the HostWindow.
 505     if (renderStyle == RenderDirectlyToHostWindow)
 506         return 0;
 507     OwnPtr<GraphicsContext3D> context(new GraphicsContext3D(attrs, hostWindow, false));
 508     return context->m_internal ? context.release() : 0;
 509 }
 510
 511 GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, bool)
 512     : m_internal(new GraphicsContext3DInternal(attrs, hostWindow))
 513 {
 514     if (!m_internal->isContextValid())
 515         m_internal = 0;
 516 }
 517
 518 GraphicsContext3D::~GraphicsContext3D()
 519 {
 520 }
 521
 522 PlatformGraphicsContext3D GraphicsContext3D::platformGraphicsContext3D()
 523 {
 524     return m_internal->m_glWidget;
 525 }
 526
 527 Platform3DObject GraphicsContext3D::platformTexture() const
 528 {
 529     return m_internal->m_texture;
 530 }
 531
 532 void GraphicsContext3D::makeContextCurrent()
 533 {
 534     m_internal->m_glWidget->makeCurrent();
 535 }
 536
 537 void GraphicsContext3D::paintRenderingResultsToCanvas(CanvasRenderingContext* context)
 538 {
 539     m_internal->m_glWidget->makeCurrent();
 540     HTMLCanvasElement* canvas = context->canvas();
 541     ImageBuffer* imageBuffer = canvas->buffer();
 542     QPainter* painter = imageBuffer->context()->platformContext();
 543     paint(painter, QRect(QPoint(0, 0), QSize(m_currentWidth, m_currentHeight)));
 544 }
 545
 546 void GraphicsContext3D::paint(QPainter* painter, const QRect& rect) const
 547 {
 548 #if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
 549     QWebPageClient* webPageClient = m_internal->m_hostWindow->platformPageClient();
 550     QGLWidget* ownerGLWidget  = m_internal->getOwnerGLWidget(webPageClient);
 551     if (ownerGLWidget) {
 552         ownerGLWidget->drawTexture(rect, m_internal->m_texture);
 553         return;
 554     }
 555 #endif
 556     m_internal->m_glWidget->makeCurrent();
 557     m_internal->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_internal->m_mainFbo);
 558     glReadPixels(/* x */ 0, /* y */ 0, m_currentWidth, m_currentHeight, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, m_internal->m_pixels.bits());
 559     painter->drawImage(/* x */ 0, /* y */ 0, m_internal->m_pixels.rgbSwapped().transformed(QMatrix().rotate(180)));
 560     m_internal->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_internal->m_currentFbo);
 561 }
 562
 563 void GraphicsContext3D::reshape(int width, int height)
 564 {
 565     if (((width == m_currentWidth) && (height == m_currentHeight)) || (!m_internal))
 566         return;
 567
 568     m_currentWidth = width;
 569     m_currentHeight = height;
 570
 571     m_internal->m_pixels = QImage(m_currentWidth, m_currentHeight, QImage::Format_ARGB32);
 572
 573     m_internal->m_glWidget->makeCurrent();
 574
 575     glBindTexture(GraphicsContext3D::TEXTURE_2D, m_internal->m_texture);
 576     glTexImage2D(GraphicsContext3D::TEXTURE_2D, /* level */ 0, GraphicsContext3D::RGBA, width, height, /* border */ 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, /* data */ 0);
 577     glBindTexture(GraphicsContext3D::TEXTURE_2D, 0);
 578
 579     m_internal->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_internal->m_mainFbo);
 580     m_internal->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_internal->m_depthBuffer);
 581 #if defined(QT_OPENGL_ES_2)
 582     renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT16, width, height);
 583 #else
 584     renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT, width, height);
 585 #endif
 586     m_internal->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
 587
 588     m_internal->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, m_internal->m_texture, 0);
 589     m_internal->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_internal->m_depthBuffer);
 590
 591     GLenum status = m_internal->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER);
 592     if (status != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
 593         LOG_ERROR("GraphicsContext3D: Wasn't able to reshape the main framebuffer");
 594         notImplemented();
 595     }
 596
 597     glClear(GraphicsContext3D::COLOR_BUFFER_BIT);
 598     glFlush();
 599 }
 600
 601 IntSize GraphicsContext3D::getInternalFramebufferSize()
 602 {
 603     return IntSize(m_currentWidth, m_currentHeight);
 604 }
 605
 606 void GraphicsContext3D::activeTexture(GC3Denum texture)
 607 {
 608     m_internal->m_glWidget->makeCurrent();
 609     m_internal->activeTexture(texture);
 610 }
 611
 612 void GraphicsContext3D::attachShader(Platform3DObject program, Platform3DObject shader)
 613 {
 614     ASSERT(program);
 615     ASSERT(shader);
 616     m_internal->m_glWidget->makeCurrent();
 617     m_internal->attachShader(program, shader);
 618 }
 619
 620 void GraphicsContext3D::getAttachedShaders(Platform3DObject program, GC3Dsizei maxCount, GC3Dsizei* count, Platform3DObject* shaders)
 621 {
 622     if (!program) {
 623         synthesizeGLError(INVALID_VALUE);
 624         return;
 625     }
 626
 627     m_internal->m_glWidget->makeCurrent();
 628     getAttachedShaders(program, maxCount, count, shaders);
 629 }
 630
 631 void GraphicsContext3D::bindAttribLocation(Platform3DObject program, GC3Duint index, const String& name)
 632 {
 633     ASSERT(program);
 634     m_internal->m_glWidget->makeCurrent();
 635     m_internal->bindAttribLocation(program, index, name.utf8().data());
 636 }
 637
 638 void GraphicsContext3D::bindBuffer(GC3Denum target, Platform3DObject buffer)
 639 {
 640     m_internal->m_glWidget->makeCurrent();
 641     m_internal->bindBuffer(target, buffer);
 642 }
 643
 644 void GraphicsContext3D::bindFramebuffer(GC3Denum target, Platform3DObject buffer)
 645 {
 646     m_internal->m_glWidget->makeCurrent();
 647     m_internal->m_currentFbo = buffer ? buffer : m_internal->m_mainFbo;
 648     m_internal->bindFramebuffer(target, m_internal->m_currentFbo);
 649 }
 650
 651 void GraphicsContext3D::bindRenderbuffer(GC3Denum target, Platform3DObject renderbuffer)
 652 {
 653     m_internal->m_glWidget->makeCurrent();
 654     m_internal->bindRenderbuffer(target, renderbuffer);
 655 }
 656
 657 void GraphicsContext3D::bindTexture(GC3Denum target, Platform3DObject texture)
 658 {
 659     m_internal->m_glWidget->makeCurrent();
 660     glBindTexture(target, texture);
 661 }
 662
 663 void GraphicsContext3D::blendColor(GC3Dclampf red, GC3Dclampf green, GC3Dclampf blue, GC3Dclampf alpha)
 664 {
 665     m_internal->m_glWidget->makeCurrent();
 666     m_internal->blendColor(red, green, blue, alpha);
 667 }
 668
 669 void GraphicsContext3D::blendEquation(GC3Denum mode)
 670 {
 671     m_internal->m_glWidget->makeCurrent();
 672     m_internal->blendEquation(mode);
 673 }
 674
 675 void GraphicsContext3D::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)
 676 {
 677     m_internal->m_glWidget->makeCurrent();
 678     m_internal->blendEquationSeparate(modeRGB, modeAlpha);
 679 }
 680
 681 void GraphicsContext3D::blendFunc(GC3Denum sfactor, GC3Denum dfactor)
 682 {
 683     m_internal->m_glWidget->makeCurrent();
 684     glBlendFunc(sfactor, dfactor);
 685 }
 686
 687 void GraphicsContext3D::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)
 688 {
 689     m_internal->m_glWidget->makeCurrent();
 690     m_internal->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 691 }
 692
 693 void GraphicsContext3D::bufferData(GC3Denum target, GC3Dsizeiptr size, GC3Denum usage)
 694 {
 695     m_internal->m_glWidget->makeCurrent();
 696     m_internal->bufferData(target, size, /* data */ 0, usage);
 697 }
 698
 699 void GraphicsContext3D::bufferData(GC3Denum target, GC3Dsizeiptr size, const void* data, GC3Denum usage)
 700 {
 701     m_internal->m_glWidget->makeCurrent();
 702     m_internal->bufferData(target, size, data, usage);
 703 }
 704
 705 void GraphicsContext3D::bufferSubData(GC3Denum target, GC3Dintptr offset, GC3Dsizeiptr size, const void* data)
 706 {
 707     m_internal->m_glWidget->makeCurrent();
 708     m_internal->bufferSubData(target, offset, size, data);
 709 }
 710
 711 GC3Denum GraphicsContext3D::checkFramebufferStatus(GC3Denum target)
 712 {
 713     m_internal->m_glWidget->makeCurrent();
 714     return m_internal->checkFramebufferStatus(target);
 715 }
 716
 717 void GraphicsContext3D::clearColor(GC3Dclampf r, GC3Dclampf g, GC3Dclampf b, GC3Dclampf a)
 718 {
 719     m_internal->m_glWidget->makeCurrent();
 720     glClearColor(r, g, b, a);
 721 }
 722
 723 void GraphicsContext3D::clear(GC3Dbitfield mask)
 724 {
 725     m_internal->m_glWidget->makeCurrent();
 726     glClear(mask);
 727 }
 728
 729 void GraphicsContext3D::clearDepth(GC3Dclampf depth)
 730 {
 731     m_internal->m_glWidget->makeCurrent();
 732 #if defined(QT_OPENGL_ES_2)
 733     glClearDepthf(depth);
 734 #else
 735     glClearDepth(depth);
 736 #endif
 737 }
 738
 739 void GraphicsContext3D::clearStencil(GC3Dint s)
 740 {
 741     m_internal->m_glWidget->makeCurrent();
 742     glClearStencil(s);
 743 }
 744
 745 void GraphicsContext3D::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)
 746 {
 747     m_internal->m_glWidget->makeCurrent();
 748     glColorMask(red, green, blue, alpha);
 749 }
 750
 751 void GraphicsContext3D::compileShader(Platform3DObject shader)
 752 {
 753     ASSERT(shader);
 754     m_internal->m_glWidget->makeCurrent();
 755     m_internal->compileShader(shader);
 756 }
 757
 758 void GraphicsContext3D::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)
 759 {
 760     m_internal->m_glWidget->makeCurrent();
 761     glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 762 }
 763
 764 void GraphicsContext3D::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
 765 {
 766     m_internal->m_glWidget->makeCurrent();
 767     glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 768 }
 769
 770 void GraphicsContext3D::cullFace(GC3Denum mode)
 771 {
 772     m_internal->m_glWidget->makeCurrent();
 773     glCullFace(mode);
 774 }
 775
 776 void GraphicsContext3D::depthFunc(GC3Denum func)
 777 {
 778     m_internal->m_glWidget->makeCurrent();
 779     glDepthFunc(func);
 780 }
 781
 782 void GraphicsContext3D::depthMask(GC3Dboolean flag)
 783 {
 784     m_internal->m_glWidget->makeCurrent();
 785     glDepthMask(flag);
 786 }
 787
 788 void GraphicsContext3D::depthRange(GC3Dclampf zNear, GC3Dclampf zFar)
 789 {
 790     m_internal->m_glWidget->makeCurrent();
 791 #if defined(QT_OPENGL_ES_2)
 792     glDepthRangef(zNear, zFar);
 793 #else
 794     glDepthRange(zNear, zFar);
 795 #endif
 796 }
 797
 798 void GraphicsContext3D::detachShader(Platform3DObject program, Platform3DObject shader)
 799 {
 800     ASSERT(program);
 801     ASSERT(shader);
 802     m_internal->m_glWidget->makeCurrent();
 803     m_internal->detachShader(program, shader);
 804 }
 805
 806 void GraphicsContext3D::disable(GC3Denum cap)
 807 {
 808     m_internal->m_glWidget->makeCurrent();
 809     glDisable(cap);
 810 }
 811
 812 void GraphicsContext3D::disableVertexAttribArray(GC3Duint index)
 813 {
 814     m_internal->m_glWidget->makeCurrent();
 815     m_internal->disableVertexAttribArray(index);
 816 }
 817
 818 void GraphicsContext3D::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count)
 819 {
 820     m_internal->m_glWidget->makeCurrent();
 821     glDrawArrays(mode, first, count);
 822 }
 823
 824 void GraphicsContext3D::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dintptr offset)
 825 {
 826     m_internal->m_glWidget->makeCurrent();
 827     glDrawElements(mode, count, type, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset)));
 828 }
 829
 830 void GraphicsContext3D::enable(GC3Denum cap)
 831 {
 832     m_internal->m_glWidget->makeCurrent();
 833     glEnable(cap);
 834 }
 835
 836 void GraphicsContext3D::enableVertexAttribArray(GC3Duint index)
 837 {
 838     m_internal->m_glWidget->makeCurrent();
 839     m_internal->enableVertexAttribArray(index);
 840 }
 841
 842 void GraphicsContext3D::finish()
 843 {
 844     m_internal->m_glWidget->makeCurrent();
 845     glFinish();
 846 }
 847
 848 void GraphicsContext3D::flush()
 849 {
 850     m_internal->m_glWidget->makeCurrent();
 851     glFlush();
 852 }
 853
 854 void GraphicsContext3D::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, Platform3DObject buffer)
 855 {
 856     m_internal->m_glWidget->makeCurrent();
 857     m_internal->framebufferRenderbuffer(target, attachment, renderbuffertarget, buffer);
 858 }
 859
 860 void GraphicsContext3D::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, Platform3DObject texture, GC3Dint level)
 861 {
 862     m_internal->m_glWidget->makeCurrent();
 863     m_internal->framebufferTexture2D(target, attachment, textarget, texture, level);
 864 }
 865
 866 void GraphicsContext3D::frontFace(GC3Denum mode)
 867 {
 868     m_internal->m_glWidget->makeCurrent();
 869     glFrontFace(mode);
 870 }
 871
 872 void GraphicsContext3D::generateMipmap(GC3Denum target)
 873 {
 874     m_internal->m_glWidget->makeCurrent();
 875     m_internal->generateMipmap(target);
 876 }
 877
 878 bool GraphicsContext3D::getActiveAttrib(Platform3DObject program, GC3Duint index, ActiveInfo& info)
 879 {
 880     if (!program) {
 881         synthesizeGLError(INVALID_VALUE);
 882         return false;
 883     }
 884
 885     m_internal->m_glWidget->makeCurrent();
 886
 887     GLint maxLength = 0;
 888     m_internal->getProgramiv(program, GraphicsContext3D::ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxLength);
 889
 890     GLchar* name = (GLchar*) fastMalloc(maxLength);
 891     GLsizei nameLength = 0;
 892     GLint size = 0;
 893     GLenum type = 0;
 894
 895     m_internal->getActiveAttrib(program, index, maxLength, &nameLength, &size, &type, name);
 896
 897     if (!nameLength) {
 898         fastFree(name);
 899         return false;
 900     }
 901
 902     info.name = String(name, nameLength);
 903     info.type = type;
 904     info.size = size;
 905
 906     fastFree(name);
 907     return true;
 908 }
 909
 910 bool GraphicsContext3D::getActiveUniform(Platform3DObject program, GC3Duint index, ActiveInfo& info)
 911 {
 912     if (!program) {
 913         synthesizeGLError(INVALID_VALUE);
 914         return false;
 915     }
 916
 917     m_internal->m_glWidget->makeCurrent();
 918
 919     GLint maxLength = 0;
 920     m_internal->getProgramiv(static_cast<GLuint>(program), GraphicsContext3D::ACTIVE_UNIFORM_MAX_LENGTH, &maxLength);
 921
 922     GLchar* name = (GLchar*) fastMalloc(maxLength);
 923     GLsizei nameLength = 0;
 924     GLint size = 0;
 925     GLenum type = 0;
 926
 927     m_internal->getActiveUniform(static_cast<GLuint>(program), index, maxLength, &nameLength, &size, &type, name);
 928
 929     if (!nameLength) {
 930         fastFree(name);
 931         return false;
 932     }
 933
 934     info.name = String(name, nameLength);
 935     info.type = type;
 936     info.size = size;
 937
 938     fastFree(name);
 939     return true;
 940 }
 941
 942 int GraphicsContext3D::getAttribLocation(Platform3DObject program, const String& name)
 943 {
 944     if (!program)
 945         return -1;
 946
 947     m_internal->m_glWidget->makeCurrent();
 948     return m_internal->getAttribLocation(program, name.utf8().data());
 949 }
 950
 951 GraphicsContext3D::Attributes GraphicsContext3D::getContextAttributes()
 952 {
 953     return m_internal->m_attrs;
 954 }
 955
 956 GC3Denum GraphicsContext3D::getError()
 957 {
 958     if (m_internal->m_syntheticErrors.size() > 0) {
 959         ListHashSet<GC3Denum>::iterator iter = m_internal->m_syntheticErrors.begin();
 960         GC3Denum err = *iter;
 961         m_internal->m_syntheticErrors.remove(iter);
 962         return err;
 963     }
 964
 965     m_internal->m_glWidget->makeCurrent();
 966     return glGetError();
 967 }
 968
 969 String GraphicsContext3D::getString(GC3Denum name)
 970 {
 971     m_internal->m_glWidget->makeCurrent();
 972     return String((const char*) glGetString(name));
 973 }
 974
 975 void GraphicsContext3D::hint(GC3Denum target, GC3Denum mode)
 976 {
 977     m_internal->m_glWidget->makeCurrent();
 978     glHint(target, mode);
 979 }
 980
 981 GC3Dboolean GraphicsContext3D::isBuffer(Platform3DObject buffer)
 982 {
 983     if (!buffer)
 984         return GL_FALSE;
 985
 986     m_internal->m_glWidget->makeCurrent();
 987     return m_internal->isBuffer(buffer);
 988 }
 989
 990 GC3Dboolean GraphicsContext3D::isEnabled(GC3Denum cap)
 991 {
 992     m_internal->m_glWidget->makeCurrent();
 993     return glIsEnabled(cap);
 994 }
 995
 996 GC3Dboolean GraphicsContext3D::isFramebuffer(Platform3DObject framebuffer)
 997 {
 998     if (!framebuffer)
 999         return GL_FALSE;
1000
1001     m_internal->m_glWidget->makeCurrent();
1002     return m_internal->isFramebuffer(framebuffer);
1003 }
1004
1005 GC3Dboolean GraphicsContext3D::isProgram(Platform3DObject program)
1006 {
1007     if (!program)
1008         return GL_FALSE;
1009
1010     m_internal->m_glWidget->makeCurrent();
1011     return m_internal->isProgram(program);
1012 }
1013
1014 GC3Dboolean GraphicsContext3D::isRenderbuffer(Platform3DObject renderbuffer)
1015 {
1016     if (!renderbuffer)
1017         return GL_FALSE;
1018
1019     m_internal->m_glWidget->makeCurrent();
1020     return m_internal->isRenderbuffer(renderbuffer);
1021 }
1022
1023 GC3Dboolean GraphicsContext3D::isShader(Platform3DObject shader)
1024 {
1025     if (!shader)
1026         return GL_FALSE;
1027
1028     m_internal->m_glWidget->makeCurrent();
1029     return m_internal->isShader(shader);
1030 }
1031
1032 GC3Dboolean GraphicsContext3D::isTexture(Platform3DObject texture)
1033 {
1034     if (!texture)
1035         return GL_FALSE;
1036
1037     m_internal->m_glWidget->makeCurrent();
1038     return glIsTexture(texture);
1039 }
1040
1041 void GraphicsContext3D::lineWidth(double width)
1042 {
1043     m_internal->m_glWidget->makeCurrent();
1044     glLineWidth(static_cast<float>(width));
1045 }
1046
1047 void GraphicsContext3D::linkProgram(Platform3DObject program)
1048 {
1049     ASSERT(program);
1050     m_internal->m_glWidget->makeCurrent();
1051     m_internal->linkProgram(program);
1052 }
1053
1054 void GraphicsContext3D::pixelStorei(GC3Denum paramName, GC3Dint param)
1055 {
1056     m_internal->m_glWidget->makeCurrent();
1057     glPixelStorei(paramName, param);
1058 }
1059
1060 void GraphicsContext3D::polygonOffset(GC3Dfloat factor, GC3Dfloat units)
1061 {
1062     m_internal->m_glWidget->makeCurrent();
1063     glPolygonOffset(factor, units);
1064 }
1065
1066 void GraphicsContext3D::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, void* data)
1067 {
1068     m_internal->m_glWidget->makeCurrent();
1069
1070     if (type != GraphicsContext3D::UNSIGNED_BYTE || format != GraphicsContext3D::RGBA)
1071         return;
1072
1073     glReadPixels(x, y, width, height, format, type, data);
1074 }
1075
1076 void GraphicsContext3D::releaseShaderCompiler()
1077 {
1078     m_internal->m_glWidget->makeCurrent();
1079     notImplemented();
1080 }
1081
1082 void GraphicsContext3D::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)
1083 {
1084     m_internal->m_glWidget->makeCurrent();
1085     m_internal->renderbufferStorage(target, internalformat, width, height);
1086 }
1087
1088 void GraphicsContext3D::sampleCoverage(GC3Dclampf value, GC3Dboolean invert)
1089 {
1090     m_internal->m_glWidget->makeCurrent();
1091     m_internal->sampleCoverage(value, invert);
1092 }
1093
1094 void GraphicsContext3D::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
1095 {
1096     m_internal->m_glWidget->makeCurrent();
1097     glScissor(x, y, width, height);
1098 }
1099
1100 void GraphicsContext3D::shaderSource(Platform3DObject shader, const String& source)
1101 {
1102     ASSERT(shader);
1103
1104     m_internal->m_glWidget->makeCurrent();
1105
1106     String prefixedSource;
1107
1108 #if defined (QT_OPENGL_ES_2)
1109     prefixedSource.append("precision mediump float;\n");
1110 #endif
1111
1112     prefixedSource.append(source);
1113
1114     CString sourceCS = prefixedSource.utf8();
1115     const char* data = sourceCS.data();
1116     int length = prefixedSource.length();
1117     m_internal->shaderSource((GLuint) shader, /* count */ 1, &data, &length);
1118 }
1119
1120 void GraphicsContext3D::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)
1121 {
1122     m_internal->m_glWidget->makeCurrent();
1123     glStencilFunc(func, ref, mask);
1124 }
1125
1126 void GraphicsContext3D::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)
1127 {
1128     m_internal->m_glWidget->makeCurrent();
1129     m_internal->stencilFuncSeparate(face, func, ref, mask);
1130 }
1131
1132 void GraphicsContext3D::stencilMask(GC3Duint mask)
1133 {
1134     m_internal->m_glWidget->makeCurrent();
1135     glStencilMask(mask);
1136 }
1137
1138 void GraphicsContext3D::stencilMaskSeparate(GC3Denum face, GC3Duint mask)
1139 {
1140     m_internal->m_glWidget->makeCurrent();
1141     m_internal->stencilMaskSeparate(face, mask);
1142 }
1143
1144 void GraphicsContext3D::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
1145 {
1146     m_internal->m_glWidget->makeCurrent();
1147     glStencilOp(fail, zfail, zpass);
1148 }
1149
1150 void GraphicsContext3D::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)
1151 {
1152     m_internal->m_glWidget->makeCurrent();
1153     m_internal->stencilOpSeparate(face, fail, zfail, zpass);
1154 }
1155
1156 void GraphicsContext3D::texParameterf(GC3Denum target, GC3Denum paramName, GC3Dfloat value)
1157 {
1158     m_internal->m_glWidget->makeCurrent();
1159     glTexParameterf(target, paramName, value);
1160 }
1161
1162 void GraphicsContext3D::texParameteri(GC3Denum target, GC3Denum paramName, GC3Dint value)
1163 {
1164     m_internal->m_glWidget->makeCurrent();
1165     glTexParameteri(target, paramName, value);
1166 }
1167
1168 void GraphicsContext3D::uniform1f(GC3Dint location, GC3Dfloat v0)
1169 {
1170     m_internal->m_glWidget->makeCurrent();
1171     m_internal->uniform1f(location, v0);
1172 }
1173
1174 void GraphicsContext3D::uniform1fv(GC3Dint location, GC3Dfloat* array, GC3Dsizei size)
1175 {
1176     m_internal->m_glWidget->makeCurrent();
1177     m_internal->uniform1fv(location, size, array);
1178 }
1179
1180 void GraphicsContext3D::uniform2f(GC3Dint location, GC3Dfloat v0, GC3Dfloat v1)
1181 {
1182     m_internal->m_glWidget->makeCurrent();
1183     m_internal->uniform2f(location, v0, v1);
1184 }
1185
1186 void GraphicsContext3D::uniform2fv(GC3Dint location, GC3Dfloat* array, GC3Dsizei size)
1187 {
1188     m_internal->m_glWidget->makeCurrent();
1189     m_internal->uniform2fv(location, size, array);
1190 }
1191
1192 void GraphicsContext3D::uniform3f(GC3Dint location, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)
1193 {
1194     m_internal->m_glWidget->makeCurrent();
1195     m_internal->uniform3f(location, v0, v1, v2);
1196 }
1197
1198 void GraphicsContext3D::uniform3fv(GC3Dint location, GC3Dfloat* array, GC3Dsizei size)
1199 {
1200     m_internal->m_glWidget->makeCurrent();
1201     m_internal->uniform3fv(location, size, array);
1202 }
1203
1204 void GraphicsContext3D::uniform4f(GC3Dint location, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)
1205 {
1206     m_internal->m_glWidget->makeCurrent();
1207     m_internal->uniform4f(location, v0, v1, v2, v3);
1208 }
1209
1210 void GraphicsContext3D::uniform4fv(GC3Dint location, GC3Dfloat* array, GC3Dsizei size)
1211 {
1212     m_internal->m_glWidget->makeCurrent();
1213     m_internal->uniform4fv(location, size, array);
1214 }
1215
1216 void GraphicsContext3D::uniform1i(GC3Dint location, GC3Dint v0)
1217 {
1218     m_internal->m_glWidget->makeCurrent();
1219     m_internal->uniform1i(location, v0);
1220 }
1221
1222 void GraphicsContext3D::uniform1iv(GC3Dint location, GC3Dint* array, GC3Dsizei size)
1223 {
1224     m_internal->m_glWidget->makeCurrent();
1225     m_internal->uniform1iv(location, size, array);
1226 }
1227
1228 void GraphicsContext3D::uniform2i(GC3Dint location, GC3Dint v0, GC3Dint v1)
1229 {
1230     m_internal->m_glWidget->makeCurrent();
1231     m_internal->uniform2i(location, v0, v1);
1232 }
1233
1234 void GraphicsContext3D::uniform2iv(GC3Dint location, GC3Dint* array, GC3Dsizei size)
1235 {
1236     m_internal->m_glWidget->makeCurrent();
1237     m_internal->uniform2iv(location, size, array);
1238 }
1239
1240 void GraphicsContext3D::uniform3i(GC3Dint location, GC3Dint v0, GC3Dint v1, GC3Dint v2)
1241 {
1242     m_internal->m_glWidget->makeCurrent();
1243     m_internal->uniform3i(location, v0, v1, v2);
1244 }
1245
1246 void GraphicsContext3D::uniform3iv(GC3Dint location, GC3Dint* array, GC3Dsizei size)
1247 {
1248     m_internal->m_glWidget->makeCurrent();
1249     m_internal->uniform3iv(location, size, array);
1250 }
1251
1252 void GraphicsContext3D::uniform4i(GC3Dint location, GC3Dint v0, GC3Dint v1, GC3Dint v2, GC3Dint v3)
1253 {
1254     m_internal->m_glWidget->makeCurrent();
1255     m_internal->uniform4i(location, v0, v1, v2, v3);
1256 }
1257
1258 void GraphicsContext3D::uniform4iv(GC3Dint location, GC3Dint* array, GC3Dsizei size)
1259 {
1260     m_internal->m_glWidget->makeCurrent();
1261     m_internal->uniform4iv(location, size, array);
1262 }
1263
1264 void GraphicsContext3D::uniformMatrix2fv(GC3Dint location, GC3Dboolean transpose, GC3Dfloat* array, GC3Dsizei size)
1265 {
1266     m_internal->m_glWidget->makeCurrent();
1267     m_internal->uniformMatrix2fv(location, size, transpose, array);
1268 }
1269
1270 void GraphicsContext3D::uniformMatrix3fv(GC3Dint location, GC3Dboolean transpose, GC3Dfloat* array, GC3Dsizei size)
1271 {
1272     m_internal->m_glWidget->makeCurrent();
1273     m_internal->uniformMatrix3fv(location, size, transpose, array);
1274 }
1275
1276 void GraphicsContext3D::uniformMatrix4fv(GC3Dint location, GC3Dboolean transpose, GC3Dfloat* array, GC3Dsizei size)
1277 {
1278     m_internal->m_glWidget->makeCurrent();
1279     m_internal->uniformMatrix4fv(location, size, transpose, array);
1280 }
1281
1282 void GraphicsContext3D::useProgram(Platform3DObject program)
1283 {
1284     ASSERT(program);
1285
1286     m_internal->m_glWidget->makeCurrent();
1287     m_internal->useProgram(program);
1288 }
1289
1290 void GraphicsContext3D::validateProgram(Platform3DObject program)
1291 {
1292     ASSERT(program);
1293
1294     m_internal->m_glWidget->makeCurrent();
1295     m_internal->validateProgram(program);
1296 }
1297
1298 void GraphicsContext3D::vertexAttrib1f(GC3Duint index, GC3Dfloat v0)
1299 {
1300     m_internal->m_glWidget->makeCurrent();
1301     m_internal->vertexAttrib1f(index, v0);
1302 }
1303
1304 void GraphicsContext3D::vertexAttrib1fv(GC3Duint index, GC3Dfloat* array)
1305 {
1306     m_internal->m_glWidget->makeCurrent();
1307     m_internal->vertexAttrib1fv(index, array);
1308 }
1309
1310 void GraphicsContext3D::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)
1311 {
1312     m_internal->m_glWidget->makeCurrent();
1313     m_internal->vertexAttrib2f(index, v0, v1);
1314 }
1315
1316 void GraphicsContext3D::vertexAttrib2fv(GC3Duint index, GC3Dfloat* array)
1317 {
1318     m_internal->m_glWidget->makeCurrent();
1319     m_internal->vertexAttrib2fv(index, array);
1320 }
1321
1322 void GraphicsContext3D::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)
1323 {
1324     m_internal->m_glWidget->makeCurrent();
1325     m_internal->vertexAttrib3f(index, v0, v1, v2);
1326 }
1327
1328 void GraphicsContext3D::vertexAttrib3fv(GC3Duint index, GC3Dfloat* array)
1329 {
1330     m_internal->m_glWidget->makeCurrent();
1331     m_internal->vertexAttrib3fv(index, array);
1332 }
1333
1334 void GraphicsContext3D::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)
1335 {
1336     m_internal->m_glWidget->makeCurrent();
1337     m_internal->vertexAttrib4f(index, v0, v1, v2, v3);
1338 }
1339
1340 void GraphicsContext3D::vertexAttrib4fv(GC3Duint index, GC3Dfloat* array)
1341 {
1342     m_internal->m_glWidget->makeCurrent();
1343     m_internal->vertexAttrib4fv(index, array);
1344 }
1345
1346 void GraphicsContext3D::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, GC3Dintptr offset)
1347 {
1348     m_internal->m_glWidget->makeCurrent();
1349     m_internal->vertexAttribPointer(index, size, type, normalized, stride, reinterpret_cast<GLvoid*>(static_cast<intptr_t>(offset)));
1350 }
1351
1352 void GraphicsContext3D::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)
1353 {
1354     m_internal->m_glWidget->makeCurrent();
1355     glViewport(x, y, width, height);
1356 }
1357
1358 void GraphicsContext3D::getBooleanv(GC3Denum paramName, GC3Dboolean* value)
1359 {
1360     m_internal->m_glWidget->makeCurrent();
1361     glGetBooleanv(paramName, value);
1362 }
1363
1364 void GraphicsContext3D::getBufferParameteriv(GC3Denum target, GC3Denum paramName, GC3Dint* value)
1365 {
1366     m_internal->m_glWidget->makeCurrent();
1367     m_internal->getBufferParameteriv(target, paramName, value);
1368 }
1369
1370 void GraphicsContext3D::getFloatv(GC3Denum paramName, GC3Dfloat* value)
1371 {
1372     m_internal->m_glWidget->makeCurrent();
1373     glGetFloatv(paramName, value);
1374 }
1375
1376 void GraphicsContext3D::getFramebufferAttachmentParameteriv(GC3Denum target, GC3Denum attachment, GC3Denum paramName, GC3Dint* value)
1377 {
1378     m_internal->m_glWidget->makeCurrent();
1379     m_internal->getFramebufferAttachmentParameteriv(target, attachment, paramName, value);
1380 }
1381
1382 void GraphicsContext3D::getIntegerv(GC3Denum paramName, GC3Dint* value)
1383 {
1384     m_internal->m_glWidget->makeCurrent();
1385     glGetIntegerv(paramName, value);
1386 }
1387
1388 void GraphicsContext3D::getProgramiv(Platform3DObject program, GC3Denum paramName, GC3Dint* value)
1389 {
1390     m_internal->m_glWidget->makeCurrent();
1391     m_internal->getProgramiv(program, paramName, value);
1392 }
1393
1394 String GraphicsContext3D::getProgramInfoLog(Platform3DObject program)
1395 {
1396     m_internal->m_glWidget->makeCurrent();
1397
1398     GLint length = 0;
1399     m_internal->getProgramiv(program, GraphicsContext3D::INFO_LOG_LENGTH, &length);
1400
1401     GLsizei size = 0;
1402
1403     GLchar* info = (GLchar*) fastMalloc(length);
1404     if (!info)
1405         return "";
1406
1407     m_internal->getProgramInfoLog(program, length, &size, info);
1408
1409     String result(info);
1410     fastFree(info);
1411
1412     return result;
1413 }
1414
1415 void GraphicsContext3D::getRenderbufferParameteriv(GC3Denum target, GC3Denum paramName, GC3Dint* value)
1416 {
1417     m_internal->m_glWidget->makeCurrent();
1418     m_internal->getRenderbufferParameteriv(target, paramName, value);
1419 }
1420
1421 void GraphicsContext3D::getShaderiv(Platform3DObject shader, GC3Denum paramName, GC3Dint* value)
1422 {
1423     ASSERT(shader);
1424     m_internal->m_glWidget->makeCurrent();
1425     m_internal->getShaderiv(shader, paramName, value);
1426 }
1427
1428 String GraphicsContext3D::getShaderInfoLog(Platform3DObject shader)
1429 {
1430     m_internal->m_glWidget->makeCurrent();
1431
1432     GLint length = 0;
1433     m_internal->getShaderiv(shader, GraphicsContext3D::INFO_LOG_LENGTH, &length);
1434
1435     GLsizei size = 0;
1436     GLchar* info = (GLchar*) fastMalloc(length);
1437     if (!info)
1438         return "";
1439
1440     m_internal->getShaderInfoLog(shader, length, &size, info);
1441
1442     String result(info);
1443     fastFree(info);
1444
1445     return result;
1446 }
1447
1448 String GraphicsContext3D::getShaderSource(Platform3DObject shader)
1449 {
1450     m_internal->m_glWidget->makeCurrent();
1451
1452     GLint length = 0;
1453     m_internal->getShaderiv(shader, GraphicsContext3D::SHADER_SOURCE_LENGTH, &length);
1454
1455     GLsizei size = 0;
1456     GLchar* info = (GLchar*) fastMalloc(length);
1457     if (!info)
1458         return "";
1459
1460     m_internal->getShaderSource(shader, length, &size, info);
1461
1462     String result(info);
1463     fastFree(info);
1464
1465     return result;
1466 }
1467
1468 void GraphicsContext3D::getTexParameterfv(GC3Denum target, GC3Denum paramName, GC3Dfloat* value)
1469 {
1470     m_internal->m_glWidget->makeCurrent();
1471     glGetTexParameterfv(target, paramName, value);
1472 }
1473
1474 void GraphicsContext3D::getTexParameteriv(GC3Denum target, GC3Denum paramName, GC3Dint* value)
1475 {
1476     m_internal->m_glWidget->makeCurrent();
1477     glGetTexParameteriv(target, paramName, value);
1478 }
1479
1480 void GraphicsContext3D::getUniformfv(Platform3DObject program, GC3Dint location, GC3Dfloat* value)
1481 {
1482     m_internal->m_glWidget->makeCurrent();
1483     m_internal->getUniformfv(program, location, value);
1484 }
1485
1486 void GraphicsContext3D::getUniformiv(Platform3DObject program, GC3Dint location, GC3Dint* value)
1487 {
1488     m_internal->m_glWidget->makeCurrent();
1489     m_internal->getUniformiv(program, location, value);
1490 }
1491
1492 long GraphicsContext3D::getUniformLocation(Platform3DObject program, const String& name)
1493 {
1494     ASSERT(program);
1495
1496     m_internal->m_glWidget->makeCurrent();
1497     return m_internal->getUniformLocation(program, name.utf8().data());
1498 }
1499
1500 void GraphicsContext3D::getVertexAttribfv(GC3Duint index, GC3Denum paramName, GC3Dfloat* value)
1501 {
1502     m_internal->m_glWidget->makeCurrent();
1503     m_internal->getVertexAttribfv(index, paramName, value);
1504 }
1505
1506 void GraphicsContext3D::getVertexAttribiv(GC3Duint index, GC3Denum paramName, GC3Dint* value)
1507 {
1508     m_internal->m_glWidget->makeCurrent();
1509     m_internal->getVertexAttribiv(index, paramName, value);
1510 }
1511
1512 GC3Dsizeiptr GraphicsContext3D::getVertexAttribOffset(GC3Duint index, GC3Denum paramName)
1513 {
1514     m_internal->m_glWidget->makeCurrent();
1515
1516     GLvoid* pointer = 0;
1517     m_internal->getVertexAttribPointerv(index, paramName, &pointer);
1518     return static_cast<GC3Dsizeiptr>(reinterpret_cast<intptr_t>(pointer));
1519 }
1520
1521 bool GraphicsContext3D::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels)
1522 {
1523     m_internal->m_glWidget->makeCurrent();
1524     glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
1525     return true;
1526 }
1527
1528 void GraphicsContext3D::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoff, GC3Dint yoff, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels)
1529 {
1530     m_internal->m_glWidget->makeCurrent();
1531     glTexSubImage2D(target, level, xoff, yoff, width, height, format, type, pixels);
1532 }
1533
1534 Platform3DObject GraphicsContext3D::createBuffer()
1535 {
1536     m_internal->m_glWidget->makeCurrent();
1537     GLuint handle = 0;
1538     m_internal->genBuffers(/* count */ 1, &handle);
1539     return handle;
1540 }
1541
1542 Platform3DObject GraphicsContext3D::createFramebuffer()
1543 {
1544     m_internal->m_glWidget->makeCurrent();
1545     GLuint handle = 0;
1546     m_internal->genFramebuffers(/* count */ 1, &handle);
1547     return handle;
1548 }
1549
1550 Platform3DObject GraphicsContext3D::createProgram()
1551 {
1552     m_internal->m_glWidget->makeCurrent();
1553     return m_internal->createProgram();
1554 }
1555
1556 Platform3DObject GraphicsContext3D::createRenderbuffer()
1557 {
1558     m_internal->m_glWidget->makeCurrent();
1559     GLuint handle = 0;
1560     m_internal->genRenderbuffers(/* count */ 1, &handle);
1561     return handle;
1562 }
1563
1564 Platform3DObject GraphicsContext3D::createShader(GC3Denum type)
1565 {
1566     m_internal->m_glWidget->makeCurrent();
1567     return m_internal->createShader(type);
1568 }
1569
1570 Platform3DObject GraphicsContext3D::createTexture()
1571 {
1572     m_internal->m_glWidget->makeCurrent();
1573     GLuint handle = 0;
1574     glGenTextures(1, &handle);
1575     return handle;
1576 }
1577
1578 void GraphicsContext3D::deleteBuffer(Platform3DObject buffer)
1579 {
1580     m_internal->m_glWidget->makeCurrent();
1581     m_internal->deleteBuffers(1, &buffer);
1582 }
1583
1584 void GraphicsContext3D::deleteFramebuffer(Platform3DObject framebuffer)
1585 {
1586     m_internal->m_glWidget->makeCurrent();
1587     m_internal->deleteFramebuffers(1, &framebuffer);
1588 }
1589
1590 void GraphicsContext3D::deleteProgram(Platform3DObject program)
1591 {
1592     m_internal->m_glWidget->makeCurrent();
1593     m_internal->deleteProgram(program);
1594 }
1595
1596 void GraphicsContext3D::deleteRenderbuffer(Platform3DObject renderbuffer)
1597 {
1598     m_internal->m_glWidget->makeCurrent();
1599     m_internal->deleteRenderbuffers(1, &renderbuffer);
1600 }
1601
1602 void GraphicsContext3D::deleteShader(Platform3DObject shader)
1603 {
1604     m_internal->m_glWidget->makeCurrent();
1605     m_internal->deleteShader(shader);
1606 }
1607
1608 void GraphicsContext3D::deleteTexture(Platform3DObject texture)
1609 {
1610     m_internal->m_glWidget->makeCurrent();
1611     glDeleteTextures(1, &texture);
1612 }
1613
1614 void GraphicsContext3D::synthesizeGLError(GC3Denum error)
1615 {
1616     m_internal->m_syntheticErrors.add(error);
1617 }
1618
1619 Extensions3D* GraphicsContext3D::getExtensions()
1620 {
1621     if (!m_internal->m_extensions)
1622         m_internal->m_extensions = adoptPtr(new Extensions3DQt);
1623     return m_internal->m_extensions;
1624 }
1625
1626 bool GraphicsContext3D::getImageData(Image* image,
1627                                      GC3Denum format,
1628                                      GC3Denum type,
1629                                      bool premultiplyAlpha,
1630                                      bool ignoreGammaAndColorProfile,
1631                                      Vector<uint8_t>& outputVector)
1632 {
1633     UNUSED_PARAM(ignoreGammaAndColorProfile);
1634     if (!image)
1635         return false;
1636     QPixmap* nativePixmap = image->nativeImageForCurrentFrame();
1637     if (!nativePixmap)
1638         return false;
1639
1640     AlphaOp neededAlphaOp = kAlphaDoNothing;
1641     if (!premultiplyAlpha)
1642         // FIXME: must fetch the image data before the premultiplication step
1643         neededAlphaOp = kAlphaDoUnmultiply;
1644     QImage nativeImage = nativePixmap->toImage().convertToFormat(QImage::Format_ARGB32);
1645     outputVector.resize(nativeImage.byteCount());
1646     return packPixels(nativeImage.rgbSwapped().bits(), kSourceFormatRGBA8, image->width(), image->height(), 0,
1647                       format, type, neededAlphaOp, outputVector.data());
1648 }
1649
1650 void GraphicsContext3D::setContextLostCallback(PassOwnPtr<ContextLostCallback>)
1651 {
1652 }
1653
1654 }
1655
1656 #endif // ENABLE(WEBGL)