OpenGLShader.hpp

Go to the documentation of this file.

#pragma once

#include "Engine/Utility/Defines.hpp"
#ifdef USING_OPENGL
#include "Engine/api.hpp"
#include "Engine/Shader/Shader.hpp"

#include <ThirdParty/glm/glm/glm.hpp>
#include <ThirdParty/EASTL-master/include/EASTL/map.h>
#include <ThirdParty/EASTL-master/include/EASTL/shared_ptr.h>
#include <ThirdParty/glew-2.1.0/include/GL/glew.h>

namespace Engine
{
    //class Shader;
    class Texture;
    class Color;

    class ShaderParameter
    {
        friend class OpenGLShader;

    public:

        bool IsValid() const { return _location != -1; }

        GLenum GetType() const { return _type; }

        GLint GetLocation() const { return _location; }
        void SetValue(float val) const;

        void SetValue(int val) const;

        void SetValue(bool val) const;

        void SetValue(const glm::vec2& vec) const;

        void SetValue(const glm::vec3& vec) const;

        void SetValue(const glm::vec4& vec) const;

        void SetValue(const Color& color);

        void SetValue(const glm::mat4x4& mtx, bool transpose = false) const;

        void SetValue(Texture& texture_) const;

    protected:

        ShaderParameter(OpenGLShader* shader, eastl::string name, GLenum type, GLint location, GLint sampler = -1)
            : _shader(shader)
            , _name(name)
            , _type(type)
            , _location(location)
            , _sampler(sampler)
        {}

        ShaderParameter() : _shader(nullptr), _name(""), _type(0), _location(-1), _sampler(-1) {}

        void Reset(OpenGLShader* shader, eastl::string name, GLenum type, GLint location, GLint sampler = -1)
        {
            this->_shader = shader;
            this->_type = type;
            this->_location = location;
            this->_name = name;
            this->_sampler = sampler;
        }

        void Invalidate()
        {
            _shader = nullptr;
            _name = "";
            _type = 0;
            _location = -1;
            _sampler = -1;
        }

        OpenGLShader*   _shader;

        eastl::string       _name;

        GLenum          _type;

        GLint           _location;

        GLint           _sampler;
    };


    class ShaderAttribute
    {
        friend class OpenGLShader;

    public:

        bool IsValid() const { return _location != -1; }

        GLenum GetType() const { return _type; }

        GLint GetLocation() const { return _location; }

        void SetAttributePointer(
            GLint size,
            GLenum type,
            GLboolean normalized,
            GLsizei stride,
            const GLvoid * pointer) const;

        void DisableAttributePointer() const;

    protected:

        ShaderAttribute(OpenGLShader* shader, eastl::string name, GLenum type, GLint location) :
            _shader(shader),
            _name(name),
            _type(type),
            _location(location)
        {}

        ShaderAttribute() : _shader(nullptr), _name(""), _type(0), _location(-1) {}


        void Reset(OpenGLShader* shader, eastl::string name, GLenum type, GLint location)
        {
            this->_shader = shader;
            this->_type = type;
            this->_location = location;
            this->_name = name;
        }

        void Invalidate()
        {
            _shader = nullptr;
            _name = "";
            _type = 0;
            _location = -1;
        }


    protected:
        OpenGLShader*   _shader;

        eastl::string  _name;

        GLenum      _type;

        GLint       _location;
    };

    class ENGINE_API OpenGLShader : public Shader
    {
    private:

    private:
        friend class OpenGLRenderer;

        explicit OpenGLShader(const eastl::string& vertexFileName,
            const eastl::string& fragmentFileName);

        explicit OpenGLShader(const eastl::string& vertexFileName,
            const eastl::string& fragmentFileName,
            const eastl::string& geometryFileName);

        explicit OpenGLShader(const Shader& other) = delete;
        OpenGLShader(OpenGLShader &&other) = delete;

    public:
        bool LoadSource(const eastl::string& vertexShader,
            const eastl::string& fragmentShader,
            const eastl::string& geometryShader);

        eastl::weak_ptr<ShaderParameter> GetParameter(const eastl::string& name);

        eastl::weak_ptr<ShaderAttribute> GetAttribute(const eastl::string& name);

        GLuint GetProgram() const;

        void Activate() override;
        void Deactivate() override;

    private:

        void LoadParameters();

        bool Validate() const;

        eastl::map<eastl::string, eastl::shared_ptr<ShaderParameter>> parameters;

        eastl::map<eastl::string, eastl::shared_ptr<ShaderAttribute>> attributes;

        GLuint program = 0;
    };
} //namespace Engine
#endif