shader.hpp

//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2014-2015 SuperTuxKart-Team
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef SERVER_ONLY
 
#ifndef HEADER_SHADER_HPP
#define HEADER_SHADER_HPP
 
#include "graphics/gl_headers.hpp"
#include "graphics/shader_files_manager.hpp"
#include "graphics/shared_gpu_objects.hpp"
#include "utils/singleton.hpp"
 
#include <matrix4.h>
#include <SColor.h>
#include <vector3d.h>
#include <array>
 
#include <string>
#include <vector>
 
class ShaderBase
{
protected:
    static std::vector<void (*)()> m_all_kill_functions;
 
    enum AttributeType
    {
        OBJECT,
        PARTICLES_SIM,
        PARTICLES_RENDERING,
        SKINNED_MESH,
    };   // AttributeType
 
    GLuint m_program;
    std::vector<std::shared_ptr<GLuint> > m_shaders;
 
    // ========================================================================
    template<typename ... Types>
    void loadAndAttachShader()
    {
        return;
    }   // loadAndAttachShader
    // ------------------------------------------------------------------------
    template<typename ... Types>
    void loadAndAttachShader(GLint shader_type, const std::string &name,
                             Types ... args)
    {
        auto shader_id = ShaderFilesManager::getInstance()
            ->getShaderFile(name, shader_type);
        if (shader_id)
        {
            m_shaders.push_back(shader_id);
            glAttachShader(m_program, *shader_id);
        }
        loadAndAttachShader(args...);
    }   // loadAndAttachShader
    // ------------------------------------------------------------------------
    template<typename ... Types>
    void loadAndAttachShader(GLint shader_type, const char *name,
                             Types ... args)
    {
        loadAndAttachShader(shader_type, std::string(name), args...);
    }   // loadAndAttachShader
 
public:
        ShaderBase();
        ~ShaderBase()
        {
            glDeleteProgram(m_program);
        }
    int loadTFBProgram(const std::string &vertex_file_path,
                       const char **varyings,
                       unsigned varyingscount);
    static void killShaders();
    GLuint createVAO();
    // ------------------------------------------------------------------------
    void use() { glUseProgram(m_program); }
    // ------------------------------------------------------------------------
    GLuint getUniformLocation(const char *name)
    {
        return glGetUniformLocation(m_program, name);
    }   // getUniformLocation
};   // ShaderBase
 
// ============================================================================
template<typename T, typename... Args>
class Shader : public ShaderBase, public Singleton<T>
{
private:
    std::vector<GLuint> m_uniforms;
 
    void bindPoint(const char *name, int index)
    {
        GLuint block_index = glGetUniformBlockIndex(m_program, name);
        if (block_index != GL_INVALID_INDEX)
            glUniformBlockBinding(m_program, block_index, index);
    }   // bindPoint
 
 
    // ========================================================================
    // assignUniforms: Variadic Template
protected:
    template<typename... U>
    void assignUniforms(U... rest)
    {
        static_assert(sizeof...(rest) == sizeof...(Args),
                      "Count of Uniform's name mismatch");
        assignUniformsImpl(rest...);
    }   // assignUniforms
private:
    // ------------------------------------------------------------------------
    void assignUniformsImpl()
    {
        bindPoint("Matrices", 0);
        bindPoint("LightingData", 1);
        bindPoint("SPFogData", 2);
    }   // assignUniformsImpl
 
