Shader.h

Go to the documentation of this file.

#ifndef GlobeEngine_Shader_h
#define GlobeEngine_Shader_h

#include "OpenGL_Includes.h"
#include "ShaderProgram.h"
#include "ShaderParser.h"
#include <fstream>
#include <vmmlib/vmmlib.hpp>
#include <iostream>
#include <string>
#include <map>
#include <memory>
#include <vector>

namespace ge {
    
    class Shader
    {
    public:
        enum ShaderType { VERTEX_FRAGMENT = 0, VERTEX_FRAGMENT_GEOMETRY = 1, VERTEX_FRAGMENT_GEOMETRY_TESSELATION = 2, COMPUTE};
        
        Shader();
        ~Shader();
        // deep copy
        Shader(const std::shared_ptr<Shader> copy) {
            this->handle = copy->handle;
            this->vertexArrayAttributeCount = copy->vertexArrayAttributeCount;
            this->repoPath = copy->repoPath;
            this->globalSourcePath = copy->globalSourcePath;
            this->shadertype = copy->shadertype;
            this->programs = copy->programs;
            this->vertexArrayAttributeLocations = copy->vertexArrayAttributeLocations;
        }
        
        void clear();
        void load(std::string _inputPath, ge::Shader::ShaderType _type, std::string _genericShaderPath="");
        void load(std::string _repopath, std::string _relPath, ge::Shader::ShaderType _type, std::string _genericShaderPath = "");
        void loadFromSourceVertFrag(std::string _vertSource, std::string _fragSource);
        //void loadWithDefine(std::string _inputPath, ge::Shader::ShaderType _type, int _defineValue);
        GLuint getVertexArrayAttributeCount() const;
        
        GLuint getHandle();

        void recompile(ShaderProgram::ReloadType _type = ShaderProgram::ReloadType::FROMFILE);

        void bind() const;
        void unbind() const;

#ifndef GENGINE_GL_BELOW_410

        void dispatchCompute(GLuint _numGroupsX, GLuint _numGroupsY, GLuint _numGroupsZ) const;
        
        void dispatchCompute(vmml::Vector3ui _numGroups) const;
        static void printComputeCapabilities();
#endif

        /* uniform calls */
#if defined GENGINE_GL_ES
#else
        void setUniform1d(std::string _name, double _value) const;
        void setUniformVector2d(std::string _name, vmml::Vector2d _value) const;
        void setUniformVector3d(std::string _name, vmml::Vector3d _value) const;
        void setUniformVector4d(std::string _name, vmml::Vector4d _value) const;
        void setUniformMatrix3d(std::string _name, vmml::Matrix3d _value, bool _transpose=false) const;
        void setUniformMatrix4d(std::string _name, vmml::Matrix4d _value, bool _transpose = false) const;
        void setUniformBlockBinding(std::string _ublockName, GLuint _ublockBinding);
        void setUniformBlockBinding(GLuint _ublockIdx, GLuint _ublockBinding);
        GLuint getUniformBlockIndex(std::string _input);
#endif
        void setUniform1i(std::string _name, int _value)const;
        void setUniform1f(std::string _name, float _value) const;
        void setUniformVector2i(std::string _name, vmml::Vector2i _value) const;
        void setUniformVector2f(std::string _name, vmml::Vector2f _value) const;
        void setUniformVector3f(std::string _name, vmml::Vector3f _value) const;
        void setUniformVector4f(std::string _name, vmml::Vector4f _value) const;
        void setUniformVector4f(std::string _name, const float* _values) const;
        void setUniformMatrix3f(std::string _name, vmml::Matrix3f _value, bool _transpose=false) const;
        void setUniformMatrix4f(std::string _name, vmml::Matrix4f _value, bool _transpose = false) const;
        
        void setUniformArrayf(std::string _name, int _count, const GLfloat* _values) const;
    
        void setDefine1i(std::string _in, int _value);
        void setDefinesToZeroWithoutRecompile();

    private:
       
        void setupPrograms(std::vector<std::string> _inputPathOrSource, bool _isSource);

        void bindAttributeLocation(unsigned int _location, std::string _name);
        void unbindAttributeLocation(unsigned int _location);
        void linkShader();
        void getOpenGLError(std::string _input);

    private:
        void load(std::vector<std::string> _inputPathOrSource, bool _isSource);
        void createShaderHandle();
        void attachProgramID(GLuint _programID);
        void setupPropertyBuffer();
        void addAttributeProperty(ShaderProperty::IOType _iotype, std::string _property);

        std::map<int, std::string> vertexArrayAttributeLocations;
        
        GLuint handle;
        GLuint vertexArrayAttributeCount;

        std::vector< std::shared_ptr<ge::ShaderProgram> > programs;
        std::string repoPath;
        
        // generic sources
        std::string globalSourcePath;
        ge::Shader::ShaderType shadertype;

    };
    
    typedef std::map<std::string, std::shared_ptr<ge::Shader> > ShaderMap;
    typedef std::pair<std::string, std::shared_ptr<ge::Shader> > ShaderMapPair;
    
}
#endif