/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtOpenGL module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/*

    When the active program changes, we need to update it's uniforms.

    We could track state for each program and only update stale uniforms

        - Could lead to lots of overhead if there's a lot of programs

    We could update all the uniforms when the program changes

        - Could end up updating lots of uniforms which don't need updating

    Updating uniforms should be cheap, so the overhead of updating up-to-date

    uniforms should be minimal. It's also less complex.

    Things which _may_ cause a different program to be used:

        - Change in brush/pen style

        - Change in painter opacity

        - Change in composition mode

    Whenever we set a mode on the shader manager - it needs to tell us if it had

    to switch to a different program.

    The shader manager should only switch when we tell it to. E.g. if we set a new

    brush style and then switch to transparent painter, we only want it to compile

    and use the correct program when we really need it.

*/

#include "qpaintengineex_opengl2_p.h"

#include <string.h> //for memcpy

#include <qmath.h>

#include <private/qgl_p.h>

#include <private/qmath_p.h>

#include <private/qpaintengineex_p.h>

#include <QPaintEngine>

#include <private/qpainter_p.h>

#include <private/qfontengine_p.h>

#include <private/qtextureglyphcache_p.h>

#include <private/qpixmapdata_gl_p.h>

#include <private/qdatabuffer_p.h>

#include "qglgradientcache_p.h"

#include "qglengineshadermanager_p.h"

#include "qgl2pexvertexarray_p.h"

#include "qtriangulatingstroker_p.h"

#include <QDebug>

QT_BEGIN_NAMESPACE

//#define QT_GL_NO_SCISSOR_TEST

static const GLuint GL_STENCIL_HIGH_BIT         = 0x80;

static const GLuint QT_BRUSH_TEXTURE_UNIT       = 0;

static const GLuint QT_IMAGE_TEXTURE_UNIT       = 0; //Can be the same as brush texture unit

static const GLuint QT_MASK_TEXTURE_UNIT        = 1;

static const GLuint QT_BACKGROUND_TEXTURE_UNIT  = 2;

#ifdef Q_WS_WIN

extern Q_GUI_EXPORT bool qt_cleartype_enabled;

#endif

class QGLTextureGlyphCache : public QObject, public QTextureGlyphCache

{

    Q_OBJECT

public:

    QGLTextureGlyphCache(QGLContext *context, QFontEngineGlyphCache::Type type, const QTransform &matrix);

    ~QGLTextureGlyphCache();

    virtual void createTextureData(int width, int height);

    virtual void resizeTextureData(int width, int height);

    virtual void fillTexture(const Coord &c, glyph_t glyph);

    virtual int glyphMargin() const;

    inline GLuint texture() const { return m_texture; }

    inline int width() const { return m_width; }

    inline int height() const { return m_height; }

    inline void setPaintEnginePrivate(QGL2PaintEngineExPrivate *p) { pex = p; }

public Q_SLOTS:

    void contextDestroyed(const QGLContext *context) {

        if (context == ctx) {

            QList<const QGLContext *> shares = qgl_share_reg()->shares(ctx);

            if (shares.isEmpty()) {

                glDeleteFramebuffers(1, &m_fbo);

                if (m_width || m_height)

                    glDeleteTextures(1, &m_texture);

                ctx = 0;

            } else {

                // since the context holding the texture is shared, and

                // about to be destroyed, we have to transfer ownership

                // of the texture to one of the share contexts

                ctx = const_cast<QGLContext *>((ctx == shares.at(0)) ? shares.at(1) : shares.at(0));

            }

        }

    }

private:

    QGLContext *ctx;

    QGL2PaintEngineExPrivate *pex;

    GLuint m_texture;

    GLuint m_fbo;

    int m_width;

    int m_height;

    QGLShaderProgram *m_program;

};

QGLTextureGlyphCache::QGLTextureGlyphCache(QGLContext *context, QFontEngineGlyphCache::Type type, const QTransform &matrix)

    : QTextureGlyphCache(type, matrix)

    , ctx(context)

    , m_width(0)

    , m_height(0)

{

    glGenFramebuffers(1, &m_fbo);

    connect(QGLSignalProxy::instance(), SIGNAL(aboutToDestroyContext(const QGLContext *)),

            SLOT(contextDestroyed(const QGLContext *)));

}

QGLTextureGlyphCache::~QGLTextureGlyphCache()

