GLESShader.h

Go to the documentation of this file.

#pragma once
#include "GLESInterface/Headers/GLESGraphicsDevice.h"
#include "Widgets/Headers/QTTools.h"
#include "Base/Headers/Exception.hpp"
#include "Base/Headers/Dictionary.h"
#include "Base/Headers/String.h"
#include "Base/Headers/RGBColor.h"
#include <QOpenGLContext>
#include <QFile>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief A Shader for rendering default OpenGL logic to the graphics card.
    **/
    class GLESShader
    {
    public:
        enum ShaderType
        {
            e_simple_points
            , e_points
            , e_linework
            , e_solid
            , e_solid_grid
            , e_solid_texture
            , e_shader_type_size//always here
            , e_all
        };
        enum ShaderPart
        {
              Vertex
            , Fragment
            , Geometry
        };
        GLESShader(ShaderType type, bool is_integer, const DynamicPointer<GLESGraphicsDevice>& device);
        ~GLESShader();
        void compileAndLink();
        void compile(ShaderPart type, const char* src);
        void linkShader();
        void compileShader(ShaderPart type, const String& shader);
        String versionedShaderCode(ShaderPart type, const char* src) const;
        int uniformLocation(const char* const location) const;
        uint04 id() const;
        template<class t_type>
        void setUniformValue(const char* const location, const t_type& value)
        {
            int var = uniformLocation(location);
            if (var == -1)
                return;
            setUniformValue(var, value);
        }
        template<size_t t_size>
        void setUniformValue(int location, const fltp04(&value)[t_size])
        {
            m_device->glUniform1fv(location, t_size, &value[0]);
        }
        template<size_t t_size>
        void setUniformValue(int location, const uint04(&value)[t_size])
        {
            m_device->glUniform1uiv(location, t_size, &value[0]);
        }
        template<size_t t_size>
        void setUniformValue(int location, const RGBColor(&value)[t_size])
        {
            m_device->glUniform1uiv(location, t_size, &value[0]);
        }
        template<uint01 t_size>
        void setUniformValue(int location, const Vector<t_size, fltp04>& value)
        {
            m_device->glUniform1fv(location, t_size, &value[0]);
        }
        template<uint01 t_size>
        void setUniformValue(int location, const Vector<t_size, RGBColor>& value)
        {
            m_device->glUniform1uiv(location, t_size, (uint04*)&value[0]);
        }
        void setUniformValue(int location, const Vector<3, sint04>& value);
        void setUniformValue(int location, const Vector<3, fltp04>& value);
        void setUniformValue(int location, const Vector<4, sint04>& value);
        void setUniformValue(int location, const Vector<4, fltp04>& value);
        void setUniformValue(int location, const Matrix<fltp04>& value);
        void setUniformValue(int location, const fltp04& value);
        void setUniformValue(int location, const uint04& value);
        void setUniformValue(int location, const RGBColor& value);
        void setUniformValue(int location, const Buffer<fltp04>& value);
        void bind();
    private:
        void checkCompileErrors(GLuint shader, String type) const;
    private:
        uint04 m_program_id = Constant<uint04>::Invalid;
        uint04 m_fragment = Constant<uint04>::Invalid;
        uint04 m_vertex = Constant<uint04>::Invalid;
        uint04 m_geometry = Constant<uint04>::Invalid;
        mutable Dictionary<uint04, int> m_shader_variables;
        DynamicPointer<GLESGraphicsDevice> m_device;
        ShaderType m_shader_type;
        bool m_is_int = false;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Manages all shaders used with OpenGL and the NDEVR API
    **/
    class GLESShaderManager
    {
    public:
        GLESShaderManager(const DynamicPointer<GLESGraphicsDevice>& device)
            : m_device(device)
        {
        }
        const Dictionary<GLESShader::ShaderType, DynamicPointer<GLESShader>>& integerShaders() const
        {
            return m_int_shaders;
        }
        const Dictionary<GLESShader::ShaderType, DynamicPointer<GLESShader>>& floatShaders() const
        {
            return m_flt_shaders;
        }
        DynamicPointer<GLESShader> shader(const GLESShader::ShaderType& id, bool is_int)
        {
            if (is_int)
            {
                auto iter = m_int_shaders.find(id);
                if (iter != m_int_shaders.end())
                    return iter.value();
                DynamicPointer<GLESShader> shader = createShader(id, true);
                m_int_shaders[id] = shader;
                return shader;
            }
            else
            {
                auto iter = m_flt_shaders.find(id);
                if (iter != m_flt_shaders.end())
                    return iter.value();
                DynamicPointer<GLESShader> shader = createShader(id, false);
                m_flt_shaders[id] = shader;
                return shader;
            }
        }
        DynamicPointer<GLESShader> createShader(const GLESShader::ShaderType& id, bool is_int)
        {
            DynamicPointer<GLESShader> shader = new GLESShader(id, is_int, m_device);
            shader->compileAndLink();
            return shader;
        }
    private:
        Dictionary<GLESShader::ShaderType, DynamicPointer<GLESShader>> m_int_shaders;
        Dictionary<GLESShader::ShaderType, DynamicPointer<GLESShader>> m_flt_shaders;
        DynamicPointer<GLESGraphicsDevice> m_device;
    };
}