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

**

** Copyright (C) 2010 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.

*/

// #define QT_OPENGL_CACHE_AS_VBOS

#include "qglgradientcache_p.h"

#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/qpixmapdata_gl_p.h>

#include <private/qdatabuffer_p.h>

#include <private/qstatictext_p.h>

#include <private/qtriangulator_p.h>

#include "qglengineshadermanager_p.h"

#include "qgl2pexvertexarray_p.h"

#include "qtriangulatingstroker_p.h"

#include "qtextureglyphcache_gl_p.h"

#include <QDebug>

QT_BEGIN_NAMESPACE

//#define QT_GL_NO_SCISSOR_TEST

#if defined(Q_WS_WIN)

extern Q_GUI_EXPORT bool qt_cleartype_enabled;

#endif

extern QImage qt_imageForBrush(int brushStyle, bool invert);

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

QGL2PaintEngineExPrivate::~QGL2PaintEngineExPrivate()

{

    delete shaderManager;

    while (pathCaches.size()) {

        QVectorPath::CacheEntry *e = *(pathCaches.constBegin());

        e->cleanup(e->engine, e->data);

        e->data = 0;

        e->engine = 0;

    }

    if (elementIndicesVBOId != 0) {

        glDeleteBuffers(1, &elementIndicesVBOId);

        elementIndicesVBOId = 0;

    }

}

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 == lastTextureUsed)

        return;

    lastTextureUsed = 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)

{

    if (qbrush_fast_equals(currentBrush, brush))

        return;

    const Qt::BrushStyle newStyle = qbrush_style(brush);

    Q_ASSERT(newStyle != Qt::NoBrush);

    currentBrush = brush;

    brushUniformsDirty = true; // All brushes have at least one uniform

    if (newStyle > Qt::SolidPattern)

        brushTextureDirty = true;

    if (currentBrush.style() == Qt::TexturePattern

        && qHasPixmapTexture(brush) && brush.texture().isQBitmap())

    {

        shaderManager->setSrcPixelType(QGLEngineShaderManager::TextureSrcWithPattern);

    } else {

        shaderManager->setSrcPixelType(newStyle);

    }

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

}

void QGL2PaintEngineExPrivate::useSimpleShader()

{

    shaderManager->useSimpleProgram();

    if (matrixDirty)

        updateMatrix();

}

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, 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 |

                                                     QGLContext::CanFlipNativePixmapBindOption);

        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);

        }

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

            const QPixmap& texPixmap = currentBrush.texture();

            if (qHasPixmapTexture(currentBrush) && currentBrush.texture().isQBitmap()) {

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

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

            }

            QSizeF invertedTextureSize(1.0 / texPixmap.width(), 1.0 / texPixmap.height());

            shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::InvertedTextureSize), invertedTextureSize);

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

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

        }

        else

            qWarning("QGL2PaintEngineEx: Unimplemented fill style");

        const QPointF &brushOrigin = q->state()->brushOrigin;

        QTransform matrix = q->state()->matrix;

        matrix.translate(brushOrigin.x(), brushOrigin.y());

        QTransform translate(1, 0, 0, 1, -translationPoint.x(), -translationPoint.y());

        QTransform gl_to_qt(1, 0, 0, -1, 0, height);

        QTransform inv_matrix;

        if (style == Qt::TexturePattern && textureInvertedY == -1)

            inv_matrix = gl_to_qt * (QTransform(1, 0, 0, -1, 0, currentBrush.texture().height()) * brushQTransform * matrix).inverted() * translate;

        else

            inv_matrix = gl_to_qt * (brushQTransform * matrix).inverted() * translate;

        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BrushTransform), inv_matrix);

        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::BrushTexture), QT_BRUSH_TEXTURE_UNIT);

    }

    brushUniformsDirty = false;

}

// This assumes the shader manager has already setup the correct shader program

void QGL2PaintEngineExPrivate::updateMatrix()

