shader_base.h

#ifndef OE_RENDER_SHADER_BASE_H
#define OE_RENDER_SHADER_BASE_H
 
#include <vector>
#include <string>
#include <map>
#include <span>
#include <unordered_map>
#include <glm/mat4x4.hpp>
 
#include "passes.h"
#include "../scene/material.h"
 
namespace oe::scene
{
    class Camera;
    class Node;
    class Material;
}
 
namespace oe::render
{
    class Texture;
    class Cubemap;

    class ShaderBase
    {
        public:
            ShaderBase(const std::string& name = "");
 
            ShaderBase(const ShaderBase&) = delete;
            ShaderBase& operator=(const ShaderBase&) = delete;
 
            ShaderBase(ShaderBase&& other) noexcept:
                _program_handle(other._program_handle),
                _name(other._name),
                _defines(other._defines),
                _locations(other._locations),
                _pass_locations(other._pass_locations),
                _pass_programs(other._pass_programs)
            {
                other._program_handle = 0;
                other._pass_programs = {};
            }
 
            ~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(std::span<const scene::TextureProperty> textures);

            void fillTextures(const std::map<std::string, std::pair<uint32_t, Texture*>>& textures);

            void fillCubemaps(const std::map<std::string, std::pair<uint32_t, 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