/*

 * Copyright (C) 2010 Google Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 *

 *     * Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above

 * copyright notice, this list of conditions and the following disclaimer

 * in the documentation and/or other materials provided with the

 * distribution.

 *     * Neither the name of Google Inc. nor the names of its

 * contributors may be used to endorse or promote products derived from

 * this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#if ENABLE(3D_CANVAS)

#include <stdio.h>

#include <string.h>

#include "WebGraphicsContext3DDefaultImpl.h"

#include "NotImplemented.h"

#if OS(LINUX)

#include <dlfcn.h>

#endif

namespace WebKit {

// Uncomment this to render to a separate window for debugging

// #define RENDER_TO_DEBUGGING_WINDOW

#if OS(DARWIN)

#define USE_TEXTURE_RECTANGLE_FOR_FRAMEBUFFER

#endif

bool WebGraphicsContext3DDefaultImpl::s_initializedGLEW = false;

#if OS(LINUX)

WebGraphicsContext3DDefaultImpl::GLConnection* WebGraphicsContext3DDefaultImpl::s_gl = 0;

WebGraphicsContext3DDefaultImpl::GLConnection* WebGraphicsContext3DDefaultImpl::GLConnection::create()

{

    Display* dpy = XOpenDisplay(0);

    if (!dpy) {

        printf("GraphicsContext3D: error opening X display\n");

        return 0;

    }

    // We use RTLD_GLOBAL semantics so that GLEW initialization works;

    // GLEW expects to be able to open the current process's handle

    // and do dlsym's of GL entry points from there.

    void* libGL = dlopen("libGL.so.1", RTLD_LAZY | RTLD_GLOBAL);

    if (!libGL) {

        XCloseDisplay(dpy);

        printf("GraphicsContext3D: error opening libGL.so.1: %s\n", dlerror());

        return 0;

    }

    PFNGLXCHOOSEFBCONFIGPROC chooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC) dlsym(libGL, "glXChooseFBConfig");

    PFNGLXCREATENEWCONTEXTPROC createNewContext = (PFNGLXCREATENEWCONTEXTPROC) dlsym(libGL, "glXCreateNewContext");

    PFNGLXCREATEPBUFFERPROC createPbuffer = (PFNGLXCREATEPBUFFERPROC) dlsym(libGL, "glXCreatePbuffer");

    PFNGLXDESTROYPBUFFERPROC destroyPbuffer = (PFNGLXDESTROYPBUFFERPROC) dlsym(libGL, "glXDestroyPbuffer");

    PFNGLXMAKECURRENTPROC makeCurrent = (PFNGLXMAKECURRENTPROC) dlsym(libGL, "glXMakeCurrent");

    PFNGLXDESTROYCONTEXTPROC destroyContext = (PFNGLXDESTROYCONTEXTPROC) dlsym(libGL, "glXDestroyContext");

    PFNGLXGETCURRENTCONTEXTPROC getCurrentContext = (PFNGLXGETCURRENTCONTEXTPROC) dlsym(libGL, "glXGetCurrentContext");

    if (!chooseFBConfig || !createNewContext || !createPbuffer

        || !destroyPbuffer || !makeCurrent || !destroyContext

        || !getCurrentContext) {

        XCloseDisplay(dpy);

        dlclose(libGL);

        printf("GraphicsContext3D: error looking up bootstrapping entry points\n");

        return 0;

    }

    return new GLConnection(dpy,

                            libGL,

                            chooseFBConfig,

                            createNewContext,

                            createPbuffer,

                            destroyPbuffer,

                            makeCurrent,

                            destroyContext,

                            getCurrentContext);

}

WebGraphicsContext3DDefaultImpl::GLConnection::~GLConnection()

{

    XCloseDisplay(m_display);

    dlclose(m_libGL);

}

#endif // OS(LINUX)

WebGraphicsContext3DDefaultImpl::VertexAttribPointerState::VertexAttribPointerState()

    : enabled(false)

    , buffer(0)

    , indx(0)

    , size(0)

    , type(0)

    , normalized(false)

    , stride(0)

    , offset(0)

{

}

WebGraphicsContext3DDefaultImpl::WebGraphicsContext3DDefaultImpl()

    : m_initialized(false)

    , m_texture(0)

    , m_fbo(0)

    , m_depthStencilBuffer(0)

    , m_multisampleFBO(0)

    , m_multisampleDepthStencilBuffer(0)

    , m_multisampleColorBuffer(0)

    , m_boundFBO(0)

#ifdef FLIP_FRAMEBUFFER_VERTICALLY

    , m_scanline(0)

#endif

    , m_boundArrayBuffer(0)

#if OS(WINDOWS)

    , m_canvasWindow(0)

    , m_canvasDC(0)

    , m_contextObj(0)

#elif PLATFORM(CG)

    , m_pbuffer(0)

    , m_contextObj(0)

    , m_renderOutput(0)

#elif OS(LINUX)

    , m_contextObj(0)

    , m_pbuffer(0)

#else

#error Must port to your platform

#endif

{

}

WebGraphicsContext3DDefaultImpl::~WebGraphicsContext3DDefaultImpl()

{

    if (m_initialized) {

        makeContextCurrent();

#ifndef RENDER_TO_DEBUGGING_WINDOW

        if (m_attributes.antialias) {

            glDeleteRenderbuffersEXT(1, &m_multisampleColorBuffer);

            if (m_attributes.depth || m_attributes.stencil)

                glDeleteRenderbuffersEXT(1, &m_multisampleDepthStencilBuffer);

            glDeleteFramebuffersEXT(1, &m_multisampleFBO);

        } else {

            if (m_attributes.depth || m_attributes.stencil)

                glDeleteRenderbuffersEXT(1, &m_depthStencilBuffer);

        }

        glDeleteTextures(1, &m_texture);

#ifdef FLIP_FRAMEBUFFER_VERTICALLY

        if (m_scanline)

            delete[] m_scanline;

#endif

        glDeleteFramebuffersEXT(1, &m_fbo);

#endif // !RENDER_TO_DEBUGGING_WINDOW

#if OS(WINDOWS)

        wglewMakeCurrent(0, 0);

        wglewDeleteContext(m_contextObj);

        ReleaseDC(m_canvasWindow, m_canvasDC);

        DestroyWindow(m_canvasWindow);

#elif PLATFORM(CG)

        CGLSetCurrentContext(0);

        CGLDestroyContext(m_contextObj);

        CGLDestroyPBuffer(m_pbuffer);

        if (m_renderOutput)

            delete[] m_renderOutput;

#elif OS(LINUX)

        s_gl->makeCurrent(0, 0);

        s_gl->destroyContext(m_contextObj);

        s_gl->destroyPbuffer(m_pbuffer);

#else

#error Must port to your platform

#endif

        m_contextObj = 0;

    }

}

bool WebGraphicsContext3DDefaultImpl::initialize(WebGraphicsContext3D::Attributes attributes, WebView* webView)

{

#if OS(WINDOWS)

    if (!s_initializedGLEW) {

        // Do this only the first time through.

        if (!wglewInit()) {

            printf("WebGraphicsContext3DDefaultImpl: wglewInit failed\n");

            return false;

        }

    }

    WNDCLASS wc;

    if (!GetClassInfo(GetModuleHandle(0), L"CANVASGL", &wc)) {

        ZeroMemory(&wc, sizeof(WNDCLASS));

        wc.style = CS_OWNDC;

        wc.hInstance = GetModuleHandle(0);

        wc.lpfnWndProc = DefWindowProc;

        wc.lpszClassName = L"CANVASGL";

        if (!RegisterClass(&wc)) {

            printf("WebGraphicsContext3DDefaultImpl: RegisterClass failed\n");

            return false;

        }

    }

    m_canvasWindow = CreateWindow(L"CANVASGL", L"CANVASGL",

                                  WS_CAPTION,

                                  CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

                                  CW_USEDEFAULT, 0, 0, GetModuleHandle(0), 0);

    if (!m_canvasWindow) {

        printf("WebGraphicsContext3DDefaultImpl: CreateWindow failed\n");

        return false;

    }

    // get the device context

    m_canvasDC = GetDC(m_canvasWindow);

    if (!m_canvasDC) {

        printf("WebGraphicsContext3DDefaultImpl: GetDC failed\n");

        return false;

    }

    // find default pixel format

    PIXELFORMATDESCRIPTOR pfd;

    ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));

    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);

    pfd.nVersion = 1;

#ifdef RENDER_TO_DEBUGGING_WINDOW

    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;

#else

    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;

#endif

    int pixelformat = ChoosePixelFormat(m_canvasDC, &pfd);

    // set the pixel format for the dc

    if (!SetPixelFormat(m_canvasDC, pixelformat, &pfd)) {

        printf("WebGraphicsContext3DDefaultImpl: SetPixelFormat failed\n");

        return false;

    }

    // create rendering context

    m_contextObj = wglewCreateContext(m_canvasDC);

    if (!m_contextObj) {

        printf("WebGraphicsContext3DDefaultImpl: wglCreateContext failed\n");

        return false;

    }

    if (!wglewMakeCurrent(m_canvasDC, m_contextObj)) {

        printf("WebGraphicsContext3DDefaultImpl: wglMakeCurrent failed\n");

        return false;

    }

#ifdef RENDER_TO_DEBUGGING_WINDOW

    typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);

    PFNWGLSWAPINTERVALEXTPROC setSwapInterval = 0;

    setSwapInterval = (PFNWGLSWAPINTERVALEXTPROC) wglewGetProcAddress("wglSwapIntervalEXT");

    if (setSwapInterval)

        setSwapInterval(1);

#endif // RENDER_TO_DEBUGGING_WINDOW

#elif PLATFORM(CG)

    // Create a 1x1 pbuffer and associated context to bootstrap things

    CGLPixelFormatAttribute attribs[] = {

        (CGLPixelFormatAttribute) kCGLPFAPBuffer,

        (CGLPixelFormatAttribute) 0

    };

    CGLPixelFormatObj pixelFormat;

    GLint numPixelFormats;

    if (CGLChoosePixelFormat(attribs, &pixelFormat, &numPixelFormats) != kCGLNoError) {

        printf("WebGraphicsContext3DDefaultImpl: error choosing pixel format\n");

        return false;

    }

    if (!pixelFormat) {

        printf("WebGraphicsContext3DDefaultImpl: no pixel format selected\n");

        return false;

    }

    CGLContextObj context;

    CGLError res = CGLCreateContext(pixelFormat, 0, &context);

    CGLDestroyPixelFormat(pixelFormat);

    if (res != kCGLNoError) {

        printf("WebGraphicsContext3DDefaultImpl: error creating context\n");

        return false;

    }

    CGLPBufferObj pbuffer;

    if (CGLCreatePBuffer(1, 1, GL_TEXTURE_2D, GL_RGBA, 0, &pbuffer) != kCGLNoError) {

        CGLDestroyContext(context);

        printf("WebGraphicsContext3DDefaultImpl: error creating pbuffer\n");

        return false;

    }

    if (CGLSetPBuffer(context, pbuffer, 0, 0, 0) != kCGLNoError) {

        CGLDestroyContext(context);

        CGLDestroyPBuffer(pbuffer);

        printf("WebGraphicsContext3DDefaultImpl: error attaching pbuffer to context\n");

        return false;

    }

    if (CGLSetCurrentContext(context) != kCGLNoError) {

        CGLDestroyContext(context);

        CGLDestroyPBuffer(pbuffer);

        printf("WebGraphicsContext3DDefaultImpl: error making context current\n");

        return false;

    }

    m_pbuffer = pbuffer;

    m_contextObj = context;

#elif OS(LINUX)

    if (!s_gl) {

        s_gl = GLConnection::create();

        if (!s_gl)

            return false;

    }

    int configAttrs[] = {

        GLX_DRAWABLE_TYPE,

        GLX_PBUFFER_BIT,

        GLX_RENDER_TYPE,

        GLX_RGBA_BIT,

        GLX_DOUBLEBUFFER,

        0,

        0

    };

    int nelements = 0;

    GLXFBConfig* config = s_gl->chooseFBConfig(0, configAttrs, &nelements);

    if (!config) {

        printf("WebGraphicsContext3DDefaultImpl: glXChooseFBConfig failed\n");

        return false;

    }

    if (!nelements) {

        printf("WebGraphicsContext3DDefaultImpl: glXChooseFBConfig returned 0 elements\n");

        XFree(config);

        return false;

    }

    GLXContext context = s_gl->createNewContext(config[0], GLX_RGBA_TYPE, 0, True);

    if (!context) {

        printf("WebGraphicsContext3DDefaultImpl: glXCreateNewContext failed\n");

        XFree(config);

        return false;

    }

    int pbufferAttrs[] = {

        GLX_PBUFFER_WIDTH,

        1,

        GLX_PBUFFER_HEIGHT,

        1,

        0

    };

    GLXPbuffer pbuffer = s_gl->createPbuffer(config[0], pbufferAttrs);

    XFree(config);

    if (!pbuffer) {

        printf("WebGraphicsContext3DDefaultImpl: glxCreatePbuffer failed\n");

        return false;

    }

    if (!s_gl->makeCurrent(pbuffer, context)) {

        printf("WebGraphicsContext3DDefaultImpl: glXMakeCurrent failed\n");

        return false;

    }

    m_contextObj = context;

    m_pbuffer = pbuffer;

#else

#error Must port to your platform

#endif

    if (!s_initializedGLEW) {

        // Initialize GLEW and check for GL 2.0 support by the drivers.

        GLenum glewInitResult = glewInit();

        if (glewInitResult != GLEW_OK) {

            printf("WebGraphicsContext3DDefaultImpl: GLEW initialization failed\n");

            return false;

        }

        if (!glewIsSupported("GL_VERSION_2_0")) {

            printf("WebGraphicsContext3DDefaultImpl: OpenGL 2.0 not supported\n");

            return false;

        }

        s_initializedGLEW = true;

    }

    m_attributes = attributes;

    validateAttributes();

    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);

    m_initialized = true;

    return true;

}

void WebGraphicsContext3DDefaultImpl::validateAttributes()

{

    const char* extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));

    if (m_attributes.stencil) {

        if (strstr(extensions, "GL_EXT_packed_depth_stencil")) {

            if (!m_attributes.depth)

                m_attributes.depth = true;

        } else

            m_attributes.stencil = false;

    }

    if (m_attributes.antialias) {

        bool isValidVendor = true;

#if PLATFORM(CG)

        // Currently in Mac we only turn on antialias if vendor is NVIDIA.

        const char* vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));

        if (!strstr(vendor, "NVIDIA"))

            isValidVendor = false;

#endif

        if (!isValidVendor || !strstr(extensions, "GL_EXT_framebuffer_multisample"))

            m_attributes.antialias = false;

    }

    // FIXME: instead of enforcing premultipliedAlpha = true, implement the

    // correct behavior when premultipliedAlpha = false is requested.

    m_attributes.premultipliedAlpha = true;

}

bool WebGraphicsContext3DDefaultImpl::makeContextCurrent()

{

#if OS(WINDOWS)

    if (wglewGetCurrentContext() != m_contextObj)

        if (wglewMakeCurrent(m_canvasDC, m_contextObj))

            return true;

#elif PLATFORM(CG)

    if (CGLGetCurrentContext() != m_contextObj)

        if (CGLSetCurrentContext(m_contextObj) == kCGLNoError)

            return true;

#elif OS(LINUX)

    if (s_gl->getCurrentContext() != m_contextObj)

        if (s_gl->makeCurrent(m_pbuffer, m_contextObj))

            return true;

#else

#error Must port to your platform

#endif

    return false;

}

int WebGraphicsContext3DDefaultImpl::width()

{

    return m_cachedWidth;

}

int WebGraphicsContext3DDefaultImpl::height()

{

    return m_cachedHeight;

}

int WebGraphicsContext3DDefaultImpl::sizeInBytes(int type)

{

    switch (type) {

    case GL_BYTE:

        return sizeof(GLbyte);

    case GL_UNSIGNED_BYTE:

        return sizeof(GLubyte);

    case GL_SHORT:

        return sizeof(GLshort);

    case GL_UNSIGNED_SHORT:

        return sizeof(GLushort);

    case GL_INT:

        return sizeof(GLint);

    case GL_UNSIGNED_INT:

        return sizeof(GLuint);

    case GL_FLOAT:

        return sizeof(GLfloat);

    }

    return 0;

}

bool WebGraphicsContext3DDefaultImpl::isGLES2Compliant()

{

    return false;

}

unsigned int WebGraphicsContext3DDefaultImpl::getPlatformTextureId()

{

    ASSERT_NOT_REACHED();

    return 0;

}

void WebGraphicsContext3DDefaultImpl::prepareTexture()

{

    ASSERT_NOT_REACHED();

}

static int createTextureObject(GLenum target)

{

    GLuint texture = 0;

    glGenTextures(1, &texture);

    glBindTexture(target, texture);

    glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    return texture;

}

void WebGraphicsContext3DDefaultImpl::reshape(int width, int height)

{

#ifdef RENDER_TO_DEBUGGING_WINDOW

    SetWindowPos(m_canvasWindow, HWND_TOP, 0, 0, width, height,

                 SWP_NOMOVE);

    ShowWindow(m_canvasWindow, SW_SHOW);

#endif

    m_cachedWidth = width;

    m_cachedHeight = height;

    makeContextCurrent();

#ifndef RENDER_TO_DEBUGGING_WINDOW

#ifdef USE_TEXTURE_RECTANGLE_FOR_FRAMEBUFFER

    // GL_TEXTURE_RECTANGLE_ARB is the best supported render target on Mac OS X

    GLenum target = GL_TEXTURE_RECTANGLE_ARB;

#else

    GLenum target = GL_TEXTURE_2D;

#endif

    if (!m_texture) {

        // Generate the texture object

        m_texture = createTextureObject(target);

        // Generate the framebuffer object

        glGenFramebuffersEXT(1, &m_fbo);

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);

        m_boundFBO = m_fbo;

        if (m_attributes.depth || m_attributes.stencil)

            glGenRenderbuffersEXT(1, &m_depthStencilBuffer);