/*
    Copyright (C) 2010 Tieto Corporation.

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
     
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.
     
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "config.h"

#include "GraphicsContext3D.h"

#include "CString.h"
#include "CanvasObject.h"
#include "GraphicsContext.h"
#include "HTMLCanvasElement.h"
#include "ImageBuffer.h"
#include "NotImplemented.h"
#include "WebGLActiveInfo.h"
#include "WebGLArray.h"
#include "WebGLBuffer.h"
#include "WebGLFloatArray.h"
#include "WebGLFramebuffer.h"
#include "WebGLIntArray.h"
#include "WebGLProgram.h"
#include "WebGLRenderbuffer.h"
#include "WebGLRenderingContext.h"
#include "WebGLShader.h"
#include "WebGLTexture.h"
#include "WebGLUnsignedByteArray.h"
#include <wtf/UnusedParam.h>

#if ENABLE(3D_CANVAS)

namespace WebCore {

#if !defined(GLchar)
typedef char GLchar;
#endif

#if !defined(APIENTRY)
#define APIENTRY
#endif

typedef void (APIENTRY* glActiveTextureType) (GLenum);
typedef void (APIENTRY* glAttachShaderType) (GLuint, GLuint);
typedef void (APIENTRY* glBindAttribLocationType) (GLuint, GLuint, const char*);
typedef void (APIENTRY* glBindBufferType) (GLenum, GLuint);
typedef void (APIENTRY* glBindFramebufferType) (GLenum, GLuint);
typedef void (APIENTRY* glBindRenderbufferType) (GLenum, GLuint);
typedef void (APIENTRY* glBlendColorType) (GLclampf, GLclampf, GLclampf, GLclampf);
typedef void (APIENTRY* glBlendEquationType) (GLenum);
typedef void (APIENTRY* glBlendEquationSeparateType)(GLenum, GLenum);
typedef void (APIENTRY* glBlendFuncSeparateType)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
typedef void (APIENTRY* glBufferDataType) (GLenum, GLsizeiptr, const GLvoid*, GLenum);
typedef void (APIENTRY* glBufferSubDataType) (GLenum, GLintptr, GLsizeiptr, const GLvoid*);
typedef GLenum (APIENTRY* glCheckFramebufferStatusType) (GLenum);
typedef void (APIENTRY* glCompileShaderType) (GLuint);
typedef GLuint (APIENTRY* glCreateProgramType) ();
typedef GLuint (APIENTRY* glCreateShaderType) (GLenum);
typedef void (APIENTRY* glDeleteBuffersType) (GLsizei, const GLuint*);
typedef void (APIENTRY* glDeleteFramebuffersType) (GLsizei n, const GLuint*);
typedef void (APIENTRY* glDeleteProgramType) (GLuint);
typedef void (APIENTRY* glDeleteRenderbuffersType) (GLsizei n, const GLuint*);
typedef void (APIENTRY* glDeleteShaderType) (GLuint);
typedef void (APIENTRY* glDetachShaderType) (GLuint, GLuint);
typedef void (APIENTRY* glDisableVertexAttribArrayType) (GLuint);
typedef void (APIENTRY* glEnableVertexAttribArrayType) (GLuint);
typedef void (APIENTRY* glFramebufferRenderbufferType) (GLenum, GLenum, GLenum, GLuint);
typedef void (APIENTRY* glFramebufferTexture2DType) (GLenum, GLenum, GLenum, GLuint, GLint);
typedef void (APIENTRY* glGenBuffersType) (GLsizei, GLuint*);
typedef void (APIENTRY* glGenerateMipmapType) (GLenum target);
typedef void (APIENTRY* glGenFramebuffersType) (GLsizei, GLuint*);
typedef void (APIENTRY* glGenRenderbuffersType) (GLsizei, GLuint*);
typedef void (APIENTRY* glGetActiveAttribType) (GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*);
typedef void (APIENTRY* glGetActiveUniformType) (GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*);
typedef GLint (APIENTRY* glGetAttribLocationType) (GLuint, const char*);
typedef void (APIENTRY* glGetBufferParameterivType) (GLenum, GLenum, GLint*);
typedef void (APIENTRY* glGetFramebufferAttachmentParameterivType) (GLenum, GLenum, GLenum, GLint* params);
typedef void (APIENTRY* glGetProgramInfoLogType) (GLuint, GLsizei, GLsizei*, char*);
typedef void (APIENTRY* glGetProgramivType) (GLuint, GLenum, GLint*);
typedef void (APIENTRY* glGetRenderbufferParameterivType) (GLenum, GLenum, GLint*);
typedef void (APIENTRY* glGetShaderInfoLogType) (GLuint, GLsizei, GLsizei*, char*);
typedef void (APIENTRY* glGetShaderivType) (GLuint, GLenum, GLint*);
typedef void (APIENTRY* glGetShaderSourceType) (GLuint, GLsizei, GLsizei*, char*);
typedef GLint (APIENTRY* glGetUniformLocationType) (GLuint, const char*);
typedef void (APIENTRY* glGetUniformfvType) (GLuint, GLint, GLfloat*);
typedef void (APIENTRY* glGetUniformivType) (GLuint, GLint, GLint*);
typedef void (APIENTRY* glGetVertexAttribfvType) (GLuint, GLenum, GLfloat*);
typedef void (APIENTRY* glGetVertexAttribivType) (GLuint, GLenum, GLint*);
typedef void (APIENTRY* glGetVertexAttribPointervType) (GLuint, GLenum, GLvoid**);
typedef GLboolean (APIENTRY* glIsBufferType) (GLuint);
typedef GLboolean (APIENTRY* glIsFramebufferType) (GLuint);
typedef GLboolean (APIENTRY* glIsProgramType) (GLuint);
typedef GLboolean (APIENTRY* glIsRenderbufferType) (GLuint);
typedef GLboolean (APIENTRY* glIsShaderType) (GLuint);
typedef void (APIENTRY* glLinkProgramType) (GLuint);
typedef void (APIENTRY* glRenderbufferStorageType) (GLenum, GLenum, GLsizei, GLsizei);
typedef void (APIENTRY* glSampleCoverageType) (GLclampf, GLboolean);
typedef void (APIENTRY* glShaderSourceType) (GLuint, GLsizei, const char**, const GLint*);
typedef void (APIENTRY* glStencilFuncSeparateType) (GLenum, GLenum, GLint, GLuint);
typedef void (APIENTRY* glStencilMaskSeparateType) (GLenum, GLuint);
typedef void (APIENTRY* glStencilOpSeparateType) (GLenum, GLenum, GLenum, GLenum);
typedef void (APIENTRY* glUniform1fType) (GLint, GLfloat);
typedef void (APIENTRY* glUniform1fvType) (GLint, GLsizei, const GLfloat*);
typedef void (APIENTRY* glUniform1iType) (GLint, GLint);
typedef void (APIENTRY* glUniform1ivType) (GLint, GLsizei, const GLint*);
typedef void (APIENTRY* glUniform2fType) (GLint, GLfloat, GLfloat);
typedef void (APIENTRY* glUniform2fvType) (GLint, GLsizei, const GLfloat*);
typedef void (APIENTRY* glUniform2iType) (GLint, GLint, GLint);
typedef void (APIENTRY* glUniform2ivType) (GLint, GLsizei, const GLint*);
typedef void (APIENTRY* glUniform3fType) (GLint, GLfloat, GLfloat, GLfloat);
typedef void (APIENTRY* glUniform3fvType) (GLint, GLsizei, const GLfloat*);
typedef void (APIENTRY* glUniform3iType) (GLint, GLint, GLint, GLint);
typedef void (APIENTRY* glUniform3ivType) (GLint, GLsizei, const GLint*);
typedef void (APIENTRY* glUniform4fType) (GLint, GLfloat, GLfloat, GLfloat, GLfloat);
typedef void (APIENTRY* glUniform4fvType) (GLint, GLsizei, const GLfloat*);
typedef void (APIENTRY* glUniform4iType) (GLint, GLint, GLint, GLint, GLint);
typedef void (APIENTRY* glUniform4ivType) (GLint, GLsizei, const GLint*);
typedef void (APIENTRY* glUniformMatrix2fvType) (GLint, GLsizei, GLboolean, const GLfloat*);
typedef void (APIENTRY* glUniformMatrix3fvType) (GLint, GLsizei, GLboolean, const GLfloat*);
typedef void (APIENTRY* glUniformMatrix4fvType) (GLint, GLsizei, GLboolean, const GLfloat*);
typedef void (APIENTRY* glUseProgramType) (GLuint);
typedef void (APIENTRY* glValidateProgramType) (GLuint);
typedef void (APIENTRY* glVertexAttrib1fType) (GLuint, const GLfloat);
typedef void (APIENTRY* glVertexAttrib1fvType) (GLuint, const GLfloat*);
typedef void (APIENTRY* glVertexAttrib2fType) (GLuint, const GLfloat, const GLfloat);
typedef void (APIENTRY* glVertexAttrib2fvType) (GLuint, const GLfloat*);
typedef void (APIENTRY* glVertexAttrib3fType) (GLuint, const GLfloat, const GLfloat, const GLfloat);
typedef void (APIENTRY* glVertexAttrib3fvType) (GLuint, const GLfloat*);
typedef void (APIENTRY* glVertexAttrib4fType) (GLuint, const GLfloat, const GLfloat, const GLfloat, const GLfloat);
typedef void (APIENTRY* glVertexAttrib4fvType) (GLuint, const GLfloat*);
typedef void (APIENTRY* glVertexAttribPointerType) (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid*);

class GraphicsContext3DInternal {
public:
    GraphicsContext3DInternal(GraphicsContext3D::Attributes attrs);
    ~GraphicsContext3DInternal();

    bool isContextValid() { return m_contextValid; }

    glActiveTextureType activeTexture;
    glAttachShaderType attachShader;
    glBindAttribLocationType bindAttribLocation;
    glBindBufferType bindBuffer;
    glBindFramebufferType bindFramebuffer;
    glBindRenderbufferType bindRenderbuffer;
    glBlendColorType blendColor;
    glBlendEquationType blendEquation;
    glBlendEquationSeparateType blendEquationSeparate;
    glBlendFuncSeparateType blendFuncSeparate;
    glBufferDataType bufferData;
    glBufferSubDataType bufferSubData;
    glCheckFramebufferStatusType checkFramebufferStatus;
    glCompileShaderType compileShader;
    glCreateProgramType createProgram;
    glCreateShaderType createShader;
    glDeleteBuffersType deleteBuffers;
    glDeleteFramebuffersType deleteFramebuffers;
    glDeleteProgramType deleteProgram;
    glDeleteRenderbuffersType deleteRenderbuffers;
    glDeleteShaderType deleteShader;
    glDetachShaderType detachShader;
    glDisableVertexAttribArrayType disableVertexAttribArray;
    glEnableVertexAttribArrayType enableVertexAttribArray;
    glFramebufferRenderbufferType framebufferRenderbuffer;
    glFramebufferTexture2DType framebufferTexture2D;
    glGenBuffersType genBuffers;
    glGenerateMipmapType generateMipmap;
    glGenFramebuffersType genFramebuffers;
    glGenRenderbuffersType genRenderbuffers;
    glGetActiveAttribType getActiveAttrib;
    glGetActiveUniformType getActiveUniform;
    glGetAttribLocationType getAttribLocation;
    glGetBufferParameterivType getBufferParameteriv;
    glGetFramebufferAttachmentParameterivType getFramebufferAttachmentParameteriv;
    glGetProgramInfoLogType getProgramInfoLog;
    glGetProgramivType getProgramiv;
    glGetRenderbufferParameterivType getRenderbufferParameteriv;
    glGetShaderInfoLogType getShaderInfoLog;
    glGetShaderivType getShaderiv;
    glGetShaderSourceType getShaderSource;
    glGetUniformfvType getUniformfv;
    glGetUniformivType getUniformiv;
    glGetUniformLocationType getUniformLocation;
    glGetVertexAttribfvType getVertexAttribfv;
    glGetVertexAttribivType getVertexAttribiv;
    glGetVertexAttribPointervType getVertexAttribPointerv;
    glIsBufferType isBuffer;
    glIsFramebufferType isFramebuffer;
    glIsProgramType isProgram;
    glIsRenderbufferType isRenderbuffer;
    glIsShaderType isShader;
    glLinkProgramType linkProgram;
    glRenderbufferStorageType renderbufferStorage;
    glSampleCoverageType sampleCoverage;
    glShaderSourceType shaderSource;
    glStencilFuncSeparateType stencilFuncSeparate;
    glStencilMaskSeparateType stencilMaskSeparate;
    glStencilOpSeparateType stencilOpSeparate;
    glUniform1fType uniform1f;
    glUniform1fvType uniform1fv;
    glUniform1iType uniform1i;
    glUniform1ivType uniform1iv;
    glUniform2fType uniform2f;
    glUniform2fvType uniform2fv;
    glUniform2iType uniform2i;
    glUniform2ivType uniform2iv;
    glUniform3fType uniform3f;
    glUniform3fvType uniform3fv;
    glUniform3iType uniform3i;
    glUniform3ivType uniform3iv;
    glUniform4fType uniform4f;
    glUniform4fvType uniform4fv;
    glUniform4iType uniform4i;
    glUniform4ivType uniform4iv;
    glUniformMatrix2fvType uniformMatrix2fv;
    glUniformMatrix3fvType uniformMatrix3fv;
    glUniformMatrix4fvType uniformMatrix4fv;
    glUseProgramType useProgram;
    glValidateProgramType validateProgram;
    glVertexAttrib1fType vertexAttrib1f;
    glVertexAttrib1fvType vertexAttrib1fv;
    glVertexAttrib2fType vertexAttrib2f;
    glVertexAttrib2fvType vertexAttrib2fv;
    glVertexAttrib3fType vertexAttrib3f;
    glVertexAttrib3fvType vertexAttrib3fv;
    glVertexAttrib4fType vertexAttrib4f;
    glVertexAttrib4fvType vertexAttrib4fv;
    glVertexAttribPointerType vertexAttribPointer;

    GraphicsContext3D::Attributes m_attrs;
    QGLWidget* m_glWidget;
    GLuint m_texture;
    GLuint m_mainFbo;
    GLuint m_currentFbo;
    GLuint m_depthBuffer;
    QImage m_pixels;
    ListHashSet<unsigned long> m_syntheticErrors;

private:

    void* getProcAddress(const String& proc);
    bool m_contextValid;
};

#if defined (QT_OPENGL_ES_2) 
#define GET_PROC_ADDRESS(Proc) Proc
#else
#define GET_PROC_ADDRESS(Proc) reinterpret_cast<Proc##Type>(getProcAddress(#Proc));
#endif
 
GraphicsContext3DInternal::GraphicsContext3DInternal(GraphicsContext3D::Attributes attrs)
    : m_attrs(attrs)
    , m_glWidget(0)
    , m_texture(0)
    , m_mainFbo(0)
    , m_currentFbo(0)
    , m_depthBuffer(0)
    , m_contextValid(true)
{
    m_attrs.alpha = true;
    m_attrs.depth = true;
    m_attrs.stencil = false;
    m_attrs.antialias = false;
    m_attrs.premultipliedAlpha = true;

    QGLFormat format;

    format.setDepth(true);
    format.setSampleBuffers(true);
    format.setStencil(false);

    m_glWidget = new QGLWidget(format);
    if (!m_glWidget->isValid()) {
        LOG_ERROR("GraphicsContext3D: QGLWidget does not have a valid context");
        m_contextValid = false;
        return;
    }

    m_glWidget->makeCurrent();

    activeTexture = GET_PROC_ADDRESS(glActiveTexture);
    attachShader = GET_PROC_ADDRESS(glAttachShader);
    bindAttribLocation = GET_PROC_ADDRESS(glBindAttribLocation);
    bindBuffer = GET_PROC_ADDRESS(glBindBuffer);
    bindFramebuffer = GET_PROC_ADDRESS(glBindFramebuffer);
    bindRenderbuffer = GET_PROC_ADDRESS(glBindRenderbuffer);
    blendColor = GET_PROC_ADDRESS(glBlendColor);
    blendEquation = GET_PROC_ADDRESS(glBlendEquation);
    blendEquationSeparate = GET_PROC_ADDRESS(glBlendEquationSeparate);
    blendFuncSeparate = GET_PROC_ADDRESS(glBlendFuncSeparate);
    bufferData = GET_PROC_ADDRESS(glBufferData);
    bufferSubData = GET_PROC_ADDRESS(glBufferSubData);
    checkFramebufferStatus = GET_PROC_ADDRESS(glCheckFramebufferStatus);
    compileShader = GET_PROC_ADDRESS(glCompileShader);
    createProgram = GET_PROC_ADDRESS(glCreateProgram);
    createShader = GET_PROC_ADDRESS(glCreateShader);
    deleteBuffers = GET_PROC_ADDRESS(glDeleteBuffers);
    deleteFramebuffers = GET_PROC_ADDRESS(glDeleteFramebuffers);
    deleteProgram = GET_PROC_ADDRESS(glDeleteProgram);
    deleteRenderbuffers = GET_PROC_ADDRESS(glDeleteRenderbuffers);
    deleteShader = GET_PROC_ADDRESS(glDeleteShader);
    detachShader = GET_PROC_ADDRESS(glDetachShader);
    disableVertexAttribArray = GET_PROC_ADDRESS(glDisableVertexAttribArray);
    enableVertexAttribArray = GET_PROC_ADDRESS(glEnableVertexAttribArray);
    framebufferRenderbuffer = GET_PROC_ADDRESS(glFramebufferRenderbuffer);
    framebufferTexture2D = GET_PROC_ADDRESS(glFramebufferTexture2D);
    genBuffers = GET_PROC_ADDRESS(glGenBuffers);
    generateMipmap = GET_PROC_ADDRESS(glGenerateMipmap);
    genFramebuffers = GET_PROC_ADDRESS(glGenFramebuffers);
    genRenderbuffers = GET_PROC_ADDRESS(glGenRenderbuffers);
    getActiveAttrib = GET_PROC_ADDRESS(glGetActiveAttrib);
    getActiveUniform = GET_PROC_ADDRESS(glGetActiveUniform);
    getAttribLocation = GET_PROC_ADDRESS(glGetAttribLocation);
    getBufferParameteriv = GET_PROC_ADDRESS(glGetBufferParameteriv);
    getFramebufferAttachmentParameteriv = GET_PROC_ADDRESS(glGetFramebufferAttachmentParameteriv);
    getProgramInfoLog = GET_PROC_ADDRESS(glGetProgramInfoLog);
    getProgramiv = GET_PROC_ADDRESS(glGetProgramiv);
    getRenderbufferParameteriv = GET_PROC_ADDRESS(glGetRenderbufferParameteriv);
    getShaderInfoLog = GET_PROC_ADDRESS(glGetShaderInfoLog);
    getShaderiv = GET_PROC_ADDRESS(glGetShaderiv);
    getShaderSource = GET_PROC_ADDRESS(glGetShaderSource);
    getUniformfv = GET_PROC_ADDRESS(glGetUniformfv);
    getUniformiv = GET_PROC_ADDRESS(glGetUniformiv);
    getUniformLocation = GET_PROC_ADDRESS(glGetUniformLocation);
    getVertexAttribfv = GET_PROC_ADDRESS(glGetVertexAttribfv);
    getVertexAttribiv = GET_PROC_ADDRESS(glGetVertexAttribiv);
    getVertexAttribPointerv = GET_PROC_ADDRESS(glGetVertexAttribPointerv);
    isBuffer = GET_PROC_ADDRESS(glIsBuffer);
    isFramebuffer = GET_PROC_ADDRESS(glIsFramebuffer);
    isProgram = GET_PROC_ADDRESS(glIsProgram);
    isRenderbuffer = GET_PROC_ADDRESS(glIsRenderbuffer);
    isShader = GET_PROC_ADDRESS(glIsShader);
    linkProgram = GET_PROC_ADDRESS(glLinkProgram);
    renderbufferStorage = GET_PROC_ADDRESS(glRenderbufferStorage);
    sampleCoverage = GET_PROC_ADDRESS(glSampleCoverage);
    shaderSource = GET_PROC_ADDRESS(glShaderSource);
    stencilFuncSeparate = GET_PROC_ADDRESS(glStencilFuncSeparate);
    stencilMaskSeparate = GET_PROC_ADDRESS(glStencilMaskSeparate);
    stencilOpSeparate = GET_PROC_ADDRESS(glStencilOpSeparate);
    uniform1f = GET_PROC_ADDRESS(glUniform1f);
    uniform1fv = GET_PROC_ADDRESS(glUniform1fv);
    uniform1i = GET_PROC_ADDRESS(glUniform1i);
    uniform1iv = GET_PROC_ADDRESS(glUniform1iv);
    uniform2f = GET_PROC_ADDRESS(glUniform2f);
    uniform2fv = GET_PROC_ADDRESS(glUniform2fv);
    uniform2i = GET_PROC_ADDRESS(glUniform2i);
    uniform2iv = GET_PROC_ADDRESS(glUniform2iv);
    uniform3f = GET_PROC_ADDRESS(glUniform3f);
    uniform3fv = GET_PROC_ADDRESS(glUniform3fv);
    uniform3i = GET_PROC_ADDRESS(glUniform3i);
    uniform3iv = GET_PROC_ADDRESS(glUniform3iv);
    uniform4f = GET_PROC_ADDRESS(glUniform4f);
    uniform4fv = GET_PROC_ADDRESS(glUniform4fv);
    uniform4i = GET_PROC_ADDRESS(glUniform4i);
    uniform4iv = GET_PROC_ADDRESS(glUniform4iv);
    uniformMatrix2fv = GET_PROC_ADDRESS(glUniformMatrix2fv);
    uniformMatrix3fv = GET_PROC_ADDRESS(glUniformMatrix3fv);
    uniformMatrix4fv = GET_PROC_ADDRESS(glUniformMatrix4fv);
    useProgram = GET_PROC_ADDRESS(glUseProgram);
    validateProgram = GET_PROC_ADDRESS(glValidateProgram);
    vertexAttrib1f = GET_PROC_ADDRESS(glVertexAttrib1f);
    vertexAttrib1fv = GET_PROC_ADDRESS(glVertexAttrib1fv);
    vertexAttrib2f = GET_PROC_ADDRESS(glVertexAttrib2f);
    vertexAttrib2fv = GET_PROC_ADDRESS(glVertexAttrib2fv);
    vertexAttrib3f = GET_PROC_ADDRESS(glVertexAttrib3f);
    vertexAttrib3fv = GET_PROC_ADDRESS(glVertexAttrib3fv);
    vertexAttrib4f = GET_PROC_ADDRESS(glVertexAttrib4f);
    vertexAttrib4fv = GET_PROC_ADDRESS(glVertexAttrib4fv);
    vertexAttribPointer = GET_PROC_ADDRESS(glVertexAttribPointer);

    if (!m_contextValid) {
        LOG_ERROR("GraphicsContext3D: All needed OpenGL extensions are not available");
        m_contextValid = false;
        return;
    }

    glGenTextures(1, &m_texture);
    glBindTexture(GraphicsContext3D::TEXTURE_2D, m_texture);
    glTexParameterf(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR);
    glTexParameterf(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR);
    glTexParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE);
    glTexParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE);
    glTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, 1, 1, 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, 0);
    glBindTexture(GraphicsContext3D::TEXTURE_2D, 0);

    genFramebuffers(/* count */ 1, &m_mainFbo);
    m_currentFbo = m_mainFbo;

    bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_mainFbo);

    genRenderbuffers(/* count */ 1, &m_depthBuffer);
    bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_depthBuffer);
