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

**

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

#include "qglextensions_p.h"

#include "qgl_p.h"

#include <QtCore/qdebug.h>

#include <QtCore/qfile.h>

#include <QtCore/qvarlengtharray.h>

#include <QtCore/qvector.h>

QT_BEGIN_NAMESPACE

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

/*!

    \class QGLShaderProgram

    \brief The QGLShaderProgram class allows OpenGL shader programs to be linked and used.

    \since 4.6

    \ingroup painting-3D

    \section1 Introduction

    This class supports shader programs written in the OpenGL Shading

    Language (GLSL) and in the OpenGL/ES Shading Language (GLSL/ES).

    QGLShader and QGLShaderProgram shelter the programmer from the details of

    compiling and linking vertex and fragment shaders.

    The following example creates a vertex shader program using the

    supplied source \c{code}.  Once compiled and linked, the shader

    program is activated in the current QGLContext by calling

    QGLShaderProgram::enable():

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

    \section1 Writing portable shaders

    Shader programs can be difficult to reuse across OpenGL implementations

    because of varying levels of support for standard vertex attributes and

    uniform variables.  In particular, GLSL/ES lacks all of the

    standard variables that are present on desktop OpenGL systems:

    \c{gl_Vertex}, \c{gl_Normal}, \c{gl_Color}, and so on.  Desktop OpenGL

    lacks the variable qualifiers \c{highp}, \c{mediump}, and \c{lowp}.

    The QGLShaderProgram class makes the process of writing portable shaders

    easier by prefixing all shader programs with the following lines on

    desktop OpenGL:

    \code

    #define highp

    #define mediump

    #define lowp

    \endcode

    This makes it possible to run most GLSL/ES shader programs

    on desktop systems.  The programmer should restrict themselves

    to just features that are present in GLSL/ES, and avoid

    standard variable names that only work on the desktop.

    \section1 Simple shader example

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

    With the above shader program active, we can draw a green triangle

    as follows:

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

    \section1 Partial shaders

    Desktop GLSL can attach an arbitrary number of vertex and fragment

    shaders to a shader program.  Embedded GLSL/ES on the other hand

    supports only a single shader of each type on a shader program.

    Multiple shaders of the same type can be useful when large libraries

    of shaders are needed.  Common functions can be factored out into

    library shaders that can be reused in multiple shader programs.

    To support this use of shaders, the application programmer can

    create shaders with the QGLShader::PartialVertexShader and

    QGLShader::PartialFragmentShader types.  These types direct

    QGLShader and QGLShaderProgram to delay shader compilation until

    link time.

    When link() is called, the sources for the partial shaders are

    concatenated, and a single vertex or fragment shader is compiled

    and linked into the shader program.

    It is more efficient to use the QGLShader::VertexShader and

    QGLShader::FragmentShader when there is only one shader of that

    type in the program.

    \sa QGLShader

*/

/*!

    \class QGLShader

    \brief The QGLShader class allows OpenGL shaders to be compiled.

    \since 4.6

    \ingroup painting-3D

    This class supports shaders written in the OpenGL Shading Language (GLSL)

    and in the OpenGL/ES Shading Language (GLSL/ES).

    QGLShader and QGLShaderProgram shelter the programmer from the details of

    compiling and linking vertex and fragment shaders.

    \sa QGLShaderProgram

*/

/*!

    \enum QGLShader::ShaderTypeBits

    This enum specifies the type of QGLShader that is being created.

    \value VertexShader Vertex shader written in the OpenGL Shading Language (GLSL).

    \value FragmentShader Fragment shader written in the OpenGL Shading Language (GLSL).

    \value PartialVertexShader Partial vertex shader that will be concatenated with all other partial vertex shaders at link time.

    \value PartialFragmentShader Partial fragment shader that will be concatenated with all other partial fragment shaders at link time.

    \omitvalue PartialShader

*/

#ifndef GL_FRAGMENT_SHADER

#define GL_FRAGMENT_SHADER 0x8B30

#endif

#ifndef GL_VERTEX_SHADER

#define GL_VERTEX_SHADER 0x8B31

#endif

#ifndef GL_COMPILE_STATUS

#define GL_COMPILE_STATUS 0x8B81

#endif

#ifndef GL_LINK_STATUS

#define GL_LINK_STATUS 0x8B82

#endif

#ifndef GL_INFO_LOG_LENGTH

#define GL_INFO_LOG_LENGTH 0x8B84

#endif

#ifndef GL_ACTIVE_UNIFORMS

#define GL_ACTIVE_UNIFORMS 0x8B86

#endif

#ifndef GL_ACTIVE_UNIFORM_MAX_LENGTH

#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87

#endif

#ifndef GL_ACTIVE_ATTRIBUTES

#define GL_ACTIVE_ATTRIBUTES 0x8B89

#endif

#ifndef GL_ACTIVE_ATTRIBUTE_MAX_LENGTH

#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A

#endif

#ifndef GL_CURRENT_VERTEX_ATTRIB

#define GL_CURRENT_VERTEX_ATTRIB 0x8626

