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
{
    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)
            : m_device(device)
            , m_shader_type(type)
            , m_is_int(is_integer)
        {
            //m_program.addShaderFromSourceCode(QOpenGLShader::Vertex, versionedShaderCode(vertex));
            //m_program.addShaderFromSourceCode(QOpenGLShader::Fragment, versionedShaderCode(fragment));
            lib_assert(m_device->isReady(), "Not yet ready to render");
            
        }
        void compileAndLink()
        {
            compileShader(ShaderPart::Vertex, "Vertex");
            compileShader(ShaderPart::Fragment, "Fragment");
            linkShader();
        }
        void compile(ShaderPart type, const char* src)
        {
            // vertex shader
            switch(type)
            {
            case ShaderPart::Vertex:
            {
                m_vertex = m_device->glCreateShader(GL_VERTEX_SHADER);
                m_device->glShaderSource(m_vertex, 1, &src, NULL);
                m_device->glCompileShader(m_vertex);
                checkCompileErrors(m_vertex, "VERTEX");
            } break;
            case ShaderPart::Fragment:
            {
                // fragment Shader
                m_fragment = m_device->glCreateShader(GL_FRAGMENT_SHADER);
                m_device->glShaderSource(m_fragment, 1, &src, NULL);
                m_device->glCompileShader(m_fragment);
                checkCompileErrors(m_fragment, "FRAGMENT");
            } break;
        #ifdef GL_GEOMETRY_SHADER
            case ShaderPart::Geometry:
            {
                m_geometry = m_device->glCreateShader(GL_GEOMETRY_SHADER);
                m_device->glShaderSource(m_geometry, 1, &src, NULL);
                m_device->glCompileShader(m_geometry);
                checkCompileErrors(m_geometry, "GEOMETRY");
            } break;
        #endif
            default:
                lib_assert(false, "unsupported shader type");
                break;
            }
            
        }
        void linkShader()
        {
            m_program_id = m_device->glCreateProgram();
            m_device->glAttachShader(m_program_id, m_vertex);
            m_device->glAttachShader(m_program_id, m_fragment);
            if (!isNaN(m_geometry))
                m_device->glAttachShader(m_program_id, m_geometry);
            m_device->glLinkProgram(m_program_id);
            checkCompileErrors(m_program_id, "PROGRAM");
            // delete the shaders as they're linked into our program now and no longer necessary
            m_device->glDeleteShader(m_vertex);
            m_device->glDeleteShader(m_fragment);
            if (!isNaN(m_geometry))
                m_device->glDeleteShader(m_geometry);
            m_geometry = Constant<uint04>::NaN;
            m_fragment = Constant<uint04>::NaN;
            m_vertex = Constant<uint04>::NaN;
        }
        ~GLESShader()
        {
            m_device->glDeleteProgram(m_program_id);
            m_program_id = Constant<uint04>::NaN;
        }
        void compileShader(ShaderPart type, const String& shader)
        {
            QFile file((":Resources/Shaders/" + shader + ".glsl").getAs<QString>());
            uint04 file_size = cast<uint04>(file.size());
            String code;
            code.setSize(file_size, '\0');
            bool success = file.open(QIODevice::ReadOnly);
            if (success)
            {
                cast<uint04>(file.read(code.begin(), cast<uint04>(file_size)));
                compile(type, versionedShaderCode(type, code.begin()));
            }
 
        }
        String versionedShaderCode(ShaderPart type, const char* src) const
        {
            String code;
            if (m_device->context()->isOpenGLES())
                code = "#version 300 es\n";
            else
                code = "#version 330\n";
            if (type == ShaderPart::Vertex)
            {
                if (m_is_int)
                    code += "layout (location = 0) in highp ivec3 in_position;\n";
                else
                    code += "layout (location = 0) in highp vec3 in_position;\n";
            }
            else
            {
                switch (m_shader_type)
                {
                case ShaderType::e_points:
                    code += "#define POINT_SHADER 1\n";
                    break;
                case ShaderType::e_linework:
                    code += "#define LINEWORK_SHADER 1\n";
                    break;
                default:
                    code += "#define SOLID_SHADER 1\n";
                    break;
                }
            }
            code.append(src);
            return code;
        }
        int uniformLocation(const char* const location) const
        {
            uint04 hash = String::hash(location);
            auto iter = m_shader_variables.find(hash);
            if (iter != m_shader_variables.end())
                return iter.value();
            int index = m_device->glGetUniformLocation(m_program_id, location);
            if (index == -1)
            {
                String bad;
            }
            //lib_assert(index >= 0, "Bad uniform location");
            m_shader_variables[hash] = index;
            return index;
        }
        uint04 id() const
        {
            return m_program_id;
        }
        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);
        }
        void setUniformValue(int location, const Vector<3, sint04>& value)
        {
            m_device->glUniform3iv(location, 1, &value[0]);
        }
        void setUniformValue(int location, const Vector<3, fltp04>& value)
        {
            m_device->glUniform3fv(location, 1, &value[0]);
        }
        void setUniformValue(int location, const Vector<4, sint04>& value)
        {
            m_device->glUniform4iv(location, 1, &value[0]);
        }
        void setUniformValue(int location, const Vector<4, fltp04>& value)
        {
            m_device->glUniform4fv(location, 1, &value[0]);
        }
        void setUniformValue(int location, const Matrix<fltp04>& value)
        {
            m_device->glUniformMatrix4fv(location, 1, false, &value[0][0]);
        }
        void setUniformValue(int location, const fltp04& value)
        {
            m_device->glUniform1f(location, value);
        }
        void setUniformValue(int location, const uint04& value)
        {
            m_device->glUniform1ui(location, value);
        }
        void setUniformValue(int location, const RGBColor& value)
        {
            m_device->glUniform1ui(location, value.convertToABGR32BitColor());
        }
        void setUniformValue(int location, const Buffer<fltp04>& value)
        {
            m_device->glUniform1fv(location, value.size(), value.begin());
        }
        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 bind()
        {
            m_device->glUseProgram(m_program_id);
        }
    protected:
        void checkCompileErrors(GLuint shader, String type) const
        {
            GLint success;
            GLchar infoLog[1024];
            if (type != "PROGRAM")
            {
                m_device->glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
                if (!success)
                {
                    m_device->glGetShaderInfoLog(shader, 1024, NULL, infoLog);
                    throw Exception("Shader Compile Error ERROR::SHADER_COMPILATION_ERROR of type: " + type + "\n" + infoLog);
                }
            }
            else
            {
                m_device->glGetProgramiv(shader, GL_LINK_STATUS, &success);
                if (!success)
                {
                    m_device->glGetProgramInfoLog(shader, 1024, NULL, infoLog);
                    throw Exception("Shader Compile Error ERROR::PROGRAM_LINKING_ERROR of type: " + type + "\n" + infoLog);
                }
            }
        }
        uint04 m_program_id = Constant<uint04>::NaN;
        uint04 m_fragment = Constant<uint04>::NaN;
        uint04 m_vertex = Constant<uint04>::NaN;
        uint04 m_geometry = Constant<uint04>::NaN;
        mutable Dictionary<uint04, int> m_shader_variables;
        DynamicPointer<GLESGraphicsDevice> m_device;
        ShaderType m_shader_type;
        bool m_is_int = false;
    };
 
    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;
        }
    protected:
        Dictionary<GLESShader::ShaderType, DynamicPointer<GLESShader>> m_int_shaders;
        Dictionary<GLESShader::ShaderType, DynamicPointer<GLESShader>> m_flt_shaders;
        DynamicPointer<GLESGraphicsDevice> m_device;
    };
}