#if defined(QT_OPENGL_ES_2)
    renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT16, /* width */ 1, /* height */ 1);
#else
    renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT, /* width */ 1, /* height */ 1);
#endif

    bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
 
    framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, m_texture, 0);
    framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_depthBuffer);
    glClearColor(/* red */ 0, /* green */ 0, /* blue */ 0, /* alpha */ 0);

    if (checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
        LOG_ERROR("GraphicsContext3D: Wasn't able to create the main framebuffer");
        m_contextValid = false;
    }
}

GraphicsContext3DInternal::~GraphicsContext3DInternal()
{
    delete m_glWidget;
    m_glWidget = 0;
}

void* GraphicsContext3DInternal::getProcAddress(const String& proc)
{
    String ext[3] = { "", "ARB", "EXT" };

    for (int i = 0; i < 3; i++) {
        String nameWithExt = proc + ext[i];

        void* addr = m_glWidget->context()->getProcAddress(nameWithExt.utf8().data());
        if (addr) 
            return addr;
    }

    LOG_ERROR("GraphicsContext3D: Did not find GL function %s", proc.utf8().data());
    m_contextValid = false;
    return 0;
}

PassOwnPtr<GraphicsContext3D> GraphicsContext3D::create(GraphicsContext3D::Attributes attrs)
{
    OwnPtr<GraphicsContext3D> context(new GraphicsContext3D(attrs));
    return context->m_internal ? context.release() : 0;
}

