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

**

** 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 "qapplication.h"

#include "qplatformdefs.h"

#include "qgl.h"

#include <qdebug.h>

#if defined(Q_WS_X11)

#include "private/qt_x11_p.h"

#include "private/qpixmap_x11_p.h"

#define INT32 dummy_INT32

#define INT8 dummy_INT8

#if !defined(QT_OPENGL_ES)

# include <GL/glx.h>

#endif

#undef INT32

#undef INT8

#include "qx11info_x11.h"

#elif defined(Q_WS_MAC)

# include <private/qt_mac_p.h>

#endif

#include <qdatetime.h>

#include <stdlib.h> // malloc

#include "qpixmap.h"

#include "qimage.h"

#include "qgl_p.h"

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

#include "gl2paintengineex/qpaintengineex_opengl2_p.h"

#endif

#ifndef QT_OPENGL_ES_2

#include <private/qpaintengine_opengl_p.h>

#endif

#ifdef Q_WS_QWS

#include <private/qglwindowsurface_qws_p.h>

#endif

#include <qglpixelbuffer.h>

#include <qglframebufferobject.h>

#include <private/qimage_p.h>

#include <private/qpixmapdata_p.h>

#include <private/qpixmapdata_gl_p.h>

#include <private/qglpixelbuffer_p.h>

#include <private/qwindowsurface_gl_p.h>

#include <private/qimagepixmapcleanuphooks_p.h>

#include "qcolormap.h"

#include "qfile.h"

#include "qlibrary.h"

QT_BEGIN_NAMESPACE

#ifdef QT_OPENGL_ES_1_CL

#include "qgl_cl_p.h"

#endif

#if defined(Q_WS_X11) || defined(Q_WS_MAC) || defined(Q_WS_QWS)

QGLExtensionFuncs QGLContextPrivate::qt_extensionFuncs;

#endif

#ifdef Q_WS_X11

extern const QX11Info *qt_x11Info(const QPaintDevice *pd);

#endif

struct QGLThreadContext {

    QGLContext *context;

};

static QThreadStorage<QGLThreadContext *> qgl_context_storage;

Q_GLOBAL_STATIC(QGLFormat, qgl_default_format)

class QGLDefaultOverlayFormat: public QGLFormat

{

public:

    inline QGLDefaultOverlayFormat()

    {

        setOption(QGL::FormatOption(0xffff << 16)); // turn off all options

        setOption(QGL::DirectRendering);

        setPlane(1);

    }

};

Q_GLOBAL_STATIC(QGLDefaultOverlayFormat, defaultOverlayFormatInstance)

Q_GLOBAL_STATIC(QGLSignalProxy, theSignalProxy)

QGLSignalProxy *QGLSignalProxy::instance()

{

    return theSignalProxy();

}

class QGLEngineSelector

{

public:

    QGLEngineSelector() : engineType(QPaintEngine::MaxUser)

    {

    }

    void setPreferredPaintEngine(QPaintEngine::Type type) {

        if (type == QPaintEngine::OpenGL || type == QPaintEngine::OpenGL2)

            engineType = type;

    }

    QPaintEngine::Type preferredPaintEngine() {

#ifdef Q_WS_MAC

        // The ATI X1600 driver for Mac OS X does not support return

        // values from functions in GLSL. Since working around this in

        // the GL2 engine would require a big, ugly rewrite, we're

        // falling back to the GL 1 engine..

        static bool mac_x1600_check_done = false;

        if (!mac_x1600_check_done) {

            QGLTemporaryContext *tmp = 0;

            if (!QGLContext::currentContext())

                tmp = new QGLTemporaryContext();

            if (strstr((char *) glGetString(GL_RENDERER), "X1600"))

                engineType = QPaintEngine::OpenGL;

            if (tmp)

                delete tmp;

            mac_x1600_check_done = true;

        }

#endif

        if (engineType == QPaintEngine::MaxUser) {

            // No user-set engine - use the defaults

#if defined(QT_OPENGL_ES_2)

            engineType = QPaintEngine::OpenGL2;

#else

            // We can't do this in the constructor for this object because it

            // needs to be called *before* the QApplication constructor.

            // Also check for the FragmentShader extension in conjunction with

            // the 2.0 version flag, to cover the case where we export the display

            // from an old GL 1.1 server to a GL 2.x client. In that case we can't

            // use GL 2.0.

            if ((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_2_0)

                && (QGLExtensions::glExtensions() & QGLExtensions::FragmentShader)

                && qgetenv("QT_GL_USE_OPENGL1ENGINE").isEmpty())

                engineType = QPaintEngine::OpenGL2;

            else

                engineType = QPaintEngine::OpenGL;

#endif

        }

        return engineType;

    }

private:

