zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2025-02-17 01:31:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

Create RenderState buffers for each thread

Browse source
This commit is contained in:
Magnus Norddahl 2023-05-12 03:30:40 +02:00 committed by Christoph Oelckers
parent 60fb2af02f
commit 17f8027cc9
14 changed files with 213 additions and 234 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

177
src/common/rendering/vulkan/buffers/vk_buffer.cpp
View file

@ -40,69 +40,10 @@ VkBufferManager::~VkBufferManager()
void VkBufferManager::Init() void VkBufferManager::Init()
{ {
static const FVertexBufferAttribute format[] = for (int threadIndex = 0; threadIndex < fb->MaxThreads; threadIndex++)
{ {
{ 0, VATTR_VERTEX, VFmt_Float3, (int)myoffsetof(FFlatVertex, x) }, RSBuffers.push_back(std::make_unique<VkRSBuffers>(fb));
{ 0, VATTR_TEXCOORD, VFmt_Float2, (int)myoffsetof(FFlatVertex, u) }, }
{ 0, VATTR_LIGHTMAP, VFmt_Float3, (int)myoffsetof(FFlatVertex, lu) },
};
Flatbuffer.VertexFormat = fb->GetRenderPassManager()->GetVertexFormat(1, 3, sizeof(FFlatVertex), format);
Flatbuffer.VertexBuffer = BufferBuilder()
.Usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, 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(Flatbuffer.BUFFER_SIZE * sizeof(FFlatVertex))
.DebugName("Flatbuffer.VertexBuffer")
.Create(fb->GetDevice());
Flatbuffer.Vertices = (FFlatVertex*)Flatbuffer.VertexBuffer->Map(0, Flatbuffer.VertexBuffer->size);
Flatbuffer.IndexBuffer = BufferBuilder()
.Usage(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VMA_MEMORY_USAGE_GPU_ONLY)
.Size(16)
.DebugName("Flatbuffer.IndexBuffer")
.Create(fb->GetDevice());
MatrixBuffer.reset(new VkStreamBuffer(this, sizeof(MatricesUBO), 50000));
StreamBuffer.reset(new VkStreamBuffer(this, sizeof(StreamUBO), 300));
Viewpoint.BlockAlign = (sizeof(HWViewpointUniforms) + fb->uniformblockalignment - 1) / fb->uniformblockalignment * fb->uniformblockalignment;
Viewpoint.UBO = BufferBuilder()
.Usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, 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(Viewpoint.Count * Viewpoint.BlockAlign)
.DebugName("Viewpoint.UBO")
.Create(fb->GetDevice());
Viewpoint.Data = Viewpoint.UBO->Map(0, Viewpoint.UBO->size);
Lightbuffer.UBO = BufferBuilder()
.Usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, 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(Lightbuffer.Count * 4 * sizeof(FVector4))
.DebugName("Lightbuffer.UBO")
.Create(fb->GetDevice());
Lightbuffer.Data = Lightbuffer.UBO->Map(0, Lightbuffer.UBO->size);
Bonebuffer.SSO = BufferBuilder()
.Usage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, 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(Bonebuffer.Count * sizeof(VSMatrix))
.DebugName("Bonebuffer.SSO")
.Create(fb->GetDevice());
Bonebuffer.Data = Bonebuffer.SSO->Map(0, Bonebuffer.SSO->size);
Shadowmap.Nodes.reset(new VkHardwareDataBuffer(fb, true, false)); Shadowmap.Nodes.reset(new VkHardwareDataBuffer(fb, true, false));
Shadowmap.Lines.reset(new VkHardwareDataBuffer(fb, true, false)); Shadowmap.Lines.reset(new VkHardwareDataBuffer(fb, true, false));
@ -113,22 +54,7 @@ void VkBufferManager::Init()
void VkBufferManager::Deinit() void VkBufferManager::Deinit()
{ {
if (Flatbuffer.VertexBuffer) RSBuffers.clear();
Flatbuffer.VertexBuffer->Unmap();
Flatbuffer.VertexBuffer.reset();
Flatbuffer.IndexBuffer.reset();
if (Viewpoint.UBO)
Viewpoint.UBO->Unmap();
Viewpoint.UBO.reset();
if (Lightbuffer.UBO)
Lightbuffer.UBO->Unmap();
Lightbuffer.UBO.reset();
if (Bonebuffer.SSO)
Bonebuffer.SSO->Unmap();
Bonebuffer.SSO.reset();
Shadowmap.Nodes.reset(); Shadowmap.Nodes.reset();
Shadowmap.Lines.reset(); Shadowmap.Lines.reset();
@ -176,9 +102,98 @@ void VkBufferManager::CreateFanToTrisIndexBuffer()
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
VkStreamBuffer::VkStreamBuffer(VkBufferManager* buffers, size_t structSize, size_t count) VkRSBuffers::VkRSBuffers(VulkanRenderDevice* fb)
{ {
mBlockSize = static_cast<uint32_t>((structSize + buffers->fb->uniformblockalignment - 1) / buffers->fb->uniformblockalignment * buffers->fb->uniformblockalignment); static const FVertexBufferAttribute format[] =
{
{ 0, VATTR_VERTEX, VFmt_Float3, (int)myoffsetof(FFlatVertex, x) },
{ 0, VATTR_TEXCOORD, VFmt_Float2, (int)myoffsetof(FFlatVertex, u) },
{ 0, VATTR_LIGHTMAP, VFmt_Float3, (int)myoffsetof(FFlatVertex, lu) },
};
Flatbuffer.VertexFormat = fb->GetRenderPassManager()->GetVertexFormat(1, 3, sizeof(FFlatVertex), format);
Flatbuffer.VertexBuffer = BufferBuilder()
.Usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, 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(Flatbuffer.BUFFER_SIZE * sizeof(FFlatVertex))
.DebugName("Flatbuffer.VertexBuffer")
.Create(fb->GetDevice());
Flatbuffer.Vertices = (FFlatVertex*)Flatbuffer.VertexBuffer->Map(0, Flatbuffer.VertexBuffer->size);
Flatbuffer.IndexBuffer = BufferBuilder()
.Usage(VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VMA_MEMORY_USAGE_GPU_ONLY)
.Size(16)
.DebugName("Flatbuffer.IndexBuffer")
.Create(fb->GetDevice());
MatrixBuffer = std::make_unique<VkStreamBuffer>(fb, sizeof(MatricesUBO), 50000);
StreamBuffer = std::make_unique<VkStreamBuffer>(fb, sizeof(StreamUBO), 300);
Viewpoint.BlockAlign = (sizeof(HWViewpointUniforms) + fb->uniformblockalignment - 1) / fb->uniformblockalignment * fb->uniformblockalignment;
Viewpoint.UBO = BufferBuilder()
.Usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, 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(Viewpoint.Count * Viewpoint.BlockAlign)
.DebugName("Viewpoint.UBO")
.Create(fb->GetDevice());
Viewpoint.Data = Viewpoint.UBO->Map(0, Viewpoint.UBO->size);
Lightbuffer.UBO = BufferBuilder()
.Usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, 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(Lightbuffer.Count * 4 * sizeof(FVector4))
.DebugName("Lightbuffer.UBO")
.Create(fb->GetDevice());
Lightbuffer.Data = Lightbuffer.UBO->Map(0, Lightbuffer.UBO->size);
Bonebuffer.SSO = BufferBuilder()
.Usage(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, 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(Bonebuffer.Count * sizeof(VSMatrix))
.DebugName("Bonebuffer.SSO")
.Create(fb->GetDevice());
Bonebuffer.Data = Bonebuffer.SSO->Map(0, Bonebuffer.SSO->size);
}
VkRSBuffers::~VkRSBuffers()
{
if (Flatbuffer.VertexBuffer)
Flatbuffer.VertexBuffer->Unmap();
Flatbuffer.VertexBuffer.reset();
Flatbuffer.IndexBuffer.reset();
if (Viewpoint.UBO)
Viewpoint.UBO->Unmap();
Viewpoint.UBO.reset();
if (Lightbuffer.UBO)
Lightbuffer.UBO->Unmap();
Lightbuffer.UBO.reset();
if (Bonebuffer.SSO)
Bonebuffer.SSO->Unmap();
Bonebuffer.SSO.reset();
}
/////////////////////////////////////////////////////////////////////////////
VkStreamBuffer::VkStreamBuffer(VulkanRenderDevice* fb, size_t structSize, size_t count)
{
mBlockSize = static_cast<uint32_t>((structSize + fb->uniformblockalignment - 1) / fb->uniformblockalignment * fb->uniformblockalignment);
UBO = BufferBuilder() UBO = BufferBuilder()
.Usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_UNKNOWN, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT) .Usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_UNKNOWN, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT)
@ -187,7 +202,7 @@ VkStreamBuffer::VkStreamBuffer(VkBufferManager* buffers, size_t structSize, size
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
.Size(mBlockSize * count) .Size(mBlockSize * count)
.DebugName("VkStreamBuffer") .DebugName("VkStreamBuffer")
.Create(buffers->fb->GetDevice()); .Create(fb->GetDevice());
Data = UBO->Map(0, UBO->size); Data = UBO->Map(0, UBO->size);
} }

44
src/common/rendering/vulkan/buffers/vk_buffer.h
View file

@ -13,20 +13,11 @@ struct FVertexBufferAttribute;
struct HWViewpointUniforms; struct HWViewpointUniforms;
struct FFlatVertex; struct FFlatVertex;
class VkBufferManager class VkRSBuffers
{ {
public: public:
VkBufferManager(VulkanRenderDevice* fb); VkRSBuffers(VulkanRenderDevice* fb);
~VkBufferManager(); ~VkRSBuffers();
void Init();
void Deinit();
IBuffer* CreateVertexBuffer(int numBindingPoints, int numAttributes, size_t stride, const FVertexBufferAttribute* attrs);
IBuffer* CreateIndexBuffer();
void AddBuffer(VkHardwareBuffer* buffer);
void RemoveBuffer(VkHardwareBuffer* buffer);
struct struct
{ {
@ -65,6 +56,27 @@ public:
void* Data = nullptr; void* Data = nullptr;
} Bonebuffer; } Bonebuffer;
std::unique_ptr<VkStreamBuffer> MatrixBuffer;
std::unique_ptr<VkStreamBuffer> StreamBuffer;
};
class VkBufferManager
{
public:
VkBufferManager(VulkanRenderDevice* fb);
~VkBufferManager();
void Init();
void Deinit();
IBuffer* CreateVertexBuffer(int numBindingPoints, int numAttributes, size_t stride, const FVertexBufferAttribute* attrs);
IBuffer* CreateIndexBuffer();
void AddBuffer(VkHardwareBuffer* buffer);
void RemoveBuffer(VkHardwareBuffer* buffer);
VkRSBuffers* GetRSBuffers(int threadIndex) { return RSBuffers[threadIndex].get(); }
struct struct
{ {
std::unique_ptr<VkHardwareDataBuffer> Nodes; std::unique_ptr<VkHardwareDataBuffer> Nodes;
@ -72,9 +84,6 @@ public:
std::unique_ptr<VkHardwareDataBuffer> Lights; std::unique_ptr<VkHardwareDataBuffer> Lights;
} Shadowmap; } Shadowmap;
std::unique_ptr<VkStreamBuffer> MatrixBuffer;
std::unique_ptr<VkStreamBuffer> StreamBuffer;
std::unique_ptr<IBuffer> FanToTrisIndexBuffer; std::unique_ptr<IBuffer> FanToTrisIndexBuffer;
private: private:
@ -83,14 +92,13 @@ private:
VulkanRenderDevice* fb = nullptr; VulkanRenderDevice* fb = nullptr;
std::list<VkHardwareBuffer*> Buffers; std::list<VkHardwareBuffer*> Buffers;
std::vector<std::unique_ptr<VkRSBuffers>> RSBuffers;
friend class VkStreamBuffer;
}; };
class VkStreamBuffer class VkStreamBuffer
{ {
public: public:
VkStreamBuffer(VkBufferManager* buffers, size_t structSize, size_t count); VkStreamBuffer(VulkanRenderDevice* fb, size_t structSize, size_t count);
~VkStreamBuffer(); ~VkStreamBuffer();
uint32_t NextStreamDataBlock(); uint32_t NextStreamDataBlock();

33
src/common/rendering/vulkan/buffers/vk_hwbuffer.cpp
View file

@ -158,39 +158,6 @@ void VkHardwareBuffer::SetSubData(size_t offset, size_t size, const void *data)
} }
} }
/*
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->GetDevice());
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() void VkHardwareBuffer::Map()
{ {
if (!mPersistent) if (!mPersistent)

8
src/common/rendering/vulkan/buffers/vk_streambuffer.cpp
View file

@ -26,9 +26,9 @@
#include "vulkan/buffers/vk_buffer.h" #include "vulkan/buffers/vk_buffer.h"
#include <zvulkan/vulkanbuilders.h> #include <zvulkan/vulkanbuilders.h>
VkStreamBufferWriter::VkStreamBufferWriter(VulkanRenderDevice* fb) VkStreamBufferWriter::VkStreamBufferWriter(VkRSBuffers* rsbuffers)
{ {
mBuffer = fb->GetBufferManager()->StreamBuffer.get(); mBuffer = rsbuffers->StreamBuffer.get();
} }
bool VkStreamBufferWriter::Write(const StreamData& data) bool VkStreamBufferWriter::Write(const StreamData& data)
@ -55,9 +55,9 @@ void VkStreamBufferWriter::Reset()
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
VkMatrixBufferWriter::VkMatrixBufferWriter(VulkanRenderDevice* fb) VkMatrixBufferWriter::VkMatrixBufferWriter(VkRSBuffers* rsbuffers)
{ {
mBuffer = fb->GetBufferManager()->MatrixBuffer.get(); mBuffer = rsbuffers->MatrixBuffer.get();
} }
bool VkMatrixBufferWriter::Write(const MatricesUBO& matrices) bool VkMatrixBufferWriter::Write(const MatricesUBO& matrices)

5
src/common/rendering/vulkan/buffers/vk_streambuffer.h
View file

@ -5,11 +5,12 @@
#include "vulkan/shaders/vk_shader.h" #include "vulkan/shaders/vk_shader.h"
class VkStreamBuffer; class VkStreamBuffer;
class VkRSBuffers;
class VkStreamBufferWriter class VkStreamBufferWriter
{ {
public: public:
VkStreamBufferWriter(VulkanRenderDevice* fb); VkStreamBufferWriter(VkRSBuffers* rsbuffers);
bool Write(const StreamData& data); bool Write(const StreamData& data);
void Reset(); void Reset();
@ -26,7 +27,7 @@ private:
class VkMatrixBufferWriter class VkMatrixBufferWriter
{ {
public: public:
VkMatrixBufferWriter(VulkanRenderDevice* fb); VkMatrixBufferWriter(VkRSBuffers* rsbuffers);
bool Write(const MatricesUBO& matrices); bool Write(const MatricesUBO& matrices);
void Reset(); void Reset();

2
src/common/rendering/vulkan/commands/vk_commandbuffer.cpp
View file

@ -78,7 +78,7 @@ VulkanCommandBuffer* VkCommandBufferManager::GetTransferCommands()
return mTransferCommands.get(); return mTransferCommands.get();
} }
VulkanCommandBuffer* VkCommandBufferManager::GetDrawCommands() VulkanCommandBuffer* VkCommandBufferManager::GetDrawCommands(int threadIndex)
{ {
if (!mDrawCommands) if (!mDrawCommands)
{ {

2
src/common/rendering/vulkan/commands/vk_commandbuffer.h
View file

@ -15,7 +15,7 @@ public:
void BeginFrame(); void BeginFrame();
VulkanCommandBuffer* GetTransferCommands(); VulkanCommandBuffer* GetTransferCommands();
VulkanCommandBuffer* GetDrawCommands(); VulkanCommandBuffer* GetDrawCommands(int threadIndex = 0);
void FlushCommands(bool finish, bool lastsubmit = false, bool uploadOnly = false); void FlushCommands(bool finish, bool lastsubmit = false, bool uploadOnly = false);

60
src/common/rendering/vulkan/descriptorsets/vk_descriptorset.cpp
View file

@ -39,9 +39,9 @@
VkDescriptorSetManager::VkDescriptorSetManager(VulkanRenderDevice* fb) : fb(fb) VkDescriptorSetManager::VkDescriptorSetManager(VulkanRenderDevice* fb) : fb(fb)
{ {
CreateHWBufferSetLayout(); CreateRSBufferSetLayout();
CreateFixedSetLayout(); CreateFixedSetLayout();
CreateHWBufferPool(); CreateRSBufferPool();
CreateFixedSetPool(); CreateFixedSetPool();
} }
@ -54,7 +54,22 @@ VkDescriptorSetManager::~VkDescriptorSetManager()
void VkDescriptorSetManager::Init() void VkDescriptorSetManager::Init()
{ {
UpdateFixedSet(); UpdateFixedSet();
UpdateHWBufferSet();
for (int threadIndex = 0; threadIndex < fb->MaxThreads; threadIndex++)
{
auto rsbuffers = fb->GetBufferManager()->GetRSBuffers(threadIndex);
auto rsbufferset = RSBufferDescriptorPool->allocate(RSBufferSetLayout.get());
WriteDescriptors()
.AddBuffer(rsbufferset.get(), 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, rsbuffers->Viewpoint.UBO.get(), 0, sizeof(HWViewpointUniforms))
.AddBuffer(rsbufferset.get(), 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, rsbuffers->MatrixBuffer->UBO.get(), 0, sizeof(MatricesUBO))
.AddBuffer(rsbufferset.get(), 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, rsbuffers->StreamBuffer->UBO.get(), 0, sizeof(StreamUBO))
.AddBuffer(rsbufferset.get(), 3, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, rsbuffers->Lightbuffer.UBO.get(), 0, sizeof(LightBufferUBO))
.AddBuffer(rsbufferset.get(), 4, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, rsbuffers->Bonebuffer.SSO.get())
.Execute(fb->GetDevice());
RSBufferSets.push_back(std::move(rsbufferset));
}
} }
void VkDescriptorSetManager::Deinit() void VkDescriptorSetManager::Deinit()
@ -66,27 +81,6 @@ void VkDescriptorSetManager::Deinit()
void VkDescriptorSetManager::BeginFrame() void VkDescriptorSetManager::BeginFrame()
{ {
UpdateFixedSet(); UpdateFixedSet();
UpdateHWBufferSet();
}
void VkDescriptorSetManager::UpdateHWBufferSet()
{
fb->GetCommands()->DrawDeleteList->Add(std::move(HWBufferSet));
HWBufferSet = HWBufferDescriptorPool->tryAllocate(HWBufferSetLayout.get());
if (!HWBufferSet)
{
fb->GetCommands()->WaitForCommands(false);
HWBufferSet = HWBufferDescriptorPool->allocate(HWBufferSetLayout.get());
}
WriteDescriptors()
.AddBuffer(HWBufferSet.get(), 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->Viewpoint.UBO.get(), 0, sizeof(HWViewpointUniforms))
.AddBuffer(HWBufferSet.get(), 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->MatrixBuffer->UBO.get(), 0, sizeof(MatricesUBO))
.AddBuffer(HWBufferSet.get(), 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->StreamBuffer->UBO.get(), 0, sizeof(StreamUBO))
.AddBuffer(HWBufferSet.get(), 3, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->Lightbuffer.UBO.get(), 0, sizeof(LightBufferUBO))
.AddBuffer(HWBufferSet.get(), 4, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->Bonebuffer.SSO.get())
.Execute(fb->GetDevice());
} }
void VkDescriptorSetManager::UpdateFixedSet() void VkDescriptorSetManager::UpdateFixedSet()
@ -254,15 +248,15 @@ std::unique_ptr<VulkanDescriptorSet> VkDescriptorSetManager::AllocatePPDescripto
return PPDescriptorPool->allocate(layout); return PPDescriptorPool->allocate(layout);
} }
void VkDescriptorSetManager::CreateHWBufferSetLayout() void VkDescriptorSetManager::CreateRSBufferSetLayout()
{ {
HWBufferSetLayout = DescriptorSetLayoutBuilder() RSBufferSetLayout = DescriptorSetLayoutBuilder()
.AddBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT) .AddBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT)
.AddBinding(1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT) .AddBinding(1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT)
.AddBinding(2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT) .AddBinding(2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT)
.AddBinding(3, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT) .AddBinding(3, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT)
.AddBinding(4, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT) .AddBinding(4, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT)
.DebugName("VkDescriptorSetManager.HWBufferSetLayout") .DebugName("VkDescriptorSetManager.RSBufferSetLayout")
.Create(fb->GetDevice()); .Create(fb->GetDevice());
} }
@ -285,13 +279,13 @@ void VkDescriptorSetManager::CreateFixedSetLayout()
FixedSetLayout = builder.Create(fb->GetDevice()); FixedSetLayout = builder.Create(fb->GetDevice());
} }
void VkDescriptorSetManager::CreateHWBufferPool() void VkDescriptorSetManager::CreateRSBufferPool()
{ {
HWBufferDescriptorPool = DescriptorPoolBuilder() RSBufferDescriptorPool = DescriptorPoolBuilder()
.AddPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 4 * maxSets) .AddPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 4 * fb->MaxThreads)
.AddPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1 * maxSets) .AddPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1 * fb->MaxThreads)
.MaxSets(maxSets) .MaxSets(fb->MaxThreads)
.DebugName("VkDescriptorSetManager.HWBufferDescriptorPool") .DebugName("VkDescriptorSetManager.RSBufferDescriptorPool")
.Create(fb->GetDevice()); .Create(fb->GetDevice());
} }

17
src/common/rendering/vulkan/descriptorsets/vk_descriptorset.h
View file

@ -19,15 +19,13 @@ public:
void Init(); void Init();
void Deinit(); void Deinit();
void BeginFrame(); void BeginFrame();
void UpdateFixedSet();
void UpdateHWBufferSet();
void ResetHWTextureSets(); void ResetHWTextureSets();
VulkanDescriptorSetLayout* GetHWBufferSetLayout() { return HWBufferSetLayout.get(); } VulkanDescriptorSetLayout* GetRSBufferSetLayout() { return RSBufferSetLayout.get(); }
VulkanDescriptorSetLayout* GetFixedSetLayout() { return FixedSetLayout.get(); } VulkanDescriptorSetLayout* GetFixedSetLayout() { return FixedSetLayout.get(); }
VulkanDescriptorSetLayout* GetTextureSetLayout(int numLayers); VulkanDescriptorSetLayout* GetTextureSetLayout(int numLayers);
VulkanDescriptorSet* GetHWBufferDescriptorSet() { return HWBufferSet.get(); } VulkanDescriptorSet* GetRSBufferDescriptorSet(int threadIndex) { return RSBufferSets[threadIndex].get(); }
VulkanDescriptorSet* GetFixedDescriptorSet() { return FixedSet.get(); } VulkanDescriptorSet* GetFixedDescriptorSet() { return FixedSet.get(); }
VulkanDescriptorSet* GetNullTextureDescriptorSet(); VulkanDescriptorSet* GetNullTextureDescriptorSet();
@ -39,20 +37,21 @@ public:
void RemoveMaterial(VkMaterial* texture); void RemoveMaterial(VkMaterial* texture);
private: private:
void CreateHWBufferSetLayout(); void CreateRSBufferSetLayout();
void CreateFixedSetLayout(); void CreateFixedSetLayout();
void CreateHWBufferPool(); void CreateRSBufferPool();
void CreateFixedSetPool(); void CreateFixedSetPool();
void UpdateFixedSet();
std::unique_ptr<VulkanDescriptorSet> AllocatePPDescriptorSet(VulkanDescriptorSetLayout* layout); std::unique_ptr<VulkanDescriptorSet> AllocatePPDescriptorSet(VulkanDescriptorSetLayout* layout);
VulkanRenderDevice* fb = nullptr; VulkanRenderDevice* fb = nullptr;
std::unique_ptr<VulkanDescriptorSetLayout> HWBufferSetLayout; std::unique_ptr<VulkanDescriptorSetLayout> RSBufferSetLayout;
std::unique_ptr<VulkanDescriptorSetLayout> FixedSetLayout; std::unique_ptr<VulkanDescriptorSetLayout> FixedSetLayout;
std::vector<std::unique_ptr<VulkanDescriptorSetLayout>> TextureSetLayouts; std::vector<std::unique_ptr<VulkanDescriptorSetLayout>> TextureSetLayouts;
std::unique_ptr<VulkanDescriptorPool> HWBufferDescriptorPool; std::unique_ptr<VulkanDescriptorPool> RSBufferDescriptorPool;
std::unique_ptr<VulkanDescriptorPool> FixedDescriptorPool; std::unique_ptr<VulkanDescriptorPool> FixedDescriptorPool;
std::unique_ptr<VulkanDescriptorPool> PPDescriptorPool; std::unique_ptr<VulkanDescriptorPool> PPDescriptorPool;
@ -61,7 +60,7 @@ private:
int TextureDescriptorsLeft = 0; int TextureDescriptorsLeft = 0;
std::vector<std::unique_ptr<VulkanDescriptorPool>> TextureDescriptorPools; std::vector<std::unique_ptr<VulkanDescriptorPool>> TextureDescriptorPools;
std::unique_ptr<VulkanDescriptorSet> HWBufferSet; std::vector<std::unique_ptr<VulkanDescriptorSet>> RSBufferSets;
std::unique_ptr<VulkanDescriptorSet> FixedSet; std::unique_ptr<VulkanDescriptorSet> FixedSet;
std::unique_ptr<VulkanDescriptorSet> NullTextureDescriptorSet; std::unique_ptr<VulkanDescriptorSet> NullTextureDescriptorSet;

2
src/common/rendering/vulkan/pipelines/vk_renderpass.cpp
View file

@ -150,7 +150,7 @@ VulkanPipelineLayout* VkRenderPassManager::GetPipelineLayout(int numLayers)
PipelineLayoutBuilder builder; PipelineLayoutBuilder builder;
builder.AddSetLayout(descriptors->GetFixedSetLayout()); builder.AddSetLayout(descriptors->GetFixedSetLayout());
builder.AddSetLayout(descriptors->GetHWBufferSetLayout()); builder.AddSetLayout(descriptors->GetRSBufferSetLayout());
if (numLayers != 0) if (numLayers != 0)
builder.AddSetLayout(descriptors->GetTextureSetLayout(numLayers)); builder.AddSetLayout(descriptors->GetTextureSetLayout(numLayers));
builder.AddPushConstantRange(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants)); builder.AddPushConstantRange(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants));

2
src/common/rendering/vulkan/vk_renderdevice.cpp
View file

@ -193,7 +193,7 @@ void VulkanRenderDevice::InitializeState()
#ifdef __APPLE__ #ifdef __APPLE__
mRenderState.reset(new VkRenderStateMolten(this)); mRenderState.reset(new VkRenderStateMolten(this));
#else #else
mRenderState.reset(new VkRenderState(this)); mRenderState.reset(new VkRenderState(this, 0));
#endif #endif
} }

2
src/common/rendering/vulkan/vk_renderdevice.h
View file

@ -86,6 +86,8 @@ public:
void WaitForCommands(bool finish) override; void WaitForCommands(bool finish) override;
int MaxThreads = 8; // To do: this may need to be limited by how much memory is available for dedicated buffer mapping (i.e. is resizeable bar available or not)
private: private:
void RenderTextureView(FCanvasTexture* tex, std::function<void(IntRect &)> renderFunc) override; void RenderTextureView(FCanvasTexture* tex, std::function<void(IntRect &)> renderFunc) override;
void PrintStartupLog(); void PrintStartupLog();

86
src/common/rendering/vulkan/vk_renderstate.cpp
View file

@ -40,7 +40,7 @@
CVAR(Int, vk_submit_size, 1000, 0); CVAR(Int, vk_submit_size, 1000, 0);
EXTERN_CVAR(Bool, r_skipmats) EXTERN_CVAR(Bool, r_skipmats)
VkRenderState::VkRenderState(VulkanRenderDevice* fb) : fb(fb), mStreamBufferWriter(fb), mMatrixBufferWriter(fb) VkRenderState::VkRenderState(VulkanRenderDevice* fb, int threadIndex) : fb(fb), threadIndex(threadIndex), mRSBuffers(fb->GetBufferManager()->GetRSBuffers(threadIndex)), mStreamBufferWriter(mRSBuffers), mMatrixBufferWriter(mRSBuffers)
{ {
mMatrices.ModelMatrix.loadIdentity(); mMatrices.ModelMatrix.loadIdentity();
mMatrices.NormalModelMatrix.loadIdentity(); mMatrices.NormalModelMatrix.loadIdentity();
@ -203,7 +203,7 @@ void VkRenderState::Apply(int dt)
ApplyDepthBias(); ApplyDepthBias();
ApplyPushConstants(); ApplyPushConstants();
ApplyVertexBuffers(); ApplyVertexBuffers();
ApplyHWBufferSet(); ApplyBufferSets();
ApplyMaterial(); ApplyMaterial();
mNeedApply = false; mNeedApply = false;
@ -224,7 +224,7 @@ void VkRenderState::ApplyRenderPass(int dt)
// Find a pipeline that matches our state // Find a pipeline that matches our state
VkPipelineKey pipelineKey; VkPipelineKey pipelineKey;
pipelineKey.DrawType = dt; pipelineKey.DrawType = dt;
pipelineKey.VertexFormat = mVertexBuffer ? static_cast<VkHardwareVertexBuffer*>(mVertexBuffer)->VertexFormat : fb->GetBufferManager()->Flatbuffer.VertexFormat; pipelineKey.VertexFormat = mVertexBuffer ? static_cast<VkHardwareVertexBuffer*>(mVertexBuffer)->VertexFormat : mRSBuffers->Flatbuffer.VertexFormat;
pipelineKey.RenderStyle = mRenderStyle; pipelineKey.RenderStyle = mRenderStyle;
pipelineKey.DepthTest = mDepthTest; pipelineKey.DepthTest = mDepthTest;
pipelineKey.DepthWrite = mDepthTest && mDepthWrite; pipelineKey.DepthWrite = mDepthTest && mDepthWrite;
@ -310,7 +310,7 @@ void VkRenderState::ApplyRenderPass(int dt)
if (!inRenderPass) if (!inRenderPass)
{ {
mCommandBuffer = fb->GetCommands()->GetDrawCommands(); mCommandBuffer = fb->GetCommands()->GetDrawCommands(threadIndex);
mScissorChanged = true; mScissorChanged = true;
mViewportChanged = true; mViewportChanged = true;
mStencilRefChanged = true; mStencilRefChanged = true;
@ -451,9 +451,8 @@ void VkRenderState::ApplyVertexBuffers()
} }
else else
{ {
auto buffers = fb->GetBufferManager(); const VkVertexFormat* format = fb->GetRenderPassManager()->GetVertexFormat(mRSBuffers->Flatbuffer.VertexFormat);
const VkVertexFormat* format = fb->GetRenderPassManager()->GetVertexFormat(buffers->Flatbuffer.VertexFormat); VkBuffer vertexBuffers[2] = { mRSBuffers->Flatbuffer.VertexBuffer->buffer, mRSBuffers->Flatbuffer.VertexBuffer->buffer };
VkBuffer vertexBuffers[2] = { buffers->Flatbuffer.VertexBuffer->buffer, buffers->Flatbuffer.VertexBuffer->buffer };
VkDeviceSize offsets[] = { mVertexOffsets[0] * format->Stride, mVertexOffsets[1] * format->Stride }; VkDeviceSize offsets[] = { mVertexOffsets[0] * format->Stride, mVertexOffsets[1] * format->Stride };
mCommandBuffer->bindVertexBuffers(0, 2, vertexBuffers, offsets); mCommandBuffer->bindVertexBuffers(0, 2, vertexBuffers, offsets);
} }
@ -471,7 +470,7 @@ void VkRenderState::ApplyVertexBuffers()
} }
else else
{ {
mCommandBuffer->bindIndexBuffer(fb->GetBufferManager()->Flatbuffer.IndexBuffer->buffer, 0, VK_INDEX_TYPE_UINT32); mCommandBuffer->bindIndexBuffer(mRSBuffers->Flatbuffer.IndexBuffer->buffer, 0, VK_INDEX_TYPE_UINT32);
} }
mLastIndexBuffer = mIndexBuffer; mLastIndexBuffer = mIndexBuffer;
mIndexBufferNeedsBind = false; mIndexBufferNeedsBind = false;
@ -495,7 +494,7 @@ void VkRenderState::ApplyMaterial()
} }
} }
void VkRenderState::ApplyHWBufferSet() void VkRenderState::ApplyBufferSets()
{ {
uint32_t matrixOffset = mMatrixBufferWriter.Offset(); uint32_t matrixOffset = mMatrixBufferWriter.Offset();
uint32_t streamDataOffset = mStreamBufferWriter.StreamDataOffset(); uint32_t streamDataOffset = mStreamBufferWriter.StreamDataOffset();
@ -507,7 +506,7 @@ void VkRenderState::ApplyHWBufferSet()
uint32_t offsets[4] = { mViewpointOffset, matrixOffset, streamDataOffset, lightsOffset }; uint32_t offsets[4] = { mViewpointOffset, matrixOffset, streamDataOffset, lightsOffset };
mCommandBuffer->bindDescriptorSet(VK_PIPELINE_BIND_POINT_GRAPHICS, passManager->GetPipelineLayout(mPipelineKey.NumTextureLayers), 0, fb->GetDescriptorSetManager()->GetFixedDescriptorSet()); mCommandBuffer->bindDescriptorSet(VK_PIPELINE_BIND_POINT_GRAPHICS, passManager->GetPipelineLayout(mPipelineKey.NumTextureLayers), 0, fb->GetDescriptorSetManager()->GetFixedDescriptorSet());
mCommandBuffer->bindDescriptorSet(VK_PIPELINE_BIND_POINT_GRAPHICS, passManager->GetPipelineLayout(mPipelineKey.NumTextureLayers), 1, descriptors->GetHWBufferDescriptorSet(), 4, offsets); mCommandBuffer->bindDescriptorSet(VK_PIPELINE_BIND_POINT_GRAPHICS, passManager->GetPipelineLayout(mPipelineKey.NumTextureLayers), 1, descriptors->GetRSBufferDescriptorSet(threadIndex), 4, offsets);
mLastViewpointOffset = mViewpointOffset; mLastViewpointOffset = mViewpointOffset;
mLastMatricesOffset = matrixOffset; mLastMatricesOffset = matrixOffset;
@ -526,21 +525,20 @@ void VkRenderState::WaitForStreamBuffers()
int VkRenderState::SetViewpoint(const HWViewpointUniforms& vp) int VkRenderState::SetViewpoint(const HWViewpointUniforms& vp)
{ {
auto buffers = fb->GetBufferManager(); if (mRSBuffers->Viewpoint.Count == mRSBuffers->Viewpoint.UploadIndex)
if (buffers->Viewpoint.Count == buffers->Viewpoint.UploadIndex)
{ {
return buffers->Viewpoint.Count - 1; return mRSBuffers->Viewpoint.Count - 1;
} }
memcpy(((char*)buffers->Viewpoint.Data) + buffers->Viewpoint.UploadIndex * buffers->Viewpoint.BlockAlign, &vp, sizeof(HWViewpointUniforms)); memcpy(((char*)mRSBuffers->Viewpoint.Data) + mRSBuffers->Viewpoint.UploadIndex * mRSBuffers->Viewpoint.BlockAlign, &vp, sizeof(HWViewpointUniforms));
int index = buffers->Viewpoint.UploadIndex++; int index = mRSBuffers->Viewpoint.UploadIndex++;
mViewpointOffset = index * buffers->Viewpoint.BlockAlign; mViewpointOffset = index * mRSBuffers->Viewpoint.BlockAlign;
mNeedApply = true; mNeedApply = true;
return index; return index;
} }
void VkRenderState::SetViewpoint(int index) void VkRenderState::SetViewpoint(int index)
{ {
mViewpointOffset = index * fb->GetBufferManager()->Viewpoint.BlockAlign; mViewpointOffset = index * mRSBuffers->Viewpoint.BlockAlign;
mNeedApply = true; mNeedApply = true;
} }
@ -561,8 +559,6 @@ void VkRenderState::SetTextureMatrix(const VSMatrix& matrix)
int VkRenderState::UploadLights(const FDynLightData& data) int VkRenderState::UploadLights(const FDynLightData& data)
{ {
auto buffers = fb->GetBufferManager();
// All meaasurements here are in vec4's. // All meaasurements here are in vec4's.
int size0 = data.arrays[0].Size() / 4; int size0 = data.arrays[0].Size() / 4;
int size1 = data.arrays[1].Size() / 4; int size1 = data.arrays[1].Size() / 4;
@ -593,17 +589,17 @@ int VkRenderState::UploadLights(const FDynLightData& data)
return -1; return -1;
// Make sure the light list doesn't cross a page boundary // Make sure the light list doesn't cross a page boundary
if (buffers->Lightbuffer.UploadIndex % MAX_LIGHT_DATA + totalsize > MAX_LIGHT_DATA) if (mRSBuffers->Lightbuffer.UploadIndex % MAX_LIGHT_DATA + totalsize > MAX_LIGHT_DATA)
buffers->Lightbuffer.UploadIndex = (buffers->Lightbuffer.UploadIndex / MAX_LIGHT_DATA + 1) * MAX_LIGHT_DATA; mRSBuffers->Lightbuffer.UploadIndex = (mRSBuffers->Lightbuffer.UploadIndex / MAX_LIGHT_DATA + 1) * MAX_LIGHT_DATA;
int thisindex = buffers->Lightbuffer.UploadIndex; int thisindex = mRSBuffers->Lightbuffer.UploadIndex;
if (thisindex + totalsize <= buffers->Lightbuffer.Count) if (thisindex + totalsize <= mRSBuffers->Lightbuffer.Count)
{ {
buffers->Lightbuffer.UploadIndex += totalsize; mRSBuffers->Lightbuffer.UploadIndex += totalsize;
float parmcnt[] = { 0, float(size0), float(size0 + size1), float(size0 + size1 + size2) }; float parmcnt[] = { 0, float(size0), float(size0 + size1), float(size0 + size1 + size2) };
float* copyptr = (float*)buffers->Lightbuffer.Data + thisindex * 4; float* copyptr = (float*)mRSBuffers->Lightbuffer.Data + thisindex * 4;
memcpy(&copyptr[0], parmcnt, sizeof(FVector4)); memcpy(&copyptr[0], parmcnt, sizeof(FVector4));
memcpy(&copyptr[4], &data.arrays[0][0], size0 * sizeof(FVector4)); memcpy(&copyptr[4], &data.arrays[0][0], size0 * sizeof(FVector4));
memcpy(&copyptr[4 + 4 * size0], &data.arrays[1][0], size1 * sizeof(FVector4)); memcpy(&copyptr[4 + 4 * size0], &data.arrays[1][0], size1 * sizeof(FVector4));
@ -618,20 +614,18 @@ int VkRenderState::UploadLights(const FDynLightData& data)
int VkRenderState::UploadBones(const TArray<VSMatrix>& bones) int VkRenderState::UploadBones(const TArray<VSMatrix>& bones)
{ {
auto buffers = fb->GetBufferManager();
int totalsize = bones.Size(); int totalsize = bones.Size();
if (bones.Size() == 0) if (bones.Size() == 0)
{ {
return -1; return -1;
} }
int thisindex = buffers->Bonebuffer.UploadIndex; int thisindex = mRSBuffers->Bonebuffer.UploadIndex;
buffers->Bonebuffer.UploadIndex += totalsize; mRSBuffers->Bonebuffer.UploadIndex += totalsize;
if (thisindex + totalsize <= buffers->Bonebuffer.Count) if (thisindex + totalsize <= mRSBuffers->Bonebuffer.Count)
{ {
memcpy((VSMatrix*)buffers->Bonebuffer.Data + thisindex, bones.Data(), bones.Size() * sizeof(VSMatrix)); memcpy((VSMatrix*)mRSBuffers->Bonebuffer.Data + thisindex, bones.Data(), bones.Size() * sizeof(VSMatrix));
return thisindex; return thisindex;
} }
else else
@ -642,25 +636,23 @@ int VkRenderState::UploadBones(const TArray<VSMatrix>& bones)
std::pair<FFlatVertex*, unsigned int> VkRenderState::AllocVertices(unsigned int count) std::pair<FFlatVertex*, unsigned int> VkRenderState::AllocVertices(unsigned int count)
{ {
auto buffers = fb->GetBufferManager(); unsigned int index = mRSBuffers->Flatbuffer.CurIndex;
unsigned int index = buffers->Flatbuffer.CurIndex; if (index + count >= mRSBuffers->Flatbuffer.BUFFER_SIZE_TO_USE)
if (index + count >= buffers->Flatbuffer.BUFFER_SIZE_TO_USE)
{ {
// If a single scene needs 2'000'000 vertices there must be something very wrong. // If a single scene needs 2'000'000 vertices there must be something very wrong.
I_FatalError("Out of vertex memory. Tried to allocate more than %u vertices for a single frame", index + count); I_FatalError("Out of vertex memory. Tried to allocate more than %u vertices for a single frame", index + count);
} }
buffers->Flatbuffer.CurIndex += count; mRSBuffers->Flatbuffer.CurIndex += count;
return std::make_pair(buffers->Flatbuffer.Vertices + index, index); return std::make_pair(mRSBuffers->Flatbuffer.Vertices + index, index);
} }
void VkRenderState::SetShadowData(const TArray<FFlatVertex>& vertices, const TArray<uint32_t>& indexes) void VkRenderState::SetShadowData(const TArray<FFlatVertex>& vertices, const TArray<uint32_t>& indexes)
{ {
auto buffers = fb->GetBufferManager();
auto commands = fb->GetCommands(); auto commands = fb->GetCommands();
UpdateShadowData(0, vertices.Data(), vertices.Size()); UpdateShadowData(0, vertices.Data(), vertices.Size());
buffers->Flatbuffer.ShadowDataSize = vertices.Size(); mRSBuffers->Flatbuffer.ShadowDataSize = vertices.Size();
buffers->Flatbuffer.CurIndex = buffers->Flatbuffer.ShadowDataSize; mRSBuffers->Flatbuffer.CurIndex = mRSBuffers->Flatbuffer.ShadowDataSize;
if (indexes.Size() > 0) if (indexes.Size() > 0)
{ {
@ -685,8 +677,8 @@ void VkRenderState::SetShadowData(const TArray<FFlatVertex>& vertices, const TAr
commands->GetTransferCommands()->copyBuffer(staging.get(), buffer.get()); commands->GetTransferCommands()->copyBuffer(staging.get(), buffer.get());
commands->TransferDeleteList->Add(std::move(staging)); commands->TransferDeleteList->Add(std::move(staging));
commands->DrawDeleteList->Add(std::move(buffers->Flatbuffer.IndexBuffer)); commands->DrawDeleteList->Add(std::move(mRSBuffers->Flatbuffer.IndexBuffer));
buffers->Flatbuffer.IndexBuffer = std::move(buffer); mRSBuffers->Flatbuffer.IndexBuffer = std::move(buffer);
mIndexBufferNeedsBind = true; mIndexBufferNeedsBind = true;
mNeedApply = true; mNeedApply = true;
@ -695,13 +687,12 @@ void VkRenderState::SetShadowData(const TArray<FFlatVertex>& vertices, const TAr
void VkRenderState::UpdateShadowData(unsigned int index, const FFlatVertex* vertices, unsigned int count) void VkRenderState::UpdateShadowData(unsigned int index, const FFlatVertex* vertices, unsigned int count)
{ {
memcpy(fb->GetBufferManager()->Flatbuffer.Vertices + index, vertices, count * sizeof(FFlatVertex)); memcpy(mRSBuffers->Flatbuffer.Vertices + index, vertices, count * sizeof(FFlatVertex));
} }
void VkRenderState::ResetVertices() void VkRenderState::ResetVertices()
{ {
auto buffers = fb->GetBufferManager(); mRSBuffers->Flatbuffer.CurIndex = mRSBuffers->Flatbuffer.ShadowDataSize;
buffers->Flatbuffer.CurIndex = buffers->Flatbuffer.ShadowDataSize;
} }
void VkRenderState::BeginFrame() void VkRenderState::BeginFrame()
@ -709,10 +700,9 @@ void VkRenderState::BeginFrame()
mMaterial.Reset(); mMaterial.Reset();
mApplyCount = 0; mApplyCount = 0;
auto buffers = fb->GetBufferManager(); mRSBuffers->Viewpoint.UploadIndex = 0;
buffers->Viewpoint.UploadIndex = 0; mRSBuffers->Lightbuffer.UploadIndex = 0;
buffers->Lightbuffer.UploadIndex = 0; mRSBuffers->Bonebuffer.UploadIndex = 0;
buffers->Bonebuffer.UploadIndex = 0;
} }
void VkRenderState::EndRenderPass() void VkRenderState::EndRenderPass()

7
src/common/rendering/vulkan/vk_renderstate.h
View file

@ -18,7 +18,7 @@ class VkTextureImage;
class VkRenderState : public FRenderState class VkRenderState : public FRenderState
{ {
public: public:
VkRenderState(VulkanRenderDevice* fb); VkRenderState(VulkanRenderDevice* fb, int threadIndex);
virtual ~VkRenderState() = default; virtual ~VkRenderState() = default;
// Draw commands // Draw commands
@ -71,7 +71,7 @@ protected:
void ApplyStreamData(); void ApplyStreamData();
void ApplyMatrices(); void ApplyMatrices();
void ApplyPushConstants(); void ApplyPushConstants();
void ApplyHWBufferSet(); void ApplyBufferSets();
void ApplyVertexBuffers(); void ApplyVertexBuffers();
void ApplyMaterial(); void ApplyMaterial();
@ -79,6 +79,9 @@ protected:
void WaitForStreamBuffers(); void WaitForStreamBuffers();
VulkanRenderDevice* fb = nullptr; VulkanRenderDevice* fb = nullptr;
int threadIndex = 0;
VkRSBuffers* mRSBuffers = nullptr;
bool mDepthClamp = true; bool mDepthClamp = true;
VulkanCommandBuffer *mCommandBuffer = nullptr; VulkanCommandBuffer *mCommandBuffer = nullptr;