GraphicsContext3D::GraphicsContext3D(GraphicsContext3D::Attributes attrs)
    : m_internal(new GraphicsContext3DInternal(attrs))
{
    if (!m_internal->isContextValid()) 
        m_internal = 0;
}

GraphicsContext3D::~GraphicsContext3D()
{
}

PlatformGraphicsContext3D GraphicsContext3D::platformGraphicsContext3D()
{
    return m_internal->m_glWidget;
}

Platform3DObject GraphicsContext3D::platformTexture() const
{
    return m_internal->m_texture;
}

void GraphicsContext3D::makeContextCurrent()
{
    m_internal->m_glWidget->makeCurrent();
}

void GraphicsContext3D::beginPaint(WebGLRenderingContext* context)
{
    m_internal->m_glWidget->makeCurrent();

    HTMLCanvasElement* canvas = context->canvas();
    ImageBuffer* imageBuffer = canvas->buffer();

    m_internal->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_internal->m_mainFbo);

    glReadPixels(/* x */ 0, /* y */ 0, m_currentWidth, m_currentHeight, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, m_internal->m_pixels.bits());

    QPainter* p = imageBuffer->context()->platformContext();
    p->drawImage(/* x */ 0, /* y */ 0, m_internal->m_pixels.transformed(QMatrix().rotate(180)));

    m_internal->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_internal->m_currentFbo);
}