    QPaintEngine::Type engineType;

};

Q_GLOBAL_STATIC(QGLEngineSelector, qgl_engine_selector)

bool qt_gl_preferGL2Engine()

{

    return qgl_engine_selector()->preferredPaintEngine() == QPaintEngine::OpenGL2;

}

/*!

    \namespace QGL

    \inmodule QtOpenGL

    \brief The QGL namespace specifies miscellaneous identifiers used

    in the Qt OpenGL module.

    \ingroup painting-3D

*/

/*!

    \enum QGL::FormatOption

    This enum specifies the format options that can be used to configure an OpenGL

    context. These are set using QGLFormat::setOption().

    \value DoubleBuffer      Specifies the use of double buffering.

    \value DepthBuffer       Enables the use of a depth buffer.

    \value Rgba              Specifies that the context should use RGBA as its pixel format.

    \value AlphaChannel      Enables the use of an alpha channel.

    \value AccumBuffer       Enables the use of an accumulation buffer.

    \value StencilBuffer     Enables the use of a stencil buffer.

    \value StereoBuffers     Enables the use of a stereo buffers for use with visualization hardware.

    \value DirectRendering   Specifies that the context is used for direct rendering to a display.

    \value HasOverlay        Enables the use of an overlay.

    \value SampleBuffers     Enables the use of sample buffers.

    \value SingleBuffer      Specifies the use of a single buffer, as opposed to double buffers.

    \value NoDepthBuffer     Disables the use of a depth buffer.

    \value ColorIndex        Specifies that the context should use a color index as its pixel format.

    \value NoAlphaChannel    Disables the use of an alpha channel.

    \value NoAccumBuffer     Disables the use of an accumulation buffer.

    \value NoStencilBuffer   Disables the use of a stencil buffer.

    \value NoStereoBuffers   Disables the use of stereo buffers.

    \value IndirectRendering Specifies that the context is used for indirect rendering to a buffer.

    \value NoOverlay         Disables the use of an overlay.

    \value NoSampleBuffers   Disables the use of sample buffers.

    \sa {Sample Buffers Example}

*/

/*!

   \fn void QGL::setPreferredPaintEngine(QPaintEngine::Type engineType)

   \since 4.6

   Sets the preferred OpenGL paint engine that is used to draw onto

   QGLWidget, QGLPixelBuffer and QGLFramebufferObject targets with QPainter

   in Qt.

   The \a engineType parameter specifies which of the GL engines to

   use. Only \c QPaintEngine::OpenGL and \c QPaintEngine::OpenGL2 are

   valid parameters to this function. All other values are ignored.

   By default, the \c QPaintEngine::OpenGL2 engine is used if GL/GLES

   version 2.0 is available, otherwise \c QPaintEngine::OpenGL is

   used.

   \warning This function must be called before the QApplication

   constructor is called.

*/

void QGL::setPreferredPaintEngine(QPaintEngine::Type engineType)

{

    qgl_engine_selector()->setPreferredPaintEngine(engineType);

}

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

  QGLFormat implementation

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

