Shader.h

Go to the documentation of this file.

#ifndef SHADER_UTIL_H
#define SHADER_UTIL_H

#include <exception>
#include <string>
#include <vector>
#include "array_ref.h"
#include <boost/utility/string_ref.hpp>
#include <boost/noncopyable.hpp>

namespace glutil
{

    class ShaderException : public std::exception
    {
    public:
        virtual ~ShaderException() throw() {}

        virtual const char *what() const throw() {return message.c_str();}

    protected:
        std::string message;

        ShaderException() {}
        ShaderException(const char *msg) : message(msg) {}
    };

    class SeparateShaderNotSupported : public ShaderException
    {
    public:
        SeparateShaderNotSupported();
    };

    class CompileLinkException : public ShaderException
    {
    public:
        CompileLinkException(GLuint shader);
        CompileLinkException(GLuint program, bool);

        virtual ~CompileLinkException() throw() {}
    };




    GLuint CompileShader(GLenum shaderType, boost::string_ref shaderText);

    GLuint CompileShader(GLenum shaderType, refs::array_ref<const char *> shaderList);

    GLuint CompileShader(GLenum shaderType, const std::vector<std::string> &shaderList);



    GLuint LinkProgram(GLuint shaderOne, GLuint shaderTwo);

    GLuint LinkProgram(GLuint program, GLuint shaderOne, GLuint shaderTwo);

    GLuint LinkProgram(boost::string_ref vertexShader, boost::string_ref fragmentShader);

    GLuint LinkProgram(GLuint program, boost::string_ref vertexShader, boost::string_ref fragmentShader);


    GLuint LinkProgram(GLuint shader, bool isSeparable = false);

    GLuint LinkProgram(refs::array_ref<GLuint> shaders, bool isSeparable = false);

    GLuint LinkProgram(GLuint program, refs::array_ref<GLuint> shaders);



    GLuint MakeSeparableProgram(GLenum shaderType, const char *shaderText);

    GLuint MakeSeparableProgram(GLenum shaderType, const std::string &shaderText);

    GLuint MakeSeparableProgram(GLenum shaderType, refs::array_ref<const char *> shaderList);

    GLuint MakeSeparableProgram(GLenum shaderType, const std::vector<std::string> &shaderList);

    class UniqueShader : public boost::noncopyable
    {
    public:
        UniqueShader() : m_shader(0) {}
        explicit UniqueShader(GLuint shader) : m_shader(shader) {}
        ~UniqueShader() {Disengage();}

        void swap(UniqueShader &other)
        {
            using std::swap;
            swap(m_shader, other.m_shader);
        }

        operator GLuint() const {return m_shader;}

        void reset(GLuint newShader = 0)
        {
            Disengage();
            m_shader = newShader;
        }

        GLuint release()
        {
            GLuint shaderName = m_shader;
            m_shader = 0;
            return shaderName;
        }

    private:
        GLuint m_shader;

        void Disengage();
    };

    class UniqueProgram : public boost::noncopyable
    {
    public:
        UniqueProgram() : m_program(0) {}
        explicit UniqueProgram(GLuint program) : m_program(program) {}
        ~UniqueProgram() {Disengage();}

        void swap(UniqueProgram &other)
        {
            using std::swap;
            swap(m_program, other.m_program);
        }

        operator GLuint () const {return m_program;}

        void reset(GLuint newProgram = 0)
        {
            Disengage();
            m_program = newProgram;
        }

        GLuint release()
        {
            GLuint programName = m_program;
            m_program = 0;
            return programName;
        }

    private:
        GLuint m_program;

        void Disengage();
    };

    inline void swap(UniqueShader &lhs, UniqueShader &rhs) {lhs.swap(rhs);}
    inline void swap(UniqueProgram &lhs, UniqueProgram &rhs) {lhs.swap(rhs);}

}

#endif //SHADER_UTIL_H