void GraphicsContext3D::endPaint()
{
}

void GraphicsContext3D::reshape(int width, int height)
{
    if (((width == m_currentWidth) && (height == m_currentHeight)) || (!m_internal))
        return;
    
    m_currentWidth = width;
    m_currentHeight = height;

    m_internal->m_pixels = QImage(m_currentWidth, m_currentHeight, QImage::Format_ARGB32);

    m_internal->m_glWidget->makeCurrent();

    glBindTexture(GraphicsContext3D::TEXTURE_2D, m_internal->m_texture);
    glTexImage2D(GraphicsContext3D::TEXTURE_2D, /* level */ 0, GraphicsContext3D::RGBA, width, height, /* border */ 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, /* data */ 0);
    glBindTexture(GraphicsContext3D::TEXTURE_2D, 0);
   
    m_internal->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_internal->m_mainFbo);
    m_internal->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, m_internal->m_depthBuffer);
#if defined(QT_OPENGL_ES_2)
    renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT16, width, height);
#else
    renderbufferStorage(GraphicsContext3D::RENDERBUFFER, GraphicsContext3D::DEPTH_COMPONENT, width, height);
#endif
    m_internal->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, 0);
    
    m_internal->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, m_internal->m_texture, 0);
    m_internal->framebufferRenderbuffer(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::DEPTH_ATTACHMENT, GraphicsContext3D::RENDERBUFFER, m_internal->m_depthBuffer);

    GLenum status = m_internal->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER);
    if (status != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
        LOG_ERROR("GraphicsContext3D: Wasn't able to reshape the main framebuffer");
        notImplemented();
    }

    glClear(GraphicsContext3D::COLOR_BUFFER_BIT);
    glFlush();
}

void GraphicsContext3D::activeTexture(unsigned long texture)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->activeTexture(texture);
}

void GraphicsContext3D::attachShader(WebGLProgram* program, WebGLShader* shader)
{
    ASSERT(program);
    ASSERT(shader);
    m_internal->m_glWidget->makeCurrent();
    m_internal->attachShader((GLuint) program->object(), (GLuint) shader->object());
}

void GraphicsContext3D::bindAttribLocation(WebGLProgram* program, unsigned long index, const String& name)
{
    ASSERT(program);
    m_internal->m_glWidget->makeCurrent();
    m_internal->bindAttribLocation((GLuint) program->object(), index, name.utf8().data());
}

void GraphicsContext3D::bindBuffer(unsigned long target, WebGLBuffer* buffer)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->bindBuffer(target, buffer ? (GLuint) buffer->object() : 0);
}

void GraphicsContext3D::bindFramebuffer(unsigned long target, WebGLFramebuffer* buffer)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->m_currentFbo = (buffer && buffer->object()) ? (GLuint) buffer->object() : m_internal->m_mainFbo;
    m_internal->bindFramebuffer(target, m_internal->m_currentFbo);
}

void GraphicsContext3D::bindRenderbuffer(unsigned long target, WebGLRenderbuffer* renderbuffer)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->bindRenderbuffer(target, renderbuffer ? (GLuint) renderbuffer->object() : 0);
}