/*!

    \class QGLFormat

    \brief The QGLFormat class specifies the display format of an OpenGL

    rendering context.

    \ingroup painting-3D

    A display format has several characteristics:

    \list

    \i \link setDoubleBuffer() Double or single buffering.\endlink

    \i \link setDepth() Depth buffer.\endlink

    \i \link setRgba() RGBA or color index mode.\endlink

    \i \link setAlpha() Alpha channel.\endlink

    \i \link setAccum() Accumulation buffer.\endlink

    \i \link setStencil() Stencil buffer.\endlink

    \i \link setStereo() Stereo buffers.\endlink

    \i \link setDirectRendering() Direct rendering.\endlink

    \i \link setOverlay() Presence of an overlay.\endlink

    \i \link setPlane() Plane of an overlay.\endlink

    \i \link setSampleBuffers() Multisample buffers.\endlink

    \endlist

    You can also specify preferred bit depths for the color buffer,

    depth buffer, alpha buffer, accumulation buffer and the stencil

    buffer with the functions: setRedBufferSize(), setGreenBufferSize(),

    setBlueBufferSize(), setDepthBufferSize(), setAlphaBufferSize(),

    setAccumBufferSize() and setStencilBufferSize().

    Note that even if you specify that you prefer a 32 bit depth

    buffer (e.g. with setDepthBufferSize(32)), the format that is

    chosen may not have a 32 bit depth buffer, even if there is a

    format available with a 32 bit depth buffer. The main reason for

    this is how the system dependant picking algorithms work on the

    different platforms, and some format options may have higher

    precedence than others.

    You create and tell a QGLFormat object what rendering options you

    want from an OpenGL rendering context.

    OpenGL drivers or accelerated hardware may or may not support

    advanced features such as alpha channel or stereographic viewing.

    If you request some features that the driver/hardware does not

    provide when you create a QGLWidget, you will get a rendering

    context with the nearest subset of features.

    There are different ways to define the display characteristics of

    a rendering context. One is to create a QGLFormat and make it the

    default for the entire application:

    \snippet doc/src/snippets/code/src_opengl_qgl.cpp 0

    Or you can specify the desired format when creating an object of

    your QGLWidget subclass:

    \snippet doc/src/snippets/code/src_opengl_qgl.cpp 1

    After the widget has been created, you can find out which of the

    requested features the system was able to provide:

    \snippet doc/src/snippets/code/src_opengl_qgl.cpp 2

    \legalese

        OpenGL is a trademark of Silicon Graphics, Inc. in the

        United States and other countries.

    \endlegalese

    \sa QGLContext, QGLWidget

*/

#ifndef QT_OPENGL_ES

static inline void transform_point(GLdouble out[4], const GLdouble m[16], const GLdouble in[4])

{

#define M(row,col)  m[col*4+row]

    out[0] =

        M(0, 0) * in[0] + M(0, 1) * in[1] + M(0, 2) * in[2] + M(0, 3) * in[3];

    out[1] =

        M(1, 0) * in[0] + M(1, 1) * in[1] + M(1, 2) * in[2] + M(1, 3) * in[3];

    out[2] =

        M(2, 0) * in[0] + M(2, 1) * in[1] + M(2, 2) * in[2] + M(2, 3) * in[3];

    out[3] =

        M(3, 0) * in[0] + M(3, 1) * in[1] + M(3, 2) * in[2] + M(3, 3) * in[3];

#undef M

}

static inline GLint qgluProject(GLdouble objx, GLdouble objy, GLdouble objz,

           const GLdouble model[16], const GLdouble proj[16],

           const GLint viewport[4],

           GLdouble * winx, GLdouble * winy, GLdouble * winz)

{

   GLdouble in[4], out[4];

   in[0] = objx;

   in[1] = objy;

   in[2] = objz;

   in[3] = 1.0;

   transform_point(out, model, in);

   transform_point(in, proj, out);

   if (in[3] == 0.0)

      return GL_FALSE;

   in[0] /= in[3];

   in[1] /= in[3];

   in[2] /= in[3];

   *winx = viewport[0] + (1 + in[0]) * viewport[2] / 2;

   *winy = viewport[1] + (1 + in[1]) * viewport[3] / 2;

   *winz = (1 + in[2]) / 2;

   return GL_TRUE;

}

