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

**

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

**

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

#include "qglframebufferobject.h"

#include "qglframebufferobject_p.h"

#include <qdebug.h>

#include <private/qgl_p.h>

#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)

#include <private/qpaintengineex_opengl2_p.h>

#endif

#ifndef QT_OPENGL_ES_2

#include <private/qpaintengine_opengl_p.h>

#endif

#include <qglframebufferobject.h>

#include <qlibrary.h>

#include <qimage.h>

#ifdef QT_OPENGL_ES_1_CL

#include "qgl_cl_p.h"

#endif

QT_BEGIN_NAMESPACE

extern QImage qt_gl_read_framebuffer(const QSize&, bool, bool);

#define QGL_FUNC_CONTEXT const QGLContext *ctx = d_ptr->fbo_guard.context();

#define QGL_FUNCP_CONTEXT const QGLContext *ctx = fbo_guard.context();

#ifndef QT_NO_DEBUG

#define QT_RESET_GLERROR()                                \

{                                                         \

    while (glGetError() != GL_NO_ERROR) {}                \

}

#define QT_CHECK_GLERROR()                                \

{                                                         \

    GLenum err = glGetError();                            \

    if (err != GL_NO_ERROR) {                             \

        qDebug("[%s line %d] GL Error: %d",               \

               __FILE__, __LINE__, (int)err);             \

    }                                                     \

}

#else

#define QT_RESET_GLERROR() {}

#define QT_CHECK_GLERROR() {}

#endif

/*!

    \class QGLFramebufferObjectFormat

    \brief The QGLFramebufferObjectFormat class specifies the format of an OpenGL

    framebuffer object.

    \since 4.6

    \ingroup painting-3D

    A framebuffer object has several characteristics:

    \list

    \i \link setSamples() Number of samples per pixels.\endlink

    \i \link setAttachment() Depth and/or stencil attachments.\endlink

    \i \link setTextureTarget() Texture target.\endlink

    \i \link setInternalTextureFormat() Internal texture format.\endlink

    \endlist

    Note that the desired attachments or number of samples per pixels might not

    be supported by the hardware driver. Call QGLFramebufferObject::format()

    after creating a QGLFramebufferObject to find the exact format that was

    used to create the frame buffer object.

    \sa QGLFramebufferObject

*/

/*!

    \internal

*/

void QGLFramebufferObjectFormat::detach()

{

    if (d->ref != 1) {

        QGLFramebufferObjectFormatPrivate *newd

            = new QGLFramebufferObjectFormatPrivate(d);

        if (!d->ref.deref())

            delete d;

        d = newd;

    }

}

/*!

    Creates a QGLFramebufferObjectFormat object for specifying

    the format of an OpenGL framebuffer object.

    By default the format specifies a non-multisample framebuffer object with no

    attachments, texture target \c GL_TEXTURE_2D, and internal format \c GL_RGBA8.

    On OpenGL/ES systems, the default internal format is \c GL_RGBA.

    \sa samples(), attachment(), target(), internalTextureFormat()

*/

QGLFramebufferObjectFormat::QGLFramebufferObjectFormat()

{

    d = new QGLFramebufferObjectFormatPrivate;

}

/*!

    Constructs a copy of \a other.

*/

QGLFramebufferObjectFormat::QGLFramebufferObjectFormat(const QGLFramebufferObjectFormat &other)

{

    d = other.d;

    d->ref.ref();

}

/*!

    Assigns \a other to this object.

*/

QGLFramebufferObjectFormat &QGLFramebufferObjectFormat::operator=(const QGLFramebufferObjectFormat &other)

{

    if (d != other.d) {

        other.d->ref.ref();

        if (!d->ref.deref())

            delete d;

        d = other.d;

    }

    return *this;

}

/*!

    Destroys the QGLFramebufferObjectFormat.

*/

QGLFramebufferObjectFormat::~QGLFramebufferObjectFormat()