    // ------------------------------------------------------------------------
    template<typename... U>
    void assignUniformsImpl(const char* name, U... rest)
    {
        m_uniforms.push_back(glGetUniformLocation(m_program, name));
        assignUniformsImpl(rest...);
    }   // assignUniformsImpl
 
 
    // ==============================================
    // setUniforms: Variadic template implementation.
 
public:
    void setUniforms(const Args & ... args) const
    {
        setUniformsImpl(args...);
    }   // setUniforms
    // ------------------------------------------------------------------------
private:
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(const std::vector<float> &v, Args1... arg) const
    {
        glUniform1fv(m_uniforms[N], (int)v.size(), v.data());
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformsImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0>
    void setUniformsImpl() const
    {
    }   // setUniformImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(const irr::core::matrix4 &mat, Args1... arg) const
    {
        glUniformMatrix4fv(m_uniforms[N], 1, GL_FALSE, mat.pointer());
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(const irr::video::SColorf &col, Args1... arg) const
    {
        glUniform3f(m_uniforms[N], col.r, col.g, col.b);
        setUniformsImpl<N + 1>(arg...);
    }  // setUniformsImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(const irr::video::SColor &col, Args1... arg) const
    {
        glUniform4i(m_uniforms[N], col.getRed(), col.getGreen(),
                                   col.getBlue(), col.getAlpha());
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformsImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(const std::array<float, 4> &ff, Args1... arg) const
    {
        glUniform4f(m_uniforms[N], ff[0], ff[1], ff[2], ff[3]);
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformsImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(const irr::core::vector3df &v, Args1... arg) const
    {
        glUniform3f(m_uniforms[N], v.X, v.Y, v.Z);
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformsImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(const irr::core::vector2df &v, Args1... arg) const
    {
        glUniform2f(m_uniforms[N], v.X, v.Y);
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformsImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(const irr::core::dimension2df &v, Args1... arg) const
    {
        glUniform2f(m_uniforms[N], v.Width, v.Height);
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformsImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(float f, Args1... arg) const
    {
        glUniform1f(m_uniforms[N], f);
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformsImpl
 
    // ------------------------------------------------------------------------
    template<unsigned N = 0, typename... Args1>
    void setUniformsImpl(int f, Args1... arg) const
    {
        glUniform1i(m_uniforms[N], f);
        setUniformsImpl<N + 1>(arg...);
    }   // setUniformsImpl
 
 
    // printFileList: Variadic template for printing a list of shader filenames
    // ========================================================================
protected:
    template<typename ...Types>
    void printFileList(GLint shader_type, const char *filepath, Types ... args)
    {
        Log::error("shader", filepath);
        printFileList(args...);
    }   // printFileList
 
    // ------------------------------------------------------------------------
private:
    template<typename ...Types>
    void printFileList()
    {
        return;
    }   // printFileList
 
 
    // Variadic template implementation of assignTextureUnit
    // ========================================================================
public:
    template<typename... T1>
    void assignTextureUnit(GLuint index, const char* uniform, T1... rest)
    {
        glUseProgram(m_program);
        GLuint uniform_loc = glGetUniformLocation(m_program, uniform);
        glUniform1i(uniform_loc, index);
        // Avoid doing any additional glUseProgram for the remaining calls
        assignTextureUnitNoUse(rest...);
        glUseProgram(0);
    }   // assignTextureUnit
 
private:
    // ------------------------------------------------------------------------
    void assignTextureUnitNoUse() {}
 
    // ------------------------------------------------------------------------
    template<typename... T1>
    void assignTextureUnitNoUse(GLuint index, const char* uniform, T1... rest)
    {
        GLuint uniform_loc = glGetUniformLocation(m_program, uniform);
        glUniform1i(uniform_loc, index);
        assignTextureUnitNoUse(rest...);
    }   // assignTextureUnitNoUse
 
    // ========================================================================
 
public:
 
    Shader()
    {
        m_all_kill_functions.push_back(this->kill);
    }   // Shader
 
    // ------------------------------------------------------------------------
    template<typename ... Types>
    void loadProgram(AttributeType type, Types ... args)
    {
        m_program = glCreateProgram();
        loadAndAttachShader(args...);
        glLinkProgram(m_program);
 
        GLint Result = GL_FALSE;
        glGetProgramiv(m_program, GL_LINK_STATUS, &Result);
        if (Result == GL_FALSE)
        {
            int info_length;
            Log::error("Shader", "Error when linking these shaders :");
            printFileList(args...);
            glGetProgramiv(m_program, GL_INFO_LOG_LENGTH, &info_length);
            char *error_message = new char[info_length];
            glGetProgramInfoLog(m_program, info_length, NULL, error_message);
            Log::error("Shader", error_message);
            delete[] error_message;
        }
        // After linking all shaders can be detached
        for (auto shader : m_shaders)
        {
            glDetachShader(m_program, *shader);
        }
    }   // loadProgram
    // ------------------------------------------------------------------------
    void drawFullScreenEffect(Args...args)
    {
        use();
        glBindVertexArray(SharedGPUObjects::getFullScreenQuadVAO());
        setUniforms(args...);
        glDrawArrays(GL_TRIANGLES, 0, 3);
    }   // drawFullScreenEffect
 
};   // Shader
 
 
#endif
 
#endif   // !SERVER_ONLY