{

    if (ctx) {

        QGLShareContextScope scope(ctx);

        glDeleteFramebuffers(1, &m_fbo);

        if (m_width || m_height)

            glDeleteTextures(1, &m_texture);

    }

}

void QGLTextureGlyphCache::createTextureData(int width, int height)

{

    glGenTextures(1, &m_texture);

    glBindTexture(GL_TEXTURE_2D, m_texture);

    m_width = width;

    m_height = height;

    QVarLengthArray<uchar> data(width * height);

    for (int i = 0; i < data.size(); ++i)

        data[i] = 0;

    if (m_type == QFontEngineGlyphCache::Raster_RGBMask)

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);

    else

        glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, &data[0]);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

}

void QGLTextureGlyphCache::resizeTextureData(int width, int height)

{

    // ### the QTextureGlyphCache API needs to be reworked to allow

    // ### resizeTextureData to fail

    int oldWidth = m_width;

    int oldHeight = m_height;

    GLuint oldTexture = m_texture;

    createTextureData(width, height);

    glBindFramebuffer(GL_FRAMEBUFFER_EXT, m_fbo);

    GLuint tmp_texture;

    glGenTextures(1, &tmp_texture);

    glBindTexture(GL_TEXTURE_2D, tmp_texture);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,

                 GL_RGBA, GL_UNSIGNED_BYTE, NULL);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glBindTexture(GL_TEXTURE_2D, 0);

    glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,

                           GL_TEXTURE_2D, tmp_texture, 0);

    glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);

    glBindTexture(GL_TEXTURE_2D, oldTexture);

    pex->transferMode(BrushDrawingMode);

#ifndef QT_OPENGL_ES_2

    if (pex->inRenderText)

        glPushAttrib(GL_ENABLE_BIT | GL_VIEWPORT_BIT | GL_SCISSOR_BIT);

#endif

    glDisable(GL_STENCIL_TEST);

    glDisable(GL_DEPTH_TEST);

    glDisable(GL_SCISSOR_TEST);

    glDisable(GL_BLEND);

    glViewport(0, 0, oldWidth, oldHeight);

    float vertexCoordinateArray[] = { -1, -1, 1, -1, 1, 1, -1, 1 };

    float textureCoordinateArray[] = { 0, 0, 1, 0, 1, 1, 0, 1 };

    glEnableVertexAttribArray(QT_VERTEX_COORDS_ATTR);

    glEnableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);

    glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, vertexCoordinateArray);

    glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, textureCoordinateArray);

    pex->shaderManager->blitProgram()->enable();

    pex->shaderManager->blitProgram()->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);

    pex->shaderManager->setDirty();

    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

    glDisableVertexAttribArray(QT_VERTEX_COORDS_ATTR);

    glDisableVertexAttribArray(QT_TEXTURE_COORDS_ATTR);

    glBindTexture(GL_TEXTURE_2D, m_texture);

#ifdef QT_OPENGL_ES_2

    QDataBuffer<uchar> buffer(4*oldWidth*oldHeight);

    buffer.resize(4*oldWidth*oldHeight);

    glReadPixels(0, 0, oldWidth, oldHeight, GL_RGBA, GL_UNSIGNED_BYTE, buffer.data());

    // do an in-place conversion from GL_RGBA to GL_ALPHA

    for (int i=0; i<oldWidth*oldHeight; ++i)

        buffer.data()[i] = buffer.at(4*i + 3);

    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, oldWidth, oldHeight,

                    GL_ALPHA, GL_UNSIGNED_BYTE, buffer.data());

#else

    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);

#endif

    glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,

                              GL_RENDERBUFFER_EXT, 0);

    glDeleteTextures(1, &tmp_texture);

    glDeleteTextures(1, &oldTexture);

    glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);

    glViewport(0, 0, pex->width, pex->height);

    pex->updateClipScissorTest();

#ifndef QT_OPENGL_ES_2

    if (pex->inRenderText)

        glPopAttrib();

#endif

}

void QGLTextureGlyphCache::fillTexture(const Coord &c, glyph_t glyph)