{

    if (!d->ref.deref())

        delete d;

}

/*!

    Sets the number of samples per pixel for a multisample framebuffer object

    to \a samples.  The default sample count of 0 represents a regular

    non-multisample framebuffer object.

    If the desired amount of samples per pixel is not supported by the hardware

    then the maximum number of samples per pixel will be used. Note that

    multisample framebuffer objects can not be bound as textures. Also, the

    \c{GL_EXT_framebuffer_multisample} extension is required to create a

    framebuffer with more than one sample per pixel.

    \sa samples()

*/

void QGLFramebufferObjectFormat::setSamples(int samples)

{

    detach();

    d->samples = samples;

}

/*!

    Returns the number of samples per pixel if a framebuffer object

    is a multisample framebuffer object. Otherwise, returns 0.

    The default value is 0.

    \sa setSamples()

*/

int QGLFramebufferObjectFormat::samples() const

{

    return d->samples;

}

/*!

    Sets the attachment configuration of a framebuffer object to \a attachment.

    \sa attachment()

*/

void QGLFramebufferObjectFormat::setAttachment(QGLFramebufferObject::Attachment attachment)

{

    detach();

    d->attachment = attachment;

}

/*!

    Returns the configuration of the depth and stencil buffers attached to

    a framebuffer object.  The default is QGLFramebufferObject::NoAttachment.

    \sa setAttachment()

*/

QGLFramebufferObject::Attachment QGLFramebufferObjectFormat::attachment() const

{

    return d->attachment;

}

/*!

    Sets the texture target of the texture attached to a framebuffer object to

    \a target. Ignored for multisample framebuffer objects.

    \sa textureTarget(), samples()

*/

void QGLFramebufferObjectFormat::setTextureTarget(GLenum target)

{

    detach();

    d->target = target;

}

/*!

    Returns the texture target of the texture attached to a framebuffer object.

    Ignored for multisample framebuffer objects.  The default is

    \c GL_TEXTURE_2D.

    \sa setTextureTarget(), samples()

*/

GLenum QGLFramebufferObjectFormat::textureTarget() const

{

    return d->target;

}

/*!

    Sets the internal format of a framebuffer object's texture or

    multisample framebuffer object's color buffer to

    \a internalTextureFormat.

    \sa internalTextureFormat()

*/

void QGLFramebufferObjectFormat::setInternalTextureFormat(GLenum internalTextureFormat)

{

    detach();

    d->internal_format = internalTextureFormat;

}

/*!

    Returns the internal format of a framebuffer object's texture or

    multisample framebuffer object's color buffer.  The default is

    \c GL_RGBA8 on desktop OpenGL systems, and \c GL_RGBA on

    OpenGL/ES systems.

    \sa setInternalTextureFormat()

*/

GLenum QGLFramebufferObjectFormat::internalTextureFormat() const

{

    return d->internal_format;

}

#ifdef Q_MAC_COMPAT_GL_FUNCTIONS

/*! \internal */

void QGLFramebufferObjectFormat::setTextureTarget(QMacCompatGLenum target)

{

    detach();

    d->target = target;

}

/*! \internal */

void QGLFramebufferObjectFormat::setInternalTextureFormat(QMacCompatGLenum internalTextureFormat)

{

    detach();

    d->internal_format = internalTextureFormat;

}

#endif

/*!

    Returns true if all the options of this framebuffer object format

    are the same as \a other; otherwise returns false.

*/

bool QGLFramebufferObjectFormat::operator==(const QGLFramebufferObjectFormat& other) const

{

    if (d == other.d)

        return true;

    else

        return d->equals(other.d);

}

/*!

    Returns false if all the options of this framebuffer object format

    are the same as \a other; otherwise returns true.

*/

bool QGLFramebufferObjectFormat::operator!=(const QGLFramebufferObjectFormat& other) const

{

    return !(*this == other);

}

