Shader.h

Go to the documentation of this file.

#ifndef B_SHADER_H
#define B_SHADER_H

#include <memory>
#include <string>
#include <unordered_map>
#include "vmmlib/matrix.hpp"
#include "Renderer_GL.h"
#include "Texture.h"


class IShaderData;

class Shader
{
public:

    /* Structs */

    struct Attrib
    {
        GLint   loc;
        GLint   size;
        GLenum  type;
        GLsizei stride;     // size of vertex data structure
        size_t  offset;
    };

    /* Typedefs */

    typedef std::unordered_map< std::string, GLint >    LocationMap;
    typedef std::unordered_map< std::string, Attrib >   AttribMap;
    
    /* Functions */

    Shader(const IShaderData &shaderData);

    virtual ~Shader()
    {
        deleteShader();
    }

    virtual void bind();
    
    virtual void setUniform(const std::string &name, const vmml::Matrix4f &arg);

    virtual void setUniform(const std::string &name, const vmml::Matrix3f &arg);

    virtual void setUniform(const std::string &name, const vmml::Vector4f &arg);

    virtual void setUniform(const std::string &name, const vmml::Vector3f &arg);

    virtual void setUniform(const std::string &name, GLfloat arg);
    
    virtual void setUniform(const std::string &name, TexturePtr texture);
    
    virtual GLint registerUniform(const std::string &name);

    virtual GLint registerAttrib(const std::string &name, GLint size, GLenum type, GLsizei stride, size_t offset);
    
    GLuint getProgramID() { return _programID; }
    
    virtual GLint findUniformLocation(const std::string &name);

    virtual GLint findAttribLocation(const std::string &name, GLint size, GLenum type, GLsizei stride, size_t offset);

    virtual GLint getUniformLocation(const std::string &name);

    virtual GLint getAttribLocation(const std::string &name);

    GLuint getMaxLights() { return _shaderMaxLights; }

    bool supportsVariableNumberOfLights() const { return _variableNumberOfLights; }

    bool supportsAmbientLighting() const    { return _ambientLighting; }

    bool supportsDiffuseLighting() const    { return _diffuseLighting; }

    bool supportsSpecularLighting() const   { return _specularLighting; }

    bool supportsCubicReflectionMap() const { return _cubicReflectionMap; }
    
    template< typename T >
    void setUniforms(const T &arg)
    {
        for (auto i = arg.cbegin(); i != arg.cend(); ++i)
        {
            setUniform(i->first, i->second);
        }
    }

    GLint getCurrentTexUnit() { return GL_TEXTURE0 + _cTexUnit; }
    
    virtual void deleteShader()
    {
        if (_programID) {
            glDeleteProgram(_programID);
        }
    }

protected:
    
    /* Functions */

    virtual void resetTexUnit();
    virtual bool compile(GLuint* shader, GLenum type, const std::string &src);
    virtual bool link();
    virtual bool validate();
    
private:

    /* Variables */

    GLuint _programID = 0;
    
    GLint   _cTexUnit = 0;
    GLint   _maxTexUnits = 0;
    
    LocationMap   _uniformLocations;
    AttribMap     _attribs;

    GLuint      _shaderMaxLights;
    bool        _variableNumberOfLights;
    bool        _ambientLighting;
    bool        _diffuseLighting;
    bool        _specularLighting;
    bool        _cubicReflectionMap;
};

typedef std::shared_ptr< Shader > ShaderPtr;

#endif /* defined(B_SHADER_H) */