GLESShader.h

#pragma once
#include "GLESGraphicsDevice.h"
#include <NDEVR/QTTools.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/String.h>
#include <NDEVR/RGBColor.h>
#include <QOpenGLContext>
namespace NDEVR
{
 
    class GLESShader
    {
    public:
        enum ShaderType
        {
            e_points              
            , e_linework          
            , e_solid             
            , e_shader_type_size  
            , e_all               
        };

        enum ShaderPart
        {
              Vertex    
            , Fragment  
            , Geometry  
        };

        struct Definition
        {
            ShaderType type = ShaderType::e_points; 
            bool is_simple = false;                 
            bool is_integer = false;                
            bool is_tbn = false;                    
            bool has_color_channel = false;          
            bool has_normal_channel = false;          
            bool has_grid = false;                   
            bool has_texture = false;                
            bool is_relative_to_camera = false;      
            uint04 palette_size = 0U;                
            uint04 id() const
            {
                if (IsInvalid(m_id))
                {
                    m_id = 1024U * cast<uint04>(type);
                    m_id += 16384U * palette_size;
                    if (is_simple)
                        m_id += 0x01;
                    if (is_integer)
                        m_id += 0x02;
                    if (is_tbn)
                        m_id += 0x04;
                    if (has_color_channel)
                        m_id += 0x08;
                    if (has_grid)
                        m_id += 0x10;
                    if (has_texture)
                        m_id += 0x20;
                    if(is_relative_to_camera)
                        m_id += 0x40;
                    if(has_normal_channel)
                        m_id += 0x80;
                }
                return m_id;
            }
        private:
            mutable uint04 m_id = Constant<uint04>::Invalid;
        };

        GLESShader(const Definition& def, const DynamicPointer<GLESGraphicsDevice>& device);
        ~GLESShader();
        void compileAndLink();
        void compile(ShaderPart type, const char* src);
        void linkShader();
        String buildVertexSource() const;
        String buildFragmentSource() const;
        String versionedShaderCode(ShaderPart type, const String& src) const;
        int uniformLocation(const char* const location) const
        {
            uint08 hash = String::hash(location);
            return uniformLocation(hash, location);
        }

        int uniformLocation(uint08 hash, const char* const location) const;
        bool checkID(int id, std::size_t value);
        template<class t_type>
        bool checkID(int id, const t_type& value)
        {
            std::hash<t_type> hasher;
            std::size_t hash = hasher(value);
            return checkID(id, hash);
        }
        template<uint01 t_dims, class t_type>
        bool checkID(int id, const Buffer<Vector<t_dims, t_type>>& value)
        {
            std::hash<t_type> hasher;
            std::size_t hash = 0;
            for (uint01 i = 0; i < value.size(); i++)
            {
                for (uint01 n = 0; n < t_dims; n++)
                    hash = (hash * 0x100000001b3ULL) ^ (hasher(value[i][n]) + 0x9e3779b97f4a7c15ULL);
            }
            return checkID(id, hash);
        }
        template<class t_type>
        bool checkID(int id, const Buffer<t_type>& value)
        {
            std::hash<t_type> hasher;
            std::size_t hash = 0;
            for (uint01 i = 0; i < value.size(); i++)
                hash = (hash * 0x100000001b3ULL) ^ (hasher(value[i]) + 0x9e3779b97f4a7c15ULL);
            return checkID(id, hash);
        }
        template<uint01 t_dims, class t_type>
        bool checkID(int id, const Vector<t_dims, t_type>& value)
        {
            std::hash<t_type> hasher;
            std::size_t hash = 0;
            for(uint01 i = 0; i < t_dims; i++)
                hash = (hash * 0x100000001b3ULL) ^ (hasher(value[i]) + 0x9e3779b97f4a7c15ULL);
            return checkID(id, hash);
        }
        template<uint01 t_dim_a, uint01 t_dim_b, class t_type>
        bool checkID(int id, const Vector<t_dim_a, Vector<t_dim_b, t_type>>& value)
        {
            std::hash<t_type> hasher;
            std::size_t hash = 0;
            for (uint01 i = 0; i < t_dim_a; i++)
                for (uint01 n = 0; n < t_dim_b; n++)
                    hash = (hash * 0x100000001b3ULL) ^ (hasher(value[i][n]) + 0x9e3779b97f4a7c15ULL);
            return checkID(id, hash);
        }
        template<uint01 t_dim_a, uint01 t_dim_b, class t_type>
        bool checkID(int id, const Matrix<t_type, t_dim_a, t_dim_b>& value)
        {
            std::hash<t_type> hasher;
            std::size_t hash = 0;
            for (uint01 i = 0; i < t_dim_a; i++)
                for (uint01 n = 0; n < t_dim_b; n++)
                    hash = (hash * 0x100000001b3ULL) ^ (hasher(value[i][n]) + 0x9e3779b97f4a7c15ULL);
            return checkID(id, hash);
        }
        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])
        {
            if(!checkID(location, value))
                m_device->glUniform1fv(location, t_size, &value[0]);
        }
        template<size_t t_size>
        void setUniformValue(int location, const uint04(&value)[t_size])
        {
            if (!checkID(location, value))
                m_device->glUniform1uiv(location, t_size, &value[0]);
        }
        template<size_t t_size>
        void setUniformValue(int location, const RGBColor(&value)[t_size])
        {
            if (!checkID(location, value))
                m_device->glUniform1uiv(location, t_size, &value[0]);
        }
        template<uint01 t_size>
        void setUniformValue(int location, const Vector<t_size, fltp04>& value)
        {
            if (!checkID(location, value))
                m_device->glUniform1fv(location, t_size, &value[0]);
        }
        template<uint01 t_size>
        void setUniformValue(int location, const Vector<t_size, Vector<4, fltp04>>& value)
        {
            if (!checkID(location, value))
                m_device->glUniform4fv(location, t_size, &value[0][0]);
        }
        void setUniformValue(int location, const Buffer<Vector<4, fltp04>>& value)
        {
            if (!checkID(location, value))
                m_device->glUniform4fv(location, value.size(), &value[0][0]);
        }
        template<uint01 t_size>
        void setUniformValue(int location, const Vector<t_size, RGBColor>& value)
        {
            if (!checkID(location, 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 sint04& value);
        //void setUniformValue(int location, const Buffer<fltp04>& value);
        void bind();
        void unBind();
        const Definition& definition() const { return m_definition; }
        static GLESShader* BoundShader();
    private:
        void checkCompileErrors(GLuint shader, StringView type) const;
        String buildFlatVertexSource() const;
        String buildFlatFragmentSource() const;
        String buildFullVertexSource() const;
        String buildFullFragmentSource() const;
        String buildTBNVertexSource() const;
        String buildTBNFragmentSource() const;
    private:
        Definition m_definition;                            
        Buffer<std::size_t> m_bound_values;                 
        static GLESShader* s_bound_shader;                  
        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<uint08, int> m_shader_variables; 
        DynamicPointer<GLESGraphicsDevice> m_device;        
    };

    class GLESShaderManager
    {
    public:
        GLESShaderManager(const DynamicPointer<GLESGraphicsDevice>& device);
        const Dictionary<uint04, GLESShader*>& shaders() const { return m_shaders; };
        GLESShader* shader(const GLESShader::Definition& def);
        GLESShader* createShader(const GLESShader::Definition& def);
    private:
        Dictionary<uint04, GLESShader*> m_shaders;       
        DynamicPointer<GLESGraphicsDevice> m_device;     
    };
}