/*

 * Copyright (C) 2009 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 "GraphicsContext3D.h"

#include "CachedImage.h"

#include "Chrome.h"

#include "ChromeClientImpl.h"

#include "HTMLCanvasElement.h"

#include "HTMLImageElement.h"

#include "ImageBuffer.h"

#include "ImageData.h"

#include "WebGLBuffer.h"

#include "Int8Array.h"

#include "Float32Array.h"

#include "WebGLFramebuffer.h"

#include "Int32Array.h"

#include "WebGLProgram.h"

#include "WebGLRenderbuffer.h"

#include "WebGLRenderingContext.h"

#include "WebGLShader.h"

#include "WebGLTexture.h"

#include "Uint8Array.h"

#include "WebGLLayerChromium.h"

#include "WebGraphicsContext3D.h"

#include "WebGraphicsContext3DDefaultImpl.h"

#include "WebKit.h"

#include "WebKitClient.h"

#include "WebViewImpl.h"

#include <stdio.h>

#include <wtf/FastMalloc.h>

#include <wtf/text/CString.h>

#if PLATFORM(CG)

#include "GraphicsContext.h"

#include <CoreGraphics/CGContext.h>

#include <CoreGraphics/CGImage.h>

#endif

// using namespace std;

// There are two levels of delegation in this file:

//

//   1. GraphicsContext3D delegates to GraphicsContext3DInternal. This is done

//      so that we have some place to store data members common among

//      implementations; GraphicsContext3D only provides us the m_internal

//      pointer. We always delegate to the GraphicsContext3DInternal. While we

//      could sidestep it and go directly to the WebGraphicsContext3D in some

//      cases, it is better for consistency to always delegate through it.

//

//   2. GraphicsContext3DInternal delegates to an implementation of

//      WebGraphicsContext3D. This is done so we have a place to inject an

//      implementation which remotes the OpenGL calls across processes.

//

// The legacy, in-process, implementation uses WebGraphicsContext3DDefaultImpl.

namespace WebCore {

//----------------------------------------------------------------------

// GraphicsContext3DInternal

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

// #define RENDER_TO_DEBUGGING_WINDOW

#define EXTRACT(val) (!val ? 0 : val->object())

class GraphicsContext3DInternal {

public:

    GraphicsContext3DInternal();

    ~GraphicsContext3DInternal();

    bool initialize(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow);

    PlatformGraphicsContext3D platformGraphicsContext3D() const;

    Platform3DObject platformTexture() const;

    bool makeContextCurrent();

    int sizeInBytes(int type);

    void reshape(int width, int height);

    void paintRenderingResultsToCanvas(WebGLRenderingContext* context);

    void beginPaint(WebGLRenderingContext* context);

    void endPaint();

    void prepareTexture();

#if USE(ACCELERATED_COMPOSITING)

    WebGLLayerChromium* platformLayer() const;

#endif

    bool isGLES2Compliant() const;

    //----------------------------------------------------------------------

    // Entry points for WebGL.

    //

    void activeTexture(unsigned long texture);

    void attachShader(WebGLProgram* program, WebGLShader* shader);

    void bindAttribLocation(WebGLProgram*, unsigned long index, const String& name);

    void bindBuffer(unsigned long target, WebGLBuffer*);

    void bindFramebuffer(unsigned long target, WebGLFramebuffer*);

    void bindRenderbuffer(unsigned long target, WebGLRenderbuffer*);

    void bindTexture(unsigned long target, WebGLTexture* texture);

    void blendColor(double red, double green, double blue, double alpha);

    void blendEquation(unsigned long mode);

    void blendEquationSeparate(unsigned long modeRGB, unsigned long modeAlpha);

    void blendFunc(unsigned long sfactor, unsigned long dfactor);

    void blendFuncSeparate(unsigned long srcRGB, unsigned long dstRGB, unsigned long srcAlpha, unsigned long dstAlpha);

    void bufferData(unsigned long target, int size, unsigned long usage);

    void bufferData(unsigned long target, ArrayBuffer* data, unsigned long usage);

    void bufferData(unsigned long target, ArrayBufferView* data, unsigned long usage);

    void bufferSubData(unsigned long target, long offset, ArrayBuffer* data);

    void bufferSubData(unsigned long target, long offset, ArrayBufferView* data);

    unsigned long checkFramebufferStatus(unsigned long target);

    void clear(unsigned long mask);

    void clearColor(double red, double green, double blue, double alpha);

    void clearDepth(double depth);

    void clearStencil(long s);

    void colorMask(bool red, bool green, bool blue, bool alpha);

    void compileShader(WebGLShader*);

    void copyTexImage2D(unsigned long target, long level, unsigned long internalformat, long x, long y, unsigned long width, unsigned long height, long border);

    void copyTexSubImage2D(unsigned long target, long level, long xoffset, long yoffset, long x, long y, unsigned long width, unsigned long height);

    void cullFace(unsigned long mode);

    void depthFunc(unsigned long func);

    void depthMask(bool flag);

    void depthRange(double zNear, double zFar);

    void detachShader(WebGLProgram*, WebGLShader*);

    void disable(unsigned long cap);

    void disableVertexAttribArray(unsigned long index);

    void drawArrays(unsigned long mode, long first, long count);

    void drawElements(unsigned long mode, unsigned long count, unsigned long type, long offset);

    void enable(unsigned long cap);

    void enableVertexAttribArray(unsigned long index);

    void finish();

    void flush();

    void framebufferRenderbuffer(unsigned long target, unsigned long attachment, unsigned long renderbuffertarget, WebGLRenderbuffer*);

    void framebufferTexture2D(unsigned long target, unsigned long attachment, unsigned long textarget, WebGLTexture*, long level);

    void frontFace(unsigned long mode);

    void generateMipmap(unsigned long target);

    bool getActiveAttrib(WebGLProgram* program, unsigned long index, ActiveInfo&);

    bool getActiveUniform(WebGLProgram* program, unsigned long index, ActiveInfo&);

    void getAttachedShaders(WebGLProgram* program, int maxCount, int* count, unsigned int* shaders);

    int  getAttribLocation(WebGLProgram*, const String& name);

    void getBooleanv(unsigned long pname, unsigned char* value);

    void getBufferParameteriv(unsigned long target, unsigned long pname, int* value);

    GraphicsContext3D::Attributes getContextAttributes();

    unsigned long getError();

    void getFloatv(unsigned long pname, float* value);

    void getFramebufferAttachmentParameteriv(unsigned long target, unsigned long attachment, unsigned long pname, int* value);

    void getIntegerv(unsigned long pname, int* value);

    void getProgramiv(WebGLProgram* program, unsigned long pname, int* value);

    String getProgramInfoLog(WebGLProgram*);

    void getRenderbufferParameteriv(unsigned long target, unsigned long pname, int* value);

    void getShaderiv(WebGLShader*, unsigned long pname, int* value);

    String getShaderInfoLog(WebGLShader*);

    String getShaderSource(WebGLShader*);

    String getString(unsigned long name);

    void getTexParameterfv(unsigned long target, unsigned long pname, float* value);

    void getTexParameteriv(unsigned long target, unsigned long pname, int* value);

    void getUniformfv(WebGLProgram* program, long location, float* value);

    void getUniformiv(WebGLProgram* program, long location, int* value);

    long getUniformLocation(WebGLProgram*, const String& name);

    void getVertexAttribfv(unsigned long index, unsigned long pname, float* value);

    void getVertexAttribiv(unsigned long index, unsigned long pname, int* value);

    long getVertexAttribOffset(unsigned long index, unsigned long pname);

    void hint(unsigned long target, unsigned long mode);

    bool isBuffer(WebGLBuffer*);

    bool isEnabled(unsigned long cap);

    bool isFramebuffer(WebGLFramebuffer*);

    bool isProgram(WebGLProgram*);

    bool isRenderbuffer(WebGLRenderbuffer*);

    bool isShader(WebGLShader*);

    bool isTexture(WebGLTexture*);

    void lineWidth(double);

    void linkProgram(WebGLProgram*);

    void pixelStorei(unsigned long pname, long param);

    void polygonOffset(double factor, double units);

    void readPixels(long x, long y, unsigned long width, unsigned long height, unsigned long format, unsigned long type, void* data);

    void releaseShaderCompiler();

    void renderbufferStorage(unsigned long target, unsigned long internalformat, unsigned long width, unsigned long height);

    void sampleCoverage(double value, bool invert);

    void scissor(long x, long y, unsigned long width, unsigned long height);

    void shaderSource(WebGLShader*, const String& string);

    void stencilFunc(unsigned long func, long ref, unsigned long mask);

    void stencilFuncSeparate(unsigned long face, unsigned long func, long ref, unsigned long mask);

    void stencilMask(unsigned long mask);

    void stencilMaskSeparate(unsigned long face, unsigned long mask);

    void stencilOp(unsigned long fail, unsigned long zfail, unsigned long zpass);

    void stencilOpSeparate(unsigned long face, unsigned long fail, unsigned long zfail, unsigned long zpass);

    // These next several functions return an error code (0 if no errors) rather than using an ExceptionCode.

    // Currently they return -1 on any error.

    int texImage2D(unsigned target, unsigned level, unsigned internalformat, unsigned width, unsigned height, unsigned border, unsigned format, unsigned type, void* pixels);

    void texParameterf(unsigned target, unsigned pname, float param);

    void texParameteri(unsigned target, unsigned pname, int param);

    int texSubImage2D(unsigned target, unsigned level, unsigned xoffset, unsigned yoffset, unsigned width, unsigned height, unsigned format, unsigned type, void* pixels);

    void uniform1f(long location, float x);

    void uniform1fv(long location, float* v, int size);

    void uniform1i(long location, int x);

    void uniform1iv(long location, int* v, int size);

    void uniform2f(long location, float x, float y);

    void uniform2fv(long location, float* v, int size);

    void uniform2i(long location, int x, int y);

    void uniform2iv(long location, int* v, int size);

    void uniform3f(long location, float x, float y, float z);

    void uniform3fv(long location, float* v, int size);

    void uniform3i(long location, int x, int y, int z);

    void uniform3iv(long location, int* v, int size);

    void uniform4f(long location, float x, float y, float z, float w);

    void uniform4fv(long location, float* v, int size);

    void uniform4i(long location, int x, int y, int z, int w);

    void uniform4iv(long location, int* v, int size);

    void uniformMatrix2fv(long location, bool transpose, float* value, int size);

    void uniformMatrix3fv(long location, bool transpose, float* value, int size);

    void uniformMatrix4fv(long location, bool transpose, float* value, int size);

    void useProgram(WebGLProgram*);

    void validateProgram(WebGLProgram*);

    void vertexAttrib1f(unsigned long indx, float x);

    void vertexAttrib1fv(unsigned long indx, float* values);

    void vertexAttrib2f(unsigned long indx, float x, float y);

    void vertexAttrib2fv(unsigned long indx, float* values);

    void vertexAttrib3f(unsigned long indx, float x, float y, float z);

    void vertexAttrib3fv(unsigned long indx, float* values);

    void vertexAttrib4f(unsigned long indx, float x, float y, float z, float w);

    void vertexAttrib4fv(unsigned long indx, float* values);

    void vertexAttribPointer(unsigned long indx, int size, int type, bool normalized,

                             unsigned long stride, unsigned long offset);

    void viewport(long x, long y, unsigned long width, unsigned long height);

    unsigned createBuffer();

    unsigned createFramebuffer();

    unsigned createProgram();

    unsigned createRenderbuffer();

    unsigned createShader(unsigned long);

    unsigned createTexture();

    void deleteBuffer(unsigned);

    void deleteFramebuffer(unsigned);

    void deleteProgram(unsigned);

    void deleteRenderbuffer(unsigned);

    void deleteShader(unsigned);

    void deleteTexture(unsigned);

    void synthesizeGLError(unsigned long error);

private:

    OwnPtr<WebKit::WebGraphicsContext3D> m_impl;

#if USE(ACCELERATED_COMPOSITING)

    RefPtr<WebGLLayerChromium> m_compositingLayer;

#endif

#if PLATFORM(SKIA)

    // If the width and height of the Canvas's backing store don't

    // match those that we were given in the most recent call to

    // reshape(), then we need an intermediate bitmap to read back the

    // frame buffer into. This seems to happen when CSS styles are

    // used to resize the Canvas.

    SkBitmap m_resizingBitmap;

#endif

#if PLATFORM(CG)

    unsigned char* m_renderOutput;

#endif

};

GraphicsContext3DInternal::GraphicsContext3DInternal()

#if PLATFORM(SKIA)

#elif PLATFORM(CG)

    : m_renderOutput(0)

#else

#error Must port to your platform

#endif

{

}

GraphicsContext3DInternal::~GraphicsContext3DInternal()

{

#if PLATFORM(CG)

    if (m_renderOutput)

        delete[] m_renderOutput;

#endif

}

bool GraphicsContext3DInternal::initialize(GraphicsContext3D::Attributes attrs,

                                           HostWindow* hostWindow)

{

    WebKit::WebGraphicsContext3D::Attributes webAttributes;

    webAttributes.alpha = attrs.alpha;

    webAttributes.depth = attrs.depth;

    webAttributes.stencil = attrs.stencil;

    webAttributes.antialias = attrs.antialias;

    webAttributes.premultipliedAlpha = attrs.premultipliedAlpha;

    WebKit::WebGraphicsContext3D* webContext = WebKit::webKitClient()->createGraphicsContext3D();

    if (!webContext)

        return false;

    Chrome* chrome = static_cast<Chrome*>(hostWindow);

    WebKit::ChromeClientImpl* chromeClientImpl = static_cast<WebKit::ChromeClientImpl*>(chrome->client());

    WebKit::WebViewImpl* webView = chromeClientImpl->webView();

    if (!webView)

        return false;

    if (!webContext->initialize(webAttributes, webView)) {

        delete webContext;

        return false;

    }

    m_impl.set(webContext);

#if USE(ACCELERATED_COMPOSITING)

    m_compositingLayer = WebGLLayerChromium::create(0);

#endif

    return true;

}

PlatformGraphicsContext3D GraphicsContext3DInternal::platformGraphicsContext3D() const

{

    return m_impl.get();

}

Platform3DObject GraphicsContext3DInternal::platformTexture() const

{

    return m_impl->getPlatformTextureId();

}

void GraphicsContext3DInternal::prepareTexture()

{

    m_impl->prepareTexture();

}

#if USE(ACCELERATED_COMPOSITING)

WebGLLayerChromium* GraphicsContext3DInternal::platformLayer() const

{

    return m_compositingLayer.get();

}

#endif

void GraphicsContext3DInternal::paintRenderingResultsToCanvas(WebGLRenderingContext* context)

{

    HTMLCanvasElement* canvas = context->canvas();

    ImageBuffer* imageBuffer = canvas->buffer();

    unsigned char* pixels = 0;

#if PLATFORM(SKIA)

    const SkBitmap* canvasBitmap = imageBuffer->context()->platformContext()->bitmap();

    const SkBitmap* readbackBitmap = 0;

    ASSERT(canvasBitmap->config() == SkBitmap::kARGB_8888_Config);

    if (canvasBitmap->width() == m_impl->width() && canvasBitmap->height() == m_impl->height()) {

        // This is the fastest and most common case. We read back

        // directly into the canvas's backing store.

        readbackBitmap = canvasBitmap;

        m_resizingBitmap.reset();

    } else {

        // We need to allocate a temporary bitmap for reading back the

        // pixel data. We will then use Skia to rescale this bitmap to

        // the size of the canvas's backing store.

        if (m_resizingBitmap.width() != m_impl->width() || m_resizingBitmap.height() != m_impl->height()) {

            m_resizingBitmap.setConfig(SkBitmap::kARGB_8888_Config,

                                       m_impl->width(),

                                       m_impl->height());

            if (!m_resizingBitmap.allocPixels()) {

                return;

            }

        }

        readbackBitmap = &m_resizingBitmap;

    }

    // Read back the frame buffer.

    SkAutoLockPixels bitmapLock(*readbackBitmap);

    pixels = static_cast<unsigned char*>(readbackBitmap->getPixels());

#elif PLATFORM(CG)

    if (m_renderOutput)

        pixels = m_renderOutput;

#else

#error Must port to your platform

#endif

    m_impl->readBackFramebuffer(pixels, 4 * m_impl->width() * m_impl->height());

#if PLATFORM(SKIA)

    if (m_resizingBitmap.readyToDraw()) {

        // We need to draw the resizing bitmap into the canvas's backing store.

        SkCanvas canvas(*canvasBitmap);

        SkRect dst;

        dst.set(SkIntToScalar(0), SkIntToScalar(0), canvasBitmap->width(), canvasBitmap->height());

        canvas.drawBitmapRect(m_resizingBitmap, 0, dst);

    }

#elif PLATFORM(CG)

    if (m_renderOutput)

        context->graphicsContext3D()->paintToCanvas(m_renderOutput, m_impl->width(), m_impl->height(),

                                                    canvas->width(), canvas->height(),

                                                    imageBuffer->context()->platformContext());

#else

#error Must port to your platform

#endif

}

void GraphicsContext3DInternal::beginPaint(WebGLRenderingContext* context)

{

    paintRenderingResultsToCanvas(context);

}

void GraphicsContext3DInternal::endPaint()

{

}

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

{

    if (width == m_impl->width() && height == m_impl->height())

        return;

    m_impl->reshape(width, height);

#if PLATFORM(CG)

    // Need to reallocate the client-side backing store.

    // FIXME: make this more efficient.

    if (m_renderOutput) {

        delete[] m_renderOutput;

        m_renderOutput = 0;

    }

    int rowBytes = width * 4;

    m_renderOutput = new unsigned char[height * rowBytes];

#endif // PLATFORM(CG)

}

// Macros to assist in delegating from GraphicsContext3DInternal to

// WebGraphicsContext3D.

#define DELEGATE_TO_IMPL(name) \

void GraphicsContext3DInternal::name() \

{ \

    m_impl->name(); \

}

#define DELEGATE_TO_IMPL_R(name, rt)           \

rt GraphicsContext3DInternal::name() \

{ \

    return m_impl->name(); \

}

#define DELEGATE_TO_IMPL_1(name, t1) \

void GraphicsContext3DInternal::name(t1 a1) \

{ \

    m_impl->name(a1); \

}

#define DELEGATE_TO_IMPL_1_X(name, t1) \

void GraphicsContext3DInternal::name(t1 a1) \

{ \

    m_impl->name(EXTRACT(a1));                  \

}

#define DELEGATE_TO_IMPL_1R(name, t1, rt)    \

rt GraphicsContext3DInternal::name(t1 a1) \

{ \

    return m_impl->name(a1); \

}

#define DELEGATE_TO_IMPL_1R_X(name, t1, rt)    \

rt GraphicsContext3DInternal::name(t1 a1) \

{ \

    return m_impl->name(EXTRACT(a1));           \

}