void GraphicsContext3D::bindTexture(unsigned long target, WebGLTexture* texture)
{
    m_internal->m_glWidget->makeCurrent();
    glBindTexture(target, texture ? (GLuint) texture->object() : 0);
}

void GraphicsContext3D::blendColor(double red, double green, double blue, double alpha)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->blendColor(static_cast<float>(red), static_cast<float>(green), static_cast<float>(blue), static_cast<float>(alpha));
}

void GraphicsContext3D::blendEquation(unsigned long mode)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->blendEquation(mode);
}

void GraphicsContext3D::blendEquationSeparate(unsigned long modeRGB, unsigned long modeAlpha)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->blendEquationSeparate(modeRGB, modeAlpha);
}

void GraphicsContext3D::blendFunc(unsigned long sfactor, unsigned long dfactor)
{
    m_internal->m_glWidget->makeCurrent();
    glBlendFunc(sfactor, dfactor);
}       

void GraphicsContext3D::blendFuncSeparate(unsigned long srcRGB, unsigned long dstRGB, unsigned long srcAlpha, unsigned long dstAlpha)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void GraphicsContext3D::bufferData(unsigned long target, int size, unsigned long usage)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->bufferData(target, size, /* data */ 0, usage);
}

void GraphicsContext3D::bufferData(unsigned long target, WebGLArray* array, unsigned long usage)
{
    if (!array || !array->length())
        return;
    
    m_internal->m_glWidget->makeCurrent();
    m_internal->bufferData(target, array->byteLength(), array->baseAddress(), usage);
}

void GraphicsContext3D::bufferSubData(unsigned long target, long offset, WebGLArray* array)
{
    if (!array || !array->length())
        return;
    
    m_internal->m_glWidget->makeCurrent();
    m_internal->bufferSubData(target, offset, array->byteLength(), array->baseAddress());
}

unsigned long GraphicsContext3D::checkFramebufferStatus(unsigned long target)
{
    m_internal->m_glWidget->makeCurrent();
    return m_internal->checkFramebufferStatus(target);
}

void GraphicsContext3D::clearColor(double r, double g, double b, double a)
{
    m_internal->m_glWidget->makeCurrent();
    glClearColor(static_cast<float>(r), static_cast<float>(g), static_cast<float>(b), static_cast<float>(a));
}

void GraphicsContext3D::clear(unsigned long mask)
{
    m_internal->m_glWidget->makeCurrent();
    glClear(mask);
}

void GraphicsContext3D::clearDepth(double depth)
{
    m_internal->m_glWidget->makeCurrent();
#if defined(QT_OPENGL_ES_2)
    glClearDepthf(depth);
#else
    glClearDepth(depth);
#endif
}

void GraphicsContext3D::clearStencil(long s)
{
    m_internal->m_glWidget->makeCurrent();
    glClearStencil(s);
}

void GraphicsContext3D::colorMask(bool red, bool green, bool blue, bool alpha)
{
    m_internal->m_glWidget->makeCurrent();
    glColorMask(red, green, blue, alpha);
}

void GraphicsContext3D::compileShader(WebGLShader* shader)
{
    ASSERT(shader);
    m_internal->m_glWidget->makeCurrent();
    m_internal->compileShader((GLuint) shader->object());
}

void GraphicsContext3D::copyTexImage2D(unsigned long target, long level, unsigned long internalformat, long x, long y, unsigned long width, unsigned long height, long border)
{
    m_internal->m_glWidget->makeCurrent();
    glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}

void GraphicsContext3D::copyTexSubImage2D(unsigned long target, long level, long xoffset, long yoffset, long x, long y, unsigned long width, unsigned long height)
{
    m_internal->m_glWidget->makeCurrent();
    glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}

void GraphicsContext3D::cullFace(unsigned long mode)
{
    m_internal->m_glWidget->makeCurrent();
    glCullFace(mode);
}

void GraphicsContext3D::depthFunc(unsigned long func)
{
    m_internal->m_glWidget->makeCurrent();
    glDepthFunc(func);
}

void GraphicsContext3D::depthMask(bool flag)
{
    m_internal->m_glWidget->makeCurrent();
    glDepthMask(flag);
}

void GraphicsContext3D::depthRange(double zNear, double zFar)
{
    m_internal->m_glWidget->makeCurrent();
#if defined(QT_OPENGL_ES_2)
    glDepthRangef(zNear, zFar);
#else
    glDepthRange(zNear, zFar);
#endif
}

void GraphicsContext3D::detachShader(WebGLProgram* program, WebGLShader* shader)
{
    ASSERT(program);
    ASSERT(shader);
    m_internal->m_glWidget->makeCurrent();
    m_internal->detachShader((GLuint) program->object(), (GLuint) shader->object());
}

void GraphicsContext3D::disable(unsigned long cap)
{
    m_internal->m_glWidget->makeCurrent();
    glDisable(cap);
}

void GraphicsContext3D::disableVertexAttribArray(unsigned long index)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->disableVertexAttribArray(index);
}

void GraphicsContext3D::drawArrays(unsigned long mode, long first, long count)
{
    m_internal->m_glWidget->makeCurrent();
    glDrawArrays(mode, first, count);
}

void GraphicsContext3D::drawElements(unsigned long mode, unsigned long count, unsigned long type, long offset)
{
    m_internal->m_glWidget->makeCurrent();
    glDrawElements(mode, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
}

void GraphicsContext3D::enable(unsigned long cap)
{
    m_internal->m_glWidget->makeCurrent();
    glEnable(cap);
}

void GraphicsContext3D::enableVertexAttribArray(unsigned long index)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->enableVertexAttribArray(index);
}

void GraphicsContext3D::finish()
{
    m_internal->m_glWidget->makeCurrent();
    glFinish();
}

void GraphicsContext3D::flush()
{
    m_internal->m_glWidget->makeCurrent();
    glFlush();
}

void GraphicsContext3D::framebufferRenderbuffer(unsigned long target, unsigned long attachment, unsigned long renderbuffertarget, WebGLRenderbuffer* buffer)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->framebufferRenderbuffer(target, attachment, renderbuffertarget, buffer ? (GLuint) buffer->object() : 0);
}

void GraphicsContext3D::framebufferTexture2D(unsigned long target, unsigned long attachment, unsigned long textarget, WebGLTexture* texture, long level)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->framebufferTexture2D(target, attachment, textarget, texture ? (GLuint) texture->object() : 0, level);
}

void GraphicsContext3D::frontFace(unsigned long mode)
{
    m_internal->m_glWidget->makeCurrent();
    glFrontFace(mode);
}

void GraphicsContext3D::generateMipmap(unsigned long target)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->generateMipmap(target);
}

bool GraphicsContext3D::getActiveAttrib(WebGLProgram* program, unsigned long index, ActiveInfo& info)
{
    if (!program->object()) {
        synthesizeGLError(INVALID_VALUE);
        return false;
    }

    m_internal->m_glWidget->makeCurrent();

    GLint maxLength;
    m_internal->getProgramiv(static_cast<GLuint>(program->object()), GraphicsContext3D::ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxLength);

    GLchar name[maxLength]; 
    GLsizei nameLength;
    GLint size;
    GLenum type;

    m_internal->getActiveAttrib(static_cast<GLuint>(program->object()), index, maxLength, &nameLength, &size, &type, name);

    if (!nameLength)
        return false;

    info.name = String(name, nameLength);
    info.type = type;
    info.size = size;

    return true;
}
    
