GLSLShader.cc

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *      Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen      *
 *                           www.openflipper.org                             *
 *                                                                           *
 *---------------------------------------------------------------------------*
 *  This file is part of OpenFlipper.                                        *
 *                                                                           *
 *  OpenFlipper is free software: you can redistribute it and/or modify      *
 *  it under the terms of the GNU Lesser General Public License as           *
 *  published by the Free Software Foundation, either version 3 of           *
 *  the License, or (at your option) any later version with the              *
 *  following exceptions:                                                    *
 *                                                                           *
 *  If other files instantiate templates or use macros                       *
 *  or inline functions from this file, or you compile this file and         *
 *  link it with other files to produce an executable, this file does        *
 *  not by itself cause the resulting executable to be covered by the        *
 *  GNU Lesser General Public License. This exception does not however       *
 *  invalidate any other reasons why the executable file might be            *
 *  covered by the GNU Lesser General Public License.                        *
 *                                                                           *
 *  OpenFlipper is distributed in the hope that it will be useful,           *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
 *  GNU Lesser General Public License for more details.                      *
 *                                                                           *
 *  You should have received a copy of the GNU LesserGeneral Public          *
 *  License along with OpenFlipper. If not,                                  *
 *  see <http://www.gnu.org/licenses/>.                                      *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision: 6743 $                                                       *
 *   $Author: moebius $                                                      *
 *   $Date: 2009-08-05 11:03:10 +0200 (Mi, 05. Aug 2009) $                   *
 *                                                                           *
\*===========================================================================*/

/*******************************************************************************
 * GLSLShader.h
 *
 * Utility classes for GLSL shaders.
 *
 * (C)2007
 * Lehrstuhl I8 RWTH-Aachen, http://www-i8.informatik.rwth-aachen.de
 * Author: Markus Tavenrath <speedygoo@speedygoo.de>
 *
 ******************************************************************************/

//==============================================================================

#include <QApplication>
#include <QDir>
#include <QString>

#include <iostream>
#include <cassert>
#include <sstream>
#include <fstream>

#include <../GL/gl.hh>

#include "gldebug.h"
#include "GLSLShader.hh"

#ifdef WIN32
#define snprintf sprintf_s
#endif

//==============================================================================

namespace GLSL {

    //--------------------------------------------------------------------------
    // Generic shader
    //--------------------------------------------------------------------------

    Shader::Shader(GLenum shaderType)
        : m_shaderId(0)
    {
        this->m_shaderId = glCreateShader(shaderType);
        assert(this->m_shaderId && "could not create shader");
    }

    Shader::~Shader()
    {
        if (this->m_shaderId) {
            glDeleteShader(m_shaderId);
        }
    }

    void Shader::setSource(StringList source)
    {
        assert(this->m_shaderId && "shader not initialized");

        const char **stringArray = new const char*[source.size()];

        int index = 0;
        for (StringList::const_iterator it = source.begin();it != source.end();++it) {
            stringArray[index] = (*it).c_str();
            ++index;
        }

        glShaderSource(this->m_shaderId, source.size(), stringArray, 0);

        delete[] stringArray;
    }

    bool Shader::compile()
    {
        assert(this->m_shaderId && "shader not initialized");

        glCompileShader(this->m_shaderId);

        GLint compileStatus;
        glGetShaderiv(this->m_shaderId, GL_COMPILE_STATUS, &compileStatus);
        if (compileStatus == GL_FALSE) {
            GLchar *errorLog = new GLchar[GLSL_MAX_LOGSIZE];
            GLsizei errorLength;
            char shaderSource[32768];
            glGetShaderSource(this->m_shaderId, 32768, &errorLength, shaderSource);
            std::cout << "shader source: " << std::endl << shaderSource << std::endl;
            glGetShaderInfoLog(this->m_shaderId, GLSL_MAX_LOGSIZE, &errorLength, errorLog);
            std::cout << "GLSL compile error:" << std::endl << errorLog << std::endl;
            delete[] errorLog;

            return false;
        }
        return true;
    }

    //--------------------------------------------------------------------------
    // Vertex shader
    //--------------------------------------------------------------------------

    VertexShader::VertexShader() : Shader(GL_VERTEX_SHADER) {}
    VertexShader::~VertexShader() {}

    //--------------------------------------------------------------------------
    // Fragment shader
    //--------------------------------------------------------------------------

    FragmentShader::FragmentShader() : Shader(GL_FRAGMENT_SHADER) {}
    FragmentShader::~FragmentShader() {}

    //--------------------------------------------------------------------------
    // Shader program object
    //--------------------------------------------------------------------------

    Program::Program()
    {
        this->m_programId = glCreateProgram();
        assert(this->m_programId && "could not create GLSL program");
    }

    Program::~Program()
    {
        if (this->m_programId) {
            glDeleteProgram(this->m_programId);
        }
        // free linked shaders
        this->m_linkedShaders.clear();
    }