{

    QImage mask = textureMapForGlyph(glyph);

    const int maskWidth = mask.width();

    const int maskHeight = mask.height();

    if (mask.format() == QImage::Format_Mono) {

        mask = mask.convertToFormat(QImage::Format_Indexed8);

        for (int y = 0; y < maskHeight; ++y) {

            uchar *src = (uchar *) mask.scanLine(y);

            for (int x = 0; x < maskWidth; ++x)

                src[x] = -src[x]; // convert 0 and 1 into 0 and 255

        }

     }

    glBindTexture(GL_TEXTURE_2D, m_texture);

    if (mask.format() == QImage::Format_RGB32) {

        glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_BGRA, GL_UNSIGNED_BYTE, mask.bits());

    } else {

#ifdef QT_OPENGL_ES2

        glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y, maskWidth, maskHeight, GL_ALPHA, GL_UNSIGNED_BYTE, mask.bits());

#else

        // glTexSubImage2D() might cause some garbage to appear in the texture if the mask width is

        // not a multiple of four bytes. The bug appeared on a computer with 32-bit Windows Vista

        // and nVidia GeForce 8500GT. GL_UNPACK_ALIGNMENT is set to four bytes, 'mask' has a

        // multiple of four bytes per line, and most of the glyph shows up correctly in the

        // texture, which makes me think that this is a driver bug.

        // One workaround is to make sure the mask width is a multiple of four bytes, for instance

        // by converting it to a format with four bytes per pixel. Another is to copy one line at a

        // time.

        for (int i = 0; i < maskHeight; ++i)

            glTexSubImage2D(GL_TEXTURE_2D, 0, c.x, c.y + i, maskWidth, 1, GL_ALPHA, GL_UNSIGNED_BYTE, mask.scanLine(i));

#endif

    }

}

int QGLTextureGlyphCache::glyphMargin() const

{

#if defined(Q_WS_MAC)

    return 2;

#elif defined (Q_WS_X11)

    return 0;

#else

    return m_type == QFontEngineGlyphCache::Raster_RGBMask ? 2 : 0;

#endif

}

extern QImage qt_imageForBrush(int brushStyle, bool invert);

////////////////////////////////// Private Methods //////////////////////////////////////////

QGL2PaintEngineExPrivate::~QGL2PaintEngineExPrivate()

{

    delete shaderManager;

}

void QGL2PaintEngineExPrivate::updateTextureFilter(GLenum target, GLenum wrapMode, bool smoothPixmapTransform, GLuint id)

{

//    glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT); //### Is it always this texture unit?

    if (id != GLuint(-1) && id == lastTexture)

        return;

    lastTexture = id;

    if (smoothPixmapTransform) {

        glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    } else {

        glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

        glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    }

    glTexParameterf(target, GL_TEXTURE_WRAP_S, wrapMode);

    glTexParameterf(target, GL_TEXTURE_WRAP_T, wrapMode);

}

inline QColor qt_premultiplyColor(QColor c, GLfloat opacity)

{

    qreal alpha = c.alphaF() * opacity;

    c.setAlphaF(alpha);

    c.setRedF(c.redF() * alpha);

    c.setGreenF(c.greenF() * alpha);

    c.setBlueF(c.blueF() * alpha);

    return c;

}

void QGL2PaintEngineExPrivate::setBrush(const QBrush* brush)

{

    currentBrush = brush;

    brushTextureDirty = true;

    brushUniformsDirty = true;

    if (currentBrush->style() == Qt::TexturePattern

        && qHasPixmapTexture(*brush) && brush->texture().isQBitmap())

    {

        shaderManager->setSrcPixelType(QGLEngineShaderManager::TextureSrcWithPattern);

    } else {

        shaderManager->setSrcPixelType(currentBrush->style());

    }

    shaderManager->optimiseForBrushTransform(currentBrush->transform());

}

void QGL2PaintEngineExPrivate::useSimpleShader()

{

    shaderManager->simpleProgram()->enable();

    shaderManager->setDirty();

    if (matrixDirty)

        updateMatrix();

    if (simpleShaderMatrixUniformDirty) {

        shaderManager->simpleProgram()->setUniformValue("pmvMatrix", pmvMatrix);

        simpleShaderMatrixUniformDirty = false;

    }

}

void QGL2PaintEngineExPrivate::updateBrushTexture()