bool GraphicsContext3D::getActiveUniform(WebGLProgram* program, unsigned long index, ActiveInfo& info)
{
    if (!program->object()) {
        synthesizeGLError(INVALID_VALUE);
        return false;
    }

    m_internal->m_glWidget->makeCurrent();

    GLint maxLength;
    m_internal->getProgramiv(static_cast<GLuint>(program->object()), GraphicsContext3D::ACTIVE_UNIFORM_MAX_LENGTH, &maxLength);

    GLchar name[maxLength];
    GLsizei nameLength;
    GLint size;
    GLenum type;

    m_internal->getActiveUniform(static_cast<GLuint>(program->object()), index, maxLength, &nameLength, &size, &type, name);

    if (!nameLength)
        return false;

    info.name = String(name, nameLength);
    info.type = type;
    info.size = size;

    return true;
}

int GraphicsContext3D::getAttribLocation(WebGLProgram* program, const String& name)
{
    if (!program)
        return -1;
    
    m_internal->m_glWidget->makeCurrent();
    return m_internal->getAttribLocation((GLuint) program->object(), name.utf8().data());
}

GraphicsContext3D::Attributes GraphicsContext3D::getContextAttributes()
{
    return m_internal->m_attrs;
}

unsigned long GraphicsContext3D::getError()
{
    if (m_internal->m_syntheticErrors.size() > 0) {
        ListHashSet<unsigned long>::iterator iter = m_internal->m_syntheticErrors.begin();
        unsigned long err = *iter;
        m_internal->m_syntheticErrors.remove(iter);
        return err;
    }

    m_internal->m_glWidget->makeCurrent();
    return glGetError();
}

String GraphicsContext3D::getString(unsigned long name)
{
    m_internal->m_glWidget->makeCurrent();
    return String((const char*) glGetString(name));
}

void GraphicsContext3D::hint(unsigned long target, unsigned long mode)
{
    m_internal->m_glWidget->makeCurrent();
    glHint(target, mode);
}

bool GraphicsContext3D::isBuffer(WebGLBuffer* buffer)
{
    if (!buffer)
        return false;
    
    m_internal->m_glWidget->makeCurrent();
    return m_internal->isBuffer((GLuint) buffer->object());
}

bool GraphicsContext3D::isEnabled(unsigned long cap)
{
    m_internal->m_glWidget->makeCurrent();
    return glIsEnabled(cap);
}

bool GraphicsContext3D::isFramebuffer(WebGLFramebuffer* framebuffer)
{
    if (!framebuffer)
        return false;
    
    m_internal->m_glWidget->makeCurrent();
    return m_internal->isFramebuffer((GLuint) framebuffer->object());
}

bool GraphicsContext3D::isProgram(WebGLProgram* program)
{
    if (!program)
        return false;
    
    m_internal->m_glWidget->makeCurrent();
    return m_internal->isProgram((GLuint) program->object());
}

bool GraphicsContext3D::isRenderbuffer(WebGLRenderbuffer* renderbuffer)
{
    if (!renderbuffer)
        return false;
    
    m_internal->m_glWidget->makeCurrent();
    return m_internal->isRenderbuffer((GLuint) renderbuffer->object());
}

bool GraphicsContext3D::isShader(WebGLShader* shader)
{
    if (!shader)
        return false;
    
    m_internal->m_glWidget->makeCurrent();
    return m_internal->isShader((GLuint) shader->object());
}

bool GraphicsContext3D::isTexture(WebGLTexture* texture)
{
    if (!texture)
        return false;
    
    m_internal->m_glWidget->makeCurrent();
    return glIsTexture((GLuint) texture->object());
}

void GraphicsContext3D::lineWidth(double width)
{
    m_internal->m_glWidget->makeCurrent();
    glLineWidth(static_cast<float>(width));
}

void GraphicsContext3D::linkProgram(WebGLProgram* program)
{
    ASSERT(program);
    m_internal->m_glWidget->makeCurrent();
    m_internal->linkProgram((GLuint) program->object());
}

void GraphicsContext3D::pixelStorei(unsigned long paramName, long param)
{
    m_internal->m_glWidget->makeCurrent();
    glPixelStorei(paramName, param);
}

void GraphicsContext3D::polygonOffset(double factor, double units)
{
    m_internal->m_glWidget->makeCurrent();
    glPolygonOffset(static_cast<float>(factor), static_cast<float>(units));
}

PassRefPtr<WebGLArray> GraphicsContext3D::readPixels(long x, long y, unsigned long width, unsigned long height, unsigned long format, unsigned long type)
{
    m_internal->m_glWidget->makeCurrent();
    
    if (type != GraphicsContext3D::UNSIGNED_BYTE || format != GraphicsContext3D::RGBA)
        return 0;
        
    RefPtr<WebGLUnsignedByteArray> array = WebGLUnsignedByteArray::create(width * height * 4);
    glReadPixels(x, y, width, height, format, type, (GLvoid*) array->data());
    return array;    
}

void GraphicsContext3D::releaseShaderCompiler()
{
    m_internal->m_glWidget->makeCurrent();
    notImplemented();
}

void GraphicsContext3D::renderbufferStorage(unsigned long target, unsigned long internalformat, unsigned long width, unsigned long height)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->renderbufferStorage(target, internalformat, width, height);
}

void GraphicsContext3D::sampleCoverage(double value, bool invert)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->sampleCoverage(static_cast<float>(value), invert);
}

void GraphicsContext3D::scissor(long x, long y, unsigned long width, unsigned long height)
{
    m_internal->m_glWidget->makeCurrent();
    glScissor(x, y, width, height);
}

void GraphicsContext3D::shaderSource(WebGLShader* shader, const String& source)
{
    ASSERT(shader);
    
    m_internal->m_glWidget->makeCurrent();

    CString sourceCS = source.utf8();
    const char* data = sourceCS.data();
    int length = source.length();
    m_internal->shaderSource((GLuint) shader->object(), /* count */ 1, &data, &length);
}

void GraphicsContext3D::stencilFunc(unsigned long func, long ref, unsigned long mask)
{
    m_internal->m_glWidget->makeCurrent();
    glStencilFunc(func, ref, mask);
}

void GraphicsContext3D::stencilFuncSeparate(unsigned long face, unsigned long func, long ref, unsigned long mask)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->stencilFuncSeparate(face, func, ref, mask);
}

void GraphicsContext3D::stencilMask(unsigned long mask)
{
    m_internal->m_glWidget->makeCurrent();
    glStencilMask(mask);
}

void GraphicsContext3D::stencilMaskSeparate(unsigned long face, unsigned long mask)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->stencilMaskSeparate(face, mask);
}

void GraphicsContext3D::stencilOp(unsigned long fail, unsigned long zfail, unsigned long zpass)
{
    m_internal->m_glWidget->makeCurrent();
    glStencilOp(fail, zfail, zpass);
}

void GraphicsContext3D::stencilOpSeparate(unsigned long face, unsigned long fail, unsigned long zfail, unsigned long zpass)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->stencilOpSeparate(face, fail, zfail, zpass);
}

void GraphicsContext3D::texParameterf(unsigned target, unsigned paramName, float value)
{
    m_internal->m_glWidget->makeCurrent();
    glTexParameterf(target, paramName, static_cast<float>(value));
}

void GraphicsContext3D::texParameteri(unsigned target, unsigned paramName, int value)
{
    m_internal->m_glWidget->makeCurrent();
    glTexParameteri(target, paramName, static_cast<float>(value));
}

