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

**

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

#include "qglextensions_p.h"

#include "qgl_p.h"

#include <QtCore/private/qobject_p.h>

#include <QtCore/qdebug.h>

#include <QtCore/qfile.h>

#include <QtCore/qvarlengtharray.h>

#include <QtCore/qvector.h>

QT_BEGIN_NAMESPACE

/*!

    \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::bind():

    \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 Binary shaders and programs

    Binary shaders may be specified using \c{glShaderBinary()} on

    the return value from QGLShader::shaderId().  The QGLShader instance

    containing the binary can then be added to the shader program with

    addShader() and linked in the usual fashion with link().

    Binary programs may be specified using \c{glProgramBinaryOES()}

    on the return value from programId().  Then the application should

    call link(), which will notice that the program has already been

    specified and linked, allowing other operations to be performed

    on the shader 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::ShaderTypeBit

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

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

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

*/

#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 QObjectPrivate

{

    Q_DECLARE_PUBLIC(QGLShader)

public:

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

        : shaderGuard(context)

        , shaderType(type)

        , compiled(false)

    {

    }

    ~QGLShaderPrivate();

    QGLSharedResourceGuard shaderGuard;

    QGLShader::ShaderType shaderType;

    bool compiled;

    QString log;

    bool create();

    bool compile(QGLShader *q);

    void deleteShader();

};

#define ctx shaderGuard.context()

QGLShaderPrivate::~QGLShaderPrivate()

{

    if (shaderGuard.id()) {

        QGLShareContextScope scope(shaderGuard.context());

        glDeleteShader(shaderGuard.id());

    }

}

bool QGLShaderPrivate::create()

{

    const QGLContext *context = shaderGuard.context();

    if (!context)

        return false;

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

        GLuint shader;

        if (shaderType == QGLShader::Vertex)

            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)

{

    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::hasOpenGLShaderPrograms() will return false.

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

    or compileSourceFile().

    The shader will be associated with the current QGLContext.

    \sa compileSourceCode(), compileSourceFile()

*/

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

    : QObject(*new QGLShaderPrivate(QGLContext::currentContext(), type), parent)

{

    Q_D(QGLShader);

    d->create();

}

/*!

    Constructs a new QGLShader object of the specified \a type

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

    then QGLShaderProgram::hasOpenGLShaderPrograms() will return false.

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

    or compileSourceFile().

    The shader will be associated with \a context.

    \sa compileSourceCode(), compileSourceFile()

*/

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

    : QObject(*new QGLShaderPrivate(context ? context : QGLContext::currentContext(), type), parent)

{

    Q_D(QGLShader);

#ifndef QT_NO_DEBUG

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

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

        return;

    }

#endif

    d->create();

}

/*!

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

{

}

/*!

    Returns the type of this shader.

*/

QGLShader::ShaderType QGLShader::shaderType() const

{

    Q_D(const QGLShader);

    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.

    \sa compileSourceFile()

*/

bool QGLShader::compileSourceCode(const char *source)

{

    Q_D(QGLShader);

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

        QVarLengthArray<const char *, 4> src;

        QVarLengthArray<GLint, 4> srclen;

        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;

        }

        if (headerLen > 0) {

            src.append(source);

            srclen.append(GLint(headerLen));

        }

#ifdef QGL_DEFINE_QUALIFIERS

        src.append(qualifierDefines);

        srclen.append(GLint(sizeof(qualifierDefines) - 1));

#endif

#ifdef QGL_REDEFINE_HIGHP

        if (d->shaderType == Fragment) {

            src.append(redefineHighp);

            srclen.append(GLint(sizeof(redefineHighp) - 1));

        }

#endif

        src.append(source + headerLen);

        srclen.append(GLint(qstrlen(source + headerLen)));

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

        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.

    \sa compileSourceFile()

*/

bool QGLShader::compileSourceCode(const QByteArray& source)

{

    return compileSourceCode(source.constData());

}

/*!

    \overload

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

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

    \sa compileSourceFile()

*/

bool QGLShader::compileSourceCode(const QString& source)

{

    return compileSourceCode(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.

    \sa compileSourceCode()

*/

bool QGLShader::compileSourceFile(const QString& fileName)

{

    QFile file(fileName);

    if (!file.open(QFile::ReadOnly)) {

        qWarning() << "QGLShader: Unable to open file" << fileName;

        return false;

    }

    QByteArray contents = file.readAll();

    return compileSourceCode(contents.constData());

}

/*!

    Returns the source code for this shader.

    \sa compileSourceCode()

*/

QByteArray QGLShader::sourceCode() const

{

    Q_D(const QGLShader);

    GLuint shader = d->shaderGuard.id();

    if (!shader)

        return QByteArray();

    GLint size = 0;

    glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &size);

    if (size <= 0)

        return QByteArray();

    GLint len = 0;

    char *source = new char [size];

    glGetShaderSource(shader, size, &len, source);

    QByteArray src(source);

    delete [] source;

    return src;

}

/*!

    Returns true if this shader has been compiled; false otherwise.

    \sa compileSourceCode(), compileSourceFile()

*/

bool QGLShader::isCompiled() const

{

    Q_D(const QGLShader);

    return d->compiled;

}

/*!

    Returns the errors and warnings that occurred during the last compile.

    \sa compileSourceCode(), compileSourceFile()

*/

QString QGLShader::log() const

{

    Q_D(const QGLShader);

    return d->log;

}

/*!

    Returns the OpenGL identifier associated with this shader.

    \sa QGLShaderProgram::programId()

*/

GLuint QGLShader::shaderId() const

{

    Q_D(const QGLShader);

    return d->shaderGuard.id();

}