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

**

** 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$

**

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

#include <qdebug.h>

#include <private/qfontengine_p.h>

#include <qmath.h>

#include <private/qmath_p.h>

#include <private/qdrawhelper_p.h>

#include <private/qpaintengine_p.h>

#include "qapplication.h"

#include "qbrush.h"

#include "qgl.h"

#include <private/qgl_p.h>

#include <private/qglpaintdevice_p.h>

#include <private/qpainter_p.h>

#include "qmap.h"

#include <private/qpaintengine_opengl_p.h>

#include <private/qdatabuffer_p.h>

#include "qpen.h"

#include "qvarlengtharray.h"

#include <private/qpainter_p.h>

#include <private/qglpixelbuffer_p.h>

#include <private/qbezier_p.h>

#include <qglframebufferobject.h>

#include "private/qtessellator_p.h"

#include "util/fragmentprograms_p.h"

#ifdef Q_WS_QWS

#include "private/qglwindowsurface_qws_p.h"

#include "qwsmanager_qws.h"

#include "private/qwsmanager_p.h"

#endif

#ifdef QT_OPENGL_ES_1_CL

#include "qgl_cl_p.h"

#endif

#define QGL_FUNC_CONTEXT QGLContext *ctx = const_cast<QGLContext *>(device->context());

#include <stdlib.h>

#include "qpaintengine_opengl_p.h"

QT_BEGIN_NAMESPACE

extern QImage qt_imageForBrush(int brushStyle, bool invert); //in qbrush.cpp

#ifdef QT_MAC_USE_COCOA

extern void *qt_current_nsopengl_context(); // qgl_mac.mm

#endif

#define QREAL_MAX 9e100

#define QREAL_MIN -9e100

extern int qt_next_power_of_two(int v);

#define DISABLE_DEBUG_ONCE

//#define DEBUG_DISPLAY_MASK_TEXTURE

#ifdef DISABLE_DEBUG_ONCE

#define DEBUG_OVERRIDE(state) ;

#define DEBUG_ONCE_STR(str) ;

#define DEBUG_ONCE if (0)

#else

static int DEBUG_OVERRIDE_FLAG = 0;

static bool DEBUG_TEMP_FLAG;

#define DEBUG_OVERRIDE(state) { state ? ++DEBUG_OVERRIDE_FLAG : --DEBUG_OVERRIDE_FLAG; }

#define DEBUG_ONCE if ((DEBUG_TEMP_FLAG = DEBUG_OVERRIDE_FLAG) && 0) ; else for (static int DEBUG_ONCE_FLAG = false; !DEBUG_ONCE_FLAG || DEBUG_TEMP_FLAG; DEBUG_ONCE_FLAG = true, DEBUG_TEMP_FLAG = false)

#define DEBUG_ONCE_STR(str) DEBUG_ONCE qDebug() << (str);

#endif

#ifdef Q_WS_X11

static bool qt_nvidiaFboNeedsFinish = false;

#endif

static inline void qt_glColor4ubv(unsigned char *col)

{

    glColor4f(col[0]/255.0f, col[1]/255.0f, col[2]/255.0f, col[3]/255.0f);

}

struct QT_PointF {

    qreal x;

    qreal y;

};

struct QGLTrapezoid

{

    QGLTrapezoid()

    {}

    QGLTrapezoid(qreal top_, qreal bottom_, qreal topLeftX_, qreal topRightX_, qreal bottomLeftX_, qreal bottomRightX_)

        : top(top_),

          bottom(bottom_),

          topLeftX(topLeftX_),

          topRightX(topRightX_),

          bottomLeftX(bottomLeftX_),

          bottomRightX(bottomRightX_)

    {}

    const QGLTrapezoid translated(const QPointF &delta) const;

    qreal top;

    qreal bottom;

    qreal topLeftX;

    qreal topRightX;

    qreal bottomLeftX;

    qreal bottomRightX;

};

const QGLTrapezoid QGLTrapezoid::translated(const QPointF &delta) const

{

    QGLTrapezoid trap(*this);

    trap.top += delta.y();

    trap.bottom += delta.y();

    trap.topLeftX += delta.x();

    trap.topRightX += delta.x();

    trap.bottomLeftX += delta.x();

    trap.bottomRightX += delta.x();

    return trap;

}

class QOpenGLImmediateModeTessellator;

class QGLMaskGenerator;

class QGLOffscreen;

class QGLMaskTextureCache

{

public:

    void setOffscreenSize(const QSize &offscreenSize);

    void setDrawableSize(const QSize &drawableSize);

    struct CacheLocation {

        QRect rect;

        int channel;

        QRect screen_rect;

    };

    struct CacheInfo {

