Added OpenGL Buffer functions, fixes and unit tests.

Added a Buffer functions to clear using offsets, download_data returning an array and check for empty.
Fixed incorrect usage for GLEnum format from GL_R8 to GL_RGBA, bad used_capacity assignment in shrink to size.

Author: MStachowicz

source/OpenGL/GLSL/prefix_sum_second_pass.comp

@@ -13,7 +13,7 @@ layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
 
 uniform uint offset; // The offset into the array for outputting the sum results per reduction stage.
 
-layout(std430) buffer readonly GlobalSum
+layout(std430) readonly buffer GlobalSum
 {
 	uint data[];
 } global_sum;

source/OpenGL/Types.cpp

@@ -111,12 +111,13 @@ namespace OpenGL
 	}
 	void Buffer::shrink_to_size(size_t p_size)
 	{
-		if (p_size >= m_used_capacity)
+		if (p_size >= m_capacity)
 			return;
 
 		Buffer new_buffer{m_flags, p_size};
 		copy_named_buffer_sub_data(m_handle, new_buffer.m_handle, 0, 0, p_size);
-		new_buffer.m_used_capacity   = p_size;
+		new_buffer.m_used_capacity = std::min(m_used_capacity, p_size);
+
 		*this               = std::move(new_buffer);
 
 		if constexpr (LogGLTypeEvents || LogGLBufferEvents) LOG("[OPENGL][BUFFER] Shrinking buffer {} from {}B to {}B", m_handle, m_used_capacity, p_size);
@@ -135,11 +136,21 @@ namespace OpenGL
 	}
 	void Buffer::clear()
 	{
-		clear_named_buffer_sub_data(m_handle, GL_R8, 0, m_used_capacity, GL_R8, GL_UNSIGNED_BYTE, nullptr);
+		clear_named_buffer_sub_data(m_handle, GL_R8, 0, m_used_capacity, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 		m_used_capacity   = 0;
 
 		if constexpr (LogGLTypeEvents || LogGLBufferEvents) LOG("[OPENGL][BUFFER] Clearing {}B of buffer data from buffer {}", m_used_capacity, m_handle);
 	}
+	void Buffer::clear(size_t p_start_offset, size_t p_size)
+	{
+		clear_named_buffer_sub_data(m_handle, GL_R8, p_start_offset, p_size, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+		// Only adjust m_used_capacity if the cleared range affects the end of the buffer. Gaps in the buffer are not considered used.
+		if (p_start_offset + p_size >= m_used_capacity)
+			m_used_capacity = p_start_offset;
+
+		if constexpr (LogGLTypeEvents || LogGLBufferEvents) LOG("[OPENGL][BUFFER] Clearing {}B of buffer data from buffer {} starting at offset {}", p_size, m_handle, p_start_offset);
+	}
 	bool Buffer::is_immutable() const
 	{
 		GLint is_immutable = 0;

source/OpenGL/Types.hpp

@@ -99,6 +99,15 @@ namespace OpenGL
 			get_named_buffer_sub_data(m_handle, 0, m_used_capacity, data.data());
 			return data;
 		}
+		template<typename T, size_t N>
+		std::array<T, N> download_data_array(size_t offset = 0) const
+		{
+			ASSERT(N * sizeof(T) <= m_used_capacity - offset, "Downloading data out of bounds.");
+
+			std::array<T, N> data;
+			get_named_buffer_sub_data(m_handle, offset, m_used_capacity, data.data());
+			return data;
+		}
 
 		// Set the section of the buffer starting at p_offset to p_data.
 		template<typename T>
@@ -177,10 +186,15 @@ namespace OpenGL
 		void shrink_to_fit();
 		// Clears the buffer object's data store. All existing data is lost.
 		void clear();
+		// Clears a section of the buffer starting at p_start_offset and p_size bytes long.
+		//@param p_start_offset The offset in bytes from the start of the buffer to the start of the data to clear.
+		//@param p_size The number of bytes to clear.
+		void clear(size_t p_start_offset, size_t p_size);
 
 		size_t capacity()           const { return m_capacity; }
 		size_t used_capacity()      const { return m_used_capacity; }
 		float used_capacity_ratio() const { return (float)m_used_capacity / (float)m_capacity; }
+		bool empty()                const { return m_used_capacity == 0; }
 		bool is_immutable()         const;
 	};
 	// Meta struct to hold information about a vertex attribute.

source/Test/TestManager.hpp

@@ -13,6 +13,16 @@
 
 namespace std
 {
+	template<>
+	struct formatter<std::byte>
+	{
+		constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
+		auto format(const std::byte& v, format_context& ctx) const
+		{
+			unsigned int byte = static_cast<unsigned int>(v);
+			return format_to(ctx.out(), "{}", byte);
+		}
+	};
 	template<>
 	struct formatter<glm::vec3>
 	{
@@ -41,6 +51,16 @@ namespace Test
 	#define CHECK_TRUE(p_conditional, p_test_name) { run_unit_test(p_conditional, p_test_name, std::format("Expected: '{}' to be true\n{}", #p_conditional, to_string(std::source_location::current()))); }
 	#define CHECK_EQUAL(p_value, p_expected_value, p_test_name) { run_unit_test(p_value == p_expected_value, p_test_name, std::format("Expected {} ({}) to equal {} ({})\n{}", #p_value, p_value, #p_expected_value, p_expected_value, to_string(std::source_location::current()))); }
 	#define CHECK_EQUAL_FLOAT(p_value, p_expected_value, p_test_name, p_epsilon) { run_unit_test(glm::epsilonEqual(p_value, p_expected_value, p_epsilon), p_test_name, std::format("Expected {} ({}) to equal {} ({}) with epsilon {}\n{}", #p_value, p_value, #p_expected_value, p_expected_value, p_epsilon, to_string(std::source_location::current()))); }
+	#define CHECK_CONTAINER_EQUAL(p_container, p_expected_container, p_test_name)\
+	{\
+		if (p_container.size() != p_expected_container.size())\
+		{\
+			CHECK_EQUAL(p_container.size(), p_expected_container.size(), "Container size mismatch");\
+			return;\
+		}\
+		for (size_t i = 0; i < p_container.size(); ++i)\
+			CHECK_EQUAL(p_container[i], p_expected_container[i], std::format("{} {}", p_test_name, i));\
+	}
 	#define SCOPE_SECTION(p_section_name) auto a_random_name_that_will_never_collide_with_anything = ScopeSection(p_section_name, *this);
 
 	// A pure-virtual API for running unit tests and performance tests.

source/Test/Tests/GraphicsTester.cpp

@@ -20,6 +20,37 @@ namespace Test
 		Platform::Core::initialise_OpenGL();
 
 
+		{SCOPE_SECTION("Buffer")
+			{SCOPE_SECTION("Memory handling")
+				OpenGL::Buffer buffer = OpenGL::Buffer({OpenGL::BufferStorageFlag::DynamicStorageBit}, 1024);
+
+				CHECK_EQUAL(buffer.capacity(), 1024, "Constructor capacity");
+				CHECK_EQUAL(buffer.used_capacity(), 0, "Constructor used capacity");
+
+				buffer.reserve(2048);
+				CHECK_EQUAL(buffer.capacity(), 2048, "Reserve capacity");
+				CHECK_EQUAL(buffer.used_capacity(), 0, "Reserve used capacity");
+
+				buffer.shrink_to_size(1024);
+				CHECK_EQUAL(buffer.capacity(), 1024, "Shrink to size capacity");
+				CHECK_EQUAL(buffer.used_capacity(), 0, "Shrink to size used capacity");
+
+				buffer.shrink_to_fit();
+				CHECK_EQUAL(buffer.capacity(), 0, "Shrink to fit capacity");
+				CHECK_EQUAL(buffer.used_capacity(), 0, "Shrink to fit used capacity");
+
+				buffer.reserve(1024);
+				CHECK_EQUAL(buffer.capacity(), 1024, "Reserve capacity");
+				CHECK_EQUAL(buffer.used_capacity(), 0, "Reserve used capacity");
+
+				test_buffer<std::byte>();
+				test_buffer<float>();
+				test_buffer<int>();
+				test_buffer<uint16_t>();
+			}
+		}
+
+
 		{SCOPE_SECTION("Compute")
 			{SCOPE_SECTION("Increment")
 				std::array<unsigned int, 8> data = { 1, 2, 3, 4, 5, 6, 7, 8 };

source/Test/Tests/GraphicsTester.hpp

@@ -2,6 +2,8 @@
 
 #include "Test/TestManager.hpp"
 
+#include "OpenGL/Types.hpp"
+
 namespace Test
 {
 	class GraphicsTester : public TestManager
@@ -11,5 +13,85 @@ namespace Test
 
 		void run_unit_tests()        override;
 		void run_performance_tests() override;
+
+	private:
+
+		template <typename value_type>
+		void test_buffer()
+		{
+			{SCOPE_SECTION("Byte")
+				OpenGL::Buffer byte_buffer = OpenGL::Buffer({OpenGL::BufferStorageFlag::DynamicStorageBit}, sizeof(value_type) * 4);
+				const auto arr             = std::array<value_type, 2>{ value_type{2}, value_type{3} };
+				const auto min_data        = std::numeric_limits<value_type>::min();
+				const auto max_data        = std::numeric_limits<value_type>::max();
+
+				{SCOPE_SECTION("Baseline")
+					bool caught_exception = false;
+					try { byte_buffer.download_data_array<value_type, 4>(); }
+					catch (const std::exception& e) { caught_exception = true; }
+
+					// Buffer = {0, 0, 0, 0}, We expect the buffer to be zeroed out on creation.
+					// Cannot download data from an empty buffer so tets for thrown exception instead.
+					CHECK_TRUE(caught_exception, "Download data from empty buffer");
+					CHECK_EQUAL(byte_buffer.used_capacity(), 0, "Used capacity");
+					CHECK_EQUAL(byte_buffer.capacity(), sizeof(value_type) * 4, "Capacity");
+				}
+
+				{SCOPE_SECTION("Set index 0")
+					byte_buffer.set_data(min_data);
+					// Buffer = {0, 0, 0, 0}, Set index 0 to min (0).
+					std::array<value_type, 1> expected_result = { min_data };
+					auto result = byte_buffer.download_data_array<value_type, 1>();
+
+					CHECK_CONTAINER_EQUAL(result, expected_result, "Check data after setting index 0");
+					CHECK_EQUAL(byte_buffer.used_capacity(), sizeof(value_type), "Used capacity");
+					CHECK_EQUAL(byte_buffer.capacity(), sizeof(value_type) * 4, "Capacity");
+				}
+				{SCOPE_SECTION("Set index 1")
+					byte_buffer.set_data(max_data);
+					// Buffer = {0, 255, 0, 0}, Set index 1 to max.
+					std::array<value_type, 2> expected_result = { min_data, max_data };
+					auto result = byte_buffer.download_data_array<value_type, 2>();
+
+					CHECK_CONTAINER_EQUAL(result, expected_result, "Check data after setting index 1");
+					CHECK_EQUAL(byte_buffer.used_capacity(), sizeof(value_type) * 2, "Used capacity");
+					CHECK_EQUAL(byte_buffer.capacity(), sizeof(value_type) * 4, "Capacity");
+				}
+				{SCOPE_SECTION("Set array to index 2")
+					byte_buffer.set_data(arr);
+					std::array<value_type, 4> expected_result = { min_data, max_data, arr[0], arr[1] };
+					// Buffer = {0, 255, 2, 3}, Set index 2 and 3 to array values.
+					auto result = byte_buffer.download_data_array<value_type, 4>();
+
+					CHECK_CONTAINER_EQUAL(result, expected_result, "Check data after setting array");
+					CHECK_EQUAL(byte_buffer.used_capacity(), sizeof(value_type) * 4, "Used capacity");
+					CHECK_EQUAL(byte_buffer.capacity(), sizeof(value_type) * 4, "Capacity");
+				}
+				{SCOPE_SECTION("Clear index 1")
+					byte_buffer.clear(sizeof(value_type), sizeof(value_type));
+					// Clear data not at the end, should not affect used capacity.
+					//              V clearing this byte.
+					// Buffer = {0, 0, 2, 3}, Clear index 1.
+					std::array<value_type, 4> expected_result_non_end_remove = { min_data, value_type{0}, arr[0], arr[1] };
+					auto result = byte_buffer.download_data_array<value_type, 4>();
+
+					CHECK_CONTAINER_EQUAL(result, expected_result_non_end_remove, "Clear byte in middle download data");
+					CHECK_EQUAL(byte_buffer.used_capacity(), sizeof(value_type) * 4, "Clear byte in middle used capacity");
+					CHECK_EQUAL(byte_buffer.capacity(), sizeof(value_type) * 4, "Capacity");
+				}
+				{SCOPE_SECTION("Clear index 3")
+					byte_buffer.clear(3 * sizeof(value_type), sizeof(value_type));
+					// Clear data from the end should reduce used capacity.
+					//                 C  V Despite clearing off the end, the value is still there in the current implementation.
+					// Buffer = {0, 0, 2, 0}, Clear index 3.
+					std::array<value_type, 3> expected_result_end = { min_data, value_type{0}, arr[0] };
+					auto result = byte_buffer.download_data_array<value_type, 3>();
+
+					CHECK_CONTAINER_EQUAL(result, expected_result_end, "Clear byte at end download data");
+					CHECK_EQUAL(byte_buffer.used_capacity(), sizeof(value_type) * 3, "Clear byte at end used capacity");
+					CHECK_EQUAL(byte_buffer.capacity(), sizeof(value_type) * 4, "Capacity");
+				}
+			}
+		}
 	};
 } // namespace Test