{

    Q_Q(QGL2PaintEngineEx);

//     qDebug("QGL2PaintEngineExPrivate::updateBrushTexture()");

    Qt::BrushStyle style = currentBrush->style();

    if ( (style >= Qt::Dense1Pattern) && (style <= Qt::DiagCrossPattern) ) {

        // Get the image data for the pattern

        QImage texImage = qt_imageForBrush(style, false);

        glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);

        ctx->d_func()->bindTexture(texImage, GL_TEXTURE_2D, GL_RGBA, true, QGLContext::InternalBindOption);

        updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);

    }

    else if (style >= Qt::LinearGradientPattern && style <= Qt::ConicalGradientPattern) {

        // Gradiant brush: All the gradiants use the same texture

        const QGradient* g = currentBrush->gradient();

        // We apply global opacity in the fragment shaders, so we always pass 1.0

        // for opacity to the cache.

        GLuint texId = QGL2GradientCache::cacheForContext(ctx)->getBuffer(*g, 1.0);

        glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);

        glBindTexture(GL_TEXTURE_2D, texId);

        if (g->spread() == QGradient::RepeatSpread || g->type() == QGradient::ConicalGradient)

            updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);

        else if (g->spread() == QGradient::ReflectSpread)

            updateTextureFilter(GL_TEXTURE_2D, GL_MIRRORED_REPEAT_IBM, q->state()->renderHints & QPainter::SmoothPixmapTransform);

        else

            updateTextureFilter(GL_TEXTURE_2D, GL_CLAMP_TO_EDGE, q->state()->renderHints & QPainter::SmoothPixmapTransform);

    }

    else if (style == Qt::TexturePattern) {

        const QPixmap& texPixmap = currentBrush->texture();

        glActiveTexture(GL_TEXTURE0 + QT_BRUSH_TEXTURE_UNIT);

        QGLTexture *tex = ctx->d_func()->bindTexture(texPixmap, GL_TEXTURE_2D, GL_RGBA, QGLContext::InternalBindOption);

        updateTextureFilter(GL_TEXTURE_2D, GL_REPEAT, q->state()->renderHints & QPainter::SmoothPixmapTransform);

        textureInvertedY = tex->options & QGLContext::InvertedYBindOption ? -1 : 1;

    }

    brushTextureDirty = false;

}

void QGL2PaintEngineExPrivate::updateBrushUniforms()

{

//     qDebug("QGL2PaintEngineExPrivate::updateBrushUniforms()");

    Qt::BrushStyle style = currentBrush->style();

    if (style == Qt::NoBrush)

        return;

    QTransform brushQTransform = currentBrush->transform();

    if (style == Qt::SolidPattern) {

        QColor col = qt_premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity);

        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::FragmentColor), col);

    }

    else {

        // All other brushes have a transform and thus need the translation point:

        QPointF translationPoint;

        if (style <= Qt::DiagCrossPattern) {

            QColor col = qt_premultiplyColor(currentBrush->color(), (GLfloat)q->state()->opacity);

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::PatternColor), col);

            QVector2D halfViewportSize(width*0.5, height*0.5);

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);

        }

        else if (style == Qt::LinearGradientPattern) {

            const QLinearGradient *g = static_cast<const QLinearGradient *>(currentBrush->gradient());

            QPointF realStart = g->start();

            QPointF realFinal = g->finalStop();

            translationPoint = realStart;

            QPointF l = realFinal - realStart;

            QVector3D linearData(

                l.x(),

                l.y(),

                1.0f / (l.x() * l.x() + l.y() * l.y())

            );

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::LinearData), linearData);

            QVector2D halfViewportSize(width*0.5, height*0.5);

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);

        }

        else if (style == Qt::ConicalGradientPattern) {

            const QConicalGradient *g = static_cast<const QConicalGradient *>(currentBrush->gradient());

            translationPoint   = g->center();

            GLfloat angle = -(g->angle() * 2 * Q_PI) / 360.0;

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Angle), angle);

            QVector2D halfViewportSize(width*0.5, height*0.5);

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);

        }

        else if (style == Qt::RadialGradientPattern) {

            const QRadialGradient *g = static_cast<const QRadialGradient *>(currentBrush->gradient());

            QPointF realCenter = g->center();

            QPointF realFocal  = g->focalPoint();

            qreal   realRadius = g->radius();

            translationPoint   = realFocal;

            QPointF fmp = realCenter - realFocal;

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Fmp), fmp);

            GLfloat fmp2_m_radius2 = -fmp.x() * fmp.x() - fmp.y() * fmp.y() + realRadius*realRadius;

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Fmp2MRadius2), fmp2_m_radius2);

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::Inverse2Fmp2MRadius2),

                                                             GLfloat(1.0 / (2.0*fmp2_m_radius2)));

            QVector2D halfViewportSize(width*0.5, height*0.5);

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::HalfViewportSize), halfViewportSize);