#endif // !QT_OPENGL_ES

/*!

    Constructs a QGLFormat object with the following default settings:

    \list

    \i \link setDoubleBuffer() Double buffer:\endlink Enabled.

    \i \link setDepth() Depth buffer:\endlink Enabled.

    \i \link setRgba() RGBA:\endlink Enabled (i.e., color index disabled).

    \i \link setAlpha() Alpha channel:\endlink Disabled.

    \i \link setAccum() Accumulator buffer:\endlink Disabled.

    \i \link setStencil() Stencil buffer:\endlink Enabled.

    \i \link setStereo() Stereo:\endlink Disabled.

    \i \link setDirectRendering() Direct rendering:\endlink Enabled.

    \i \link setOverlay() Overlay:\endlink Disabled.

    \i \link setPlane() Plane:\endlink 0 (i.e., normal plane).

    \i \link setSampleBuffers() Multisample buffers:\endlink Disabled.

    \endlist

*/

QGLFormat::QGLFormat()

{

    d = new QGLFormatPrivate;

}

/*!

    Creates a QGLFormat object that is a copy of the current

    defaultFormat().

    If \a options is not 0, the default format is modified by the

    specified format options. The \a options parameter should be

    QGL::FormatOption values OR'ed together.

    This constructor makes it easy to specify a certain desired format

    in classes derived from QGLWidget, for example:

    \snippet doc/src/snippets/code/src_opengl_qgl.cpp 3

    Note that there are QGL::FormatOption values to turn format settings

    both on and off, e.g. QGL::DepthBuffer and QGL::NoDepthBuffer,

    QGL::DirectRendering and QGL::IndirectRendering, etc.

    The \a plane parameter defaults to 0 and is the plane which this

    format should be associated with. Not all OpenGL implementations

    supports overlay/underlay rendering planes.

    \sa defaultFormat(), setOption(), setPlane()

*/

QGLFormat::QGLFormat(QGL::FormatOptions options, int plane)

{

    d = new QGLFormatPrivate;

    QGL::FormatOptions newOpts = options;

    d->opts = defaultFormat().d->opts;

    d->opts |= (newOpts & 0xffff);

    d->opts &= ~(newOpts >> 16);

    d->pln = plane;

}

/*!

    \internal

*/

void QGLFormat::detach()

{

    if (d->ref != 1) {

        QGLFormatPrivate *newd = new QGLFormatPrivate(d);

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

            delete d;

        d = newd;

    }

}

/*!

    Constructs a copy of \a other.

*/

QGLFormat::QGLFormat(const QGLFormat &other)

{

    d = other.d;

    d->ref.ref();

}

/*!

    Assigns \a other to this object.

*/

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

{

    if (d != other.d) {

        other.d->ref.ref();

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

            delete d;

        d = other.d;

    }

    return *this;

}

/*!

    Destroys the QGLFormat.

*/

QGLFormat::~QGLFormat()

{

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

        delete d;

}

/*!

    \fn bool QGLFormat::doubleBuffer() const

    Returns true if double buffering is enabled; otherwise returns

    false. Double buffering is enabled by default.

    \sa setDoubleBuffer()

*/

/*!

    If \a enable is true sets double buffering; otherwise sets single

    buffering.

    Double buffering is enabled by default.

    Double buffering is a technique where graphics are rendered on an

    off-screen buffer and not directly to the screen. When the drawing

    has been completed, the program calls a swapBuffers() function to

    exchange the screen contents with the buffer. The result is

    flicker-free drawing and often better performance.

    \sa doubleBuffer(), QGLContext::swapBuffers(),

    QGLWidget::swapBuffers()

*/

void QGLFormat::setDoubleBuffer(bool enable)

{

    setOption(enable ? QGL::DoubleBuffer : QGL::SingleBuffer);

}

/*!

    \fn bool QGLFormat::depth() const

    Returns true if the depth buffer is enabled; otherwise returns

    false. The depth buffer is enabled by default.

    \sa setDepth(), setDepthBufferSize()