#endif

#ifndef GL_SHADER_SOURCE_LENGTH

#define GL_SHADER_SOURCE_LENGTH 0x8B88

#endif

#ifndef GL_SHADER_BINARY_FORMATS

#define GL_SHADER_BINARY_FORMATS          0x8DF8

#endif

#ifndef GL_NUM_SHADER_BINARY_FORMATS

#define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9

#endif

class QGLShaderPrivate

{

public:

    QGLShaderPrivate(const QGLContext *context, QGLShader::ShaderType type)

        : shaderGuard(context)

        , shaderType(type)

        , compiled(false)

        , isPartial((type & QGLShader::PartialShader) != 0)

        , hasPartialSource(false)

    {

    }

    QGLSharedResourceGuard shaderGuard;

    QGLShader::ShaderType shaderType;

    bool compiled;

    bool isPartial;

    bool hasPartialSource;

    QString log;

    QByteArray partialSource;

    bool create();

    bool compile(QGLShader *q);

    void deleteShader();

};

#define ctx shaderGuard.context()

bool QGLShaderPrivate::create()

{

    const QGLContext *context = shaderGuard.context();

    if (!context)

        return false;

    if (isPartial)

        return true;

    if (qt_resolve_glsl_extensions(const_cast<QGLContext *>(context))) {

        GLuint shader;

        if (shaderType == QGLShader::VertexShader)

            shader = glCreateShader(GL_VERTEX_SHADER);

        else

            shader = glCreateShader(GL_FRAGMENT_SHADER);

        if (!shader) {

            qWarning() << "QGLShader: could not create shader";

            return false;

        }

        shaderGuard.setId(shader);

        return true;

    } else {

        return false;

    }

}

bool QGLShaderPrivate::compile(QGLShader *q)

{

    // Partial shaders are compiled during QGLShaderProgram::link().

    if (isPartial && hasPartialSource) {

        compiled = true;

        return true;

    }

    GLuint shader = shaderGuard.id();

    if (!shader)

        return false;

    glCompileShader(shader);

    GLint value = 0;

    glGetShaderiv(shader, GL_COMPILE_STATUS, &value);

    compiled = (value != 0);

    value = 0;

    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &value);

    if (!compiled && value > 1) {

        char *logbuf = new char [value];

        GLint len;

        glGetShaderInfoLog(shader, value, &len, logbuf);

        log = QString::fromLatin1(logbuf);

        QString name = q->objectName();

        if (name.isEmpty())

            qWarning() << "QGLShader::compile:" << log;

        else

            qWarning() << "QGLShader::compile[" << name << "]:" << log;

        delete [] logbuf;

    }

    return compiled;

}

void QGLShaderPrivate::deleteShader()

{

    if (shaderGuard.id()) {

        glDeleteShader(shaderGuard.id());

        shaderGuard.setId(0);

    }

}

#undef ctx

#define ctx d->shaderGuard.context()

/*!

    Constructs a new QGLShader object of the specified \a type

    and attaches it to \a parent.  If shader programs are not supported,

    QGLShaderProgram::hasShaderPrograms() will return false.

    This constructor is normally followed by a call to compile()

    or compileFile().

    The shader will be associated with the current QGLContext.

    \sa compile(), compileFile()

*/

QGLShader::QGLShader(QGLShader::ShaderType type, QObject *parent)

    : QObject(parent)

{

    d = new QGLShaderPrivate(QGLContext::currentContext(), type);

    d->create();

}

/*!

    Constructs a new QGLShader object of the specified \a type from the

    source code in \a fileName and attaches it to \a parent.

    If the shader could not be loaded, then isCompiled() will return false.

    The shader will be associated with the current QGLContext.

    \sa isCompiled()

*/

QGLShader::QGLShader

        (const QString& fileName, QGLShader::ShaderType type, QObject *parent)

    : QObject(parent)

{

    d = new QGLShaderPrivate(QGLContext::currentContext(), type);

    if (d->create() && !compileFile(fileName))

        d->deleteShader();

}

/*!

    Constructs a new QGLShader object of the specified \a type

    and attaches it to \a parent.  If shader programs are not supported,

    then QGLShaderProgram::hasShaderPrograms() will return false.

    This constructor is normally followed by a call to compile()

    or compileFile().

    The shader will be associated with \a context.

    \sa compile(), compileFile()

*/

QGLShader::QGLShader(QGLShader::ShaderType type, const QGLContext *context, QObject *parent)

    : QObject(parent)

{

    if (!context)

        context = QGLContext::currentContext();

    d = new QGLShaderPrivate(context, type);

#ifndef QT_NO_DEBUG

    if (context && !QGLContext::areSharing(context, QGLContext::currentContext())) {

        qWarning("QGLShader::QGLShader: \'context\' must be the currect context or sharing with it.");

        return;

    }

#endif

    d->create();

}

/*!

    Constructs a new QGLShader object of the specified \a type from the

    source code in \a fileName and attaches it to \a parent.

    If the shader could not be loaded, then isCompiled() will return false.

    The shader will be associated with \a context.

    \sa isCompiled()

*/

