ConstantBuffer.h

#pragma once
#include "Graphics/Common.h"
 
namespace Nui::Graphics
{
    constexpr U32 CalculateCBSize(U32 size)
    {
        return ((size + 15) / 16) * 16;
    }
 
    template <typename T>
    class ConstantBuffer
    {
    public:
        ConstantBuffer()
            : GPUWritable(false)
        {
            ZeroMemory(&Data, sizeof(T));
        }
 
        static ConstantBuffer<T> Create(ID3D11Device1* device, bool gpuWritable = false)
        {
            ConstantBuffer<T> cb;
 
            D3D11_BUFFER_DESC desc;
            desc.Usage          = D3D11_USAGE_DYNAMIC;
            desc.BindFlags      = D3D11_BIND_CONSTANT_BUFFER;
            desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
            desc.MiscFlags      = 0;
            desc.ByteWidth      = static_cast<U32>(sizeof(T) + (16 - (sizeof(T) % 16)));
 
            if (gpuWritable)
            {
                desc.Usage          = D3D11_USAGE_DEFAULT;
                desc.CPUAccessFlags = 0;
            }
            GPUWritable = gpuWritable;
 
            DXCall(device->CreateBuffer(&desc, nullptr, cb.Buffer.ReleaseAndGetAddressOf()));
 
            return cb;
        }
 
        void ApplyChanges(ID3D11DeviceContext1* ctx)
        {
            if (!Buffer)
                throw std::runtime_error("Trying to apply changes on a constant buffer that was not created");
 
            if (GPUWritable)
            {
                ctx->UpdateSubresource(Buffer.Get(), 0, nullptr, &Data, 0, 0);
            }
            else
            {
                D3D11_MAPPED_SUBRESOURCE mappedResource{};
                DXCall(ctx->Map(Buffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource));
                CopyMemory(mappedResource.pData, &Data, sizeof(T));
                ctx->Unmap(Buffer, 0);
            }
        }
 
        void SetVS(ID3D11DeviceContext1* ctx, U32 slot)
        {
            if (!Buffer)
                throw std::runtime_error("Constant buffer was nullptr when trying to set for VS");
 
            ID3D11Buffer* bufferArray[1];
            bufferArray[0] = Buffer.Get();
 
            ctx->VSSetConstantBuffers(slot, 1, bufferArray);
        }
 
        void SetPS(ID3D11DeviceContext1* ctx, U32 slot)
        {
            if (!Buffer)
                throw std::runtime_error("Constant buffer was nullptr when trying to set for PS");
 
            ID3D11Buffer* bufferArray[1];
            bufferArray[0] = Buffer.Get();
 
            ctx->PSSetConstantBuffers(slot, 1, bufferArray);
        }
 
        void SetCS(ID3D11DeviceContext1* ctx, U32 slot)
        {
            if (!Buffer)
                throw std::runtime_error("Constant buffer was nullptr when trying to set for CS");
 
            ID3D11Buffer* bufferArray[1];
            bufferArray[0] = Buffer.Get();
 
            ctx->CSSetConstantBuffers(slot, 1, bufferArray);
        }
 
        void SetGS(ID3D11DeviceContext1* ctx, U32 slot)
        {
            if (!Buffer)
                throw std::runtime_error("Constant buffer was nullptr when trying to set for GS");
 
            ID3D11Buffer* bufferArray[1];
            bufferArray[0] = Buffer.Get();
 
            ctx->GSSetConstantBuffers(slot, 1, bufferArray);
        }
 
        void SetHS(ID3D11DeviceContext1* ctx, U32 slot)
        {
            if (!Buffer)
                throw std::runtime_error("Constant buffer was nullptr when trying to set for HS");
 
            ID3D11Buffer* bufferArray[1];
            bufferArray[0] = Buffer.Get();
 
            ctx->HSSetConstantBuffers(slot, 1, bufferArray);
        }
 
        void SetDS(ID3D11DeviceContext1* ctx, U32 slot)
        {
            if (!Buffer)
                throw std::runtime_error("Constant buffer was nullptr when trying to set for DS");
 
            ID3D11Buffer* bufferArray[1];
            bufferArray[0] = Buffer.Get();
 
            ctx->DSSetConstantBuffers(slot, 1, bufferArray);
        }
 
    public:
        T Data;
        ComPtr<ID3D11Buffer> Buffer;
        bool GPUWritable;
    };
}