ShaderUniform.h

#pragma once
 
#include "LkEngine/Core/Core.h"
#include "LkEngine/Core/Math/MathLibrary.h"
 
#include "LkEngine/Serialization/StreamReader.h"
#include "LkEngine/Serialization/StreamWriter.h"
 
 
namespace LkEngine {
 
    enum class ShaderUniformType
    {
        None = 0, 
        Bool, Int, UInt, Float, 
        Vec2, Vec3, Vec4, 
        Mat3, Mat4,
        IVec2, IVec3, IVec4
    };
 
    class ShaderUniform
    {
    public:
        ShaderUniform() = default;
        ShaderUniform(std::string name, ShaderUniformType type, uint32_t size, uint32_t offset);
 
        const std::string& GetName() const { return m_Name; }
        ShaderUniformType GetType() const { return m_Type; }
        uint32_t GetSize() const { return m_Size; }
        uint32_t GetOffset() const { return m_Offset; }
 
        static void Serialize(StreamWriter* serializer, const ShaderUniform& instance)
        {
            serializer->WriteString(instance.m_Name);
            serializer->WriteRaw(instance.m_Type);
            serializer->WriteRaw(instance.m_Size);
            serializer->WriteRaw(instance.m_Offset);
        }
 
        static void Deserialize(StreamReader* deserializer, ShaderUniform& instance)
        {
            deserializer->ReadString(instance.m_Name);
            deserializer->ReadRaw(instance.m_Type);
            deserializer->ReadRaw(instance.m_Size);
            deserializer->ReadRaw(instance.m_Offset);
        }
    private:
        std::string m_Name;
        ShaderUniformType m_Type = ShaderUniformType::None;
        uint32_t m_Size = 0;
        uint32_t m_Offset = 0;
    };
 
    struct ShaderUniformBuffer
    {
        std::string Name;
        uint32_t Index;
        uint32_t BindingPoint;
        uint32_t Size;
        uint32_t RendererID;
        std::vector<ShaderUniform> Uniforms;
    };
 
    struct ShaderStorageBuffer
    {
        std::string Name;
        uint32_t Index;
        uint32_t BindingPoint;
        uint32_t Size;
        uint32_t RendererID;
        std::vector<ShaderUniform> Uniforms;
    };
 
    struct ShaderBuffer
    {
        std::string Name;
        uint32_t Size = 0;
        std::unordered_map<std::string, ShaderUniform> Uniforms;
 
        static void Serialize(StreamWriter* serializer, const ShaderBuffer& instance)
        {
            serializer->WriteString(instance.Name);
            serializer->WriteRaw(instance.Size);
            serializer->WriteMap(instance.Uniforms);
        }
 
        static void Deserialize(StreamReader* deserializer, ShaderBuffer& instance)
        {
            deserializer->ReadString(instance.Name);
            deserializer->ReadRaw(instance.Size);
            deserializer->ReadMap(instance.Uniforms);
        }
    };
 
    namespace VKUtils {
 
        static constexpr std::string_view UniformTypeToString(ShaderUniformType type); // Defined in LkVulkan.cpp
 
    }
 
}