Change the folder structure of the vulkan backend to better reflect what is going on

src/common/rendering/vulkan/buffers/vk_buffer.cpp

@@ -0,0 +1,134 @@
+/*
+**  Vulkan backend
+**  Copyright (c) 2016-2020 Magnus Norddahl
+**
+**  This software is provided 'as-is', without any express or implied
+**  warranty.  In no event will the authors be held liable for any damages
+**  arising from the use of this software.
+**
+**  Permission is granted to anyone to use this software for any purpose,
+**  including commercial applications, and to alter it and redistribute it
+**  freely, subject to the following restrictions:
+**
+**  1. The origin of this software must not be misrepresented; you must not
+**     claim that you wrote the original software. If you use this software
+**     in a product, an acknowledgment in the product documentation would be
+**     appreciated but is not required.
+**  2. Altered source versions must be plainly marked as such, and must not be
+**     misrepresented as being the original software.
+**  3. This notice may not be removed or altered from any source distribution.
+**
+*/
+
+#include "vk_buffer.h"
+#include "vk_hwbuffer.h"
+#include "vulkan/vk_streambuffer.h"
+#include "hwrenderer/data/shaderuniforms.h"
+
+VkBufferManager::VkBufferManager(VulkanRenderDevice* fb) : fb(fb)
+{
+}
+
+VkBufferManager::~VkBufferManager()
+{
+}
+
+void VkBufferManager::Init()
+{
+	MatrixBuffer.reset(new VkStreamBuffer(this, sizeof(MatricesUBO), 50000));
+	StreamBuffer.reset(new VkStreamBuffer(this, sizeof(StreamUBO), 300));
+
+	CreateFanToTrisIndexBuffer();
+}
+
+void VkBufferManager::Deinit()
+{
+	while (!Buffers.empty())
+		RemoveBuffer(Buffers.back());
+}
+
+void VkBufferManager::AddBuffer(VkHardwareBuffer* buffer)
+{
+	buffer->it = Buffers.insert(Buffers.end(), buffer);
+}
+
+void VkBufferManager::RemoveBuffer(VkHardwareBuffer* buffer)
+{
+	buffer->Reset();
+	buffer->fb = nullptr;
+	Buffers.erase(buffer->it);
+
+	for (VkHardwareDataBuffer** knownbuf : { &ViewpointUBO, &LightBufferSSO, &LightNodes, &LightLines, &LightList, &BoneBufferSSO })
+	{
+		if (buffer == *knownbuf) *knownbuf = nullptr;
+	}
+}
+
+IVertexBuffer* VkBufferManager::CreateVertexBuffer()
+{
+	return new VkHardwareVertexBuffer(fb);
+}
+
+IIndexBuffer* VkBufferManager::CreateIndexBuffer()
+{
+	return new VkHardwareIndexBuffer(fb);
+}
+
+IDataBuffer* VkBufferManager::CreateDataBuffer(int bindingpoint, bool ssbo, bool needsresize)
+{
+	auto buffer = new VkHardwareDataBuffer(fb, bindingpoint, ssbo, needsresize);
+
+	switch (bindingpoint)
+	{
+	case LIGHTBUF_BINDINGPOINT: LightBufferSSO = buffer; break;
+	case VIEWPOINT_BINDINGPOINT: ViewpointUBO = buffer; break;
+	case LIGHTNODES_BINDINGPOINT: LightNodes = buffer; break;
+	case LIGHTLINES_BINDINGPOINT: LightLines = buffer; break;
+	case LIGHTLIST_BINDINGPOINT: LightList = buffer; break;
+	case BONEBUF_BINDINGPOINT: BoneBufferSSO = buffer; break;
+	case POSTPROCESS_BINDINGPOINT: break;
+	default: break;
+	}
+
+	return buffer;
+}
+
+void VkBufferManager::CreateFanToTrisIndexBuffer()
+{
+	TArray<uint32_t> data;
+	for (int i = 2; i < 1000; i++)
+	{
+		data.Push(0);
+		data.Push(i - 1);
+		data.Push(i);
+	}
+
+	FanToTrisIndexBuffer.reset(CreateIndexBuffer());
+	FanToTrisIndexBuffer->SetData(sizeof(uint32_t) * data.Size(), data.Data(), BufferUsageType::Static);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+VkStreamBuffer::VkStreamBuffer(VkBufferManager* buffers, size_t structSize, size_t count)
+{
+	mBlockSize = static_cast<uint32_t>((structSize + screen->uniformblockalignment - 1) / screen->uniformblockalignment * screen->uniformblockalignment);
+
+	UniformBuffer = (VkHardwareDataBuffer*)buffers->CreateDataBuffer(-1, false, false);
+	UniformBuffer->SetData(mBlockSize * count, nullptr, BufferUsageType::Persistent);
+}
+
+VkStreamBuffer::~VkStreamBuffer()
+{
+	delete UniformBuffer;
+}
+
+uint32_t VkStreamBuffer::NextStreamDataBlock()
+{
+	mStreamDataOffset += mBlockSize;
+	if (mStreamDataOffset + (size_t)mBlockSize >= UniformBuffer->Size())
+	{
+		mStreamDataOffset = 0;
+		return 0xffffffff;
+	}
+	return mStreamDataOffset;
+}

src/common/rendering/vulkan/buffers/vk_buffer.h

@@ -0,0 +1,65 @@
+
+#pragma once
+
+#include "zvulkan/vulkanobjects.h"
+#include <list>
+
+class VulkanRenderDevice;
+class VkHardwareBuffer;
+class VkHardwareDataBuffer;
+class VkStreamBuffer;
+class IIndexBuffer;
+class IVertexBuffer;
+class IDataBuffer;
+
+class VkBufferManager
+{
+public:
+	VkBufferManager(VulkanRenderDevice* fb);
+	~VkBufferManager();
+
+	void Init();
+	void Deinit();
+
+	IVertexBuffer* CreateVertexBuffer();
+	IIndexBuffer* CreateIndexBuffer();
+	IDataBuffer* CreateDataBuffer(int bindingpoint, bool ssbo, bool needsresize);
+
+	void AddBuffer(VkHardwareBuffer* buffer);
+	void RemoveBuffer(VkHardwareBuffer* buffer);
+
+	VkHardwareDataBuffer* ViewpointUBO = nullptr;
+	VkHardwareDataBuffer* LightBufferSSO = nullptr;
+	VkHardwareDataBuffer* LightNodes = nullptr;
+	VkHardwareDataBuffer* LightLines = nullptr;
+	VkHardwareDataBuffer* LightList = nullptr;
+	VkHardwareDataBuffer* BoneBufferSSO = nullptr;
+
+	std::unique_ptr<VkStreamBuffer> MatrixBuffer;
+	std::unique_ptr<VkStreamBuffer> StreamBuffer;
+
+	std::unique_ptr<IIndexBuffer> FanToTrisIndexBuffer;
+
+private:
+	void CreateFanToTrisIndexBuffer();
+
+	VulkanRenderDevice* fb = nullptr;
+
+	std::list<VkHardwareBuffer*> Buffers;
+};
+
+class VkStreamBuffer
+{
+public:
+	VkStreamBuffer(VkBufferManager* buffers, size_t structSize, size_t count);
+	~VkStreamBuffer();
+
+	uint32_t NextStreamDataBlock();
+	void Reset() { mStreamDataOffset = 0; }
+
+	VkHardwareDataBuffer* UniformBuffer = nullptr;
+
+private:
+	uint32_t mBlockSize = 0;
+	uint32_t mStreamDataOffset = 0;
+};

src/common/rendering/vulkan/buffers/vk_hwbuffer.cpp

@@ -0,0 +1,254 @@
+/*
+**  Vulkan backend
+**  Copyright (c) 2016-2020 Magnus Norddahl
+**
+**  This software is provided 'as-is', without any express or implied
+**  warranty.  In no event will the authors be held liable for any damages
+**  arising from the use of this software.
+**
+**  Permission is granted to anyone to use this software for any purpose,
+**  including commercial applications, and to alter it and redistribute it
+**  freely, subject to the following restrictions:
+**
+**  1. The origin of this software must not be misrepresented; you must not
+**     claim that you wrote the original software. If you use this software
+**     in a product, an acknowledgment in the product documentation would be
+**     appreciated but is not required.
+**  2. Altered source versions must be plainly marked as such, and must not be
+**     misrepresented as being the original software.
+**  3. This notice may not be removed or altered from any source distribution.
+**
+*/
+
+#include "vk_hwbuffer.h"
+#include "vk_buffer.h"
+#include "vulkan/vk_renderdevice.h"
+#include "vulkan/vk_renderstate.h"
+#include "vulkan/commands/vk_commandbuffer.h"
+#include "vulkan/descriptorsets/vk_descriptorset.h"
+#include <zvulkan/vulkanbuilders.h>
+#include "engineerrors.h"
+
+VkHardwareBuffer::VkHardwareBuffer(VulkanRenderDevice* fb) : fb(fb)
+{
+	fb->GetBufferManager()->AddBuffer(this);
+}
+
+VkHardwareBuffer::~VkHardwareBuffer()
+{
+	if (fb)
+		fb->GetBufferManager()->RemoveBuffer(this);
+}
+
+void VkHardwareBuffer::Reset()
+{
+	if (fb)
+	{
+		if (mBuffer && map)
+		{
+			mBuffer->Unmap();
+			map = nullptr;
+		}
+		if (mBuffer)
+			fb->GetCommands()->DrawDeleteList->Add(std::move(mBuffer));
+		if (mStaging)
+			fb->GetCommands()->TransferDeleteList->Add(std::move(mStaging));
+	}
+}
+
+void VkHardwareBuffer::SetData(size_t size, const void *data, BufferUsageType usage)
+{
+	size_t bufsize = max(size, (size_t)16); // For supporting zero byte buffers
+
+	// If SetData is called multiple times we have to keep the old buffers alive as there might still be draw commands referencing them
+	if (mBuffer)
+	{
+		fb->GetCommands()->DrawDeleteList->Add(std::move(mBuffer));
+	}
+	if (mStaging)
+	{
+		fb->GetCommands()->TransferDeleteList->Add(std::move(mStaging));
+	}
+
+	if (usage == BufferUsageType::Static || usage == BufferUsageType::Stream)
+	{
+		// Note: we could recycle buffers here for the stream usage type to improve performance
+
+		mPersistent = false;
+
+		mBuffer = BufferBuilder()
+			.Usage(VK_BUFFER_USAGE_TRANSFER_DST_BIT | mBufferType, VMA_MEMORY_USAGE_GPU_ONLY)
+			.Size(bufsize)
+			.DebugName(usage == BufferUsageType::Static ? "VkHardwareBuffer.Static" : "VkHardwareBuffer.Stream")
+			.Create(fb->device.get());
+
+		mStaging = BufferBuilder()
+			.Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY)
+			.Size(bufsize)
+			.DebugName(usage == BufferUsageType::Static ? "VkHardwareBuffer.Staging.Static" : "VkHardwareBuffer.Staging.Stream")
+			.Create(fb->device.get());
+
+		if (data)
+		{
+			void* dst = mStaging->Map(0, bufsize);
+			memcpy(dst, data, size);
+			mStaging->Unmap();
+		}
+
+		fb->GetCommands()->GetTransferCommands()->copyBuffer(mStaging.get(), mBuffer.get());
+	}
+	else if (usage == BufferUsageType::Persistent)
+	{
+		mPersistent = true;
+
+		mBuffer = BufferBuilder()
+			.Usage(mBufferType, VMA_MEMORY_USAGE_UNKNOWN, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT)
+			.MemoryType(
+				VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+				VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
+			.Size(bufsize)
+			.DebugName("VkHardwareBuffer.Persistent")
+			.Create(fb->device.get());
+
+		map = mBuffer->Map(0, bufsize);
+		if (data)
+			memcpy(map, data, size);
+	}
+	else if (usage == BufferUsageType::Mappable)
+	{
+		mPersistent = false;
+
+		mBuffer = BufferBuilder()
+			.Usage(mBufferType, VMA_MEMORY_USAGE_UNKNOWN, 0)
+			.MemoryType(
+				VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+				VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
+			.Size(bufsize)
+			.DebugName("VkHardwareBuffer.Mappable")
+			.Create(fb->device.get());
+
+		if (data)
+		{
+			void* dst = mBuffer->Map(0, bufsize);
+			memcpy(dst, data, size);
+			mBuffer->Unmap();
+		}
+	}
+
+	buffersize = size;
+}
+
+void VkHardwareBuffer::SetSubData(size_t offset, size_t size, const void *data)
+{
+	size = max(size, (size_t)16); // For supporting zero byte buffers
+
+	if (mStaging)
+	{
+		void *dst = mStaging->Map(offset, size);
+		memcpy(dst, data, size);
+		mStaging->Unmap();
+
+		fb->GetCommands()->GetTransferCommands()->copyBuffer(mStaging.get(), mBuffer.get(), offset, offset, size);
+	}
+	else
+	{
+		void *dst = mBuffer->Map(offset, size);
+		memcpy(dst, data, size);
+		mBuffer->Unmap();
+	}
+}
+
+void VkHardwareBuffer::Resize(size_t newsize)
+{
+	newsize = max(newsize, (size_t)16); // For supporting zero byte buffers
+
+	// Grab old buffer
+	size_t oldsize = buffersize;
+	std::unique_ptr<VulkanBuffer> oldBuffer = std::move(mBuffer);
+	oldBuffer->Unmap();
+	map = nullptr;
+
+	// Create new buffer
+	mBuffer = BufferBuilder()
+		.Usage(mBufferType, VMA_MEMORY_USAGE_UNKNOWN, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT)
+		.MemoryType(
+			VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+			VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
+		.Size(newsize)
+		.DebugName("VkHardwareBuffer.Resized")
+		.Create(fb->device.get());
+	buffersize = newsize;
+
+	// Transfer data from old to new
+	fb->GetCommands()->GetTransferCommands()->copyBuffer(oldBuffer.get(), mBuffer.get(), 0, 0, oldsize);
+	fb->GetCommands()->TransferDeleteList->Add(std::move(oldBuffer));
+	fb->GetCommands()->WaitForCommands(false);
+	fb->GetDescriptorSetManager()->UpdateHWBufferSet(); // Old buffer may be part of the bound descriptor set
+
+	// Fetch pointer to new buffer
+	map = mBuffer->Map(0, newsize);
+}
+
+void VkHardwareBuffer::Map()
+{
+	if (!mPersistent)
+		map = mBuffer->Map(0, mBuffer->size);
+}
+
+void VkHardwareBuffer::Unmap()
+{
+	if (!mPersistent)
+	{
+		mBuffer->Unmap();
+		map = nullptr;
+	}
+}
+
+void *VkHardwareBuffer::Lock(unsigned int size)
+{
+	size = max(size, (unsigned int)16); // For supporting zero byte buffers
+
+	if (!mBuffer)
+	{
+		// The model mesh loaders lock multiple non-persistent buffers at the same time. This is not allowed in vulkan.
+		// VkDeviceMemory can only be mapped once and multiple non-persistent buffers may come from the same device memory object.
+		mStaticUpload.Resize(size);
+		map = mStaticUpload.Data();
+	}
+	else if (!mPersistent)
+	{
+		map = mBuffer->Map(0, size);
+	}
+	return map;
+}
+
+void VkHardwareBuffer::Unlock()
+{
+	if (!mBuffer)
+	{
+		map = nullptr;
+		SetData(mStaticUpload.Size(), mStaticUpload.Data(), BufferUsageType::Static);
+		mStaticUpload.Clear();
+	}
+	else if (!mPersistent)
+	{
+		mBuffer->Unmap();
+		map = nullptr;
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+void VkHardwareVertexBuffer::SetFormat(int numBindingPoints, int numAttributes, size_t stride, const FVertexBufferAttribute *attrs)
+{
+	VertexFormat = fb->GetRenderPassManager()->GetVertexFormat(numBindingPoints, numAttributes, stride, attrs);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+
+void VkHardwareDataBuffer::BindRange(FRenderState* state, size_t start, size_t length)
+{
+	static_cast<VkRenderState*>(state)->Bind(bindingpoint, (uint32_t)start);
+}
+

src/common/rendering/vulkan/buffers/vk_hwbuffer.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "hwrenderer/data/buffers.h"
+#include "zvulkan/vulkanobjects.h"
+#include "tarray.h"
+#include <list>
+
+#ifdef _MSC_VER
+// silence bogus warning C4250: 'VkHardwareVertexBuffer': inherits 'VkHardwareBuffer::VkHardwareBuffer::SetData' via dominance
+// According to internet infos, the warning is erroneously emitted in this case.
+#pragma warning(disable:4250) 
+#endif
+
+class VulkanRenderDevice;
+
+class VkHardwareBuffer : virtual public IBuffer
+{
+public:
+	VkHardwareBuffer(VulkanRenderDevice* fb);
+	~VkHardwareBuffer();
+
+	void Reset();
+
+	void SetData(size_t size, const void *data, BufferUsageType usage) override;
+	void SetSubData(size_t offset, size_t size, const void *data) override;
+	void Resize(size_t newsize) override;
+
+	void Map() override;
+	void Unmap() override;
+
+	void *Lock(unsigned int size) override;
+	void Unlock() override;
+
+	VulkanRenderDevice* fb = nullptr;
+	std::list<VkHardwareBuffer*>::iterator it;
+
+	VkBufferUsageFlags mBufferType = 0;
+	std::unique_ptr<VulkanBuffer> mBuffer;
+	std::unique_ptr<VulkanBuffer> mStaging;
+	bool mPersistent = false;
+	TArray<uint8_t> mStaticUpload;
+};
+
+class VkHardwareVertexBuffer : public IVertexBuffer, public VkHardwareBuffer
+{
+public:
+	VkHardwareVertexBuffer(VulkanRenderDevice* fb) : VkHardwareBuffer(fb) { mBufferType = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; }
+	void SetFormat(int numBindingPoints, int numAttributes, size_t stride, const FVertexBufferAttribute *attrs) override;
+
+	int VertexFormat = -1;
+};
+
+class VkHardwareIndexBuffer : public IIndexBuffer, public VkHardwareBuffer
+{
+public:
+	VkHardwareIndexBuffer(VulkanRenderDevice* fb) : VkHardwareBuffer(fb) { mBufferType = VK_BUFFER_USAGE_INDEX_BUFFER_BIT; }
+};
+
+class VkHardwareDataBuffer : public IDataBuffer, public VkHardwareBuffer
+{
+public:
+	VkHardwareDataBuffer(VulkanRenderDevice* fb, int bindingpoint, bool ssbo, bool needresize) : VkHardwareBuffer(fb), bindingpoint(bindingpoint)
+	{
+		mBufferType = ssbo ? VK_BUFFER_USAGE_STORAGE_BUFFER_BIT : VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+		if (needresize)
+		{
+			mBufferType |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+		}
+	}
+
+	void BindRange(FRenderState *state, size_t start, size_t length) override;
+
+	int bindingpoint;
+};