shader_base.h

#ifndef OE_RENDER_SHADER_BASE_H
#define OE_RENDER_SHADER_BASE_H
 
#include "common.h"
 
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <glm/mat4x4.hpp>
 
#include "../scene/material.h"
#include "../util/non_copyable.h"
 
namespace oe::scene
{
    class Camera;
    class Node;
    class Material;
}
 
namespace oe::render
{
    class Texture;
    class Cubemap;
 
    class ShaderBase : public oe::util::NonCopyable
    {
        public:
            ShaderBase(const std::string& name = "");
 
            ~ShaderBase();
 
            template <typename T>
            void define(const std::string& name, const T& value)
            {
                _defines[name] = std::to_string(value);
            }
 
            void define(const std::string& name, const char* value)
            {
                _defines[name] = std::string(value);
            }
 
            void define(const std::string& name, const std::string& value)
            {
                _defines[name] = value;
            }
 
            void define(const std::string& name)
            {
                _defines[name] = "";
            }
 
            const std::string& getName() const
            {
                return _name;
            }
 
            void compile(const GeometryPass vertex_pass, const RenderingPass fragment_pass);
 
            void bind(const GeometryPass vertex_pass, const RenderingPass fragment_pass);
 
            void fillFromCamera(const scene::Camera& camera) noexcept;
 
            void fillTextures(const std::map<std::string, std::pair<uint32_t, std::shared_ptr<oe::render::Texture>>>& textures);
 
            void fillCubemaps(const std::map<std::string, std::pair<uint32_t, std::shared_ptr<oe::render::Cubemap>>>& cubemaps);
 
            void fillFromMaterial(const scene::Material* material);
 
            void unbind();
 
            /*
             *
             */
            //std::string getShaderContent(const VertexPass vertex_pass, const RenderingPass fragment_pass) const;
 
            void setInt(const std::string& name, const int32_t value);
 
            void setUInt(const std::string& name, const uint32_t value);
 
            void setFloat(const std::string& name, const float value);
 
            void setDouble(const std::string& name, const double value);
 
            void setMat3(const std::string& name, const glm::mat3& value);
 
            void setMat4(const std::string& name, const glm::mat4& value);
 
            void setVec2i(const std::string& name, const glm::ivec2& value);
 
            void setVec2(const std::string& name, const glm::vec2& value);
 
            void setVec3(const std::string& name, const glm::vec3& value);
 
            void setVec4(const std::string& name, const glm::vec4& value);
 
            void setIntArray(const std::string& name, const std::vector<int32_t>& values);
 
            void setUIntArray(const std::string& name, const std::vector<uint32_t>& values);
 
            void setFloatArray(const std::string& name, const std::vector<float>& values);
 
            void setDoubleArray(const std::string& name, const std::vector<double>& values);
 
            void setVec2iArray(const std::string& name, const std::vector<glm::ivec2>& values);
 
            void setVec2Array(const std::string& name, const std::vector<glm::vec2>& values);
 
            void setVec3Array(const std::string& name, const std::vector<glm::vec3>& values);
 
            void setVec4Array(const std::string& name, const std::vector<glm::vec4>& values);
 
            void setMat4Array(const std::string& name, const std::vector<glm::mat4>& values);
 
        protected:
            std::unordered_map<GeometryPass, std::string> _vertex_shader_sources;
            std::unordered_map<RenderingPass, std::string> _fragment_shader_sources;
 
            std::string _header;
 
        private:
 
            struct PassPairHash
            {
                std::size_t operator ()(const std::pair<GeometryPass, RenderingPass> &p) const
                {
                    auto h1 = std::hash<GeometryPass>{}(p.first);
                    auto h2 = std::hash<RenderingPass>{}(p.second);
 
                    return h1 ^ h2;
                }
            };
 
            std::string _generate_header() const noexcept;
 
            uint32_t _program_handle = 0;
 
            std::string _name;
 
            std::unordered_map<std::string, std::string> _defines;
 
            std::unordered_map<std::string, int32_t> _locations;
 
            std::unordered_map<std::pair<GeometryPass, RenderingPass>, std::unordered_map<std::string, int32_t>, PassPairHash> _pass_locations;
            std::unordered_map<std::pair<GeometryPass, RenderingPass>, uint32_t, PassPairHash> _pass_programs;
 
            static uint32_t _last_bound_shader;
    };
}
 
#endif