Resolve "Resource Management"

Closes #22 (closed)

include/vkcv/Buffer.hpp

@@ -14,13 +14,10 @@ namespace vkcv {
 	//Enum of buffertypes
 	enum BufferType { VERTEX, UNIFORM, STORAGE };
 
-	//(temporary?) struct example for T
-	//TODO
-	struct vertex_t {
-		//glm::vec3 pos;
-		//glm::vec3 color;
-		float x, y, z;
-	};
+	//Functions outsourced to Buffer.cpp file:
+	void outsourcedDestructor(vk::Device device, vk::DeviceMemory bufferMemory, vk::Buffer buffer);
+	vk::Buffer outsourcedCreateBuffer(vk::Device device, BufferType type, size_t size);
+	vk::DeviceMemory outsourcedAllocateMemory(vk::Device device, vk::PhysicalDevice physicalDevice, vk::MemoryRequirements memoryRequirements);
 
 	template<typename T>
 	class Buffer {
@@ -34,30 +31,32 @@ namespace vkcv {
 		// explicit destruction of default constructor
 		Buffer<T>() = delete;
 		// is never called directly
-		~Buffer<T>() {
-			m_Device.freeMemory(m_BufferMemory);
-			m_Device.destroyBuffer(m_Buffer);
-		} //noexcept; //gibt Fehlermeldung
+		~Buffer<T>() noexcept {
+			outsourcedDestructor(m_Device, m_BufferMemory, m_Buffer);
+		}
 
 		Buffer<T>(const Buffer<T>& other) = delete; // copy-ctor
-		Buffer<T>(Buffer<T>&& other) {
+		Buffer<T>(Buffer<T>&& other) noexcept :
+		        m_Buffer(other.m_Buffer),
+				m_BufferMemory(other.m_BufferMemory),
+				m_Device(other.m_Device),
+		        m_Type(other.m_Type),
+		        m_Size(other.m_Size),
+		        m_DataP(other.m_DataP)
+		{
 			other.m_Buffer = nullptr;
 			other.m_BufferMemory = nullptr;
 			other.m_Device = nullptr;
-			other.m_MemoryRequirement = nullptr;
-			other.m_Type = vkcv::VERTEX;
+			other.m_Type = vkcv::VERTEX; //set to 0
 			other.m_Size = 0;
 			other.m_DataP = nullptr;
-
-			return *this;
-		} //noexcept; // move-ctor
+		} // move-ctor
 
 		Buffer<T>& operator=(const Buffer<T>& other) = delete; // copy assignment
-		Buffer<T>& operator=(Buffer<T>&& other) {
+		Buffer<T>& operator=(Buffer<T>&& other) noexcept {
 			m_Buffer = other.m_Buffer;
 			m_BufferMemory = other.m_BufferMemory;
 			m_Device = other.m_Device;
-			m_MemoryRequirement = other.m_MemoryRequirement;
 			m_Type = other.m_Type;
 			m_Size = other.m_Size;
 			m_DataP = other.m_DataP;
@@ -65,90 +64,100 @@ namespace vkcv {
 			other.m_Buffer = nullptr;
 			other.m_BufferMemory = nullptr;
 			other.m_Device = nullptr;
-			other.m_MemoryRequirement = nullptr;
-			other.m_Type = vkcv::VERTEX;
+			other.m_Type = vkcv::VERTEX; //set to 0
 			other.m_Size = 0;
 			other.m_DataP = nullptr;
 
-		}//noexcept; // move assignment
+		}// move assignment
 
 		BufferType getType() { return m_Type; };
 		size_t getSize() { return m_Size; };
-
-		//i'm not sure what the input argument has to be, WORK IN PROGRESS
-		//TODO
-		void fill(void* data) {
-			m_DataP = static_cast<uint8_t*>(m_Device.mapMemory(m_BufferMemory, 0, m_MemoryRequirement.size));
-			memcpy(m_DataP, data, sizeof(data));
+		
+		/**
+		 * Maps this buffers Memory, fills this buffer with @p data of type T and count @p count
+		 * unmaps afterwards.
+		 * @p data Pointer to data
+		 * @p count Amount of data of type T
+		 */
+		 // TODO: we will probably need staging-buffer here later (possible add in BufferManager later?)
+		void fill(T* data, size_t count) {
+			const vk::MemoryRequirements requirements = m_Device.getBufferMemoryRequirements(m_Buffer);
+			
+			// TODO: check if mapped already
+			m_DataP = static_cast<uint8_t*>(m_Device.mapMemory(m_BufferMemory, 0, requirements.size));
+			memcpy(m_DataP, data, sizeof(T) * count);
 			m_Device.unmapMemory(m_BufferMemory);
 		};
-		void map() {
-			m_DataP = static_cast<uint8_t*>(m_Device.mapMemory(m_BufferMemory, 0, m_MemoryRequirement.size));
+		
+		T* map() {
+			const vk::MemoryRequirements requirements = m_Device.getBufferMemoryRequirements(m_Buffer);
+			
+			m_DataP = static_cast<uint8_t*>(m_Device.mapMemory(m_BufferMemory, 0, requirements.size));
+			// TODO: make sure to unmap before deallocation
+			
+			return reinterpret_cast<T*>(m_DataP);
 		};
+		
 		void unmap() {
 			m_Device.unmapMemory(m_BufferMemory);
+			// TODO: mark m_DataP as invalid?
 		};
+		
+		/**
+		 * * Create function of #Buffer requires a @p device, a @p physicalDevice, a @p buffer type and a @p size.		 *
+		 * @param device Vulkan-Device
+		 * @param physicalDevice Vulkan-PhysicalDevice
+		 * @param type Enum type of possible vkcv::BufferType
+		 * @param Size size of data
+		 */
+		static Buffer<T> create(vk::Device device, vk::PhysicalDevice physicalDevice, BufferType type, size_t size) {
+			vk::Buffer buffer = nullptr;
+			
+
+			buffer = outsourcedCreateBuffer(device, type, sizeof(T) * size);
+			
+			if (!buffer) {
+				//TODO: potential issue
+			}
+			
+			//get requirements for allocation
+			const vk::MemoryRequirements requirements = device.getBufferMemoryRequirements(buffer);
+			
+			vk::DeviceMemory memory= outsourcedAllocateMemory(device, physicalDevice, requirements);
+			
+			if (!memory) {
+				//TODO: other potential issue
+			}
+			
+			device.bindBufferMemory(buffer, memory, 0);
+			
+			return Buffer<T>(buffer, memory, device, type, size);
+		}
 
 	private:
 		vk::Buffer m_Buffer;
 		vk::DeviceMemory m_BufferMemory;
 		vk::Device m_Device;
-		vk::MemoryRequirements m_MemoryRequirement;
 		BufferType m_Type;
 		size_t m_Size=0;
-		static uint8_t* m_DataP;
+		uint8_t* m_DataP;
 
 		/**
-		 * @brief searches memory type index for buffer allocation, inspired by vulkan tutorial and "https://github.com/KhronosGroup/Vulkan-Hpp/blob/master/samples/utils/utils.hpp"
-		 * @param memoryProperties 
-		 * @param typeBits 
-		 * @param requirementsMask 
-		 * @return memory type for Buffer
-		*/
-		uint32_t searchMemoryType(vk::PhysicalDeviceMemoryProperties const& physicalMemoryProperties, uint32_t typeBits, vk::MemoryPropertyFlags requirements) {
-			uint32_t memoryTypeIndex = uint32_t(0);
-			for (uint32_t i = 0; i < physicalMemoryProperties.memoryTypeCount; i++)
-			{
-				if ((typeBits & 1) &&
-					((physicalMemoryProperties.memoryTypes[i].propertyFlags & requirements) == requirements))
-				{
-					memoryTypeIndex = i;
-					break;
-				}
-				typeBits >>= 1;
-			}
-			return memoryTypeIndex;
-		};
-
-		/**
-		 * * Constructor of #Buffer requires a @p device, a @p physicalDevice, a @p buffer type and a @p size.
-		 *
+		 * * Constructor of #Buffer requires a @p buffer, a @p memory, @p device, @ requirement, a @p buffer type and a @p size.
+		 * @param buffer Vulkan-Buffer
+		 * @param memory Vulkan-DeviceMemory
 		 * @param device Vulkan-Device
-		 * @param physicalDevice Vulkan-PhysicalDevice
+		 * @param requirement Vulkan-MemoryRequirements
 		 * @param type Enum type of possible vkcv::BufferType
 		 * @param Size size of data
 		 */
-		Buffer<T>(vk::Device device, vk::PhysicalDevice physicalDevice, BufferType type, size_t size) {
-			m_Type = type;
-			m_Size = size;
-			m_Device = device;
-
-
-			switch (m_Type) {
-				case VERTEX: {
-					//create vertex buffer
-					m_Buffer = m_Device.createBuffer(vk::BufferCreateInfo(vk::BufferCreateFlags(), sizeof(T) * m_Size, vk::BufferUsageFlagBits::eVertexBuffer));
-				}
-			}
-			//get requirements for allocation
-			m_MemoryRequirement = m_Device.getBufferMemoryRequirements(m_Buffer);
-			//find Memory Type 
-			uint32_t memoryType = searchMemoryType(physicalDevice.getMemoryProperties(), m_MemoryRequirement.memoryTypeBits, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);
-			//allocate memory for buffer
-			m_BufferMemory = m_Device.allocateMemory(vk::MemoryAllocateInfo(m_MemoryRequirement.size, memoryType));
-
-			device.bindBufferMemory(m_Buffer, m_BufferMemory, 0);
-		}
-	
+		Buffer<T>(vk::Buffer buffer, vk::DeviceMemory memory, vk::Device device, BufferType type, size_t size) :
+				m_Buffer(buffer),
+				m_BufferMemory(memory),
+				m_Device(device),
+				m_Type(type),
+				m_Size(size),
+				m_DataP(nullptr)
+		{}	
 	};
 }