        inline CacheInfo(const QPainterPath &p, const QTransform &m, qreal w = -1) :

            path(p), matrix(m), stroke_width(w), age(0) {}

        QPainterPath path;

        QTransform matrix;

        qreal stroke_width;

        CacheLocation loc;

        int age;

    };

    struct QuadTreeNode {

        quint64 key;

        int largest_available_block;

        int largest_used_block;

    };

    CacheLocation getMask(QGLMaskGenerator &maskGenerator, QOpenGLPaintEnginePrivate *engine);

    typedef QMultiHash<quint64, CacheInfo> QGLTextureCacheHash;

    enum {block_size = 64};

    // throw out keys that are too old

    void maintainCache();

    void clearCache();

private:

    quint64 hash(const QPainterPath &p, const QTransform &m, qreal w);

    void createMask(quint64 key, CacheInfo &info, QGLMaskGenerator &maskGenerator);

    QSize offscreenSize;

    QSize drawableSize;

    QGLTextureCacheHash cache;

    QVector<QuadTreeNode> occupied_quadtree[4];

    void quadtreeUpdate(int channel, int node, int current_block_size);

    void quadtreeAllocate(quint64 key, const QSize &size, QRect *rect, int *channel);

    bool quadtreeFindAvailableLocation(const QSize &size, QRect *rect, int *channel);

    void quadtreeFindExistingLocation(const QSize &size, QRect *rect, int *channel);

    void quadtreeInsert(int channel, quint64 key, const QRect &rect, int node = 0);

    void quadtreeClear(int channel, const QRect &rect, int node = 0);

    int quadtreeBlocksize(int node);

    QPoint quadtreeLocation(int node);

    QOpenGLPaintEnginePrivate *engine;

};

Q_GLOBAL_STATIC(QGLMaskTextureCache, qt_mask_texture_cache)

class QGLOffscreen : public QObject

{

    Q_OBJECT

public:

    QGLOffscreen()

        : QObject(),

          offscreen(0),

          ctx(0),

          mask_dim(0),

          activated(false),

          bound(false)

    {

        connect(QGLSignalProxy::instance(),

                SIGNAL(aboutToDestroyContext(const QGLContext*)),

                SLOT(cleanupGLContextRefs(const QGLContext*)));

    }

    inline void setDevice(QPaintDevice *pdev);

    void begin();

    void end();

    inline void bind();

    inline void release();

    inline bool isBound() const;

    inline QSize drawableSize() const;

    inline QSize offscreenSize() const;

    inline GLuint offscreenTexture() const;

    QGLContext *context() const;

    static bool isSupported();

    inline void initialize();

    inline bool isValid() const;

public Q_SLOTS:

    void cleanupGLContextRefs(const QGLContext *context) {

        if (context == ctx) {

            delete offscreen;

            ctx = 0;

            offscreen = 0;

            mask_dim = 0;

        }

    }

private:

    QGLPaintDevice* device;

    QGLFramebufferObject *offscreen;

    QGLContext *ctx;

    // dimensions of mask texture (square)

    int mask_dim;

    QSize last_failed_size;

    bool drawable_fbo;

    bool activated;

    bool initialized;

    bool bound;

};

inline void QGLOffscreen::setDevice(QPaintDevice *pdev)

{

    if (pdev->devType() == QInternal::OpenGL)

        device = static_cast<QGLPaintDevice*>(pdev);

    else

        device = QGLPaintDevice::getDevice(pdev);

    if (!device)

        return;

    drawable_fbo = (pdev->devType() == QInternal::FramebufferObject);

}

void QGLOffscreen::begin()

{

#ifndef QT_OPENGL_ES

    initialized = false;

    if (activated)

        initialize();

#endif

}

void QGLOffscreen::initialize()

{

#ifndef QT_OPENGL_ES

    if (initialized)

        return;

    activated = true;

    initialized = true;

    int dim = qMax(2048, static_cast<int>(qt_next_power_of_two(qMax(device->size().width(), device->size().height()))));

    bool shared_context = QGLContext::areSharing(device->context(), ctx);

    bool would_fail = last_failed_size.isValid() &&

                      (device->size().width() >= last_failed_size.width() ||

                       device->size().height() >= last_failed_size.height());

    bool needs_refresh = dim > mask_dim || !shared_context;

    if (needs_refresh && !would_fail) {

        DEBUG_ONCE qDebug() << "QGLOffscreen::initialize(): creating offscreen of size" << dim;

        delete offscreen;

        offscreen = new QGLFramebufferObject(dim, dim, GLenum(GL_TEXTURE_2D));

        mask_dim = dim;

        if (!offscreen->isValid()) {

            qWarning("QGLOffscreen: Invalid offscreen fbo (size %dx%d)", mask_dim, mask_dim);

            delete offscreen;

            offscreen = 0;

            mask_dim = 0;

            last_failed_size = device->size();

        }

    }

    qt_mask_texture_cache()->setOffscreenSize(offscreenSize());

    qt_mask_texture_cache()->setDrawableSize(device->size());

    ctx = device->context();

#endif

}