void GraphicsContext3D::uniform1f(long location, float v0)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform1f(location, v0);
}

void GraphicsContext3D::uniform1fv(long location, float* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform1fv(location, size, array);
}

void GraphicsContext3D::uniform2f(long location, float v0, float v1)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform2f(location, v0, v1);
}

void GraphicsContext3D::uniform2fv(long location, float* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform2fv(location, size, array);
}

void GraphicsContext3D::uniform3f(long location, float v0, float v1, float v2)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform3f(location, v0, v1, v2);
}

void GraphicsContext3D::uniform3fv(long location, float* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform3fv(location, size, array);
}

void GraphicsContext3D::uniform4f(long location, float v0, float v1, float v2, float v3)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform4f(location, v0, v1, v2, v3);
}

void GraphicsContext3D::uniform4fv(long location, float* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform4fv(location, size, array);
}

void GraphicsContext3D::uniform1i(long location, int v0)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform1i(location, v0);
}

void GraphicsContext3D::uniform1iv(long location, int* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform1iv(location, size, array);
}

void GraphicsContext3D::uniform2i(long location, int v0, int v1)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform2i(location, v0, v1);
}

void GraphicsContext3D::uniform2iv(long location, int* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform2iv(location, size, array);
}

void GraphicsContext3D::uniform3i(long location, int v0, int v1, int v2)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform3i(location, v0, v1, v2);
}

void GraphicsContext3D::uniform3iv(long location, int* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform3iv(location, size, array);
}

void GraphicsContext3D::uniform4i(long location, int v0, int v1, int v2, int v3)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform4i(location, v0, v1, v2, v3);
}

void GraphicsContext3D::uniform4iv(long location, int* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniform4iv(location, size, array);
}

void GraphicsContext3D::uniformMatrix2fv(long location, bool transpose, float* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniformMatrix2fv(location, size, transpose, array);
}

void GraphicsContext3D::uniformMatrix3fv(long location, bool transpose, float* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniformMatrix3fv(location, size, transpose, array);
}

void GraphicsContext3D::uniformMatrix4fv(long location, bool transpose, float* array, int size)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->uniformMatrix4fv(location, size, transpose, array);
}

void GraphicsContext3D::useProgram(WebGLProgram* program)
{
    ASSERT(program);
    
    m_internal->m_glWidget->makeCurrent();
    m_internal->useProgram((GLuint) program->object());
}

void GraphicsContext3D::validateProgram(WebGLProgram* program)
{
    ASSERT(program);
    
    m_internal->m_glWidget->makeCurrent();
    m_internal->validateProgram((GLuint) program->object());
}

void GraphicsContext3D::vertexAttrib1f(unsigned long indx, float v0)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttrib1f(indx, v0);
}

void GraphicsContext3D::vertexAttrib1fv(unsigned long indx, float* array)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttrib1fv(indx, array);
}

void GraphicsContext3D::vertexAttrib2f(unsigned long indx, float v0, float v1)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttrib2f(indx, v0, v1);
}

void GraphicsContext3D::vertexAttrib2fv(unsigned long indx, float* array)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttrib2fv(indx, array);
}

void GraphicsContext3D::vertexAttrib3f(unsigned long indx, float v0, float v1, float v2)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttrib3f(indx, v0, v1, v2);
}

void GraphicsContext3D::vertexAttrib3fv(unsigned long indx, float* array)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttrib3fv(indx, array);
}

void GraphicsContext3D::vertexAttrib4f(unsigned long indx, float v0, float v1, float v2, float v3)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttrib4f(indx, v0, v1, v2, v3);
}

void GraphicsContext3D::vertexAttrib4fv(unsigned long indx, float* array)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttrib4fv(indx, array);
}

void GraphicsContext3D::vertexAttribPointer(unsigned long indx, int size, int type, bool normalized, unsigned long stride, unsigned long offset)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->vertexAttribPointer(indx, size, type, normalized, stride, reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
}

void GraphicsContext3D::viewport(long x, long y, unsigned long width, unsigned long height)
{
    m_internal->m_glWidget->makeCurrent();
    glViewport(static_cast<GLint>(x), static_cast<GLint>(y), static_cast<GLsizei>(width), static_cast<GLsizei>(height));
}

void GraphicsContext3D::getBooleanv(unsigned long paramName, unsigned char* value)
{
    m_internal->m_glWidget->makeCurrent();
    glGetBooleanv(paramName, value);
}

void GraphicsContext3D::getBufferParameteriv(unsigned long target, unsigned long paramName, int* value)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->getBufferParameteriv(target, paramName, value);
}

void GraphicsContext3D::getFloatv(unsigned long paramName, float* value)
{
    m_internal->m_glWidget->makeCurrent();
    glGetFloatv(paramName, value);
}

void GraphicsContext3D::getFramebufferAttachmentParameteriv(unsigned long target, unsigned long attachment, unsigned long paramName, int* value)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->getFramebufferAttachmentParameteriv(target, attachment, paramName, value);
}

void GraphicsContext3D::getIntegerv(unsigned long paramName, int* value)
{
    m_internal->m_glWidget->makeCurrent();
    glGetIntegerv(paramName, value);
}

void GraphicsContext3D::getProgramiv(WebGLProgram* program, unsigned long paramName, int* value)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->getProgramiv((GLuint) program->object(), paramName, value);
}

String GraphicsContext3D::getProgramInfoLog(WebGLProgram* program)
{
    m_internal->m_glWidget->makeCurrent();

    GLint length;
    m_internal->getProgramiv((GLuint) program->object(), GraphicsContext3D::INFO_LOG_LENGTH, &length);

    GLsizei size;

    GLchar* info = (GLchar*) fastMalloc(length);
    if (!info)
        return "";

    m_internal->getProgramInfoLog((GLuint) program->object(), length, &size, info);

    String result(info);
    fastFree(info);

    return result;
}

void GraphicsContext3D::getRenderbufferParameteriv(unsigned long target, unsigned long paramName, int* value)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->getRenderbufferParameteriv(target, paramName, value);
}

void GraphicsContext3D::getShaderiv(WebGLShader* shader, unsigned long paramName, int* value)
{
    ASSERT(shader);
    m_internal->m_glWidget->makeCurrent();
    m_internal->getShaderiv((GLuint) shader->object(), paramName, value);
}

String GraphicsContext3D::getShaderInfoLog(WebGLShader* shader)
{
    m_internal->m_glWidget->makeCurrent();

    GLint length;
    m_internal->getShaderiv((GLuint) shader->object(), GraphicsContext3D::INFO_LOG_LENGTH, &length);

    GLsizei size;
    GLchar* info = (GLchar*) fastMalloc(length);
    if (!info)
        return "";

    m_internal->getShaderInfoLog((GLuint) shader->object(), length, &size, info);

    String result(info);
    fastFree(info);

    return result;
}

String GraphicsContext3D::getShaderSource(WebGLShader* shader)
{
    m_internal->m_glWidget->makeCurrent();

    GLint length;
    m_internal->getShaderiv((GLuint) shader->object(), GraphicsContext3D::SHADER_SOURCE_LENGTH, &length);

    GLsizei size;
    GLchar* info = (GLchar*) fastMalloc(length);
    if (!info)
        return "";

    m_internal->getShaderSource((GLuint) shader->object(), length, &size, info);

    String result(info);
    fastFree(info);

    return result;
}

