buffer.h

#ifndef INCLUDE_BUFFER_H
#define INCLUDE_BUFFER_H

// --- STDLIB ---------------------------------------------
#include <vector>

// --- EXTERN ---------------------------------------------
#include <util/opengl.h>
#include <util/templates.h>

// --- INTERN ---------------------------------------------

namespace glare::core
{
	template<gl::BufferType TBuffer>
	class Buffer
	{
	public:
		Buffer();
		Buffer(Buffer& other) = delete;
		Buffer& operator=(Buffer& other) = delete;
		Buffer(Buffer&& other) = default;
		Buffer& operator=(Buffer&& other) = default;
		~Buffer();

		void bind() const;
		void bind(unsigned point) const;
		void unbind() const;

		unsigned id() const;
		uint64_t residentAddress() const;

		bool resident() const;
		uint64_t makeResident(gl::Access access);
		void makeNonResident() const;

		template<typename T> void upload(size_t count, const T* data, gl::BufferUsage usage) const;
		template<typename T> void upload(const std::vector<T>& data, gl::BufferUsage usage) const;
		template<typename T = uint8_t> void reserve(size_t count, gl::BufferUsage usage) const;
		template<typename T> std::vector<T> download(size_t count, size_t offset = 0) const;

		template<typename TReturn = void> TReturn* map(size_t count, size_t offset, gl::BufferMapBit flags) const;
		template<typename TReturn = void> TReturn* map(size_t count, gl::BufferMapBit flags) const;
		void unmap() const;

	protected:
		gl::handle::buffer m_handle;
		uint64_t m_resident_address = 0;
	};

	// -------------------------------------------------------------------------------------------------------------------------
	// --- IMPLEMENTATIONS -----------------------------------------------------------------------------------------------------
	// -------------------------------------------------------------------------------------------------------------------------

	template<gl::BufferType TBuffer> Buffer<TBuffer>::Buffer() {}

	template<gl::BufferType TBuffer>
	Buffer<TBuffer>::~Buffer()
	{
		makeNonResident();
	}

	template<gl::BufferType TBuffer>
	void Buffer<TBuffer>::bind() const
	{
		gl::bindBuffer(TBuffer, m_handle);
	}

	template<gl::BufferType TBuffer>
	void Buffer<TBuffer>::bind(unsigned point) const
	{
		bind();
		gl::bindBufferBase(TBuffer, point, m_handle);
	}

	template<gl::BufferType TBuffer>
	void Buffer<TBuffer>::unbind() const
	{
		gl::bindBuffer(TBuffer, 0);
	}

	template<gl::BufferType TBuffer>
	unsigned Buffer<TBuffer>::id() const
	{
		return m_handle;
	}

	template<gl::BufferType TBuffer>
	uint64_t Buffer<TBuffer>::residentAddress() const
	{
		return m_resident_address;
	}

	template<gl::BufferType TBuffer>
	bool Buffer<TBuffer>::resident() const
	{
		return gl::isNamedBufferResident(m_handle);
	}

	template<gl::BufferType TBuffer>
	uint64_t Buffer<TBuffer>::makeResident(gl::Access access)
	{
		if (!resident())
		{
			bind();
			gl::makeNamedBufferResident(m_handle, access);
			gl::getNamedBufferParameterui64v(m_handle, gl::GetNamedBufferParameters::eGPUAddress, &m_resident_address);
		}
		assert(resident());
		return m_resident_address;
	}

	template<gl::BufferType TBuffer>
	void Buffer<TBuffer>::makeNonResident() const
	{
		if (resident())
		{
			gl::makeNamedBufferNonResident(m_handle);
		}
	}

	template<gl::BufferType TBuffer>
	template<typename T>
	void Buffer<TBuffer>::upload(size_t count, const T* data, gl::BufferUsage usage) const
	{
		gl::namedBufferData(m_handle, sizeof(T) * count, data, usage);
	}

	template<gl::BufferType TBuffer>
	template<typename T>
	void Buffer<TBuffer>::upload(const std::vector<T>& data, gl::BufferUsage usage) const
	{
		gl::namedBufferData(m_handle, sizeof(T) * data.size(), data.data(), usage);
	}

	template<gl::BufferType TBuffer>
	template<typename T>
	void Buffer<TBuffer>::reserve(size_t count, gl::BufferUsage usage) const
	{
		upload<T>(count, nullptr, usage);
	}

	template<gl::BufferType TBuffer>
	template<typename T>
	std::vector<T> Buffer<TBuffer>::download(size_t count, size_t offset) const
	{
		std::vector<T> out(count);
		memcpy(out.data(), map(count, offset, gl::BufferMapBit::eRead), count * sizeof(T));
		unmap();
		return out;
	}

	template<gl::BufferType TBuffer>
	template<typename TReturn>
	TReturn* Buffer<TBuffer>::map(size_t count, size_t offset, gl::BufferMapBit flags) const
	{
		// as you can't do sizeof(void), you can set it equivalent to 8 bit.
		using measure_t = templates::decide_on_t<std::is_same<void, TReturn>::value, uint8_t, TReturn>;
		return reinterpret_cast<TReturn*>(gl::mapNamedBufferRange(m_handle, offset * sizeof(measure_t), count * sizeof(measure_t), flags));
	}

	template<gl::BufferType TBuffer>
	template<typename TReturn>
	TReturn* Buffer<TBuffer>::map(size_t count, gl::BufferMapBit flags) const
	{
		return map<TReturn>(count, 0, flags);
	}

	template<gl::BufferType TBuffer>
	void Buffer<TBuffer>::unmap() const
	{
		gl::unmapNamedBuffer(m_handle);
	}
}

#endif //INCLUDE_BUFFER_H