void QGLFBOGLPaintDevice::setFBO(QGLFramebufferObject* f,

                                 QGLFramebufferObject::Attachment attachment)

{

    fbo = f;

    m_thisFBO = fbo->d_func()->fbo(); // This shouldn't be needed

    // The context that the fbo was created in may not have depth

    // and stencil buffers, but the fbo itself might.

    fboFormat = QGLContext::currentContext()->format();

    if (attachment == QGLFramebufferObject::CombinedDepthStencil) {

        fboFormat.setDepth(true);

        fboFormat.setStencil(true);

    } else if (attachment == QGLFramebufferObject::Depth) {

        fboFormat.setDepth(true);

    }

}

QGLContext *QGLFBOGLPaintDevice::context() const

{

    QGLContext *fboContext = const_cast<QGLContext *>(fbo->d_ptr->fbo_guard.context());

    QGLContext *currentContext = const_cast<QGLContext *>(QGLContext::currentContext());

    if (QGLContextPrivate::contextGroup(fboContext) == QGLContextPrivate::contextGroup(currentContext))

        return currentContext;

    else

        return fboContext;

}

void QGLFBOGLPaintDevice::ensureActiveTarget()

{

    if (QGLContext::currentContext() != context())

        context()->makeCurrent();

    QGLContext* ctx = const_cast<QGLContext*>(QGLContext::currentContext());

    Q_ASSERT(ctx);

    const GLuint fboId = fbo->d_func()->fbo();

    if (ctx->d_func()->current_fbo != fboId) {

        ctx->d_func()->current_fbo = fboId;

        glBindFramebuffer(GL_FRAMEBUFFER_EXT, fboId);

    }

}

void QGLFBOGLPaintDevice::beginPaint()

{

    if (QGLContext::currentContext() != context())

        context()->makeCurrent();

    // We let QFBO track the previously bound FBO rather than doing it

    // ourselves here. This has the advantage that begin/release & bind/end

    // work as expected.

    wasBound = fbo->isBound();

    if (!wasBound)

        fbo->bind();

}

void QGLFBOGLPaintDevice::endPaint()

{

    if (!wasBound)

        fbo->release();

}

bool QGLFramebufferObjectPrivate::checkFramebufferStatus() const

{

    QGL_FUNCP_CONTEXT;

    if (!ctx)

        return false;   // Context no longer exists.

    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER_EXT);

    switch(status) {

    case GL_NO_ERROR:

    case GL_FRAMEBUFFER_COMPLETE_EXT:

        return true;

        break;

    case GL_FRAMEBUFFER_UNSUPPORTED_EXT:

        qDebug("QGLFramebufferObject: Unsupported framebuffer format.");

        break;

    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:

        qDebug("QGLFramebufferObject: Framebuffer incomplete attachment.");

        break;

    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:

        qDebug("QGLFramebufferObject: Framebuffer incomplete, missing attachment.");

        break;

#ifdef GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT

    case GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT:

        qDebug("QGLFramebufferObject: Framebuffer incomplete, duplicate attachment.");

        break;

#endif

    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:

        qDebug("QGLFramebufferObject: Framebuffer incomplete, attached images must have same dimensions.");

        break;

    case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:

        qDebug("QGLFramebufferObject: Framebuffer incomplete, attached images must have same format.");

        break;

    case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:

        qDebug("QGLFramebufferObject: Framebuffer incomplete, missing draw buffer.");

        break;

    case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:

        qDebug("QGLFramebufferObject: Framebuffer incomplete, missing read buffer.");

        break;

    case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT:

        qDebug("QGLFramebufferObject: Framebuffer incomplete, attachments must have same number of samples per pixel.");

        break;

    default:

        qDebug() <<"QGLFramebufferObject: An undefined error has occurred: "<< status;

        break;

    }

    return false;

}