void GraphicsContext3D::getTexParameterfv(unsigned long target, unsigned long paramName, float* value)
{
    m_internal->m_glWidget->makeCurrent();
    glGetTexParameterfv(target, paramName, value);
}

void GraphicsContext3D::getTexParameteriv(unsigned long target, unsigned long paramName, int* value)
{
    m_internal->m_glWidget->makeCurrent();
    glGetTexParameteriv(target, paramName, value);
}

void GraphicsContext3D::getUniformfv(WebGLProgram* program, long location, float* value)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->getUniformfv((GLuint) program->object(), location, value);
}

void GraphicsContext3D::getUniformiv(WebGLProgram* program, long location, int* value)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->getUniformiv((GLuint) program->object(), location, value);
}

long GraphicsContext3D::getUniformLocation(WebGLProgram* program, const String& name)
{
    ASSERT(program);
    
    m_internal->m_glWidget->makeCurrent();
    return m_internal->getUniformLocation((GLuint) program->object(), name.utf8().data());
}

void GraphicsContext3D::getVertexAttribfv(unsigned long index, unsigned long paramName, float* value)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->getVertexAttribfv(index, paramName, value);
}

void GraphicsContext3D::getVertexAttribiv(unsigned long index, unsigned long paramName, int* value)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->getVertexAttribiv(index, paramName, value);
}

long GraphicsContext3D::getVertexAttribOffset(unsigned long index, unsigned long paramName)
{
    m_internal->m_glWidget->makeCurrent();
    
    void* pointer;
    m_internal->getVertexAttribPointerv(index, paramName, &pointer);
    return reinterpret_cast<long>(pointer);
}

int GraphicsContext3D::texImage2D(unsigned target, unsigned level, unsigned internalformat, unsigned width, unsigned height, unsigned border, unsigned format, unsigned type, void* pixels)
{
    glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
    return 0;
}

int GraphicsContext3D::texImage2D(unsigned target, unsigned level, Image* image, bool flipY, bool premultiplyAlpha)
{
    ASSERT(image);
    
    m_internal->m_glWidget->makeCurrent();

    Vector<uint8_t> imageData;
    GLuint format;
    GLuint internalFormat;

    if (!extractImageData(image, flipY, premultiplyAlpha, imageData, &format, &internalFormat)) {
        LOG_ERROR("GraphicsContext3D::texImage2D: could not extract Image data");
        return -1;
    }

    glTexImage2D(target, level, internalFormat, image->width(), image->height(), 
                 /* border */ 0, format, GraphicsContext3D::UNSIGNED_BYTE, imageData.data());

    return 0;
}
    
int GraphicsContext3D::texSubImage2D(unsigned target, unsigned level, unsigned xoff, unsigned yoff, unsigned width, unsigned height, unsigned format, unsigned type, void* pixels)
{
    glTexSubImage2D(target, level, xoff, yoff, width, height, format, type, pixels);
    return 0;
}

int GraphicsContext3D::texSubImage2D(unsigned target, unsigned level, unsigned xoff, unsigned yoff, Image* image, bool flipY, bool premultiplyAlpha)
{
    ASSERT(image);

    Vector<uint8_t> imageData;
    GLuint format;
    GLuint internalFormat;

    if (!extractImageData(image, flipY, premultiplyAlpha, imageData, &format, &internalFormat)) {
        LOG_ERROR("GraphicsContext3D::texSubImage2D: could not extract Image data");
        return -1;
    }

    glTexSubImage2D(target, level, xoff, yoff, image->width(), image->height(), 
                    format, GraphicsContext3D::UNSIGNED_BYTE, imageData.data());

    return 0;
}

unsigned GraphicsContext3D::createBuffer()
{
    m_internal->m_glWidget->makeCurrent();
    GLuint handle;
    m_internal->genBuffers(/* count */ 1, &handle);
    return handle;
}

unsigned GraphicsContext3D::createFramebuffer()
{
    m_internal->m_glWidget->makeCurrent();
    GLuint handle;
    m_internal->genFramebuffers(/* count */ 1, &handle);
    return handle;
}

unsigned GraphicsContext3D::createProgram()
{
    m_internal->m_glWidget->makeCurrent();
    return m_internal->createProgram();
}

unsigned GraphicsContext3D::createRenderbuffer()
{
    m_internal->m_glWidget->makeCurrent();
    GLuint handle;
    m_internal->genRenderbuffers(/* count */ 1, &handle);
    return handle;
}

unsigned GraphicsContext3D::createShader(unsigned long type)
{
    m_internal->m_glWidget->makeCurrent();
    return m_internal->createShader((type == FRAGMENT_SHADER) ? GraphicsContext3D::FRAGMENT_SHADER : GraphicsContext3D::VERTEX_SHADER);
}

unsigned GraphicsContext3D::createTexture()
{
    m_internal->m_glWidget->makeCurrent();
    GLuint handle;
    glGenTextures(1, &handle);
    return handle;
}

void GraphicsContext3D::deleteBuffer(unsigned buffer)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->deleteBuffers(1, &buffer);
}

void GraphicsContext3D::deleteFramebuffer(unsigned framebuffer)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->deleteFramebuffers(1, &framebuffer);
}

void GraphicsContext3D::deleteProgram(unsigned program)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->deleteProgram(program);
}

void GraphicsContext3D::deleteRenderbuffer(unsigned renderbuffer)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->deleteRenderbuffers(1, &renderbuffer);
}

void GraphicsContext3D::deleteShader(unsigned shader)
{
    m_internal->m_glWidget->makeCurrent();
    m_internal->deleteShader(shader);
}

void GraphicsContext3D::deleteTexture(unsigned texture)
{
    m_internal->m_glWidget->makeCurrent();
    glDeleteTextures(1, &texture);
}

int GraphicsContext3D::sizeInBytes(int type)
{
    switch (type) {
    case GraphicsContext3D::BYTE:
        return sizeof(GLbyte);
    case GraphicsContext3D::UNSIGNED_BYTE:
        return sizeof(GLubyte);
    case GraphicsContext3D::SHORT:
        return sizeof(GLshort);
    case GraphicsContext3D::UNSIGNED_SHORT:
        return sizeof(GLushort);
    case GraphicsContext3D::INT:
        return sizeof(GLint);
    case GraphicsContext3D::UNSIGNED_INT:
        return sizeof(GLuint);
    case GraphicsContext3D::FLOAT:
        return sizeof(GLfloat);
    default:
        return 0;
    }
}

void GraphicsContext3D::synthesizeGLError(unsigned long error)
{
    m_internal->m_syntheticErrors.add(error);
}

bool GraphicsContext3D::getImageData(Image* image,
                                     Vector<uint8_t>& outputVector,
                                     bool premultiplyAlpha,
                                     bool* hasAlphaChannel,
                                     AlphaOp* neededAlphaOp,
                                     unsigned int* format)
{
    QImage::Format imageFormat = (!premultiplyAlpha) ? 
        QImage::Format_ARGB32 :
        QImage::Format_ARGB32_Premultiplied;
 
    QPixmap* nativePixmap = image->nativeImageForCurrentFrame(); 

    *hasAlphaChannel = true;
    *neededAlphaOp = kAlphaDoNothing;
    *format = GraphicsContext3D::RGBA;

    QImage nativeImage = nativePixmap->toImage().convertToFormat(imageFormat);
    outputVector.append(nativeImage.bits(), nativeImage.byteCount());

    return true;
}

}

#endif // ENABLE(3D_CANVAS)
