When utilizing uniform buffers do you have to set the dimensions of the buffer to actually massive to have the ability to use several types of shaders with totally different variety of parameters. for instance shall we say i’ve a cloth class that could be a pbr materials that has a vec4, and three floats and one other materials class that has 1 float or perhaps 10 params would you create a uniform buffer for every materials or use one, proper now i’ve a renderer that create a uniform buffer with a particular dimension, that will get up to date per body for every materials would this trigger an issue later if i made a decision so as to add a brand new materials with many extra params? When making an attempt to offer every object its personal knowledge to submit and creating an uniform buffer each time a cloth was created the final values set would override the primary however since its within the renderer it doesnt have this drawback. this the fabric code a have which is straightforward

class Material : public MaterialInterface
{
public:
    Material(const Ref<Shader>& shader, MaterialFlags::Flag flags = 0)

    digital ~Material();

    Ref<Shader>& GetShader() override { return m_Shader; }

    digital void Bind() override;

    digital void UnBind() override;

    void SetTexture(const std::string& title, const Ref<Texture>& texture);

    MaterialFlags::Flag m_Flags;

    digital uint32_t GetParametersSize() override = 0;

    digital ShaderSamplerMetaData& GetTextureParameters() { return m_Textures; };


protected:

    Ref<Shader> m_Shader;

    //Ref<UniformBuffer> m_MaterialBuffer;

    Ref<Texture> m_WhiteTexture;
    Ref<Texture> m_BlueTexture;
    Ref<Texture> m_BlackTexture;


    ShaderSamplerMetaData m_Textures;

non-public:

    void SendParameterDataToShader();
    void ShipTextureIDsToShader();
};

struct PBRParameters : MaterialParameters
{
    glm::vec4 AlbedoColor = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
    float Metallic = 1.0f;
    float Roughness = 0.1f;
    float Emissive = 1.0f;
    
};

class PBRMaterial : public Material
{
public:

    PBRMaterial(const Ref<Shader>& shader, MaterialFlags::Flag flags = 0);

    digital MaterialParameters* GetParameters() override { return &m_Parameters; }

    digital uint32_t GetParametersSize() override { return sizeof(PBRParameters); }

    PBRParameters m_Parameters;
}; struct LineVertex
{
    glm::vec3 m_Position;
    glm::vec4 m_Color;
};

struct RenderData
{
    
    struct CameraKnowledge
    {
        glm::mat4 m_ViewProjection;
        glm::vec3 m_Position;
        float m_Time;
    };

    

    struct LevelLightKnowledge
    {
        struct alignas(16) LevelLight
        {
            glm::vec4 m_Position{};
            glm::vec4 m_Color{};
            float m_Constant{};
            float m_Linear{};
            float m_Quadratic{};
        };

        int m_NumPointLights = 0;
        LevelLight m_PointLights[100] = {};

        static uint32_t GetSize()
        {
            return (uint32_t)(sizeof(LevelLightKnowledge) * 100 + sizeof(int));
        }
        
    };

    CameraKnowledge m_CameraBuffer;
    LevelLightKnowledge m_LightBuffer;
    Ref<UniformBuffer> CameraUniformBuffer;
    Ref<UniformBuffer> TranformUniformBuffer;
    Ref<UniformBuffer> LightUniformBuffer;
    Ref<UniformBuffer> MaterialUniformBuffer;
};

static RenderData s_RenderData;

void Renderer::Init()
{
    RenderCommand::Init();
    RenderCommand::SetLineWidth(1.0f);
    
    s_RenderData.CameraUniformBuffer = UniformBuffer::Create(sizeof(RenderData::CameraKnowledge), 0);
    s_RenderData.TranformUniformBuffer = UniformBuffer::Create(sizeof(glm::mat4), 1);
    s_RenderData.LightUniformBuffer = UniformBuffer::Create(RenderData::LevelLightKnowledge::GetSize(), 3);
    s_RenderData.MaterialUniformBuffer = UniformBuffer::Create(sizeof(PBRParameters), 2);

    RenderCommand::SetClearColor({ 0.2f, 0.2f, 0.2f, 1.0f });
}

void Renderer::ShutDown()
{
    
}

void Renderer::BeginScene(Camera* digicam, const Transform& digicamTransform)
{
    s_RenderData.m_CameraBuffer.m_ViewProjection = camera->GetProjection() * glm::inverse(digicamTransform.GetTransform());
    s_RenderData.m_CameraBuffer.m_Position = digicamTransform.m_Translation;
    s_RenderData.m_CameraBuffer.m_Time = Time::GetTime();
    s_RenderData.CameraUniformBuffer->SetData(&s_RenderData.m_CameraBuffer, sizeof(RenderData::CameraKnowledge));
}

void Renderer::SubmitLightKnowledge(Light* mild, const Transform& mildTransform)
{

    if (auto point_light = Cast<LevelLight>(mild))
    {
        SubmitLevelLightKnowledge(point_light, mildTransform);
    }
}

void Renderer::EndScene()
{
    s_RenderData.m_LightBuffer.m_NumPointLights = 0;
}

void Renderer::OnWindowResize(uint32_t width, int32_t top)
{
    RenderCommand::SetViewport(width, top);
}

void Renderer::Submit(const Ref<MaterialInterface>& materialinterface, const Ref<VertexArray>& vertexArray, const Transform& rework)
{
    if (materialinterface)
    {
        materialinterface->Bind();
    }

    auto transformmatrix = rework.GetTransform();
    s_RenderData.TranformUniformBuffer->SetData(&transformmatrix, sizeof(glm::mat4));

    auto parameters = materialinterface->GetParameters();
    s_RenderData.MaterialUniformBuffer->SetData(parameters, materialinterface->GetParametersSize());

    vertexArray->Bind();
    RenderCommand::DrawIndexed(vertexArray);

    if (materialinterface)
    {
        materialinterface->UnBind();
    }
}

void Renderer::SubmitLightUniformBufferData()
{
    s_RenderData.LightUniformBuffer->SetData(&s_RenderData.m_LightBuffer, RenderData::LevelLightKnowledge::GetSize());
}

void Renderer::SubmitLevelLightKnowledge(LevelLight* levelLight, const Transform& mildTransform)
{
    int index = s_RenderData.m_LightBuffer.m_NumPointLights++;

    s_RenderData.m_LightBuffer.m_PointLights[index].m_Constant  =   levelLight->m_Constant;
    s_RenderData.m_LightBuffer.m_PointLights[index].m_Linear    =   levelLight->m_Linear;
    s_RenderData.m_LightBuffer.m_PointLights[index].m_Quadratic =   levelLight->m_Quadratic;
    s_RenderData.m_LightBuffer.m_PointLights[index].m_Color     =   glm::vec4(levelLight->m_Color, 0.0f);
    s_RenderData.m_LightBuffer.m_PointLights[index].m_Position  =   glm::vec4(mildTransform.m_Translation, 0.0f);

}