void QGLFramebufferObjectPrivate::init(QGLFramebufferObject *q, const QSize &sz,

                                       QGLFramebufferObject::Attachment attachment,

                                       GLenum texture_target, GLenum internal_format, GLint samples)

{

    QGLContext *ctx = const_cast<QGLContext *>(QGLContext::currentContext());

    fbo_guard.setContext(ctx);

    bool ext_detected = (QGLExtensions::glExtensions & QGLExtensions::FramebufferObject);

    if (!ext_detected || (ext_detected && !qt_resolve_framebufferobject_extensions(ctx)))

        return;

    size = sz;

    target = texture_target;

    // texture dimensions

    QT_RESET_GLERROR(); // reset error state

    GLuint fbo = 0;

    glGenFramebuffers(1, &fbo);

    glBindFramebuffer(GL_FRAMEBUFFER_EXT, fbo);

    fbo_guard.setId(fbo);

    glDevice.setFBO(q, attachment);

    QT_CHECK_GLERROR();

    // init texture

    if (samples == 0) {

        glGenTextures(1, &texture);

        glBindTexture(target, texture);

        glTexImage2D(target, 0, internal_format, size.width(), size.height(), 0,

                GL_RGBA, GL_UNSIGNED_BYTE, NULL);

#ifndef QT_OPENGL_ES

        glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

        glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

        glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

        glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

#else

        glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

        glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

        glTexParameterf(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

        glTexParameterf(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

#endif

        glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,

                target, texture, 0);

        QT_CHECK_GLERROR();

        valid = checkFramebufferStatus();

        glBindTexture(target, 0);

        color_buffer = 0;

    } else {

        GLint maxSamples;

        glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSamples);

        samples = qBound(1, int(samples), int(maxSamples));

        glGenRenderbuffers(1, &color_buffer);

        glBindRenderbuffer(GL_RENDERBUFFER_EXT, color_buffer);

        if (glRenderbufferStorageMultisampleEXT) {

            glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,

                internal_format, size.width(), size.height());

        } else {

            samples = 0;

            glRenderbufferStorage(GL_RENDERBUFFER_EXT, internal_format,

                size.width(), size.height());

        }

        glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,

                                     GL_RENDERBUFFER_EXT, color_buffer);

        QT_CHECK_GLERROR();

        valid = checkFramebufferStatus();

        if (valid)

            glGetRenderbufferParameteriv(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_SAMPLES_EXT, &samples);

    }

    if (attachment == QGLFramebufferObject::CombinedDepthStencil

        && (QGLExtensions::glExtensions & QGLExtensions::PackedDepthStencil)) {

        // depth and stencil buffer needs another extension

        glGenRenderbuffers(1, &depth_stencil_buffer);

        Q_ASSERT(!glIsRenderbuffer(depth_stencil_buffer));

        glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth_stencil_buffer);

        Q_ASSERT(glIsRenderbuffer(depth_stencil_buffer));

        if (samples != 0 && glRenderbufferStorageMultisampleEXT)

            glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, samples,

                GL_DEPTH24_STENCIL8_EXT, size.width(), size.height());

        else

            glRenderbufferStorage(GL_RENDERBUFFER_EXT,

                GL_DEPTH24_STENCIL8_EXT, size.width(), size.height());

        GLint i = 0;

        glGetRenderbufferParameteriv(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_DEPTH_SIZE_EXT, &i);

        glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,

                                     GL_RENDERBUFFER_EXT, depth_stencil_buffer);

        glFramebufferRenderbuffer(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT,

                                     GL_RENDERBUFFER_EXT, depth_stencil_buffer);

        fbo_attachment = QGLFramebufferObject::CombinedDepthStencil;

        valid = checkFramebufferStatus();

        if (!valid)

            glDeleteRenderbuffers(1, &depth_stencil_buffer);

    } else if (attachment == QGLFramebufferObject::Depth

               || attachment == QGLFramebufferObject::CombinedDepthStencil)

    {