QGLShader::QGLShader

        (const QString& fileName, QGLShader::ShaderType type, const QGLContext *context, QObject *parent)

    : QObject(parent)

{

    if (!context)

        context = QGLContext::currentContext();

    d = new QGLShaderPrivate(context, type);

#ifndef QT_NO_DEBUG

    if (context && !QGLContext::areSharing(context, QGLContext::currentContext())) {

        qWarning("QGLShader::QGLShader: \'context\' must be currect context or sharing with it.");

        return;

    }

#endif

    if (d->create() && !compileFile(fileName))

        d->deleteShader();

}

/*!

    Deletes this shader.  If the shader has been attached to a

    QGLShaderProgram object, then the actual shader will stay around

    until the QGLShaderProgram is destroyed.

*/

QGLShader::~QGLShader()

{

    if (d->shaderGuard.id()) {

        QGLShareContextScope scope(d->shaderGuard.context());

        glDeleteShader(d->shaderGuard.id());

    }

    delete d;

}

/*!

    Returns the type of this shader.

*/

QGLShader::ShaderType QGLShader::shaderType() const

{

    return d->shaderType;

}

// The precision qualifiers are useful on OpenGL/ES systems,

// but usually not present on desktop systems.  Define the

// keywords to empty strings on desktop systems.

#ifndef QT_OPENGL_ES

#define QGL_DEFINE_QUALIFIERS 1

static const char qualifierDefines[] =

    "#define lowp\n"

    "#define mediump\n"

    "#define highp\n";

#endif

// The "highp" qualifier doesn't exist in fragment shaders

// on all ES platforms.  When it doesn't exist, use "mediump".

#ifdef QT_OPENGL_ES

#define QGL_REDEFINE_HIGHP 1

static const char redefineHighp[] =

    "#ifndef GL_FRAGMENT_PRECISION_HIGH\n"

    "#define highp mediump\n"

    "#endif\n";

#endif

/*!

    Sets the \a source code for this shader and compiles it.

    Returns true if the source was successfully compiled, false otherwise.

    If shaderType() is PartialVertexShader or PartialFragmentShader,

    then this function will always return true, even if the source code

    is invalid.  Partial shaders are compiled when QGLShaderProgram::link()

    is called.

    \sa compileFile()

*/

bool QGLShader::compile(const char *source)

{

    if (d->isPartial) {

        d->partialSource = QByteArray(source);

        d->hasPartialSource = true;

        return d->compile(this);

    } else if (d->shaderGuard.id()) {

        QVarLengthArray<const char *> src;

        int headerLen = 0;

        while (source && source[headerLen] == '#') {

            // Skip #version and #extension directives at the start of

            // the shader code.  We need to insert the qualifierDefines

            // and redefineHighp just after them.

            if (qstrncmp(source + headerLen, "#version", 8) != 0 &&

                    qstrncmp(source + headerLen, "#extension", 10) != 0) {

                break;

            }

            while (source[headerLen] != '\0' && source[headerLen] != '\n')

                ++headerLen;

            if (source[headerLen] == '\n')

                ++headerLen;

        }

        QByteArray header;

        if (headerLen > 0) {

            header = QByteArray(source, headerLen);

            src.append(header.constData());

        }

#ifdef QGL_DEFINE_QUALIFIERS

        src.append(qualifierDefines);

#endif

#ifdef QGL_REDEFINE_HIGHP

        if (d->shaderType == FragmentShader ||

                d->shaderType == PartialFragmentShader)

            src.append(redefineHighp);

#endif

        src.append(source + headerLen);

        glShaderSource(d->shaderGuard.id(), src.size(), src.data(), 0);

        return d->compile(this);

    } else {

        return false;

    }

}

/*!

    \overload

    Sets the \a source code for this shader and compiles it.

    Returns true if the source was successfully compiled, false otherwise.

    If shaderType() is PartialVertexShader or PartialFragmentShader,

    then this function will always return true, even if the source code

    is invalid.  Partial shaders are compiled when QGLShaderProgram::link()

    is called.

    \sa compileFile()

*/

bool QGLShader::compile(const QByteArray& source)

{

    return compile(source.constData());

}

/*!

    \overload

    Sets the \a source code for this shader and compiles it.

    Returns true if the source was successfully compiled, false otherwise.

    If shaderType() is PartialVertexShader or PartialFragmentShader,

    then this function will always return true, even if the source code

    is invalid.  Partial shaders are compiled when QGLShaderProgram::link()

    is called.

    \sa compileFile()

*/

bool QGLShader::compile(const QString& source)

{

    return compile(source.toLatin1().constData());

}

/*!

    Sets the source code for this shader to the contents of \a fileName

    and compiles it.  Returns true if the file could be opened and the

    source compiled, false otherwise.

    If shaderType() is PartialVertexShader or PartialFragmentShader,

    then this function will always return true, even if the source code

    is invalid.  Partial shaders are compiled when QGLShaderProgram::link()

    is called.