inline bool QGLOffscreen::isValid() const

{

    return offscreen;

}

void QGLOffscreen::end()

{

    if (bound)

        release();

#ifdef DEBUG_DISPLAY_MASK_TEXTURE

    glReadBuffer(GL_BACK);

    glDrawBuffer(GL_BACK);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    glColor4f(1, 1, 1, 1);

    glDisable(GL_DEPTH_TEST);

    glBlendFunc(GL_ONE, GL_ZERO);

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

    glEnable(GL_TEXTURE_2D);

    glBindTexture(GL_TEXTURE_2D, offscreen->texture());

    glBegin(GL_QUADS);

    glTexCoord2f(0.0, 1.0); glVertex2f(0.0, 0.0);

    glTexCoord2f(1.0, 1.0); glVertex2f(drawable.size().width(), 0.0);

    glTexCoord2f(1.0, 0.0); glVertex2f(drawable.size().width(), drawable.size().height());

    glTexCoord2f(0.0, 0.0); glVertex2f(0.0, drawable.size().height());

    glEnd();

    glBindTexture(GL_TEXTURE_2D, 0);

    glDisable(GL_TEXTURE_2D);

#endif

}

inline void QGLOffscreen::bind()

{

#ifndef QT_OPENGL_ES

    Q_ASSERT(initialized);

    if (!offscreen || bound)

        return;

    DEBUG_ONCE qDebug() << "QGLOffscreen: binding offscreen";

    offscreen->bind();

    bound = true;

    glViewport(0, 0, offscreenSize().width(), offscreenSize().height());

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrtho(0, offscreenSize().width(), offscreenSize().height(), 0, -999999, 999999);

    glMatrixMode(GL_MODELVIEW);

#endif

}

inline void QGLOffscreen::release()

{

#ifndef QT_OPENGL_ES

    if (!offscreen || !bound)

        return;

#ifdef Q_WS_X11

    // workaround for bug in nvidia driver versions 9x.xx

    if (qt_nvidiaFboNeedsFinish)

        glFinish();

#endif

    DEBUG_ONCE_STR("QGLOffscreen: releasing offscreen");

    if (drawable_fbo)

        device->ensureActiveTarget(); //###

    else

        offscreen->release();

    QSize sz(device->size());

    glViewport(0, 0, sz.width(), sz.height());

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

#ifndef QT_OPENGL_ES

    glOrtho(0, sz.width(), sz.height(), 0, -999999, 999999);

#else

    glOrthof(0, sz.width(), sz.height(), 0, -999999, 999999);

#endif

    glMatrixMode(GL_MODELVIEW);

    bound = false;

#endif

}

inline bool QGLOffscreen::isBound() const

{

    return bound;

}

inline QSize QGLOffscreen::drawableSize() const

{

    return device->size();

}

inline QSize QGLOffscreen::offscreenSize() const

{

    return QSize(mask_dim, mask_dim);

}

inline GLuint QGLOffscreen::offscreenTexture() const

{

    return offscreen ? offscreen->texture() : 0;

}

inline QGLContext *QGLOffscreen::context() const

{

    return ctx;

}

bool QGLOffscreen::isSupported()

{

    return (QGLExtensions::glExtensions() & QGLExtensions::FramebufferObject); // for fbo

}

struct QDrawQueueItem

{

    QDrawQueueItem(qreal _opacity,

                   QBrush _brush,

                   const QPointF &_brush_origion,

                   QPainter::CompositionMode _composition_mode,

                   const QTransform &_matrix,

                   QGLMaskTextureCache::CacheLocation _location)

        : opacity(_opacity),

          brush(_brush),

          brush_origin(_brush_origion),

          composition_mode(_composition_mode),

          matrix(_matrix),

          location(_location) {}

    qreal opacity;

    QBrush brush;

    QPointF brush_origin;

    QPainter::CompositionMode composition_mode;

    QTransform matrix;

    QGLMaskTextureCache::CacheLocation location;

};

////////// GL program cache: start

typedef struct {

    int brush; // brush index or mask index

    int mode;  // composition mode index

    bool mask;

    GLuint program;

} GLProgram;

typedef QMultiHash<const QGLContext *, GLProgram> QGLProgramHash;

class QGLProgramCache : public QObject

{

    Q_OBJECT

public:

    QGLProgramCache() {

        // we have to know when a context is deleted so we can free

        // any program handles it holds