/*

 * Copyright (C) 2009 Apple 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:

 * 1. Redistributions of source code must retain the above copyright

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

 * 2. 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.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 APPLE COMPUTER, INC. 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 "WebGLRenderingContext.h"

#include "CheckedInt.h"

#include "CanvasPixelArray.h"

#include "Console.h"

#include "DOMWindow.h"

#include "FrameView.h"

#include "HTMLCanvasElement.h"

#include "HTMLImageElement.h"

#include "ImageBuffer.h"

#include "ImageData.h"

#include "NotImplemented.h"

#include "RenderBox.h"

#include "RenderLayer.h"

#include "WebGLActiveInfo.h"

#include "Uint16Array.h"

#include "WebGLBuffer.h"

#include "WebGLContextAttributes.h"

#include "WebGLFramebuffer.h"

#include "WebGLProgram.h"

#include "WebGLRenderbuffer.h"

#include "WebGLTexture.h"

#include "WebGLShader.h"

#include "WebGLUniformLocation.h"

#include <wtf/ByteArray.h>

#include <wtf/OwnArrayPtr.h>

namespace WebCore {

class WebGLStateRestorer {

public:

    WebGLStateRestorer(WebGLRenderingContext* context,

                       bool changed)

        : m_context(context)

        , m_changed(changed)

    {

    }

    ~WebGLStateRestorer()

    {

        m_context->cleanupAfterGraphicsCall(m_changed);

    }

private:

    WebGLRenderingContext* m_context;

    bool m_changed;

};

PassOwnPtr<WebGLRenderingContext> WebGLRenderingContext::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs)

{

    HostWindow* hostWindow = canvas->document()->view()->root()->hostWindow();

    OwnPtr<GraphicsContext3D> context(GraphicsContext3D::create(attrs->attributes(), hostWindow));

    if (!context)

        return 0;

    return new WebGLRenderingContext(canvas, context.release());

}

WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassOwnPtr<GraphicsContext3D> context)

    : CanvasRenderingContext(passedCanvas)

    , m_context(context)

    , m_needsUpdate(true)

    , m_markedCanvasDirty(false)

    , m_activeTextureUnit(0)

    , m_packAlignment(4)

    , m_unpackAlignment(4)

    , m_unpackFlipY(false)

    , m_unpackPremultiplyAlpha(false)

{

    ASSERT(m_context);

    int numCombinedTextureImageUnits = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);

    m_textureUnits.resize(numCombinedTextureImageUnits);

    int numVertexAttribs = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &numVertexAttribs);

    m_maxVertexAttribs = numVertexAttribs;

    int implementationColorReadFormat = GraphicsContext3D::RGBA;

    m_context->getIntegerv(GraphicsContext3D::IMPLEMENTATION_COLOR_READ_FORMAT, &implementationColorReadFormat);

    m_implementationColorReadFormat = implementationColorReadFormat;

    int implementationColorReadType = GraphicsContext3D::UNSIGNED_BYTE;

    m_context->getIntegerv(GraphicsContext3D::IMPLEMENTATION_COLOR_READ_TYPE, &implementationColorReadType);

    m_implementationColorReadType = implementationColorReadType;

    m_maxTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize);

    m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize);

    m_maxCubeMapTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);

    m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize);

    if (!isGLES2Compliant()) {

        createFallbackBlackTextures1x1();

        initVertexAttrib0();

    }

    m_context->reshape(canvas()->width(), canvas()->height());

    m_context->viewport(0, 0, canvas()->width(), canvas()->height());

}

WebGLRenderingContext::~WebGLRenderingContext()

{

    detachAndRemoveAllObjects();

}

void WebGLRenderingContext::markContextChanged()

{

#if USE(ACCELERATED_COMPOSITING)

    RenderBox* renderBox = canvas()->renderBox();

    if (renderBox && renderBox->hasLayer() && renderBox->layer()->hasAcceleratedCompositing())

        renderBox->layer()->rendererContentChanged();

#endif

    if (!m_markedCanvasDirty) {

        // Make sure the canvas's image buffer is allocated.

        canvas()->buffer();

        canvas()->willDraw(FloatRect(0, 0, canvas()->width(), canvas()->height()));

        m_markedCanvasDirty = true;

    }

}

bool WebGLRenderingContext::paintRenderingResultsToCanvas()

{

    if (m_markedCanvasDirty) {

        m_markedCanvasDirty = false;

        m_context->paintRenderingResultsToCanvas(this);

        return true;

    }

    return false;

}

void WebGLRenderingContext::beginPaint()

{

    if (m_markedCanvasDirty) {

        m_context->beginPaint(this);

    }

}

void WebGLRenderingContext::endPaint()

{

    if (m_markedCanvasDirty) {

        m_markedCanvasDirty = false;

        m_context->endPaint();

    }

}

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

{

    if (m_needsUpdate) {

#if USE(ACCELERATED_COMPOSITING)

        RenderBox* renderBox = canvas()->renderBox();

        if (renderBox && renderBox->hasLayer())

            renderBox->layer()->rendererContentChanged();

#endif

        m_needsUpdate = false;

    }

    m_context->reshape(width, height);

}

int WebGLRenderingContext::sizeInBytes(int type, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    int result = m_context->sizeInBytes(type);

    if (result <= 0)

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

    return result;

}

void WebGLRenderingContext::activeTexture(unsigned long texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (texture - GraphicsContext3D::TEXTURE0 >= m_textureUnits.size()) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

        return;

    }

    m_activeTextureUnit = texture - GraphicsContext3D::TEXTURE0;

    m_context->activeTexture(texture);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::attachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (!validateWebGLObject(program) || !validateWebGLObject(shader))

        return;

    m_context->attachShader(program, shader);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bindAttribLocation(WebGLProgram* program, unsigned long index, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (!validateWebGLObject(program))

        return;

    m_context->bindAttribLocation(program, index, name);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bindBuffer(unsigned long target, WebGLBuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (buffer && buffer->context() != this) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

        return;

    }

    if (buffer && buffer->getTarget() && buffer->getTarget() != target) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

        return;

    }

    if (target == GraphicsContext3D::ARRAY_BUFFER)

        m_boundArrayBuffer = buffer;

    else if (target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)

        m_boundElementArrayBuffer = buffer;

    else {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

        return;

    }

    m_context->bindBuffer(target, buffer);

    if (buffer)

        buffer->setTarget(target);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bindFramebuffer(unsigned long target, WebGLFramebuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (buffer && buffer->context() != this) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

        return;

    }

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

        return;

    }

    m_framebufferBinding = buffer;

    m_context->bindFramebuffer(target, buffer);

    if (m_framebufferBinding)

        m_framebufferBinding->onBind();

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bindRenderbuffer(unsigned long target, WebGLRenderbuffer* renderBuffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (renderBuffer && renderBuffer->context() != this) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

        return;

    }

    if (target != GraphicsContext3D::RENDERBUFFER) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

        return;

    }

    m_renderbufferBinding = renderBuffer;

    m_context->bindRenderbuffer(target, renderBuffer);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bindTexture(unsigned long target, WebGLTexture* texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (texture && texture->context() != this) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

        return;

    }

    int maxLevel = 0;

    if (target == GraphicsContext3D::TEXTURE_2D) {

        m_textureUnits[m_activeTextureUnit].m_texture2DBinding = texture;

        maxLevel = m_maxTextureLevel;

    } else if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {

        m_textureUnits[m_activeTextureUnit].m_textureCubeMapBinding = texture;

        maxLevel = m_maxCubeMapTextureLevel;

    } else {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

        return;

    }

    m_context->bindTexture(target, texture);

    if (!isGLES2Compliant() && texture)

        texture->setTarget(target, maxLevel);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::blendColor(double red, double green, double blue, double alpha)

{

    m_context->blendColor(red, green, blue, alpha);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::blendEquation( unsigned long mode )

{

    if (!isGLES2Compliant()) {

        if (!validateBlendEquation(mode))

            return;

    }

    m_context->blendEquation(mode);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::blendEquationSeparate(unsigned long modeRGB, unsigned long modeAlpha)

{

    if (!isGLES2Compliant()) {

        if (!validateBlendEquation(modeRGB) || !validateBlendEquation(modeAlpha))

            return;

    }

    m_context->blendEquationSeparate(modeRGB, modeAlpha);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::blendFunc(unsigned long sfactor, unsigned long dfactor)

{

    m_context->blendFunc(sfactor, dfactor);

    cleanupAfterGraphicsCall(false);

}       

void WebGLRenderingContext::blendFuncSeparate(unsigned long srcRGB, unsigned long dstRGB, unsigned long srcAlpha, unsigned long dstAlpha)

{

    m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bufferData(unsigned long target, int size, unsigned long usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    WebGLBuffer* buffer = validateBufferDataParameters(target, usage);

    if (!buffer)

        return;

    if (!buffer->associateBufferData(size)) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

        return;

    }

    m_context->bufferData(target, size, usage);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bufferData(unsigned long target, ArrayBuffer* data, unsigned long usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    WebGLBuffer* buffer = validateBufferDataParameters(target, usage);

    if (!buffer)

        return;

    if (!buffer->associateBufferData(data)) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

        return;

    }

    m_context->bufferData(target, data, usage);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bufferData(unsigned long target, ArrayBufferView* data, unsigned long usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    WebGLBuffer* buffer = validateBufferDataParameters(target, usage);

    if (!buffer)

        return;

    if (!buffer->associateBufferData(data)) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

        return;

    }

    m_context->bufferData(target, data, usage);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bufferSubData(unsigned long target, long offset, ArrayBuffer* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    WebGLBuffer* buffer = validateBufferDataParameters(target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (!buffer->associateBufferSubData(offset, data)) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

        return;

    }

    m_context->bufferSubData(target, offset, data);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::bufferSubData(unsigned long target, long offset, ArrayBufferView* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    WebGLBuffer* buffer = validateBufferDataParameters(target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (!buffer->associateBufferSubData(offset, data)) {

        m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

        return;

    }

    m_context->bufferSubData(target, offset, data);

    cleanupAfterGraphicsCall(false);

}

unsigned long WebGLRenderingContext::checkFramebufferStatus(unsigned long target)

{

    if (!isGLES2Compliant()) {

        if (target != GraphicsContext3D::FRAMEBUFFER) {

            m_context->synthesizeGLError(GraphicsContext3D::INVALID_ENUM);

            return 0;

        }

    }

    if (!m_framebufferBinding || !m_framebufferBinding->object())

        return GraphicsContext3D::FRAMEBUFFER_COMPLETE;

    return m_context->checkFramebufferStatus(target);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::clear(unsigned long mask)

{

    if (!isGLES2Compliant()) {

        if (mask & ~(GraphicsContext3D::COLOR_BUFFER_BIT | GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

            m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

            return;

        }

    }

    m_context->clear(mask);

    cleanupAfterGraphicsCall(true);

}

void WebGLRenderingContext::clearColor(double r, double g, double b, double a)

{

    if (isnan(r))

        r = 0;

    if (isnan(g))

        g = 0;

    if (isnan(b))

        b = 0;

    if (isnan(a))

        a = 1;

    m_context->clearColor(r, g, b, a);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::clearDepth(double depth)

{

    m_context->clearDepth(depth);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::clearStencil(long s)

{

    m_context->clearStencil(s);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::colorMask(bool red, bool green, bool blue, bool alpha)

{

    m_context->colorMask(red, green, blue, alpha);

    cleanupAfterGraphicsCall(false);

}

void WebGLRenderingContext::compileShader(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (!validateWebGLObject(shader))

        return;

    m_context->compileShader(shader);

    cleanupAfterGraphicsCall(false);

}

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

{

    if (!validateTexFuncParameters(target, level, internalformat, width, height, border, internalformat, GraphicsContext3D::UNSIGNED_BYTE))

        return;

    if (!isGLES2Compliant()) {

        if (m_framebufferBinding && m_framebufferBinding->object()

            && !isTexInternalFormatColorBufferCombinationValid(internalformat,

                                                               m_framebufferBinding->getColorBufferFormat())) {

            m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);

            return;

        }

        if (level && WebGLTexture::isNPOT(width, height)) {

            m_context->synthesizeGLError(GraphicsContext3D::INVALID_VALUE);

            return;

        }

    }

    m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    // FIXME: if the framebuffer is not complete, none of the below should be executed.

    WebGLTexture* tex = getTextureBinding(target);

    if (!isGLES2Compliant()) {

        if (tex)

            tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

    }

    if (m_framebufferBinding && tex)

        m_framebufferBinding->onAttachedObjectChange(tex);

    cleanupAfterGraphicsCall(false);

}

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