    void
    Program::attach(PtrConstShader shader)
    {
        assert(this->m_programId && "attach invalid program");
        assert(shader->m_shaderId && "attach invalid shader");

        glAttachShader(this->m_programId, shader->m_shaderId);
        m_linkedShaders.push_back(shader);
    }

    void Program::detach(PtrConstShader shader)
    {
        assert(this->m_programId && "detach invalid program");
        assert(shader->m_shaderId && "detach invalid shader");

        glDetachShader(this->m_programId, shader->m_shaderId);
        m_linkedShaders.remove(shader);
    }

    void Program::link()
    {
        glLinkProgram(this->m_programId);
        checkGLError2("link program failed");
    }

    void Program::use()
    {
        glUseProgram(this->m_programId);
        checkGLError2("use program failed");
    }

    void Program::disable() {
        glUseProgram(0);
        checkGLError2("shader disable failed");
    }

    bool Program::isActive()
    {
        GLint programId;
        glGetIntegerv(GL_CURRENT_PROGRAM, &programId);
        return programId == this->m_programId;
    }

    void Program::setUniform(const char *name, GLint value)
    {
        checkGLError();
        GLint location = glGetUniformLocation(this->m_programId, name);
        checkGLError2(name);
        glUniform1i(location, value);
        checkGLError2(name);
    }

    void Program::setUniform(const char *name, GLfloat value)
    {
        checkGLError2("prev opengl error");
        GLint location = glGetUniformLocation(this->m_programId, name);
        checkGLError2(name);
        glUniform1f(location, value);
        checkGLError2(name);
    }

    void Program::setUniform(const char *name, const ACG::Vec3f &value)
    {
        checkGLError();
        GLint location = glGetUniformLocation(this->m_programId, name);
        checkGLError2(name);
        glUniform3fv(location, 1, value.data());
        checkGLError();
    }

    void Program::setUniform(const char *name, GLint *values, int count)
    {
        checkGLError();
        GLint location = glGetUniformLocation(this->m_programId, name);
        checkGLError2(name);
        glUniform1iv(location, count, values);
        checkGLError();
    }

    void Program::setUniform(const char *name, int index, bool value)
    {
        char varName[1024];
        snprintf(varName, 1024, "%s[%d]", name, index);
        setUniform(varName, (GLint) value);
    }

    void Program::setUniform(const char *name, int index, int value)
    {
        char varName[1024];
        snprintf(varName, 1024, "%s[%d]", name, index);
        setUniform(varName, (GLint) value);
    }

    void Program::setUniform(const char *name, int index, float value)
    {
        char varName[1024];
        snprintf(varName, 1024, "%s[%d]", name, index);
        setUniform(varName, value);
    }

    void Program::bindAttributeLocation(unsigned int index, const char *name) {
        glBindAttribLocation(this->m_programId, index, name);
        checkGLError2(name);
    }

    int Program::getAttributeLocation(const char *name) {
        int attributeLocation = glGetAttribLocationARB(this->m_programId, name);
        checkGLError2(name);
        return attributeLocation;
    }

    int Program::getUniformLocation(const char *name) {
        int attributeLocation = glGetUniformLocationARB(this->m_programId, name);
        checkGLError2(name);
        return attributeLocation;
    }

    GLSL::StringList loadShader(const char *filename)
    {
        QString path_file;
        if (QDir(filename).isRelative()) {
            path_file = qApp->applicationDirPath() + QString("/../shader/")
                + QString(filename);
        } else {
            path_file = QString::fromAscii(filename);
        }
        std::ifstream iShader(path_file.toAscii());
        if (!iShader) {
            std::cout << "ERROR: Could not open file " << path_file.toStdString() << std::endl;
            return GLSL::StringList();
        }

        GLSL::StringList shaderSource;

        while (!iShader.eof()) {
            std::string strLine;
            std::getline(iShader, strLine);
            strLine += "\n";
            shaderSource.push_back(strLine);
        }
        iShader.close();
        return shaderSource;
    }

    GLSL::PtrVertexShader loadVertexShader(const char *name)
    {
        PtrVertexShader vertexShader = 0;
        StringList sourceVertex = loadShader(name);

        if (sourceVertex.size() != 0) {
            vertexShader = GLSL::PtrVertexShader(new GLSL::VertexShader());
            vertexShader->setSource(sourceVertex);
            vertexShader->compile();
        }
        return vertexShader;
    }

    GLSL::PtrFragmentShader loadFragmentShader(const char *name)
    {
        PtrFragmentShader fragmentShader = 0;
        StringList sourceVertex = loadShader(name);

        if (sourceVertex.size() != 0) {
            fragmentShader = GLSL::PtrFragmentShader(new GLSL::FragmentShader());
            fragmentShader->setSource(sourceVertex);
            fragmentShader->compile();
        }
        return fragmentShader;
    }

}


//==============================================================================

// Local Variables:
// mode: C++
// c-basic-offset: 4
// indent-tabs-mode: nil
// End:

//==============================================================================