{

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

    const QTransform& transform = q->state()->matrix;

    // The projection matrix converts from Qt's coordinate system to GL's coordinate system

    //    * GL's viewport is 2x2, Qt's is width x height

    //    * GL has +y -> -y going from bottom -> top, Qt is the other way round

    //    * GL has [0,0] in the center, Qt has it in the top-left

    //

    // This results in the Projection matrix below, which is multiplied by the painter's

    // transformation matrix, as shown below:

    //

    //                Projection Matrix                      Painter Transform

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

    // | 2.0 / width  |      0.0      |     -1.0      |   |  m11  |  m21  |  dx  |

    // |     0.0      | -2.0 / height |      1.0      | * |  m12  |  m22  |  dy  |

    // |     0.0      |      0.0      |      1.0      |   |  m13  |  m23  |  m33 |

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

    //

    // NOTE: The resultant matrix is also transposed, as GL expects column-major matracies

    const GLfloat wfactor = 2.0f / width;

    const GLfloat hfactor = -2.0f / height;

    GLfloat dx = transform.dx();

    GLfloat dy = transform.dy();

    // Non-integer translates can have strange effects for some rendering operations such as

    // anti-aliased text rendering. In such cases, we snap the translate to the pixel grid.

    if (snapToPixelGrid && transform.type() == QTransform::TxTranslate) {

        // 0.50 needs to rounded down to 0.0 for consistency with raster engine:

        dx = ceilf(dx - 0.5f);

        dy = ceilf(dy - 0.5f);

    }

    if (addOffset) {

        dx += 0.49f;

        dy += 0.49f;

    }

    pmvMatrix[0][0] = (wfactor * transform.m11())  - transform.m13();

    pmvMatrix[1][0] = (wfactor * transform.m21())  - transform.m23();

    pmvMatrix[2][0] = (wfactor * dx) - transform.m33();

    pmvMatrix[0][1] = (hfactor * transform.m12())  + transform.m13();

    pmvMatrix[1][1] = (hfactor * transform.m22())  + transform.m23();

    pmvMatrix[2][1] = (hfactor * dy) + transform.m33();

    pmvMatrix[0][2] = transform.m13();

    pmvMatrix[1][2] = transform.m23();

    pmvMatrix[2][2] = transform.m33();

    // 1/10000 == 0.0001, so we have good enough res to cover curves

    // that span the entire widget...

    inverseScale = qMax(1 / qMax( qMax(qAbs(transform.m11()), qAbs(transform.m22())),

                                  qMax(qAbs(transform.m12()), qAbs(transform.m21())) ),

                        qreal(0.0001));

    matrixDirty = false;

    matrixUniformDirty = true;

    // Set the PMV matrix attribute. As we use an attributes rather than uniforms, we only

    // need to do this once for every matrix change and persists across all shader programs.

    glVertexAttrib3fv(QT_PMV_MATRIX_1_ATTR, pmvMatrix[0]);

    glVertexAttrib3fv(QT_PMV_MATRIX_2_ATTR, pmvMatrix[1]);

    glVertexAttrib3fv(QT_PMV_MATRIX_3_ATTR, pmvMatrix[2]);

    dasher.setInvScale(inverseScale);

    stroker.setInvScale(inverseScale);

}

void QGL2PaintEngineExPrivate::updateCompositionMode()

{

    // NOTE: The entire paint engine works on pre-multiplied data - which is why some of these

    //       composition modes look odd.

//     qDebug() << "QGL2PaintEngineExPrivate::updateCompositionMode() - Setting GL composition mode for " << q->state()->composition_mode;

    switch(q->state()->composition_mode) {

    case QPainter::CompositionMode_SourceOver:

        glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

        break;

    case QPainter::CompositionMode_DestinationOver:

        glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);

        break;

    case QPainter::CompositionMode_Clear:

        glBlendFunc(GL_ZERO, GL_ZERO);

        break;

    case QPainter::CompositionMode_Source:

        glBlendFunc(GL_ONE, GL_ZERO);

        break;

    case QPainter::CompositionMode_Destination:

        glBlendFunc(GL_ZERO, GL_ONE);

        break;

    case QPainter::CompositionMode_SourceIn:

        glBlendFunc(GL_DST_ALPHA, GL_ZERO);

        break;

    case QPainter::CompositionMode_DestinationIn:

        glBlendFunc(GL_ZERO, GL_SRC_ALPHA);

        break;

    case QPainter::CompositionMode_SourceOut:

        glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ZERO);

        break;

    case QPainter::CompositionMode_DestinationOut:

        glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);

        break;

    case QPainter::CompositionMode_SourceAtop:

        glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        break;

    case QPainter::CompositionMode_DestinationAtop:

        glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA);

        break;

    case QPainter::CompositionMode_Xor:

        glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        break;

    case QPainter::CompositionMode_Plus:

        glBlendFunc(GL_ONE, GL_ONE);

        break;

    default:

        qWarning("Unsupported composition mode");

        break;

    }

    compositionModeDirty = false;

}

static inline void setCoords(GLfloat *coords, const QGLRect &rect)

{

    coords[0] = rect.left;

    coords[1] = rect.top;

    coords[2] = rect.right;

    coords[3] = rect.top;

    coords[4] = rect.right;

    coords[5] = rect.bottom;

    coords[6] = rect.left;

    coords[7] = rect.bottom;

}

void QGL2PaintEngineExPrivate::drawTexture(const QGLRect& dest, const QGLRect& src, const QSize &textureSize, bool opaque, bool pattern)

{

    // Setup for texture drawing

    currentBrush = noBrush;

    shaderManager->setSrcPixelType(pattern ? QGLEngineShaderManager::PatternSrc : QGLEngineShaderManager::ImageSrc);

    if (addOffset) {

        addOffset = false;

        matrixDirty = true;

    }

    if (snapToPixelGrid) {

        snapToPixelGrid = false;

        matrixDirty = true;

    }

    if (prepareForDraw(opaque))

        shaderManager->currentProgram()->setUniformValue(location(QGLEngineShaderManager::ImageTexture), QT_IMAGE_TEXTURE_UNIT);

    if (pattern) {

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

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

    }

    GLfloat dx = 1.0 / textureSize.width();

    GLfloat dy = 1.0 / textureSize.height();

    QGLRect srcTextureRect(src.left*dx, src.top*dy, src.right*dx, src.bottom*dy);

    setCoords(staticVertexCoordinateArray, dest);

    setCoords(staticTextureCoordinateArray, srcTextureRect);

    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

}

void QGL2PaintEngineEx::beginNativePainting()

{