From ed134c9b196eeaa3a2f96cd671fde23a36941e32 Mon Sep 17 00:00:00 2001 From: Magnus Norddahl Date: Wed, 15 Jun 2022 07:04:42 +0200 Subject: [PATCH] Improve the builder syntax so that fewer temp variables are required to build vulkan objects --- .../vulkan/renderer/vk_descriptorset.cpp | 112 +++--- .../vulkan/renderer/vk_postprocess.cpp | 47 +-- .../rendering/vulkan/renderer/vk_raytrace.cpp | 112 +++--- .../vulkan/renderer/vk_renderpass.cpp | 165 +++++---- .../vulkan/renderer/vk_renderstate.cpp | 16 +- .../rendering/vulkan/shaders/vk_ppshader.cpp | 16 +- .../rendering/vulkan/shaders/vk_shader.cpp | 18 +- .../rendering/vulkan/system/vk_builders.cpp | 343 ++++++++++++------ .../rendering/vulkan/system/vk_builders.h | 224 +++++++----- .../vulkan/system/vk_commandbuffer.cpp | 18 +- .../vulkan/system/vk_framebuffer.cpp | 34 +- .../rendering/vulkan/system/vk_hwbuffer.cpp | 70 ++-- .../vulkan/textures/vk_hwtexture.cpp | 173 +++++---- .../vulkan/textures/vk_imagetransition.cpp | 31 +- .../vulkan/textures/vk_imagetransition.h | 4 +- .../vulkan/textures/vk_pptexture.cpp | 51 +-- .../vulkan/textures/vk_renderbuffers.cpp | 156 ++++---- .../rendering/vulkan/textures/vk_samplers.cpp | 116 +++--- .../rendering/vulkan/textures/vk_texture.cpp | 96 ++--- 19 files changed, 975 insertions(+), 827 deletions(-) diff --git a/src/common/rendering/vulkan/renderer/vk_descriptorset.cpp b/src/common/rendering/vulkan/renderer/vk_descriptorset.cpp index 64a010c56..0daa3cfe5 100644 --- a/src/common/rendering/vulkan/renderer/vk_descriptorset.cpp +++ b/src/common/rendering/vulkan/renderer/vk_descriptorset.cpp @@ -80,12 +80,12 @@ void VkDescriptorSetManager::UpdateHWBufferSet() HWBufferSet = HWBufferDescriptorPool->allocate(HWBufferSetLayout.get()); } - WriteDescriptors update; - update.addBuffer(HWBufferSet.get(), 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->ViewpointUBO->mBuffer.get(), 0, sizeof(HWViewpointUniforms)); - update.addBuffer(HWBufferSet.get(), 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->MatrixBuffer->UniformBuffer->mBuffer.get(), 0, sizeof(MatricesUBO)); - update.addBuffer(HWBufferSet.get(), 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->StreamBuffer->UniformBuffer->mBuffer.get(), 0, sizeof(StreamUBO)); - update.addBuffer(HWBufferSet.get(), 3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightBufferSSO->mBuffer.get()); - update.updateSets(fb->device); + WriteDescriptors() + .AddBuffer(HWBufferSet.get(), 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->ViewpointUBO->mBuffer.get(), 0, sizeof(HWViewpointUniforms)) + .AddBuffer(HWBufferSet.get(), 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->MatrixBuffer->UniformBuffer->mBuffer.get(), 0, sizeof(MatricesUBO)) + .AddBuffer(HWBufferSet.get(), 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->StreamBuffer->UniformBuffer->mBuffer.get(), 0, sizeof(StreamUBO)) + .AddBuffer(HWBufferSet.get(), 3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightBufferSSO->mBuffer.get()) + .Execute(fb->device); } void VkDescriptorSetManager::UpdateFixedSet() @@ -100,11 +100,11 @@ void VkDescriptorSetManager::UpdateFixedSet() } WriteDescriptors update; - update.addCombinedImageSampler(FixedSet.get(), 0, fb->GetTextureManager()->Shadowmap.View.get(), fb->GetSamplerManager()->ShadowmapSampler.get(), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); - update.addCombinedImageSampler(FixedSet.get(), 1, fb->GetTextureManager()->Lightmap.View.get(), fb->GetSamplerManager()->LightmapSampler.get(), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + update.AddCombinedImageSampler(FixedSet.get(), 0, fb->GetTextureManager()->Shadowmap.View.get(), fb->GetSamplerManager()->ShadowmapSampler.get(), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + update.AddCombinedImageSampler(FixedSet.get(), 1, fb->GetTextureManager()->Lightmap.View.get(), fb->GetSamplerManager()->LightmapSampler.get(), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); if (fb->device->SupportsDeviceExtension(VK_KHR_RAY_QUERY_EXTENSION_NAME)) - update.addAccelerationStructure(FixedSet.get(), 2, fb->GetRaytrace()->GetAccelStruct()); - update.updateSets(fb->device); + update.AddAccelerationStructure(FixedSet.get(), 2, fb->GetRaytrace()->GetAccelStruct()); + update.Execute(fb->device); } void VkDescriptorSetManager::ResetHWTextureSets() @@ -133,9 +133,9 @@ VulkanDescriptorSet* VkDescriptorSetManager::GetNullTextureDescriptorSet() WriteDescriptors update; for (int i = 0; i < SHADER_MIN_REQUIRED_TEXTURE_LAYERS; i++) { - update.addCombinedImageSampler(NullTextureDescriptorSet.get(), i, fb->GetTextureManager()->GetNullTextureView(), fb->GetSamplerManager()->Get(CLAMP_XY_NOMIP), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + update.AddCombinedImageSampler(NullTextureDescriptorSet.get(), i, fb->GetTextureManager()->GetNullTextureView(), fb->GetSamplerManager()->Get(CLAMP_XY_NOMIP), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); } - update.updateSets(fb->device); + update.Execute(fb->device); } return NullTextureDescriptorSet.get(); @@ -148,11 +148,11 @@ std::unique_ptr VkDescriptorSetManager::AllocateTextureDesc TextureDescriptorSetsLeft = 1000; TextureDescriptorsLeft = 2000; - DescriptorPoolBuilder builder; - builder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, TextureDescriptorsLeft); - builder.setMaxSets(TextureDescriptorSetsLeft); - TextureDescriptorPools.push_back(builder.create(fb->device)); - TextureDescriptorPools.back()->SetDebugName("VkDescriptorSetManager.TextureDescriptorPool"); + TextureDescriptorPools.push_back(DescriptorPoolBuilder() + .AddPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, TextureDescriptorsLeft) + .MaxSets(TextureDescriptorSetsLeft) + .DebugName("VkDescriptorSetManager.TextureDescriptorPool") + .Create(fb->device)); } TextureDescriptorSetsLeft--; @@ -172,10 +172,10 @@ VulkanDescriptorSetLayout* VkDescriptorSetManager::GetTextureSetLayout(int numLa DescriptorSetLayoutBuilder builder; for (int i = 0; i < numLayers; i++) { - builder.addBinding(i, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); + builder.AddBinding(i, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); } - layout = builder.create(fb->device); - layout->SetDebugName("VkDescriptorSetManager.TextureSetLayout"); + builder.DebugName("VkDescriptorSetManager.TextureSetLayout"); + layout = builder.Create(fb->device); return layout.get(); } @@ -205,19 +205,19 @@ VulkanDescriptorSet* VkDescriptorSetManager::GetInput(VkPPRenderPassSetup* passS VulkanSampler* sampler = fb->GetSamplerManager()->Get(input.Filter, input.Wrap); VkTextureImage* tex = fb->GetTextureManager()->GetTexture(input.Type, input.Texture); - write.addCombinedImageSampler(descriptors.get(), index, tex->DepthOnlyView ? tex->DepthOnlyView.get() : tex->View.get(), sampler, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); - imageTransition.addImage(tex, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false); + write.AddCombinedImageSampler(descriptors.get(), index, tex->DepthOnlyView ? tex->DepthOnlyView.get() : tex->View.get(), sampler, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + imageTransition.AddImage(tex, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false); } if (bindShadowMapBuffers) { - write.addBuffer(descriptors.get(), LIGHTNODES_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightNodes->mBuffer.get()); - write.addBuffer(descriptors.get(), LIGHTLINES_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightLines->mBuffer.get()); - write.addBuffer(descriptors.get(), LIGHTLIST_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightList->mBuffer.get()); + write.AddBuffer(descriptors.get(), LIGHTNODES_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightNodes->mBuffer.get()); + write.AddBuffer(descriptors.get(), LIGHTLINES_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightLines->mBuffer.get()); + write.AddBuffer(descriptors.get(), LIGHTLIST_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightList->mBuffer.get()); } - write.updateSets(fb->device); - imageTransition.execute(fb->GetCommands()->GetDrawCommands()); + write.Execute(fb->device); + imageTransition.Execute(fb->GetCommands()->GetDrawCommands()); VulkanDescriptorSet* set = descriptors.get(); fb->GetCommands()->DrawDeleteList->Add(std::move(descriptors)); @@ -235,55 +235,55 @@ std::unique_ptr VkDescriptorSetManager::AllocatePPDescripto fb->GetCommands()->DrawDeleteList->Add(std::move(PPDescriptorPool)); } - DescriptorPoolBuilder builder; - builder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 200); - builder.addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 4); - builder.setMaxSets(100); - PPDescriptorPool = builder.create(fb->device); - PPDescriptorPool->SetDebugName("PPDescriptorPool"); + PPDescriptorPool = DescriptorPoolBuilder() + .AddPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 200) + .AddPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 4) + .MaxSets(100) + .DebugName("PPDescriptorPool") + .Create(fb->device); return PPDescriptorPool->allocate(layout); } void VkDescriptorSetManager::CreateHWBufferSetLayout() { - DescriptorSetLayoutBuilder builder; - builder.addBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); - builder.addBinding(1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); - builder.addBinding(2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT); - builder.addBinding(3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); - HWBufferSetLayout = builder.create(fb->device); - HWBufferSetLayout->SetDebugName("VkDescriptorSetManager.HWBufferSetLayout"); + HWBufferSetLayout = DescriptorSetLayoutBuilder() + .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(2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT) + .AddBinding(3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT) + .DebugName("VkDescriptorSetManager.HWBufferSetLayout") + .Create(fb->device); } void VkDescriptorSetManager::CreateFixedSetLayout() { DescriptorSetLayoutBuilder builder; - builder.addBinding(0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); - builder.addBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); + builder.AddBinding(0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); + builder.AddBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); if (fb->device->SupportsDeviceExtension(VK_KHR_RAY_QUERY_EXTENSION_NAME)) - builder.addBinding(2, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1, VK_SHADER_STAGE_FRAGMENT_BIT); - FixedSetLayout = builder.create(fb->device); - FixedSetLayout->SetDebugName("VkDescriptorSetManager.FixedSetLayout"); + builder.AddBinding(2, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1, VK_SHADER_STAGE_FRAGMENT_BIT); + builder.DebugName("VkDescriptorSetManager.FixedSetLayout"); + FixedSetLayout = builder.Create(fb->device); } void VkDescriptorSetManager::CreateHWBufferPool() { - DescriptorPoolBuilder poolbuilder; - poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 3 * maxSets); - poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1 * maxSets); - poolbuilder.setMaxSets(maxSets); - HWBufferDescriptorPool = poolbuilder.create(fb->device); - HWBufferDescriptorPool->SetDebugName("VkDescriptorSetManager.HWBufferDescriptorPool"); + HWBufferDescriptorPool = DescriptorPoolBuilder() + .AddPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 3 * maxSets) + .AddPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1 * maxSets) + .MaxSets(maxSets) + .DebugName("VkDescriptorSetManager.HWBufferDescriptorPool") + .Create(fb->device); } void VkDescriptorSetManager::CreateFixedSetPool() { DescriptorPoolBuilder poolbuilder; - poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2 * maxSets); + poolbuilder.AddPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2 * maxSets); if (fb->device->SupportsDeviceExtension(VK_KHR_RAY_QUERY_EXTENSION_NAME)) - poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1 * maxSets); - poolbuilder.setMaxSets(maxSets); - FixedDescriptorPool = poolbuilder.create(fb->device); - FixedDescriptorPool->SetDebugName("VkDescriptorSetManager.FixedDescriptorPool"); + poolbuilder.AddPoolSize(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1 * maxSets); + poolbuilder.MaxSets(maxSets); + poolbuilder.DebugName("VkDescriptorSetManager.FixedDescriptorPool"); + FixedDescriptorPool = poolbuilder.Create(fb->device); } diff --git a/src/common/rendering/vulkan/renderer/vk_postprocess.cpp b/src/common/rendering/vulkan/renderer/vk_postprocess.cpp index f79167bf7..8c9834c39 100644 --- a/src/common/rendering/vulkan/renderer/vk_postprocess.cpp +++ b/src/common/rendering/vulkan/renderer/vk_postprocess.cpp @@ -55,9 +55,9 @@ void VkPostprocess::SetActiveRenderTarget() { auto buffers = fb->GetBuffers(); - VkImageTransition imageTransition; - imageTransition.addImage(&buffers->PipelineImage[mCurrentPipelineImage], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, false); - imageTransition.execute(fb->GetCommands()->GetDrawCommands()); + VkImageTransition() + .AddImage(&buffers->PipelineImage[mCurrentPipelineImage], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, false) + .Execute(fb->GetCommands()->GetDrawCommands()); fb->GetRenderState()->SetRenderTarget(&buffers->PipelineImage[mCurrentPipelineImage], nullptr, buffers->GetWidth(), buffers->GetHeight(), VK_FORMAT_R16G16B16A16_SFLOAT, VK_SAMPLE_COUNT_1_BIT); } @@ -84,10 +84,10 @@ void VkPostprocess::BlitSceneToPostprocess() mCurrentPipelineImage = 0; - VkImageTransition imageTransition; - imageTransition.addImage(&buffers->SceneColor, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, false); - imageTransition.addImage(&buffers->PipelineImage[mCurrentPipelineImage], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true); - imageTransition.execute(fb->GetCommands()->GetDrawCommands()); + VkImageTransition() + .AddImage(&buffers->SceneColor, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, false) + .AddImage(&buffers->PipelineImage[mCurrentPipelineImage], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true) + .Execute(fb->GetCommands()->GetDrawCommands()); if (buffers->GetSceneSamples() != VK_SAMPLE_COUNT_1_BIT) { @@ -136,12 +136,12 @@ void VkPostprocess::ImageTransitionScene(bool undefinedSrcLayout) { auto buffers = fb->GetBuffers(); - VkImageTransition imageTransition; - imageTransition.addImage(&buffers->SceneColor, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, undefinedSrcLayout); - imageTransition.addImage(&buffers->SceneFog, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, undefinedSrcLayout); - imageTransition.addImage(&buffers->SceneNormal, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, undefinedSrcLayout); - imageTransition.addImage(&buffers->SceneDepthStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, undefinedSrcLayout); - imageTransition.execute(fb->GetCommands()->GetDrawCommands()); + VkImageTransition() + .AddImage(&buffers->SceneColor, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, undefinedSrcLayout) + .AddImage(&buffers->SceneFog, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, undefinedSrcLayout) + .AddImage(&buffers->SceneNormal, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, undefinedSrcLayout) + .AddImage(&buffers->SceneDepthStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, undefinedSrcLayout) + .Execute(fb->GetCommands()->GetDrawCommands()); } void VkPostprocess::BlitCurrentToImage(VkTextureImage *dstimage, VkImageLayout finallayout) @@ -151,10 +151,10 @@ void VkPostprocess::BlitCurrentToImage(VkTextureImage *dstimage, VkImageLayout f auto srcimage = &fb->GetBuffers()->PipelineImage[mCurrentPipelineImage]; auto cmdbuffer = fb->GetCommands()->GetDrawCommands(); - VkImageTransition imageTransition0; - imageTransition0.addImage(srcimage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, false); - imageTransition0.addImage(dstimage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true); - imageTransition0.execute(cmdbuffer); + VkImageTransition() + .AddImage(srcimage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, false) + .AddImage(dstimage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true) + .Execute(cmdbuffer); VkImageBlit blit = {}; blit.srcOffsets[0] = { 0, 0, 0 }; @@ -169,14 +169,15 @@ void VkPostprocess::BlitCurrentToImage(VkTextureImage *dstimage, VkImageLayout f blit.dstSubresource.mipLevel = 0; blit.dstSubresource.baseArrayLayer = 0; blit.dstSubresource.layerCount = 1; + cmdbuffer->blitImage( srcimage->Image->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstimage->Image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_NEAREST); - VkImageTransition imageTransition1; - imageTransition1.addImage(dstimage, finallayout, false); - imageTransition1.execute(cmdbuffer); + VkImageTransition() + .AddImage(dstimage, finallayout, false) + .Execute(cmdbuffer); } void VkPostprocess::DrawPresentTexture(const IntRect &box, bool applyGamma, bool screenshot) @@ -277,9 +278,9 @@ void VkPostprocess::UpdateShadowMap() VkPPRenderState renderstate(fb); hw_postprocess.shadowmap.Update(&renderstate); - VkImageTransition imageTransition; - imageTransition.addImage(&fb->GetTextureManager()->Shadowmap, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false); - imageTransition.execute(fb->GetCommands()->GetDrawCommands()); + VkImageTransition() + .AddImage(&fb->GetTextureManager()->Shadowmap, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false) + .Execute(fb->GetCommands()->GetDrawCommands()); screen->mShadowMap.FinishUpdate(); } diff --git a/src/common/rendering/vulkan/renderer/vk_raytrace.cpp b/src/common/rendering/vulkan/renderer/vk_raytrace.cpp index 87353b3e4..c0594931b 100644 --- a/src/common/rendering/vulkan/renderer/vk_raytrace.cpp +++ b/src/common/rendering/vulkan/renderer/vk_raytrace.cpp @@ -95,36 +95,36 @@ void VkRaytrace::CreateVertexAndIndexBuffers() size_t vertexoffset = 0; size_t indexoffset = vertexoffset + vertexbuffersize; - BufferBuilder tbuilder; - tbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY); - tbuilder.setSize(transferbuffersize); - transferBuffer = tbuilder.create(fb->device); - transferBuffer->SetDebugName("transferBuffer"); + transferBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY) + .Size(transferbuffersize) + .DebugName("transferBuffer") + .Create(fb->device); + uint8_t* data = (uint8_t*)transferBuffer->Map(0, transferbuffersize); memcpy(data + vertexoffset, Mesh->MeshVertices.Data(), vertexbuffersize); memcpy(data + indexoffset, Mesh->MeshElements.Data(), indexbuffersize); transferBuffer->Unmap(); - BufferBuilder vbuilder; - vbuilder.setUsage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); - vbuilder.setSize(vertexbuffersize); - vertexBuffer = vbuilder.create(fb->device); - vertexBuffer->SetDebugName("vertexBuffer"); + vertexBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) + .Size(vertexbuffersize) + .DebugName("vertexBuffer") + .Create(fb->device); - BufferBuilder ibuilder; - ibuilder.setUsage(VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); - ibuilder.setSize(indexbuffersize); - indexBuffer = ibuilder.create(fb->device); - indexBuffer->SetDebugName("indexBuffer"); + indexBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) + .Size(indexbuffersize) + .DebugName("indexBuffer") + .Create(fb->device); fb->GetCommands()->GetTransferCommands()->copyBuffer(transferBuffer.get(), vertexBuffer.get(), vertexoffset); fb->GetCommands()->GetTransferCommands()->copyBuffer(transferBuffer.get(), indexBuffer.get(), indexoffset); // Finish transfer before using it for building - VkMemoryBarrier barrier = { VK_STRUCTURE_TYPE_MEMORY_BARRIER }; - barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - fb->GetCommands()->GetTransferCommands()->pipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, 0, 1, &barrier, 0, nullptr, 0, nullptr); + PipelineBarrier() + .AddMemory(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT) + .Execute(fb->GetCommands()->GetTransferCommands(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR); } void VkRaytrace::CreateBottomLevelAccelerationStructure() @@ -158,11 +158,11 @@ void VkRaytrace::CreateBottomLevelAccelerationStructure() VkAccelerationStructureBuildSizesInfoKHR sizeInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR }; vkGetAccelerationStructureBuildSizesKHR(fb->device->device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildInfo, &maxPrimitiveCount, &sizeInfo); - BufferBuilder blbufbuilder; - blbufbuilder.setUsage(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT); - blbufbuilder.setSize(sizeInfo.accelerationStructureSize); - blAccelStructBuffer = blbufbuilder.create(fb->device); - blAccelStructBuffer->SetDebugName("blAccelStructBuffer"); + blAccelStructBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) + .Size(sizeInfo.accelerationStructureSize) + .DebugName("blAccelStructBuffer") + .Create(fb->device); VkAccelerationStructureKHR blAccelStructHandle = {}; VkAccelerationStructureCreateInfoKHR createInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR }; @@ -175,11 +175,11 @@ void VkRaytrace::CreateBottomLevelAccelerationStructure() blAccelStruct = std::make_unique(fb->device, blAccelStructHandle); blAccelStruct->SetDebugName("blAccelStruct"); - BufferBuilder sbuilder; - sbuilder.setUsage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); - sbuilder.setSize(sizeInfo.buildScratchSize); - blScratchBuffer = sbuilder.create(fb->device); - blScratchBuffer->SetDebugName("blScratchBuffer"); + blScratchBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) + .Size(sizeInfo.buildScratchSize) + .DebugName("blScratchBuffer") + .Create(fb->device); buildInfo.dstAccelerationStructure = blAccelStruct->accelstruct; buildInfo.scratchData.deviceAddress = blScratchBuffer->GetDeviceAddress(); @@ -187,10 +187,9 @@ void VkRaytrace::CreateBottomLevelAccelerationStructure() fb->GetCommands()->GetTransferCommands()->buildAccelerationStructures(1, &buildInfo, rangeInfos); // Finish building before using it as input to a toplevel accel structure - VkMemoryBarrier barrier = { VK_STRUCTURE_TYPE_MEMORY_BARRIER }; - barrier.srcAccessMask = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR; - barrier.dstAccessMask = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR; - fb->GetCommands()->GetTransferCommands()->pipelineBarrier(VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, 0, 1, &barrier, 0, nullptr, 0, nullptr); + PipelineBarrier() + .AddMemory(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR) + .Execute(fb->GetCommands()->GetTransferCommands(), VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR); } void VkRaytrace::CreateTopLevelAccelerationStructure() @@ -203,20 +202,21 @@ void VkRaytrace::CreateTopLevelAccelerationStructure() instance.flags = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR; instance.accelerationStructureReference = blAccelStruct->GetDeviceAddress(); - BufferBuilder tbuilder; - tbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY); - tbuilder.setSize(sizeof(VkAccelerationStructureInstanceKHR)); - tlTransferBuffer = tbuilder.create(fb->device); - tlTransferBuffer->SetDebugName("tlTransferBuffer"); + tlTransferBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY) + .Size(sizeof(VkAccelerationStructureInstanceKHR)) + .DebugName("tlTransferBuffer") + .Create(fb->device); + auto data = (uint8_t*)tlTransferBuffer->Map(0, sizeof(VkAccelerationStructureInstanceKHR)); memcpy(data, &instance, sizeof(VkAccelerationStructureInstanceKHR)); tlTransferBuffer->Unmap(); - BufferBuilder instbufbuilder; - instbufbuilder.setUsage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_DST_BIT); - instbufbuilder.setSize(sizeof(VkAccelerationStructureInstanceKHR)); - tlInstanceBuffer = instbufbuilder.create(fb->device); - tlInstanceBuffer->SetDebugName("tlInstanceBuffer"); + tlInstanceBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_DST_BIT) + .Size(sizeof(VkAccelerationStructureInstanceKHR)) + .DebugName("tlInstanceBuffer") + .Create(fb->device); fb->GetCommands()->GetTransferCommands()->copyBuffer(tlTransferBuffer.get(), tlInstanceBuffer.get()); @@ -249,11 +249,11 @@ void VkRaytrace::CreateTopLevelAccelerationStructure() VkAccelerationStructureBuildSizesInfoKHR sizeInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR }; vkGetAccelerationStructureBuildSizesKHR(fb->device->device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &buildInfo, &maxInstanceCount, &sizeInfo); - BufferBuilder tlbufbuilder; - tlbufbuilder.setUsage(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT); - tlbufbuilder.setSize(sizeInfo.accelerationStructureSize); - tlAccelStructBuffer = tlbufbuilder.create(fb->device); - tlAccelStructBuffer->SetDebugName("tlAccelStructBuffer"); + tlAccelStructBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) + .Size(sizeInfo.accelerationStructureSize) + .DebugName("tlAccelStructBuffer") + .Create(fb->device); VkAccelerationStructureKHR tlAccelStructHandle = {}; VkAccelerationStructureCreateInfoKHR createInfo = { VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR }; @@ -265,11 +265,11 @@ void VkRaytrace::CreateTopLevelAccelerationStructure() throw std::runtime_error("vkCreateAccelerationStructureKHR failed"); tlAccelStruct = std::make_unique(fb->device, tlAccelStructHandle); - BufferBuilder sbuilder; - sbuilder.setUsage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); - sbuilder.setSize(sizeInfo.buildScratchSize); - tlScratchBuffer = sbuilder.create(fb->device); - tlScratchBuffer->SetDebugName("tlScratchBuffer"); + tlScratchBuffer = BufferBuilder() + .Usage(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) + .Size(sizeInfo.buildScratchSize) + .DebugName("tlScratchBuffer") + .Create(fb->device); buildInfo.dstAccelerationStructure = tlAccelStruct->accelstruct; buildInfo.scratchData.deviceAddress = tlScratchBuffer->GetDeviceAddress(); @@ -277,7 +277,7 @@ void VkRaytrace::CreateTopLevelAccelerationStructure() fb->GetCommands()->GetTransferCommands()->buildAccelerationStructures(1, &buildInfo, rangeInfos); // Finish building the accel struct before using as input in a fragment shader - PipelineBarrier finishbuildbarrier; - finishbuildbarrier.addMemory(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_SHADER_READ_BIT); - finishbuildbarrier.execute(fb->GetCommands()->GetTransferCommands(), VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); + PipelineBarrier() + .AddMemory(VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, VK_ACCESS_SHADER_READ_BIT) + .Execute(fb->GetCommands()->GetTransferCommands(), VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); } diff --git a/src/common/rendering/vulkan/renderer/vk_renderpass.cpp b/src/common/rendering/vulkan/renderer/vk_renderpass.cpp index d7f9d5a21..ea8d97b58 100644 --- a/src/common/rendering/vulkan/renderer/vk_renderpass.cpp +++ b/src/common/rendering/vulkan/renderer/vk_renderpass.cpp @@ -112,13 +112,13 @@ VulkanPipelineLayout* VkRenderPassManager::GetPipelineLayout(int numLayers) auto descriptors = fb->GetDescriptorSetManager(); PipelineLayoutBuilder builder; - builder.addSetLayout(descriptors->GetFixedSetLayout()); - builder.addSetLayout(descriptors->GetHWBufferSetLayout()); + builder.AddSetLayout(descriptors->GetFixedSetLayout()); + builder.AddSetLayout(descriptors->GetHWBufferSetLayout()); if (numLayers != 0) - builder.addSetLayout(descriptors->GetTextureSetLayout(numLayers)); - builder.addPushConstantRange(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants)); - layout = builder.create(fb->device); - layout->SetDebugName("VkRenderPassManager.PipelineLayout"); + builder.AddSetLayout(descriptors->GetTextureSetLayout(numLayers)); + builder.AddPushConstantRange(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants)); + builder.DebugName("VkRenderPassManager.PipelineLayout"); + layout = builder.Create(fb->device); return layout.get(); } @@ -144,33 +144,33 @@ std::unique_ptr VkRenderPassSetup::CreateRenderPass(int clearT RenderPassBuilder builder; - builder.addAttachment( + builder.AddAttachment( PassKey.DrawBufferFormat, (VkSampleCountFlagBits)PassKey.Samples, (clearTargets & CT_Color) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); for (int i = 1; i < PassKey.DrawBuffers; i++) { - builder.addAttachment( + builder.AddAttachment( drawBufferFormats[i], buffers->GetSceneSamples(), (clearTargets & CT_Color) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); } if (PassKey.DepthStencil) { - builder.addDepthStencilAttachment( + builder.AddDepthStencilAttachment( buffers->SceneDepthStencilFormat, PassKey.DrawBufferFormat == VK_FORMAT_R8G8B8A8_UNORM ? VK_SAMPLE_COUNT_1_BIT : buffers->GetSceneSamples(), (clearTargets & CT_Depth) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, (clearTargets & CT_Stencil) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); } - builder.addSubpass(); + builder.AddSubpass(); for (int i = 0; i < PassKey.DrawBuffers; i++) - builder.addSubpassColorAttachmentRef(i, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + builder.AddSubpassColorAttachmentRef(i, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); if (PassKey.DepthStencil) { - builder.addSubpassDepthStencilAttachmentRef(PassKey.DrawBuffers, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); - builder.addExternalSubpassDependency( + builder.AddSubpassDepthStencilAttachmentRef(PassKey.DrawBuffers, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); + builder.AddExternalSubpassDependency( VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, @@ -178,15 +178,14 @@ std::unique_ptr VkRenderPassSetup::CreateRenderPass(int clearT } else { - builder.addExternalSubpassDependency( + builder.AddExternalSubpassDependency( VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT); } - auto renderpass = builder.create(fb->device); - renderpass->SetDebugName("VkRenderPassSetup.RenderPass"); - return renderpass; + builder.DebugName("VkRenderPassSetup.RenderPass"); + return builder.Create(fb->device); } VulkanRenderPass *VkRenderPassSetup::GetRenderPass(int clearTargets) @@ -217,13 +216,13 @@ std::unique_ptr VkRenderPassSetup::CreatePipeline(const VkPipeli { program = fb->GetShaderManager()->Get(key.EffectState, key.AlphaTest, PassKey.DrawBuffers > 1 ? GBUFFER_PASS : NORMAL_PASS); } - builder.addVertexShader(program->vert.get()); - builder.addFragmentShader(program->frag.get()); + builder.AddVertexShader(program->vert.get()); + builder.AddFragmentShader(program->frag.get()); const VkVertexFormat &vfmt = *fb->GetRenderPassManager()->GetVertexFormat(key.VertexFormat); for (int i = 0; i < vfmt.NumBindingPoints; i++) - builder.addVertexBufferBinding(i, vfmt.Stride); + builder.AddVertexBufferBinding(i, vfmt.Stride); const static VkFormat vkfmts[] = { VK_FORMAT_R32G32B32A32_SFLOAT, @@ -239,7 +238,7 @@ std::unique_ptr VkRenderPassSetup::CreatePipeline(const VkPipeli for (size_t i = 0; i < vfmt.Attrs.size(); i++) { const auto &attr = vfmt.Attrs[i]; - builder.addVertexAttribute(attr.location, attr.binding, vkfmts[attr.format], attr.offset); + builder.AddVertexAttribute(attr.location, attr.binding, vkfmts[attr.format], attr.offset); inputLocations[attr.location] = true; } @@ -247,17 +246,17 @@ std::unique_ptr VkRenderPassSetup::CreatePipeline(const VkPipeli for (int i = 0; i < 7; i++) { if (!inputLocations[i]) - builder.addVertexAttribute(i, 0, VK_FORMAT_R32G32B32_SFLOAT, 0); + builder.AddVertexAttribute(i, 0, VK_FORMAT_R32G32B32_SFLOAT, 0); } - builder.addDynamicState(VK_DYNAMIC_STATE_VIEWPORT); - builder.addDynamicState(VK_DYNAMIC_STATE_SCISSOR); - builder.addDynamicState(VK_DYNAMIC_STATE_DEPTH_BIAS); - builder.addDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE); + builder.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT); + builder.AddDynamicState(VK_DYNAMIC_STATE_SCISSOR); + builder.AddDynamicState(VK_DYNAMIC_STATE_DEPTH_BIAS); + builder.AddDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE); // Note: the actual values are ignored since we use dynamic viewport+scissor states - builder.setViewport(0.0f, 0.0f, 320.0f, 200.0f); - builder.setScissor(0, 0, 320, 200); + builder.Viewport(0.0f, 0.0f, 320.0f, 200.0f); + builder.Scissor(0, 0, 320, 200); static const VkPrimitiveTopology vktopology[] = { VK_PRIMITIVE_TOPOLOGY_POINT_LIST, @@ -270,28 +269,28 @@ std::unique_ptr VkRenderPassSetup::CreatePipeline(const VkPipeli static const VkStencilOp op2vk[] = { VK_STENCIL_OP_KEEP, VK_STENCIL_OP_INCREMENT_AND_CLAMP, VK_STENCIL_OP_DECREMENT_AND_CLAMP }; static const VkCompareOp depthfunc2vk[] = { VK_COMPARE_OP_LESS, VK_COMPARE_OP_LESS_OR_EQUAL, VK_COMPARE_OP_ALWAYS }; - builder.setTopology(vktopology[key.DrawType]); - builder.setDepthStencilEnable(key.DepthTest, key.DepthWrite, key.StencilTest); - builder.setDepthFunc(depthfunc2vk[key.DepthFunc]); + builder.Topology(vktopology[key.DrawType]); + builder.DepthStencilEnable(key.DepthTest, key.DepthWrite, key.StencilTest); + builder.DepthFunc(depthfunc2vk[key.DepthFunc]); if (fb->device->UsedDeviceFeatures.depthClamp) - builder.setDepthClampEnable(key.DepthClamp); - builder.setDepthBias(key.DepthBias, 0.0f, 0.0f, 0.0f); + builder.DepthClampEnable(key.DepthClamp); + builder.DepthBias(key.DepthBias, 0.0f, 0.0f, 0.0f); // Note: CCW and CW is intentionally swapped here because the vulkan and opengl coordinate systems differ. // main.vp addresses this by patching up gl_Position.z, which has the side effect of flipping the sign of the front face calculations. - builder.setCull(key.CullMode == Cull_None ? VK_CULL_MODE_NONE : VK_CULL_MODE_BACK_BIT, key.CullMode == Cull_CW ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE); + builder.Cull(key.CullMode == Cull_None ? VK_CULL_MODE_NONE : VK_CULL_MODE_BACK_BIT, key.CullMode == Cull_CW ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE); - builder.setColorWriteMask((VkColorComponentFlags)key.ColorMask); - builder.setStencil(VK_STENCIL_OP_KEEP, op2vk[key.StencilPassOp], VK_STENCIL_OP_KEEP, VK_COMPARE_OP_EQUAL, 0xffffffff, 0xffffffff, 0); - builder.setBlendMode(key.RenderStyle); - builder.setSubpassColorAttachmentCount(PassKey.DrawBuffers); - builder.setRasterizationSamples((VkSampleCountFlagBits)PassKey.Samples); + builder.ColorWriteMask((VkColorComponentFlags)key.ColorMask); + builder.Stencil(VK_STENCIL_OP_KEEP, op2vk[key.StencilPassOp], VK_STENCIL_OP_KEEP, VK_COMPARE_OP_EQUAL, 0xffffffff, 0xffffffff, 0); + builder.BlendMode(key.RenderStyle); + builder.SubpassColorAttachmentCount(PassKey.DrawBuffers); + builder.RasterizationSamples((VkSampleCountFlagBits)PassKey.Samples); - builder.setLayout(fb->GetRenderPassManager()->GetPipelineLayout(key.NumTextureLayers)); - builder.setRenderPass(GetRenderPass(0)); - auto pipeline = builder.create(fb->device); - pipeline->SetDebugName("VkRenderPassSetup.Pipeline"); - return pipeline; + builder.Layout(fb->GetRenderPassManager()->GetPipelineLayout(key.NumTextureLayers)); + builder.RenderPass(GetRenderPass(0)); + builder.DebugName("VkRenderPassSetup.Pipeline"); + + return builder.Create(fb->device); } ///////////////////////////////////////////////////////////////////////////// @@ -308,78 +307,78 @@ void VkPPRenderPassSetup::CreateDescriptorLayout(const VkPPRenderPassKey& key) { DescriptorSetLayoutBuilder builder; for (int i = 0; i < key.InputTextures; i++) - builder.addBinding(i, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); + builder.AddBinding(i, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); if (key.ShadowMapBuffers) { - builder.addBinding(LIGHTNODES_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); - builder.addBinding(LIGHTLINES_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); - builder.addBinding(LIGHTLIST_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); + builder.AddBinding(LIGHTNODES_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); + builder.AddBinding(LIGHTLINES_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); + builder.AddBinding(LIGHTLIST_BINDINGPOINT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT); } - DescriptorLayout = builder.create(fb->device); - DescriptorLayout->SetDebugName("VkPPRenderPassSetup.DescriptorLayout"); + builder.DebugName("VkPPRenderPassSetup.DescriptorLayout"); + DescriptorLayout = builder.Create(fb->device); } void VkPPRenderPassSetup::CreatePipelineLayout(const VkPPRenderPassKey& key) { PipelineLayoutBuilder builder; - builder.addSetLayout(DescriptorLayout.get()); + builder.AddSetLayout(DescriptorLayout.get()); if (key.Uniforms > 0) - builder.addPushConstantRange(VK_SHADER_STAGE_FRAGMENT_BIT, 0, key.Uniforms); - PipelineLayout = builder.create(fb->device); - PipelineLayout->SetDebugName("VkPPRenderPassSetup.PipelineLayout"); + builder.AddPushConstantRange(VK_SHADER_STAGE_FRAGMENT_BIT, 0, key.Uniforms); + builder.DebugName("VkPPRenderPassSetup.PipelineLayout"); + PipelineLayout = builder.Create(fb->device); } void VkPPRenderPassSetup::CreatePipeline(const VkPPRenderPassKey& key) { GraphicsPipelineBuilder builder; - builder.addVertexShader(key.Shader->VertexShader.get()); - builder.addFragmentShader(key.Shader->FragmentShader.get()); + builder.AddVertexShader(key.Shader->VertexShader.get()); + builder.AddFragmentShader(key.Shader->FragmentShader.get()); - builder.addVertexBufferBinding(0, sizeof(FFlatVertex)); - builder.addVertexAttribute(0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(FFlatVertex, x)); - builder.addVertexAttribute(1, 0, VK_FORMAT_R32G32_SFLOAT, offsetof(FFlatVertex, u)); - builder.addDynamicState(VK_DYNAMIC_STATE_VIEWPORT); - builder.addDynamicState(VK_DYNAMIC_STATE_SCISSOR); + builder.AddVertexBufferBinding(0, sizeof(FFlatVertex)); + builder.AddVertexAttribute(0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(FFlatVertex, x)); + builder.AddVertexAttribute(1, 0, VK_FORMAT_R32G32_SFLOAT, offsetof(FFlatVertex, u)); + builder.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT); + builder.AddDynamicState(VK_DYNAMIC_STATE_SCISSOR); // Note: the actual values are ignored since we use dynamic viewport+scissor states - builder.setViewport(0.0f, 0.0f, 320.0f, 200.0f); - builder.setScissor(0, 0, 320, 200); + builder.Viewport(0.0f, 0.0f, 320.0f, 200.0f); + builder.Scissor(0, 0, 320, 200); if (key.StencilTest) { - builder.addDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE); - builder.setDepthStencilEnable(false, false, true); - builder.setStencil(VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_EQUAL, 0xffffffff, 0xffffffff, 0); + builder.AddDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE); + builder.DepthStencilEnable(false, false, true); + builder.Stencil(VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_EQUAL, 0xffffffff, 0xffffffff, 0); } - builder.setTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP); - builder.setBlendMode(key.BlendMode); - builder.setRasterizationSamples(key.Samples); - builder.setLayout(PipelineLayout.get()); - builder.setRenderPass(RenderPass.get()); - Pipeline = builder.create(fb->device); - Pipeline->SetDebugName("VkPPRenderPassSetup.Pipeline"); + builder.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP); + builder.BlendMode(key.BlendMode); + builder.RasterizationSamples(key.Samples); + builder.Layout(PipelineLayout.get()); + builder.RenderPass(RenderPass.get()); + builder.DebugName("VkPPRenderPassSetup.Pipeline"); + Pipeline = builder.Create(fb->device); } void VkPPRenderPassSetup::CreateRenderPass(const VkPPRenderPassKey& key) { RenderPassBuilder builder; if (key.SwapChain) - builder.addAttachment(key.OutputFormat, key.Samples, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); + builder.AddAttachment(key.OutputFormat, key.Samples, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); else - builder.addAttachment(key.OutputFormat, key.Samples, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + builder.AddAttachment(key.OutputFormat, key.Samples, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); if (key.StencilTest) { - builder.addDepthStencilAttachment( + builder.AddDepthStencilAttachment( fb->GetBuffers()->SceneDepthStencilFormat, key.Samples, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); } - builder.addSubpass(); - builder.addSubpassColorAttachmentRef(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + builder.AddSubpass(); + builder.AddSubpassColorAttachmentRef(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); if (key.StencilTest) { - builder.addSubpassDepthStencilAttachmentRef(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); - builder.addExternalSubpassDependency( + builder.AddSubpassDepthStencilAttachmentRef(1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); + builder.AddExternalSubpassDependency( VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, @@ -387,13 +386,13 @@ void VkPPRenderPassSetup::CreateRenderPass(const VkPPRenderPassKey& key) } else { - builder.addExternalSubpassDependency( + builder.AddExternalSubpassDependency( VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT); } - RenderPass = builder.create(fb->device); - RenderPass->SetDebugName("VkPPRenderPassSetup.RenderPass"); + builder.DebugName("VkPPRenderPassSetup.RenderPass"); + RenderPass = builder.Create(fb->device); } diff --git a/src/common/rendering/vulkan/renderer/vk_renderstate.cpp b/src/common/rendering/vulkan/renderer/vk_renderstate.cpp index 8e490f6ab..d2a68d951 100644 --- a/src/common/rendering/vulkan/renderer/vk_renderstate.cpp +++ b/src/common/rendering/vulkan/renderer/vk_renderstate.cpp @@ -544,17 +544,17 @@ void VkRenderState::BeginRenderPass(VulkanCommandBuffer *cmdbuffer) { auto buffers = fb->GetBuffers(); FramebufferBuilder builder; - builder.setRenderPass(mPassSetup->GetRenderPass(0)); - builder.setSize(mRenderTarget.Width, mRenderTarget.Height); - builder.addAttachment(mRenderTarget.Image->View.get()); + builder.RenderPass(mPassSetup->GetRenderPass(0)); + builder.Size(mRenderTarget.Width, mRenderTarget.Height); + builder.AddAttachment(mRenderTarget.Image->View.get()); if (key.DrawBuffers > 1) - builder.addAttachment(buffers->SceneFog.View.get()); + builder.AddAttachment(buffers->SceneFog.View.get()); if (key.DrawBuffers > 2) - builder.addAttachment(buffers->SceneNormal.View.get()); + builder.AddAttachment(buffers->SceneNormal.View.get()); if (key.DepthStencil) - builder.addAttachment(mRenderTarget.DepthStencil); - framebuffer = builder.create(fb->device); - framebuffer->SetDebugName("VkRenderPassSetup.Framebuffer"); + builder.AddAttachment(mRenderTarget.DepthStencil); + builder.DebugName("VkRenderPassSetup.Framebuffer"); + framebuffer = builder.Create(fb->device); } // Only clear depth+stencil if the render target actually has that diff --git a/src/common/rendering/vulkan/shaders/vk_ppshader.cpp b/src/common/rendering/vulkan/shaders/vk_ppshader.cpp index d0261a60f..225bb6adb 100644 --- a/src/common/rendering/vulkan/shaders/vk_ppshader.cpp +++ b/src/common/rendering/vulkan/shaders/vk_ppshader.cpp @@ -34,15 +34,15 @@ VkPPShader::VkPPShader(VulkanFrameBuffer* fb, PPShader *shader) : fb(fb) prolog = UniformBlockDecl::Create("Uniforms", shader->Uniforms, -1); prolog += shader->Defines; - ShaderBuilder vertbuilder; - vertbuilder.setVertexShader(LoadShaderCode(shader->VertexShader, "", shader->Version)); - VertexShader = vertbuilder.create(shader->VertexShader.GetChars(), fb->device); - VertexShader->SetDebugName(shader->VertexShader.GetChars()); + VertexShader = ShaderBuilder() + .VertexShader(LoadShaderCode(shader->VertexShader, "", shader->Version)) + .DebugName(shader->VertexShader.GetChars()) + .Create(shader->VertexShader.GetChars(), fb->device); - ShaderBuilder fragbuilder; - fragbuilder.setFragmentShader(LoadShaderCode(shader->FragmentShader, prolog, shader->Version)); - FragmentShader = fragbuilder.create(shader->FragmentShader.GetChars(), fb->device); - FragmentShader->SetDebugName(shader->FragmentShader.GetChars()); + FragmentShader = ShaderBuilder() + .FragmentShader(LoadShaderCode(shader->FragmentShader, prolog, shader->Version)) + .DebugName(shader->FragmentShader.GetChars()) + .Create(shader->FragmentShader.GetChars(), fb->device); fb->GetShaderManager()->AddVkPPShader(this); } diff --git a/src/common/rendering/vulkan/shaders/vk_shader.cpp b/src/common/rendering/vulkan/shaders/vk_shader.cpp index 47ebd03b8..b3bcec420 100644 --- a/src/common/rendering/vulkan/shaders/vk_shader.cpp +++ b/src/common/rendering/vulkan/shaders/vk_shader.cpp @@ -341,11 +341,10 @@ std::unique_ptr VkShaderManager::LoadVertShader(FString shadername code << "#line 1\n"; code << LoadPrivateShaderLump(vert_lump).GetChars() << "\n"; - ShaderBuilder builder; - builder.setVertexShader(code); - auto shader = builder.create(shadername.GetChars(), fb->device); - shader->SetDebugName(shadername.GetChars()); - return shader; + return ShaderBuilder() + .VertexShader(code) + .DebugName(shadername.GetChars()) + .Create(shadername.GetChars(), fb->device); } std::unique_ptr VkShaderManager::LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char *light_lump, const char *defines, bool alphatest, bool gbufferpass) @@ -434,11 +433,10 @@ std::unique_ptr VkShaderManager::LoadFragShader(FString shadername code << LoadPrivateShaderLump(light_lump).GetChars(); } - ShaderBuilder builder; - builder.setFragmentShader(code); - auto shader = builder.create(shadername.GetChars(), fb->device); - shader->SetDebugName(shadername.GetChars()); - return shader; + return ShaderBuilder() + .FragmentShader(code) + .DebugName(shadername.GetChars()) + .Create(shadername.GetChars(), fb->device); } FString VkShaderManager::GetTargetGlslVersion() diff --git a/src/common/rendering/vulkan/system/vk_builders.cpp b/src/common/rendering/vulkan/system/vk_builders.cpp index 4bf40305f..2a19a4bc2 100644 --- a/src/common/rendering/vulkan/system/vk_builders.cpp +++ b/src/common/rendering/vulkan/system/vk_builders.cpp @@ -138,19 +138,21 @@ ShaderBuilder::ShaderBuilder() { } -void ShaderBuilder::setVertexShader(const FString &c) +ShaderBuilder& ShaderBuilder::VertexShader(const FString &c) { code = c; stage = EShLanguage::EShLangVertex; + return *this; } -void ShaderBuilder::setFragmentShader(const FString &c) +ShaderBuilder& ShaderBuilder::FragmentShader(const FString &c) { code = c; stage = EShLanguage::EShLangFragment; + return *this; } -std::unique_ptr ShaderBuilder::create(const char *shadername, VulkanDevice *device) +std::unique_ptr ShaderBuilder::Create(const char *shadername, VulkanDevice *device) { EShLanguage stage = (EShLanguage)this->stage; const char *sources[] = { code.GetChars() }; @@ -213,18 +215,21 @@ std::unique_ptr ShaderBuilder::create(const char *shadername, Vulk VulkanError(msg.GetChars()); } - return std::make_unique(device, shaderModule); + auto obj = std::make_unique(device, shaderModule); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// -void GraphicsPipelineBuilder::setBlendMode(const FRenderStyle &style) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::BlendMode(const FRenderStyle &style) { // Just in case Vulkan doesn't do this optimization itself if (style.BlendOp == STYLEOP_Add && style.SrcAlpha == STYLEALPHA_One && style.DestAlpha == STYLEALPHA_Zero && style.Flags == 0) { colorBlendAttachment.blendEnable = VK_FALSE; - return; + return *this; } static const int blendstyles[] = { @@ -255,7 +260,7 @@ void GraphicsPipelineBuilder::setBlendMode(const FRenderStyle &style) blendequation = VK_BLEND_OP_ADD; } - setBlendMode((VkBlendOp)blendequation, (VkBlendFactor)srcblend, (VkBlendFactor)dstblend); + BlendMode((VkBlendOp)blendequation, (VkBlendFactor)srcblend, (VkBlendFactor)dstblend); } ///////////////////////////////////////////////////////////////////////////// @@ -273,44 +278,50 @@ ImageBuilder::ImageBuilder() imageInfo.flags = 0; } -void ImageBuilder::setSize(int width, int height, int mipLevels, int arrayLayers) +ImageBuilder& ImageBuilder::Size(int width, int height, int mipLevels, int arrayLayers) { imageInfo.extent.width = width; imageInfo.extent.height = height; imageInfo.mipLevels = mipLevels; imageInfo.arrayLayers = arrayLayers; + return *this; } -void ImageBuilder::setSamples(VkSampleCountFlagBits samples) +ImageBuilder& ImageBuilder::Samples(VkSampleCountFlagBits samples) { imageInfo.samples = samples; + return *this; } -void ImageBuilder::setFormat(VkFormat format) +ImageBuilder& ImageBuilder::Format(VkFormat format) { imageInfo.format = format; + return *this; } -void ImageBuilder::setLinearTiling() +ImageBuilder& ImageBuilder::LinearTiling() { imageInfo.tiling = VK_IMAGE_TILING_LINEAR; + return *this; } -void ImageBuilder::setUsage(VkImageUsageFlags usage, VmaMemoryUsage memoryUsage, VmaAllocationCreateFlags allocFlags) +ImageBuilder& ImageBuilder::Usage(VkImageUsageFlags usage, VmaMemoryUsage memoryUsage, VmaAllocationCreateFlags allocFlags) { imageInfo.usage = usage; allocInfo.usage = memoryUsage; allocInfo.flags = allocFlags; + return *this; } -void ImageBuilder::setMemoryType(VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags preferredFlags, uint32_t memoryTypeBits) +ImageBuilder& ImageBuilder::MemoryType(VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags preferredFlags, uint32_t memoryTypeBits) { allocInfo.requiredFlags = requiredFlags; allocInfo.preferredFlags = preferredFlags; allocInfo.memoryTypeBits = memoryTypeBits; + return *this; } -bool ImageBuilder::isFormatSupported(VulkanDevice* device, VkFormatFeatureFlags bufferFeatures) +bool ImageBuilder::IsFormatSupported(VulkanDevice* device, VkFormatFeatureFlags bufferFeatures) { VkImageFormatProperties properties = { }; VkResult result = vkGetPhysicalDeviceImageFormatProperties(device->PhysicalDevice.Device, imageInfo.format, imageInfo.imageType, imageInfo.tiling, imageInfo.usage, imageInfo.flags, &properties); @@ -331,7 +342,7 @@ bool ImageBuilder::isFormatSupported(VulkanDevice* device, VkFormatFeatureFlags return true; } -std::unique_ptr ImageBuilder::create(VulkanDevice* device, VkDeviceSize* allocatedBytes) +std::unique_ptr ImageBuilder::Create(VulkanDevice* device, VkDeviceSize* allocatedBytes) { VkImage image; VmaAllocation allocation; @@ -347,10 +358,13 @@ std::unique_ptr ImageBuilder::create(VulkanDevice* device, VkDevice *allocatedBytes = allocatedInfo.size; } - return std::make_unique(device, image, allocation, imageInfo.extent.width, imageInfo.extent.height, imageInfo.mipLevels, imageInfo.arrayLayers); + auto obj = std::make_unique(device, image, allocation, imageInfo.extent.width, imageInfo.extent.height, imageInfo.mipLevels, imageInfo.arrayLayers); + if (debugName) + obj->SetDebugName(debugName); + return obj; } -std::unique_ptr ImageBuilder::tryCreate(VulkanDevice* device) +std::unique_ptr ImageBuilder::TryCreate(VulkanDevice* device) { VkImage image; VmaAllocation allocation; @@ -359,7 +373,10 @@ std::unique_ptr ImageBuilder::tryCreate(VulkanDevice* device) if (result != VK_SUCCESS) return nullptr; - return std::make_unique(device, image, allocation, imageInfo.extent.width, imageInfo.extent.height, imageInfo.mipLevels, imageInfo.arrayLayers); + auto obj = std::make_unique(device, image, allocation, imageInfo.extent.width, imageInfo.extent.height, imageInfo.mipLevels, imageInfo.arrayLayers); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -374,27 +391,32 @@ ImageViewBuilder::ImageViewBuilder() viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; } -void ImageViewBuilder::setType(VkImageViewType type) +ImageViewBuilder& ImageViewBuilder::Type(VkImageViewType type) { viewInfo.viewType = type; + return *this; } -void ImageViewBuilder::setImage(VulkanImage* image, VkFormat format, VkImageAspectFlags aspectMask) +ImageViewBuilder& ImageViewBuilder::Image(VulkanImage* image, VkFormat format, VkImageAspectFlags aspectMask) { viewInfo.image = image->image; viewInfo.format = format; viewInfo.subresourceRange.levelCount = image->mipLevels; viewInfo.subresourceRange.aspectMask = aspectMask; viewInfo.subresourceRange.layerCount = image->layerCount; + return *this; } -std::unique_ptr ImageViewBuilder::create(VulkanDevice* device) +std::unique_ptr ImageViewBuilder::Create(VulkanDevice* device) { VkImageView view; VkResult result = vkCreateImageView(device->device, &viewInfo, nullptr, &view); CheckVulkanError(result, "Could not create texture image view"); - return std::make_unique(device, view); + auto obj = std::make_unique(device, view); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -419,52 +441,62 @@ SamplerBuilder::SamplerBuilder() samplerInfo.maxLod = 100.0f; } -void SamplerBuilder::setAddressMode(VkSamplerAddressMode addressMode) +SamplerBuilder& SamplerBuilder::AddressMode(VkSamplerAddressMode addressMode) { samplerInfo.addressModeU = addressMode; samplerInfo.addressModeV = addressMode; samplerInfo.addressModeW = addressMode; + return *this; } -void SamplerBuilder::setAddressMode(VkSamplerAddressMode u, VkSamplerAddressMode v, VkSamplerAddressMode w) +SamplerBuilder& SamplerBuilder::AddressMode(VkSamplerAddressMode u, VkSamplerAddressMode v, VkSamplerAddressMode w) { samplerInfo.addressModeU = u; samplerInfo.addressModeV = v; samplerInfo.addressModeW = w; + return *this; } -void SamplerBuilder::setMinFilter(VkFilter minFilter) +SamplerBuilder& SamplerBuilder::MinFilter(VkFilter minFilter) { samplerInfo.minFilter = minFilter; + return *this; } -void SamplerBuilder::setMagFilter(VkFilter magFilter) +SamplerBuilder& SamplerBuilder::MagFilter(VkFilter magFilter) { samplerInfo.magFilter = magFilter; + return *this; } -void SamplerBuilder::setMipmapMode(VkSamplerMipmapMode mode) +SamplerBuilder& SamplerBuilder::MipmapMode(VkSamplerMipmapMode mode) { samplerInfo.mipmapMode = mode; + return *this; } -void SamplerBuilder::setAnisotropy(float maxAnisotropy) +SamplerBuilder& SamplerBuilder::Anisotropy(float maxAnisotropy) { samplerInfo.anisotropyEnable = VK_TRUE; samplerInfo.maxAnisotropy = maxAnisotropy; + return *this; } -void SamplerBuilder::setMaxLod(float value) +SamplerBuilder& SamplerBuilder::MaxLod(float value) { samplerInfo.maxLod = value; + return *this; } -std::unique_ptr SamplerBuilder::create(VulkanDevice* device) +std::unique_ptr SamplerBuilder::Create(VulkanDevice* device) { VkSampler sampler; VkResult result = vkCreateSampler(device->device, &samplerInfo, nullptr, &sampler); CheckVulkanError(result, "Could not create texture sampler"); - return std::make_unique(device, sampler); + auto obj = std::make_unique(device, sampler); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -475,26 +507,29 @@ BufferBuilder::BufferBuilder() bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; } -void BufferBuilder::setSize(size_t size) +BufferBuilder& BufferBuilder::Size(size_t size) { bufferInfo.size = max(size, (size_t)16); + return *this; } -void BufferBuilder::setUsage(VkBufferUsageFlags bufferUsage, VmaMemoryUsage memoryUsage, VmaAllocationCreateFlags allocFlags) +BufferBuilder& BufferBuilder::Usage(VkBufferUsageFlags bufferUsage, VmaMemoryUsage memoryUsage, VmaAllocationCreateFlags allocFlags) { bufferInfo.usage = bufferUsage; allocInfo.usage = memoryUsage; allocInfo.flags = allocFlags; + return *this; } -void BufferBuilder::setMemoryType(VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags preferredFlags, uint32_t memoryTypeBits) +BufferBuilder& BufferBuilder::MemoryType(VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags preferredFlags, uint32_t memoryTypeBits) { allocInfo.requiredFlags = requiredFlags; allocInfo.preferredFlags = preferredFlags; allocInfo.memoryTypeBits = memoryTypeBits; + return *this; } -std::unique_ptr BufferBuilder::create(VulkanDevice* device) +std::unique_ptr BufferBuilder::Create(VulkanDevice* device) { VkBuffer buffer; VmaAllocation allocation; @@ -502,7 +537,10 @@ std::unique_ptr BufferBuilder::create(VulkanDevice* device) VkResult result = vmaCreateBuffer(device->allocator, &bufferInfo, &allocInfo, &buffer, &allocation, nullptr); CheckVulkanError(result, "Could not allocate memory for vulkan buffer"); - return std::make_unique(device, buffer, allocation, bufferInfo.size); + auto obj = std::make_unique(device, buffer, allocation, bufferInfo.size); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -513,25 +551,30 @@ ComputePipelineBuilder::ComputePipelineBuilder() stageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; } -void ComputePipelineBuilder::setLayout(VulkanPipelineLayout* layout) +ComputePipelineBuilder& ComputePipelineBuilder::Layout(VulkanPipelineLayout* layout) { pipelineInfo.layout = layout->layout; + return *this; } -void ComputePipelineBuilder::setComputeShader(VulkanShader* shader) +ComputePipelineBuilder& ComputePipelineBuilder::ComputeShader(VulkanShader* shader) { stageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT; stageInfo.module = shader->module; stageInfo.pName = "main"; pipelineInfo.stage = stageInfo; + return *this; } -std::unique_ptr ComputePipelineBuilder::create(VulkanDevice* device) +std::unique_ptr ComputePipelineBuilder::Create(VulkanDevice* device) { VkPipeline pipeline; vkCreateComputePipelines(device->device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline); - return std::make_unique(device, pipeline); + auto obj = std::make_unique(device, pipeline); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -541,7 +584,7 @@ DescriptorSetLayoutBuilder::DescriptorSetLayoutBuilder() layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; } -void DescriptorSetLayoutBuilder::addBinding(int index, VkDescriptorType type, int arrayCount, VkShaderStageFlags stageFlags) +DescriptorSetLayoutBuilder& DescriptorSetLayoutBuilder::AddBinding(int index, VkDescriptorType type, int arrayCount, VkShaderStageFlags stageFlags) { VkDescriptorSetLayoutBinding binding = { }; binding.binding = index; @@ -553,14 +596,18 @@ void DescriptorSetLayoutBuilder::addBinding(int index, VkDescriptorType type, in layoutInfo.bindingCount = (uint32_t)bindings.Size(); layoutInfo.pBindings = &bindings[0]; + return *this; } -std::unique_ptr DescriptorSetLayoutBuilder::create(VulkanDevice* device) +std::unique_ptr DescriptorSetLayoutBuilder::Create(VulkanDevice* device) { VkDescriptorSetLayout layout; VkResult result = vkCreateDescriptorSetLayout(device->device, &layoutInfo, nullptr, &layout); CheckVulkanError(result, "Could not create descriptor set layout"); - return std::make_unique(device, layout); + auto obj = std::make_unique(device, layout); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -572,12 +619,13 @@ DescriptorPoolBuilder::DescriptorPoolBuilder() poolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; } -void DescriptorPoolBuilder::setMaxSets(int value) +DescriptorPoolBuilder& DescriptorPoolBuilder::MaxSets(int value) { poolInfo.maxSets = value; + return *this; } -void DescriptorPoolBuilder::addPoolSize(VkDescriptorType type, int count) +DescriptorPoolBuilder& DescriptorPoolBuilder::AddPoolSize(VkDescriptorType type, int count) { VkDescriptorPoolSize size; size.type = type; @@ -586,14 +634,18 @@ void DescriptorPoolBuilder::addPoolSize(VkDescriptorType type, int count) poolInfo.poolSizeCount = (uint32_t)poolSizes.size(); poolInfo.pPoolSizes = poolSizes.data(); + return *this; } -std::unique_ptr DescriptorPoolBuilder::create(VulkanDevice* device) +std::unique_ptr DescriptorPoolBuilder::Create(VulkanDevice* device) { VkDescriptorPool descriptorPool; VkResult result = vkCreateDescriptorPool(device->device, &poolInfo, nullptr, &descriptorPool); CheckVulkanError(result, "Could not create descriptor pool"); - return std::make_unique(device, descriptorPool); + auto obj = std::make_unique(device, descriptorPool); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -603,19 +655,23 @@ QueryPoolBuilder::QueryPoolBuilder() poolInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; } -void QueryPoolBuilder::setQueryType(VkQueryType type, int count, VkQueryPipelineStatisticFlags pipelineStatistics) +QueryPoolBuilder& QueryPoolBuilder::QueryType(VkQueryType type, int count, VkQueryPipelineStatisticFlags pipelineStatistics) { poolInfo.queryType = type; poolInfo.queryCount = count; poolInfo.pipelineStatistics = pipelineStatistics; + return *this; } -std::unique_ptr QueryPoolBuilder::create(VulkanDevice* device) +std::unique_ptr QueryPoolBuilder::Create(VulkanDevice* device) { VkQueryPool queryPool; VkResult result = vkCreateQueryPool(device->device, &poolInfo, nullptr, &queryPool); CheckVulkanError(result, "Could not create query pool"); - return std::make_unique(device, queryPool); + auto obj = std::make_unique(device, queryPool); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -625,40 +681,47 @@ FramebufferBuilder::FramebufferBuilder() framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; } -void FramebufferBuilder::setRenderPass(VulkanRenderPass* renderPass) +FramebufferBuilder& FramebufferBuilder::RenderPass(VulkanRenderPass* renderPass) { framebufferInfo.renderPass = renderPass->renderPass; + return *this; } -void FramebufferBuilder::addAttachment(VulkanImageView* view) +FramebufferBuilder& FramebufferBuilder::AddAttachment(VulkanImageView* view) { attachments.push_back(view->view); framebufferInfo.attachmentCount = (uint32_t)attachments.size(); framebufferInfo.pAttachments = attachments.data(); + return *this; } -void FramebufferBuilder::addAttachment(VkImageView view) +FramebufferBuilder& FramebufferBuilder::AddAttachment(VkImageView view) { attachments.push_back(view); framebufferInfo.attachmentCount = (uint32_t)attachments.size(); framebufferInfo.pAttachments = attachments.data(); + return *this; } -void FramebufferBuilder::setSize(int width, int height, int layers) +FramebufferBuilder& FramebufferBuilder::Size(int width, int height, int layers) { framebufferInfo.width = width; framebufferInfo.height = height; framebufferInfo.layers = 1; + return *this; } -std::unique_ptr FramebufferBuilder::create(VulkanDevice* device) +std::unique_ptr FramebufferBuilder::Create(VulkanDevice* device) { VkFramebuffer framebuffer = 0; VkResult result = vkCreateFramebuffer(device->device, &framebufferInfo, nullptr, &framebuffer); CheckVulkanError(result, "Could not create framebuffer"); - return std::make_unique(device, framebuffer); + auto obj = std::make_unique(device, framebuffer); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -741,32 +804,37 @@ GraphicsPipelineBuilder::GraphicsPipelineBuilder() dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; } -void GraphicsPipelineBuilder::setRasterizationSamples(VkSampleCountFlagBits samples) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::RasterizationSamples(VkSampleCountFlagBits samples) { multisampling.rasterizationSamples = samples; + return *this; } -void GraphicsPipelineBuilder::setSubpass(int subpass) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::Subpass(int subpass) { pipelineInfo.subpass = subpass; + return *this; } -void GraphicsPipelineBuilder::setLayout(VulkanPipelineLayout* layout) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::Layout(VulkanPipelineLayout* layout) { pipelineInfo.layout = layout->layout; + return *this; } -void GraphicsPipelineBuilder::setRenderPass(VulkanRenderPass* renderPass) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::RenderPass(VulkanRenderPass* renderPass) { pipelineInfo.renderPass = renderPass->renderPass; + return *this; } -void GraphicsPipelineBuilder::setTopology(VkPrimitiveTopology topology) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::Topology(VkPrimitiveTopology topology) { inputAssembly.topology = topology; + return *this; } -void GraphicsPipelineBuilder::setViewport(float x, float y, float width, float height, float minDepth, float maxDepth) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::Viewport(float x, float y, float width, float height, float minDepth, float maxDepth) { viewport.x = 0.0f; viewport.y = 0.0f; @@ -777,9 +845,10 @@ void GraphicsPipelineBuilder::setViewport(float x, float y, float width, float h viewportState.viewportCount = 1; viewportState.pViewports = &viewport; + return *this; } -void GraphicsPipelineBuilder::setScissor(int x, int y, int width, int height) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::Scissor(int x, int y, int width, int height) { scissor.offset.x = x; scissor.offset.y = y; @@ -788,22 +857,25 @@ void GraphicsPipelineBuilder::setScissor(int x, int y, int width, int height) viewportState.scissorCount = 1; viewportState.pScissors = &scissor; + return *this; } -void GraphicsPipelineBuilder::setCull(VkCullModeFlags cullMode, VkFrontFace frontFace) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::Cull(VkCullModeFlags cullMode, VkFrontFace frontFace) { rasterizer.cullMode = cullMode; rasterizer.frontFace = frontFace; + return *this; } -void GraphicsPipelineBuilder::setDepthStencilEnable(bool test, bool write, bool stencil) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::DepthStencilEnable(bool test, bool write, bool stencil) { depthStencil.depthTestEnable = test ? VK_TRUE : VK_FALSE; depthStencil.depthWriteEnable = write ? VK_TRUE : VK_FALSE; depthStencil.stencilTestEnable = stencil ? VK_TRUE : VK_FALSE; + return *this; } -void GraphicsPipelineBuilder::setStencil(VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp, uint32_t compareMask, uint32_t writeMask, uint32_t reference) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::Stencil(VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp, uint32_t compareMask, uint32_t writeMask, uint32_t reference) { depthStencil.front.failOp = failOp; depthStencil.front.passOp = passOp; @@ -820,32 +892,37 @@ void GraphicsPipelineBuilder::setStencil(VkStencilOp failOp, VkStencilOp passOp, depthStencil.back.compareMask = compareMask; depthStencil.back.writeMask = writeMask; depthStencil.back.reference = reference; + return *this; } -void GraphicsPipelineBuilder::setDepthFunc(VkCompareOp func) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::DepthFunc(VkCompareOp func) { depthStencil.depthCompareOp = func; + return *this; } -void GraphicsPipelineBuilder::setDepthClampEnable(bool value) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::DepthClampEnable(bool value) { rasterizer.depthClampEnable = value ? VK_TRUE : VK_FALSE; + return *this; } -void GraphicsPipelineBuilder::setDepthBias(bool enable, float biasConstantFactor, float biasClamp, float biasSlopeFactor) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::DepthBias(bool enable, float biasConstantFactor, float biasClamp, float biasSlopeFactor) { rasterizer.depthBiasEnable = enable ? VK_TRUE : VK_FALSE; rasterizer.depthBiasConstantFactor = biasConstantFactor; rasterizer.depthBiasClamp = biasClamp; rasterizer.depthBiasSlopeFactor = biasSlopeFactor; + return *this; } -void GraphicsPipelineBuilder::setColorWriteMask(VkColorComponentFlags mask) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::ColorWriteMask(VkColorComponentFlags mask) { colorBlendAttachment.colorWriteMask = mask; + return *this; } -void GraphicsPipelineBuilder::setAdditiveBlendMode() +GraphicsPipelineBuilder& GraphicsPipelineBuilder::AdditiveBlendMode() { colorBlendAttachment.blendEnable = VK_TRUE; colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; @@ -854,9 +931,10 @@ void GraphicsPipelineBuilder::setAdditiveBlendMode() colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE; colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; + return *this; } -void GraphicsPipelineBuilder::setAlphaBlendMode() +GraphicsPipelineBuilder& GraphicsPipelineBuilder::AlphaBlendMode() { colorBlendAttachment.blendEnable = VK_TRUE; colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; @@ -865,9 +943,10 @@ void GraphicsPipelineBuilder::setAlphaBlendMode() colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; + return *this; } -void GraphicsPipelineBuilder::setBlendMode(VkBlendOp op, VkBlendFactor src, VkBlendFactor dst) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::BlendMode(VkBlendOp op, VkBlendFactor src, VkBlendFactor dst) { colorBlendAttachment.blendEnable = VK_TRUE; colorBlendAttachment.srcColorBlendFactor = src; @@ -876,16 +955,18 @@ void GraphicsPipelineBuilder::setBlendMode(VkBlendOp op, VkBlendFactor src, VkBl colorBlendAttachment.srcAlphaBlendFactor = src; colorBlendAttachment.dstAlphaBlendFactor = dst; colorBlendAttachment.alphaBlendOp = op; + return *this; } -void GraphicsPipelineBuilder::setSubpassColorAttachmentCount(int count) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::SubpassColorAttachmentCount(int count) { colorBlendAttachments.resize(count, colorBlendAttachment); colorBlending.pAttachments = colorBlendAttachments.data(); colorBlending.attachmentCount = (uint32_t)colorBlendAttachments.size(); + return *this; } -void GraphicsPipelineBuilder::addVertexShader(VulkanShader* shader) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddVertexShader(VulkanShader* shader) { VkPipelineShaderStageCreateInfo vertShaderStageInfo = {}; vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; @@ -896,9 +977,10 @@ void GraphicsPipelineBuilder::addVertexShader(VulkanShader* shader) pipelineInfo.stageCount = (uint32_t)shaderStages.size(); pipelineInfo.pStages = shaderStages.data(); + return *this; } -void GraphicsPipelineBuilder::addFragmentShader(VulkanShader* shader) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddFragmentShader(VulkanShader* shader) { VkPipelineShaderStageCreateInfo fragShaderStageInfo = {}; fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; @@ -909,9 +991,10 @@ void GraphicsPipelineBuilder::addFragmentShader(VulkanShader* shader) pipelineInfo.stageCount = (uint32_t)shaderStages.size(); pipelineInfo.pStages = shaderStages.data(); + return *this; } -void GraphicsPipelineBuilder::addVertexBufferBinding(int index, size_t stride) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddVertexBufferBinding(int index, size_t stride) { VkVertexInputBindingDescription desc = {}; desc.binding = index; @@ -921,9 +1004,10 @@ void GraphicsPipelineBuilder::addVertexBufferBinding(int index, size_t stride) vertexInputInfo.vertexBindingDescriptionCount = (uint32_t)vertexInputBindings.size(); vertexInputInfo.pVertexBindingDescriptions = vertexInputBindings.data(); + return *this; } -void GraphicsPipelineBuilder::addVertexAttribute(int location, int binding, VkFormat format, size_t offset) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddVertexAttribute(int location, int binding, VkFormat format, size_t offset) { VkVertexInputAttributeDescription desc = { }; desc.location = location; @@ -934,21 +1018,26 @@ void GraphicsPipelineBuilder::addVertexAttribute(int location, int binding, VkFo vertexInputInfo.vertexAttributeDescriptionCount = (uint32_t)vertexInputAttributes.size(); vertexInputInfo.pVertexAttributeDescriptions = vertexInputAttributes.data(); + return *this; } -void GraphicsPipelineBuilder::addDynamicState(VkDynamicState state) +GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddDynamicState(VkDynamicState state) { dynamicStates.push_back(state); dynamicState.dynamicStateCount = (uint32_t)dynamicStates.size(); dynamicState.pDynamicStates = dynamicStates.data(); + return *this; } -std::unique_ptr GraphicsPipelineBuilder::create(VulkanDevice* device) +std::unique_ptr GraphicsPipelineBuilder::Create(VulkanDevice* device) { VkPipeline pipeline = 0; VkResult result = vkCreateGraphicsPipelines(device->device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline); CheckVulkanError(result, "Could not create graphics pipeline"); - return std::make_unique(device, pipeline); + auto obj = std::make_unique(device, pipeline); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -958,14 +1047,15 @@ PipelineLayoutBuilder::PipelineLayoutBuilder() pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; } -void PipelineLayoutBuilder::addSetLayout(VulkanDescriptorSetLayout* setLayout) +PipelineLayoutBuilder& PipelineLayoutBuilder::AddSetLayout(VulkanDescriptorSetLayout* setLayout) { setLayouts.push_back(setLayout->layout); pipelineLayoutInfo.setLayoutCount = (uint32_t)setLayouts.size(); pipelineLayoutInfo.pSetLayouts = setLayouts.data(); + return *this; } -void PipelineLayoutBuilder::addPushConstantRange(VkShaderStageFlags stageFlags, size_t offset, size_t size) +PipelineLayoutBuilder& PipelineLayoutBuilder::AddPushConstantRange(VkShaderStageFlags stageFlags, size_t offset, size_t size) { VkPushConstantRange range = { }; range.stageFlags = stageFlags; @@ -974,14 +1064,18 @@ void PipelineLayoutBuilder::addPushConstantRange(VkShaderStageFlags stageFlags, pushConstantRanges.push_back(range); pipelineLayoutInfo.pushConstantRangeCount = (uint32_t)pushConstantRanges.size(); pipelineLayoutInfo.pPushConstantRanges = pushConstantRanges.data(); + return *this; } -std::unique_ptr PipelineLayoutBuilder::create(VulkanDevice* device) +std::unique_ptr PipelineLayoutBuilder::Create(VulkanDevice* device) { VkPipelineLayout pipelineLayout; VkResult result = vkCreatePipelineLayout(device->device, &pipelineLayoutInfo, nullptr, &pipelineLayout); CheckVulkanError(result, "Could not create pipeline layout"); - return std::make_unique(device, pipelineLayout); + auto obj = std::make_unique(device, pipelineLayout); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// @@ -991,7 +1085,7 @@ RenderPassBuilder::RenderPassBuilder() renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; } -void RenderPassBuilder::addAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load, VkAttachmentStoreOp store, VkImageLayout initialLayout, VkImageLayout finalLayout) +RenderPassBuilder& RenderPassBuilder::AddAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load, VkAttachmentStoreOp store, VkImageLayout initialLayout, VkImageLayout finalLayout) { VkAttachmentDescription attachment = {}; attachment.format = format; @@ -1005,9 +1099,10 @@ void RenderPassBuilder::addAttachment(VkFormat format, VkSampleCountFlagBits sam attachments.push_back(attachment); renderPassInfo.pAttachments = attachments.data(); renderPassInfo.attachmentCount = (uint32_t)attachments.size(); + return *this; } -void RenderPassBuilder::addDepthStencilAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load, VkAttachmentStoreOp store, VkAttachmentLoadOp stencilLoad, VkAttachmentStoreOp stencilStore, VkImageLayout initialLayout, VkImageLayout finalLayout) +RenderPassBuilder& RenderPassBuilder::AddDepthStencilAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load, VkAttachmentStoreOp store, VkAttachmentLoadOp stencilLoad, VkAttachmentStoreOp stencilStore, VkImageLayout initialLayout, VkImageLayout finalLayout) { VkAttachmentDescription attachment = {}; attachment.format = format; @@ -1021,9 +1116,10 @@ void RenderPassBuilder::addDepthStencilAttachment(VkFormat format, VkSampleCount attachments.push_back(attachment); renderPassInfo.pAttachments = attachments.data(); renderPassInfo.attachmentCount = (uint32_t)attachments.size(); + return *this; } -void RenderPassBuilder::addExternalSubpassDependency(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) +RenderPassBuilder& RenderPassBuilder::AddExternalSubpassDependency(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) { VkSubpassDependency dependency = {}; dependency.srcSubpass = VK_SUBPASS_EXTERNAL; @@ -1036,9 +1132,10 @@ void RenderPassBuilder::addExternalSubpassDependency(VkPipelineStageFlags srcSta dependencies.push_back(dependency); renderPassInfo.pDependencies = dependencies.data(); renderPassInfo.dependencyCount = (uint32_t)dependencies.size(); + return *this; } -void RenderPassBuilder::addSubpass() +RenderPassBuilder& RenderPassBuilder::AddSubpass() { VkSubpassDescription subpass = {}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; @@ -1048,9 +1145,10 @@ void RenderPassBuilder::addSubpass() renderPassInfo.subpassCount = (uint32_t)subpasses.size(); subpassData.push_back(std::make_unique()); + return *this; } -void RenderPassBuilder::addSubpassColorAttachmentRef(uint32_t index, VkImageLayout layout) +RenderPassBuilder& RenderPassBuilder::AddSubpassColorAttachmentRef(uint32_t index, VkImageLayout layout) { VkAttachmentReference colorAttachmentRef = {}; colorAttachmentRef.attachment = index; @@ -1059,9 +1157,10 @@ void RenderPassBuilder::addSubpassColorAttachmentRef(uint32_t index, VkImageLayo subpassData.back()->colorRefs.push_back(colorAttachmentRef); subpasses.back().pColorAttachments = subpassData.back()->colorRefs.data(); subpasses.back().colorAttachmentCount = (uint32_t)subpassData.back()->colorRefs.size(); + return *this; } -void RenderPassBuilder::addSubpassDepthStencilAttachmentRef(uint32_t index, VkImageLayout layout) +RenderPassBuilder& RenderPassBuilder::AddSubpassDepthStencilAttachmentRef(uint32_t index, VkImageLayout layout) { VkAttachmentReference& depthAttachmentRef = subpassData.back()->depthRef; depthAttachmentRef.attachment = index; @@ -1069,33 +1168,38 @@ void RenderPassBuilder::addSubpassDepthStencilAttachmentRef(uint32_t index, VkIm VkSubpassDescription& subpass = subpasses.back(); subpass.pDepthStencilAttachment = &depthAttachmentRef; + return *this; } -std::unique_ptr RenderPassBuilder::create(VulkanDevice* device) +std::unique_ptr RenderPassBuilder::Create(VulkanDevice* device) { VkRenderPass renderPass = 0; VkResult result = vkCreateRenderPass(device->device, &renderPassInfo, nullptr, &renderPass); CheckVulkanError(result, "Could not create render pass"); - return std::make_unique(device, renderPass); + auto obj = std::make_unique(device, renderPass); + if (debugName) + obj->SetDebugName(debugName); + return obj; } ///////////////////////////////////////////////////////////////////////////// -void PipelineBarrier::addMemory(VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) +PipelineBarrier& PipelineBarrier::AddMemory(VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) { VkMemoryBarrier barrier = { }; barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; barrier.srcAccessMask = srcAccessMask; barrier.dstAccessMask = dstAccessMask; memoryBarriers.push_back(barrier); + return *this; } -void PipelineBarrier::addBuffer(VulkanBuffer* buffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) +PipelineBarrier& PipelineBarrier::AddBuffer(VulkanBuffer* buffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) { - addBuffer(buffer, 0, buffer->size, srcAccessMask, dstAccessMask); + return AddBuffer(buffer, 0, buffer->size, srcAccessMask, dstAccessMask); } -void PipelineBarrier::addBuffer(VulkanBuffer* buffer, VkDeviceSize offset, VkDeviceSize size, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) +PipelineBarrier& PipelineBarrier::AddBuffer(VulkanBuffer* buffer, VkDeviceSize offset, VkDeviceSize size, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) { VkBufferMemoryBarrier barrier = { }; barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; @@ -1107,14 +1211,15 @@ void PipelineBarrier::addBuffer(VulkanBuffer* buffer, VkDeviceSize offset, VkDev barrier.offset = offset; barrier.size = size; bufferMemoryBarriers.push_back(barrier); + return *this; } -void PipelineBarrier::addImage(VulkanImage* image, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask, int baseMipLevel, int levelCount) +PipelineBarrier& PipelineBarrier::AddImage(VulkanImage* image, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask, int baseMipLevel, int levelCount) { - addImage(image->image, oldLayout, newLayout, srcAccessMask, dstAccessMask, aspectMask, baseMipLevel, levelCount); + return AddImage(image->image, oldLayout, newLayout, srcAccessMask, dstAccessMask, aspectMask, baseMipLevel, levelCount); } -void PipelineBarrier::addImage(VkImage image, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask, int baseMipLevel, int levelCount) +PipelineBarrier& PipelineBarrier::AddImage(VkImage image, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask, int baseMipLevel, int levelCount) { VkImageMemoryBarrier barrier = { }; barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; @@ -1131,9 +1236,10 @@ void PipelineBarrier::addImage(VkImage image, VkImageLayout oldLayout, VkImageLa barrier.subresourceRange.baseArrayLayer = 0; barrier.subresourceRange.layerCount = 1; imageMemoryBarriers.push_back(barrier); + return *this; } -void PipelineBarrier::addQueueTransfer(int srcFamily, int dstFamily, VulkanBuffer* buffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) +PipelineBarrier& PipelineBarrier::AddQueueTransfer(int srcFamily, int dstFamily, VulkanBuffer* buffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask) { VkBufferMemoryBarrier barrier = { }; barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; @@ -1145,9 +1251,10 @@ void PipelineBarrier::addQueueTransfer(int srcFamily, int dstFamily, VulkanBuffe barrier.offset = 0; barrier.size = buffer->size; bufferMemoryBarriers.push_back(barrier); + return *this; } -void PipelineBarrier::addQueueTransfer(int srcFamily, int dstFamily, VulkanImage* image, VkImageLayout layout, VkImageAspectFlags aspectMask, int baseMipLevel, int levelCount) +PipelineBarrier& PipelineBarrier::AddQueueTransfer(int srcFamily, int dstFamily, VulkanImage* image, VkImageLayout layout, VkImageAspectFlags aspectMask, int baseMipLevel, int levelCount) { VkImageMemoryBarrier barrier = { }; barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; @@ -1162,9 +1269,10 @@ void PipelineBarrier::addQueueTransfer(int srcFamily, int dstFamily, VulkanImage barrier.subresourceRange.baseArrayLayer = 0; barrier.subresourceRange.layerCount = 1; imageMemoryBarriers.push_back(barrier); + return *this; } -void PipelineBarrier::execute(VulkanCommandBuffer* commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags) +void PipelineBarrier::Execute(VulkanCommandBuffer* commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags) { commandBuffer->pipelineBarrier( srcStageMask, dstStageMask, dependencyFlags, @@ -1180,14 +1288,15 @@ QueueSubmit::QueueSubmit() submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; } -void QueueSubmit::addCommandBuffer(VulkanCommandBuffer* buffer) +QueueSubmit& QueueSubmit::AddCommandBuffer(VulkanCommandBuffer* buffer) { commandBuffers.push_back(buffer->buffer); submitInfo.pCommandBuffers = commandBuffers.data(); submitInfo.commandBufferCount = (uint32_t)commandBuffers.size(); + return *this; } -void QueueSubmit::addWait(VkPipelineStageFlags waitStageMask, VulkanSemaphore* semaphore) +QueueSubmit& QueueSubmit::AddWait(VkPipelineStageFlags waitStageMask, VulkanSemaphore* semaphore) { waitStages.push_back(waitStageMask); waitSemaphores.push_back(semaphore->semaphore); @@ -1195,16 +1304,18 @@ void QueueSubmit::addWait(VkPipelineStageFlags waitStageMask, VulkanSemaphore* s submitInfo.pWaitDstStageMask = waitStages.data(); submitInfo.pWaitSemaphores = waitSemaphores.data(); submitInfo.waitSemaphoreCount = (uint32_t)waitSemaphores.size(); + return *this; } -void QueueSubmit::addSignal(VulkanSemaphore* semaphore) +QueueSubmit& QueueSubmit::AddSignal(VulkanSemaphore* semaphore) { signalSemaphores.push_back(semaphore->semaphore); submitInfo.pSignalSemaphores = signalSemaphores.data(); submitInfo.signalSemaphoreCount = (uint32_t)signalSemaphores.size(); + return *this; } -void QueueSubmit::execute(VulkanDevice* device, VkQueue queue, VulkanFence* fence) +void QueueSubmit::Execute(VulkanDevice* device, VkQueue queue, VulkanFence* fence) { VkResult result = vkQueueSubmit(device->graphicsQueue, 1, &submitInfo, fence ? fence->fence : VK_NULL_HANDLE); CheckVulkanError(result, "Could not submit command buffer"); @@ -1212,12 +1323,12 @@ void QueueSubmit::execute(VulkanDevice* device, VkQueue queue, VulkanFence* fenc ///////////////////////////////////////////////////////////////////////////// -void WriteDescriptors::addBuffer(VulkanDescriptorSet* descriptorSet, int binding, VkDescriptorType type, VulkanBuffer* buffer) +WriteDescriptors& WriteDescriptors::AddBuffer(VulkanDescriptorSet* descriptorSet, int binding, VkDescriptorType type, VulkanBuffer* buffer) { - addBuffer(descriptorSet, binding, type, buffer, 0, buffer->size); + return AddBuffer(descriptorSet, binding, type, buffer, 0, buffer->size); } -void WriteDescriptors::addBuffer(VulkanDescriptorSet* descriptorSet, int binding, VkDescriptorType type, VulkanBuffer* buffer, size_t offset, size_t range) +WriteDescriptors& WriteDescriptors::AddBuffer(VulkanDescriptorSet* descriptorSet, int binding, VkDescriptorType type, VulkanBuffer* buffer, size_t offset, size_t range) { VkDescriptorBufferInfo bufferInfo = {}; bufferInfo.buffer = buffer->buffer; @@ -1237,9 +1348,10 @@ void WriteDescriptors::addBuffer(VulkanDescriptorSet* descriptorSet, int binding descriptorWrite.pBufferInfo = &extra->bufferInfo; writes.push_back(descriptorWrite); writeExtras.push_back(std::move(extra)); + return *this; } -void WriteDescriptors::addStorageImage(VulkanDescriptorSet* descriptorSet, int binding, VulkanImageView* view, VkImageLayout imageLayout) +WriteDescriptors& WriteDescriptors::AddStorageImage(VulkanDescriptorSet* descriptorSet, int binding, VulkanImageView* view, VkImageLayout imageLayout) { VkDescriptorImageInfo imageInfo = {}; imageInfo.imageView = view->view; @@ -1258,9 +1370,10 @@ void WriteDescriptors::addStorageImage(VulkanDescriptorSet* descriptorSet, int b descriptorWrite.pImageInfo = &extra->imageInfo; writes.push_back(descriptorWrite); writeExtras.push_back(std::move(extra)); + return *this; } -void WriteDescriptors::addCombinedImageSampler(VulkanDescriptorSet* descriptorSet, int binding, VulkanImageView* view, VulkanSampler* sampler, VkImageLayout imageLayout) +WriteDescriptors& WriteDescriptors::AddCombinedImageSampler(VulkanDescriptorSet* descriptorSet, int binding, VulkanImageView* view, VulkanSampler* sampler, VkImageLayout imageLayout) { VkDescriptorImageInfo imageInfo = {}; imageInfo.imageView = view->view; @@ -1280,9 +1393,10 @@ void WriteDescriptors::addCombinedImageSampler(VulkanDescriptorSet* descriptorSe descriptorWrite.pImageInfo = &extra->imageInfo; writes.push_back(descriptorWrite); writeExtras.push_back(std::move(extra)); + return *this; } -void WriteDescriptors::addAccelerationStructure(VulkanDescriptorSet* descriptorSet, int binding, VulkanAccelerationStructure* accelStruct) +WriteDescriptors& WriteDescriptors::AddAccelerationStructure(VulkanDescriptorSet* descriptorSet, int binding, VulkanAccelerationStructure* accelStruct) { auto extra = std::make_unique(); extra->accelStruct = {}; @@ -1300,9 +1414,10 @@ void WriteDescriptors::addAccelerationStructure(VulkanDescriptorSet* descriptorS descriptorWrite.pNext = &extra->accelStruct; writes.push_back(descriptorWrite); writeExtras.push_back(std::move(extra)); + return *this; } -void WriteDescriptors::updateSets(VulkanDevice* device) +void WriteDescriptors::Execute(VulkanDevice* device) { vkUpdateDescriptorSets(device->device, (uint32_t)writes.size(), writes.data(), 0, nullptr); } diff --git a/src/common/rendering/vulkan/system/vk_builders.h b/src/common/rendering/vulkan/system/vk_builders.h index 98e634e65..2f47942cb 100644 --- a/src/common/rendering/vulkan/system/vk_builders.h +++ b/src/common/rendering/vulkan/system/vk_builders.h @@ -9,21 +9,23 @@ class ImageBuilder public: ImageBuilder(); - void setSize(int width, int height, int miplevels = 1, int arrayLayers = 1); - void setSamples(VkSampleCountFlagBits samples); - void setFormat(VkFormat format); - void setUsage(VkImageUsageFlags imageUsage, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY, VmaAllocationCreateFlags allocFlags = 0); - void setMemoryType(VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags preferredFlags, uint32_t memoryTypeBits = 0); - void setLinearTiling(); + ImageBuilder& Size(int width, int height, int miplevels = 1, int arrayLayers = 1); + ImageBuilder& Samples(VkSampleCountFlagBits samples); + ImageBuilder& Format(VkFormat format); + ImageBuilder& Usage(VkImageUsageFlags imageUsage, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY, VmaAllocationCreateFlags allocFlags = 0); + ImageBuilder& MemoryType(VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags preferredFlags, uint32_t memoryTypeBits = 0); + ImageBuilder& LinearTiling(); + ImageBuilder& DebugName(const char* name) { debugName = name; return *this; } - bool isFormatSupported(VulkanDevice *device, VkFormatFeatureFlags bufferFeatures = 0); + bool IsFormatSupported(VulkanDevice *device, VkFormatFeatureFlags bufferFeatures = 0); - std::unique_ptr create(VulkanDevice *device, VkDeviceSize* allocatedBytes = nullptr); - std::unique_ptr tryCreate(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device, VkDeviceSize* allocatedBytes = nullptr); + std::unique_ptr TryCreate(VulkanDevice *device); private: VkImageCreateInfo imageInfo = {}; VmaAllocationCreateInfo allocInfo = {}; + const char* debugName = nullptr; }; class ImageViewBuilder @@ -31,13 +33,15 @@ class ImageViewBuilder public: ImageViewBuilder(); - void setType(VkImageViewType type); - void setImage(VulkanImage *image, VkFormat format, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT); + ImageViewBuilder& Type(VkImageViewType type); + ImageViewBuilder& Image(VulkanImage *image, VkFormat format, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT); + ImageViewBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device); private: VkImageViewCreateInfo viewInfo = {}; + const char* debugName = nullptr; }; class SamplerBuilder @@ -45,18 +49,20 @@ class SamplerBuilder public: SamplerBuilder(); - void setAddressMode(VkSamplerAddressMode addressMode); - void setAddressMode(VkSamplerAddressMode u, VkSamplerAddressMode v, VkSamplerAddressMode w); - void setMinFilter(VkFilter minFilter); - void setMagFilter(VkFilter magFilter); - void setMipmapMode(VkSamplerMipmapMode mode); - void setAnisotropy(float maxAnisotropy); - void setMaxLod(float value); + SamplerBuilder& AddressMode(VkSamplerAddressMode addressMode); + SamplerBuilder& AddressMode(VkSamplerAddressMode u, VkSamplerAddressMode v, VkSamplerAddressMode w); + SamplerBuilder& MinFilter(VkFilter minFilter); + SamplerBuilder& MagFilter(VkFilter magFilter); + SamplerBuilder& MipmapMode(VkSamplerMipmapMode mode); + SamplerBuilder& Anisotropy(float maxAnisotropy); + SamplerBuilder& MaxLod(float value); + SamplerBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device); private: VkSamplerCreateInfo samplerInfo = {}; + const char* debugName = nullptr; }; class BufferBuilder @@ -64,15 +70,17 @@ class BufferBuilder public: BufferBuilder(); - void setSize(size_t size); - void setUsage(VkBufferUsageFlags bufferUsage, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY, VmaAllocationCreateFlags allocFlags = 0); - void setMemoryType(VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags preferredFlags, uint32_t memoryTypeBits = 0); + BufferBuilder& Size(size_t size); + BufferBuilder& Usage(VkBufferUsageFlags bufferUsage, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY, VmaAllocationCreateFlags allocFlags = 0); + BufferBuilder& MemoryType(VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags preferredFlags, uint32_t memoryTypeBits = 0); + BufferBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device); private: VkBufferCreateInfo bufferInfo = {}; VmaAllocationCreateInfo allocInfo = {}; + const char* debugName = nullptr; }; class ShaderBuilder @@ -80,14 +88,16 @@ class ShaderBuilder public: ShaderBuilder(); - void setVertexShader(const FString &code); - void setFragmentShader(const FString &code); + ShaderBuilder& VertexShader(const FString &code); + ShaderBuilder& FragmentShader(const FString &code); + ShaderBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(const char *shadername, VulkanDevice *device); + std::unique_ptr Create(const char *shadername, VulkanDevice *device); private: FString code; - int stage; + int stage = 0; + const char* debugName = nullptr; }; class ComputePipelineBuilder @@ -95,14 +105,16 @@ class ComputePipelineBuilder public: ComputePipelineBuilder(); - void setLayout(VulkanPipelineLayout *layout); - void setComputeShader(VulkanShader *shader); + ComputePipelineBuilder& Layout(VulkanPipelineLayout *layout); + ComputePipelineBuilder& ComputeShader(VulkanShader *shader); + ComputePipelineBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device); private: VkComputePipelineCreateInfo pipelineInfo = {}; VkPipelineShaderStageCreateInfo stageInfo = {}; + const char* debugName = nullptr; }; class DescriptorSetLayoutBuilder @@ -110,13 +122,15 @@ class DescriptorSetLayoutBuilder public: DescriptorSetLayoutBuilder(); - void addBinding(int binding, VkDescriptorType type, int arrayCount, VkShaderStageFlags stageFlags); + DescriptorSetLayoutBuilder& AddBinding(int binding, VkDescriptorType type, int arrayCount, VkShaderStageFlags stageFlags); + DescriptorSetLayoutBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device); private: VkDescriptorSetLayoutCreateInfo layoutInfo = {}; TArray bindings; + const char* debugName = nullptr; }; class DescriptorPoolBuilder @@ -124,14 +138,16 @@ class DescriptorPoolBuilder public: DescriptorPoolBuilder(); - void setMaxSets(int value); - void addPoolSize(VkDescriptorType type, int count); + DescriptorPoolBuilder& MaxSets(int value); + DescriptorPoolBuilder& AddPoolSize(VkDescriptorType type, int count); + DescriptorPoolBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device); private: std::vector poolSizes; VkDescriptorPoolCreateInfo poolInfo = {}; + const char* debugName = nullptr; }; class QueryPoolBuilder @@ -139,12 +155,14 @@ class QueryPoolBuilder public: QueryPoolBuilder(); - void setQueryType(VkQueryType type, int count, VkQueryPipelineStatisticFlags pipelineStatistics = 0); + QueryPoolBuilder& QueryType(VkQueryType type, int count, VkQueryPipelineStatisticFlags pipelineStatistics = 0); + QueryPoolBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device); private: VkQueryPoolCreateInfo poolInfo = {}; + const char* debugName = nullptr; }; class FramebufferBuilder @@ -152,16 +170,18 @@ class FramebufferBuilder public: FramebufferBuilder(); - void setRenderPass(VulkanRenderPass *renderPass); - void addAttachment(VulkanImageView *view); - void addAttachment(VkImageView view); - void setSize(int width, int height, int layers = 1); + FramebufferBuilder& RenderPass(VulkanRenderPass *renderPass); + FramebufferBuilder& AddAttachment(VulkanImageView *view); + FramebufferBuilder& AddAttachment(VkImageView view); + FramebufferBuilder& Size(int width, int height, int layers = 1); + FramebufferBuilder& DebugName(const char* name) { debugName = name; return *this; } - std::unique_ptr create(VulkanDevice *device); + std::unique_ptr Create(VulkanDevice *device); private: VkFramebufferCreateInfo framebufferInfo = {}; std::vector attachments; + const char* debugName = nullptr; }; union FRenderStyle; @@ -171,37 +191,39 @@ class GraphicsPipelineBuilder public: GraphicsPipelineBuilder(); - void setSubpass(int subpass); - void setLayout(VulkanPipelineLayout *layout); - void setRenderPass(VulkanRenderPass *renderPass); - void setTopology(VkPrimitiveTopology topology); - void setViewport(float x, float y, float width, float height, float minDepth = 0.0f, float maxDepth = 1.0f); - void setScissor(int x, int y, int width, int height); - void setRasterizationSamples(VkSampleCountFlagBits samples); + GraphicsPipelineBuilder& Subpass(int subpass); + GraphicsPipelineBuilder& Layout(VulkanPipelineLayout *layout); + GraphicsPipelineBuilder& RenderPass(VulkanRenderPass *renderPass); + GraphicsPipelineBuilder& Topology(VkPrimitiveTopology topology); + GraphicsPipelineBuilder& Viewport(float x, float y, float width, float height, float minDepth = 0.0f, float maxDepth = 1.0f); + GraphicsPipelineBuilder& Scissor(int x, int y, int width, int height); + GraphicsPipelineBuilder& RasterizationSamples(VkSampleCountFlagBits samples); - void setCull(VkCullModeFlags cullMode, VkFrontFace frontFace); - void setDepthStencilEnable(bool test, bool write, bool stencil); - void setDepthFunc(VkCompareOp func); - void setDepthClampEnable(bool value); - void setDepthBias(bool enable, float biasConstantFactor, float biasClamp, float biasSlopeFactor); - void setColorWriteMask(VkColorComponentFlags mask); - void setStencil(VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp, uint32_t compareMask, uint32_t writeMask, uint32_t reference); + GraphicsPipelineBuilder& Cull(VkCullModeFlags cullMode, VkFrontFace frontFace); + GraphicsPipelineBuilder& DepthStencilEnable(bool test, bool write, bool stencil); + GraphicsPipelineBuilder& DepthFunc(VkCompareOp func); + GraphicsPipelineBuilder& DepthClampEnable(bool value); + GraphicsPipelineBuilder& DepthBias(bool enable, float biasConstantFactor, float biasClamp, float biasSlopeFactor); + GraphicsPipelineBuilder& ColorWriteMask(VkColorComponentFlags mask); + GraphicsPipelineBuilder& Stencil(VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp, uint32_t compareMask, uint32_t writeMask, uint32_t reference); - void setAdditiveBlendMode(); - void setAlphaBlendMode(); - void setBlendMode(const FRenderStyle &style); - void setBlendMode(VkBlendOp op, VkBlendFactor src, VkBlendFactor dst); - void setSubpassColorAttachmentCount(int count); + GraphicsPipelineBuilder& AdditiveBlendMode(); + GraphicsPipelineBuilder& AlphaBlendMode(); + GraphicsPipelineBuilder& BlendMode(const FRenderStyle &style); + GraphicsPipelineBuilder& BlendMode(VkBlendOp op, VkBlendFactor src, VkBlendFactor dst); + GraphicsPipelineBuilder& SubpassColorAttachmentCount(int count); - void addVertexShader(VulkanShader *shader); - void addFragmentShader(VulkanShader *shader); + GraphicsPipelineBuilder& AddVertexShader(VulkanShader *shader); + GraphicsPipelineBuilder& AddFragmentShader(VulkanShader *shader); - void addVertexBufferBinding(int index, size_t stride); - void addVertexAttribute(int location, int binding, VkFormat format, size_t offset); + GraphicsPipelineBuilder& AddVertexBufferBinding(int index, size_t stride); + GraphicsPipelineBuilder& AddVertexAttribute(int location, int binding, VkFormat format, size_t offset); - void addDynamicState(VkDynamicState state); + GraphicsPipelineBuilder& AddDynamicState(VkDynamicState state); - std::unique_ptr create(VulkanDevice *device); + GraphicsPipelineBuilder& DebugName(const char* name) { debugName = name; return *this; } + + std::unique_ptr Create(VulkanDevice *device); private: VkGraphicsPipelineCreateInfo pipelineInfo = { }; @@ -222,6 +244,8 @@ private: std::vector vertexInputBindings; std::vector vertexInputAttributes; std::vector dynamicStates; + + const char* debugName = nullptr; }; class PipelineLayoutBuilder @@ -229,15 +253,18 @@ class PipelineLayoutBuilder public: PipelineLayoutBuilder(); - void addSetLayout(VulkanDescriptorSetLayout *setLayout); - void addPushConstantRange(VkShaderStageFlags stageFlags, size_t offset, size_t size); + PipelineLayoutBuilder& AddSetLayout(VulkanDescriptorSetLayout *setLayout); + PipelineLayoutBuilder& AddPushConstantRange(VkShaderStageFlags stageFlags, size_t offset, size_t size); - std::unique_ptr create(VulkanDevice *device); + PipelineLayoutBuilder& DebugName(const char* name) { debugName = name; return *this; } + + std::unique_ptr Create(VulkanDevice *device); private: VkPipelineLayoutCreateInfo pipelineLayoutInfo = {}; std::vector setLayouts; std::vector pushConstantRanges; + const char* debugName = nullptr; }; class RenderPassBuilder @@ -245,16 +272,18 @@ class RenderPassBuilder public: RenderPassBuilder(); - void addAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load, VkAttachmentStoreOp store, VkImageLayout initialLayout, VkImageLayout finalLayout); - void addDepthStencilAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load, VkAttachmentStoreOp store, VkAttachmentLoadOp stencilLoad, VkAttachmentStoreOp stencilStore, VkImageLayout initialLayout, VkImageLayout finalLayout); + RenderPassBuilder& AddAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load, VkAttachmentStoreOp store, VkImageLayout initialLayout, VkImageLayout finalLayout); + RenderPassBuilder& AddDepthStencilAttachment(VkFormat format, VkSampleCountFlagBits samples, VkAttachmentLoadOp load, VkAttachmentStoreOp store, VkAttachmentLoadOp stencilLoad, VkAttachmentStoreOp stencilStore, VkImageLayout initialLayout, VkImageLayout finalLayout); - void addExternalSubpassDependency(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); + RenderPassBuilder& AddExternalSubpassDependency(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); - void addSubpass(); - void addSubpassColorAttachmentRef(uint32_t index, VkImageLayout layout); - void addSubpassDepthStencilAttachmentRef(uint32_t index, VkImageLayout layout); + RenderPassBuilder& AddSubpass(); + RenderPassBuilder& AddSubpassColorAttachmentRef(uint32_t index, VkImageLayout layout); + RenderPassBuilder& AddSubpassDepthStencilAttachmentRef(uint32_t index, VkImageLayout layout); - std::unique_ptr create(VulkanDevice *device); + RenderPassBuilder& DebugName(const char* name) { debugName = name; return *this; } + + std::unique_ptr Create(VulkanDevice *device); private: VkRenderPassCreateInfo renderPassInfo = { }; @@ -270,20 +299,22 @@ private: }; std::vector> subpassData; + + const char* debugName = nullptr; }; class PipelineBarrier { public: - void addMemory(VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); - void addBuffer(VulkanBuffer *buffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); - void addBuffer(VulkanBuffer *buffer, VkDeviceSize offset, VkDeviceSize size, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); - void addImage(VulkanImage *image, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, int baseMipLevel = 0, int levelCount = 1); - void addImage(VkImage image, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, int baseMipLevel = 0, int levelCount = 1); - void addQueueTransfer(int srcFamily, int dstFamily, VulkanBuffer *buffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); - void addQueueTransfer(int srcFamily, int dstFamily, VulkanImage *image, VkImageLayout layout, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, int baseMipLevel = 0, int levelCount = 1); + PipelineBarrier& AddMemory(VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); + PipelineBarrier& AddBuffer(VulkanBuffer *buffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); + PipelineBarrier& AddBuffer(VulkanBuffer *buffer, VkDeviceSize offset, VkDeviceSize size, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); + PipelineBarrier& AddImage(VulkanImage *image, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, int baseMipLevel = 0, int levelCount = 1); + PipelineBarrier& AddImage(VkImage image, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, int baseMipLevel = 0, int levelCount = 1); + PipelineBarrier& AddQueueTransfer(int srcFamily, int dstFamily, VulkanBuffer *buffer, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask); + PipelineBarrier& AddQueueTransfer(int srcFamily, int dstFamily, VulkanImage *image, VkImageLayout layout, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, int baseMipLevel = 0, int levelCount = 1); - void execute(VulkanCommandBuffer *commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags = 0); + void Execute(VulkanCommandBuffer *commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags = 0); private: std::vector memoryBarriers; @@ -296,10 +327,10 @@ class QueueSubmit public: QueueSubmit(); - void addCommandBuffer(VulkanCommandBuffer *buffer); - void addWait(VkPipelineStageFlags waitStageMask, VulkanSemaphore *semaphore); - void addSignal(VulkanSemaphore *semaphore); - void execute(VulkanDevice *device, VkQueue queue, VulkanFence *fence = nullptr); + QueueSubmit& AddCommandBuffer(VulkanCommandBuffer *buffer); + QueueSubmit& AddWait(VkPipelineStageFlags waitStageMask, VulkanSemaphore *semaphore); + QueueSubmit& AddSignal(VulkanSemaphore *semaphore); + void Execute(VulkanDevice *device, VkQueue queue, VulkanFence *fence = nullptr); private: VkSubmitInfo submitInfo = {}; @@ -312,13 +343,12 @@ private: class WriteDescriptors { public: - void addBuffer(VulkanDescriptorSet *descriptorSet, int binding, VkDescriptorType type, VulkanBuffer *buffer); - void addBuffer(VulkanDescriptorSet *descriptorSet, int binding, VkDescriptorType type, VulkanBuffer *buffer, size_t offset, size_t range); - void addStorageImage(VulkanDescriptorSet *descriptorSet, int binding, VulkanImageView *view, VkImageLayout imageLayout); - void addCombinedImageSampler(VulkanDescriptorSet *descriptorSet, int binding, VulkanImageView *view, VulkanSampler *sampler, VkImageLayout imageLayout); - void addAccelerationStructure(VulkanDescriptorSet* descriptorSet, int binding, VulkanAccelerationStructure* accelStruct); - - void updateSets(VulkanDevice *device); + WriteDescriptors& AddBuffer(VulkanDescriptorSet *descriptorSet, int binding, VkDescriptorType type, VulkanBuffer *buffer); + WriteDescriptors& AddBuffer(VulkanDescriptorSet *descriptorSet, int binding, VkDescriptorType type, VulkanBuffer *buffer, size_t offset, size_t range); + WriteDescriptors& AddStorageImage(VulkanDescriptorSet *descriptorSet, int binding, VulkanImageView *view, VkImageLayout imageLayout); + WriteDescriptors& AddCombinedImageSampler(VulkanDescriptorSet *descriptorSet, int binding, VulkanImageView *view, VulkanSampler *sampler, VkImageLayout imageLayout); + WriteDescriptors& AddAccelerationStructure(VulkanDescriptorSet* descriptorSet, int binding, VulkanAccelerationStructure* accelStruct); + void Execute(VulkanDevice *device); private: struct WriteExtra diff --git a/src/common/rendering/vulkan/system/vk_commandbuffer.cpp b/src/common/rendering/vulkan/system/vk_commandbuffer.cpp index 1694fe017..7018d9df5 100644 --- a/src/common/rendering/vulkan/system/vk_commandbuffer.cpp +++ b/src/common/rendering/vulkan/system/vk_commandbuffer.cpp @@ -55,9 +55,9 @@ VkCommandBufferManager::VkCommandBufferManager(VulkanFrameBuffer* fb) : fb(fb) if (fb->device->graphicsTimeQueries) { - QueryPoolBuilder querybuilder; - querybuilder.setQueryType(VK_QUERY_TYPE_TIMESTAMP, MaxTimestampQueries); - mTimestampQueryPool = querybuilder.create(fb->device); + mTimestampQueryPool = QueryPoolBuilder() + .QueryType(VK_QUERY_TYPE_TIMESTAMP, MaxTimestampQueries) + .Create(fb->device); GetDrawCommands()->resetQueryPool(mTimestampQueryPool.get(), 0, MaxTimestampQueries); } @@ -111,21 +111,21 @@ void VkCommandBufferManager::FlushCommands(VulkanCommandBuffer** commands, size_ QueueSubmit submit; for (size_t i = 0; i < count; i++) - submit.addCommandBuffer(commands[i]); + submit.AddCommandBuffer(commands[i]); if (mNextSubmit > 0) - submit.addWait(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, mSubmitSemaphore[(mNextSubmit - 1) % maxConcurrentSubmitCount].get()); + submit.AddWait(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, mSubmitSemaphore[(mNextSubmit - 1) % maxConcurrentSubmitCount].get()); if (finish && presentImageIndex != 0xffffffff) { - submit.addWait(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, mSwapChainImageAvailableSemaphore.get()); - submit.addSignal(mRenderFinishedSemaphore.get()); + submit.AddWait(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, mSwapChainImageAvailableSemaphore.get()); + submit.AddSignal(mRenderFinishedSemaphore.get()); } if (!lastsubmit) - submit.addSignal(mSubmitSemaphore[currentIndex].get()); + submit.AddSignal(mSubmitSemaphore[currentIndex].get()); - submit.execute(fb->device, fb->device->graphicsQueue, mSubmitFence[currentIndex].get()); + submit.Execute(fb->device, fb->device->graphicsQueue, mSubmitFence[currentIndex].get()); mNextSubmit++; } diff --git a/src/common/rendering/vulkan/system/vk_framebuffer.cpp b/src/common/rendering/vulkan/system/vk_framebuffer.cpp index 19f16f932..4a80c0dbe 100644 --- a/src/common/rendering/vulkan/system/vk_framebuffer.cpp +++ b/src/common/rendering/vulkan/system/vk_framebuffer.cpp @@ -200,9 +200,9 @@ void VulkanFrameBuffer::RenderTextureView(FCanvasTexture* tex, std::functionEndRenderPass(); - VkImageTransition barrier0; - barrier0.addImage(image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true); - barrier0.execute(mCommands->GetDrawCommands()); + VkImageTransition() + .AddImage(image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true) + .Execute(mCommands->GetDrawCommands()); mRenderState->SetRenderTarget(image, depthStencil->View.get(), image->Image->width, image->Image->height, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT); @@ -215,9 +215,9 @@ void VulkanFrameBuffer::RenderTextureView(FCanvasTexture* tex, std::functionEndRenderPass(); - VkImageTransition barrier1; - barrier1.addImage(image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false); - barrier1.execute(mCommands->GetDrawCommands()); + VkImageTransition() + .AddImage(image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false) + .Execute(mCommands->GetDrawCommands()); mRenderState->SetRenderTarget(&GetBuffers()->SceneColor, GetBuffers()->SceneDepthStencil.View.get(), GetBuffers()->GetWidth(), GetBuffers()->GetHeight(), VK_FORMAT_R16G16B16A16_SFLOAT, GetBuffers()->GetSceneSamples()); @@ -341,19 +341,21 @@ void VulkanFrameBuffer::CopyScreenToBuffer(int w, int h, uint8_t *data) VkTextureImage image; // Convert from rgba16f to rgba8 using the GPU: - ImageBuilder imgbuilder; - imgbuilder.setFormat(VK_FORMAT_R8G8B8A8_UNORM); - imgbuilder.setUsage(VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); - imgbuilder.setSize(w, h); - image.Image = imgbuilder.create(device); + image.Image = ImageBuilder() + .Format(VK_FORMAT_R8G8B8A8_UNORM) + .Usage(VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT) + .Size(w, h) + .DebugName("CopyScreenToBuffer") + .Create(device); + GetPostprocess()->BlitCurrentToImage(&image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); // Staging buffer for download - BufferBuilder bufbuilder; - bufbuilder.setSize(w * h * 4); - bufbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_TO_CPU); - auto staging = bufbuilder.create(device); - staging->SetDebugName("CopyScreenToBuffer"); + auto staging = BufferBuilder() + .Size(w * h * 4) + .Usage(VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_TO_CPU) + .DebugName("CopyScreenToBuffer") + .Create(device); // Copy from image to buffer VkBufferImageCopy region = {}; diff --git a/src/common/rendering/vulkan/system/vk_hwbuffer.cpp b/src/common/rendering/vulkan/system/vk_hwbuffer.cpp index ca5b7233e..cd0eb56eb 100644 --- a/src/common/rendering/vulkan/system/vk_hwbuffer.cpp +++ b/src/common/rendering/vulkan/system/vk_hwbuffer.cpp @@ -64,12 +64,10 @@ void VkHardwareBuffer::SetData(size_t size, const void *data, BufferUsageType us if (mBuffer) { fb->GetCommands()->DrawDeleteList->Add(std::move(mBuffer)); - mBuffer = {}; } if (mStaging) { fb->GetCommands()->TransferDeleteList->Add(std::move(mStaging)); - mStaging = {}; } if (usage == BufferUsageType::Static || usage == BufferUsageType::Stream) @@ -78,17 +76,17 @@ void VkHardwareBuffer::SetData(size_t size, const void *data, BufferUsageType us mPersistent = false; - BufferBuilder builder; - builder.setUsage(VK_BUFFER_USAGE_TRANSFER_DST_BIT | mBufferType, VMA_MEMORY_USAGE_GPU_ONLY); - builder.setSize(bufsize); - mBuffer = builder.create(fb->device); - mBuffer->SetDebugName(usage == BufferUsageType::Static ? "VkHardwareBuffer.Static" : "VkHardwareBuffer.Stream"); + 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); - BufferBuilder builder2; - builder2.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY); - builder2.setSize(bufsize); - mStaging = builder2.create(fb->device); - mStaging->SetDebugName(usage == BufferUsageType::Static ? "VkHardwareBuffer.Staging.Static" : "VkHardwareBuffer.Staging.Stream"); + 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); if (data) { @@ -103,14 +101,14 @@ void VkHardwareBuffer::SetData(size_t size, const void *data, BufferUsageType us { mPersistent = true; - BufferBuilder builder; - builder.setUsage(mBufferType, VMA_MEMORY_USAGE_UNKNOWN, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT); - builder.setMemoryType( - 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); - builder.setSize(bufsize); - mBuffer = builder.create(fb->device); - mBuffer->SetDebugName("VkHardwareBuffer.Persistent"); + 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); map = mBuffer->Map(0, bufsize); if (data) @@ -120,14 +118,14 @@ void VkHardwareBuffer::SetData(size_t size, const void *data, BufferUsageType us { mPersistent = false; - BufferBuilder builder; - builder.setUsage(mBufferType, VMA_MEMORY_USAGE_UNKNOWN, 0); - builder.setMemoryType( - 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); - builder.setSize(bufsize); - mBuffer = builder.create(fb->device); - mBuffer->SetDebugName("VkHardwareBuffer.Mappable"); + 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); if (data) { @@ -171,14 +169,14 @@ void VkHardwareBuffer::Resize(size_t newsize) map = nullptr; // Create new buffer - BufferBuilder builder; - builder.setUsage(mBufferType, VMA_MEMORY_USAGE_UNKNOWN, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT); - builder.setMemoryType( - 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); - builder.setSize(newsize); - mBuffer = builder.create(fb->device); - mBuffer->SetDebugName("VkHardwareBuffer.Resized"); + 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); buffersize = newsize; // Transfer data from old to new diff --git a/src/common/rendering/vulkan/textures/vk_hwtexture.cpp b/src/common/rendering/vulkan/textures/vk_hwtexture.cpp index b613ad67c..3cc69ccef 100644 --- a/src/common/rendering/vulkan/textures/vk_hwtexture.cpp +++ b/src/common/rendering/vulkan/textures/vk_hwtexture.cpp @@ -81,23 +81,24 @@ VkTextureImage *VkHardwareTexture::GetDepthStencil(FTexture *tex) int w = tex->GetWidth(); int h = tex->GetHeight(); - ImageBuilder builder; - builder.setSize(w, h); - builder.setSamples(VK_SAMPLE_COUNT_1_BIT); - builder.setFormat(format); - builder.setUsage(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT); - mDepthStencil.Image = builder.create(fb->device); - mDepthStencil.Image->SetDebugName("VkHardwareTexture.DepthStencil"); + mDepthStencil.Image = ImageBuilder() + .Size(w, h) + .Samples(VK_SAMPLE_COUNT_1_BIT) + .Format(format) + .Usage(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) + .DebugName("VkHardwareTexture.DepthStencil") + .Create(fb->device); + mDepthStencil.AspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; - ImageViewBuilder viewbuilder; - viewbuilder.setImage(mDepthStencil.Image.get(), format, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); - mDepthStencil.View = viewbuilder.create(fb->device); - mDepthStencil.View->SetDebugName("VkHardwareTexture.DepthStencilView"); + mDepthStencil.View = ImageViewBuilder() + .Image(mDepthStencil.Image.get(), format, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) + .DebugName("VkHardwareTexture.DepthStencilView") + .Create(fb->device); - VkImageTransition barrier; - barrier.addImage(&mDepthStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, true); - barrier.execute(fb->GetCommands()->GetTransferCommands()); + VkImageTransition() + .AddImage(&mDepthStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, true) + .Execute(fb->GetCommands()->GetTransferCommands()); } return &mDepthStencil; } @@ -116,23 +117,21 @@ void VkHardwareTexture::CreateImage(FTexture *tex, int translation, int flags) int w = tex->GetWidth(); int h = tex->GetHeight(); - ImageBuilder imgbuilder; - imgbuilder.setFormat(format); - imgbuilder.setSize(w, h); - imgbuilder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); - mImage.Image = imgbuilder.create(fb->device); - mImage.Image->SetDebugName("VkHardwareTexture.mImage"); + mImage.Image = ImageBuilder() + .Format(format) + .Size(w, h) + .Usage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT) + .DebugName("VkHardwareTexture.mImage") + .Create(fb->device); - ImageViewBuilder viewbuilder; - viewbuilder.setImage(mImage.Image.get(), format); - mImage.View = viewbuilder.create(fb->device); - mImage.View->SetDebugName("VkHardwareTexture.mImageView"); + mImage.View = ImageViewBuilder() + .Image(mImage.Image.get(), format) + .DebugName("VkHardwareTexture.mImageView") + .Create(fb->device); - auto cmdbuffer = fb->GetCommands()->GetTransferCommands(); - - VkImageTransition imageTransition; - imageTransition.addImage(&mImage, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, true); - imageTransition.execute(cmdbuffer); + VkImageTransition() + .AddImage(&mImage, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, true) + .Execute(fb->GetCommands()->GetTransferCommands()); } } @@ -143,33 +142,33 @@ void VkHardwareTexture::CreateTexture(int w, int h, int pixelsize, VkFormat form int totalSize = w * h * pixelsize; - BufferBuilder bufbuilder; - bufbuilder.setSize(totalSize); - bufbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY); - std::unique_ptr stagingBuffer = bufbuilder.create(fb->device); - stagingBuffer->SetDebugName("VkHardwareTexture.mStagingBuffer"); + auto stagingBuffer = BufferBuilder() + .Size(totalSize) + .Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY) + .DebugName("VkHardwareTexture.mStagingBuffer") + .Create(fb->device); uint8_t *data = (uint8_t*)stagingBuffer->Map(0, totalSize); memcpy(data, pixels, totalSize); stagingBuffer->Unmap(); - ImageBuilder imgbuilder; - imgbuilder.setFormat(format); - imgbuilder.setSize(w, h, !mipmap ? 1 : GetMipLevels(w, h)); - imgbuilder.setUsage(VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); - mImage.Image = imgbuilder.create(fb->device); - mImage.Image->SetDebugName("VkHardwareTexture.mImage"); + mImage.Image = ImageBuilder() + .Format(format) + .Size(w, h, !mipmap ? 1 : GetMipLevels(w, h)) + .Usage(VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT) + .DebugName("VkHardwareTexture.mImage") + .Create(fb->device); - ImageViewBuilder viewbuilder; - viewbuilder.setImage(mImage.Image.get(), format); - mImage.View = viewbuilder.create(fb->device); - mImage.View->SetDebugName("VkHardwareTexture.mImageView"); + mImage.View = ImageViewBuilder() + .Image(mImage.Image.get(), format) + .DebugName("VkHardwareTexture.mImageView") + .Create(fb->device); auto cmdbuffer = fb->GetCommands()->GetTransferCommands(); - VkImageTransition imageTransition; - imageTransition.addImage(&mImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true); - imageTransition.execute(cmdbuffer); + VkImageTransition() + .AddImage(&mImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true) + .Execute(cmdbuffer); VkBufferImageCopy region = {}; region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; @@ -210,29 +209,28 @@ void VkHardwareTexture::AllocateBuffer(int w, int h, int texelsize) { VkFormat format = texelsize == 4 ? VK_FORMAT_B8G8R8A8_UNORM : VK_FORMAT_R8_UNORM; - ImageBuilder imgbuilder; VkDeviceSize allocatedBytes = 0; - imgbuilder.setFormat(format); - imgbuilder.setSize(w, h); - imgbuilder.setLinearTiling(); - imgbuilder.setUsage(VK_IMAGE_USAGE_SAMPLED_BIT, VMA_MEMORY_USAGE_UNKNOWN, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT); - imgbuilder.setMemoryType( - 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); - mImage.Image = imgbuilder.create(fb->device, &allocatedBytes); - mImage.Image->SetDebugName("VkHardwareTexture.mImage"); + mImage.Image = ImageBuilder() + .Format(format) + .Size(w, h) + .LinearTiling() + .Usage(VK_IMAGE_USAGE_SAMPLED_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) + .DebugName("VkHardwareTexture.mImage") + .Create(fb->device, &allocatedBytes); + mTexelsize = texelsize; - ImageViewBuilder viewbuilder; - viewbuilder.setImage(mImage.Image.get(), format); - mImage.View = viewbuilder.create(fb->device); - mImage.View->SetDebugName("VkHardwareTexture.mImageView"); + mImage.View = ImageViewBuilder() + .Image(mImage.Image.get(), format) + .DebugName("VkHardwareTexture.mImageView") + .Create(fb->device); - auto cmdbuffer = fb->GetCommands()->GetTransferCommands(); - - VkImageTransition imageTransition; - imageTransition.addImage(&mImage, VK_IMAGE_LAYOUT_GENERAL, true); - imageTransition.execute(cmdbuffer); + VkImageTransition() + .AddImage(&mImage, VK_IMAGE_LAYOUT_GENERAL, true) + .Execute(fb->GetCommands()->GetTransferCommands()); bufferpitch = int(allocatedBytes / h / texelsize); } @@ -257,18 +255,19 @@ void VkHardwareTexture::CreateWipeTexture(int w, int h, const char *name) { VkFormat format = VK_FORMAT_B8G8R8A8_UNORM; - ImageBuilder imgbuilder; - imgbuilder.setFormat(format); - imgbuilder.setSize(w, h); - imgbuilder.setUsage(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY); - mImage.Image = imgbuilder.create(fb->device); - mImage.Image->SetDebugName(name); + mImage.Image = ImageBuilder() + .Format(format) + .Size(w, h) + .Usage(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY) + .DebugName(name) + .Create(fb->device); + mTexelsize = 4; - ImageViewBuilder viewbuilder; - viewbuilder.setImage(mImage.Image.get(), format); - mImage.View = viewbuilder.create(fb->device); - mImage.View->SetDebugName(name); + mImage.View = ImageViewBuilder() + .Image(mImage.Image.get(), format) + .DebugName(name) + .Create(fb->device); if (fb->GetBuffers()->GetWidth() > 0 && fb->GetBuffers()->GetHeight() > 0) { @@ -279,9 +278,9 @@ void VkHardwareTexture::CreateWipeTexture(int w, int h, const char *name) // hwrenderer asked image data from a frame buffer that was never written into. Let's give it that.. // (ideally the hwrenderer wouldn't do this, but the calling code is too complex for me to fix) - VkImageTransition transition0; - transition0.addImage(&mImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true); - transition0.execute(fb->GetCommands()->GetTransferCommands()); + VkImageTransition() + .AddImage(&mImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true) + .Execute(fb->GetCommands()->GetTransferCommands()); VkImageSubresourceRange range = {}; range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; @@ -295,9 +294,9 @@ void VkHardwareTexture::CreateWipeTexture(int w, int h, const char *name) value.float32[3] = 1.0f; fb->GetCommands()->GetTransferCommands()->clearColorImage(mImage.Image->image, mImage.Layout, &value, 1, &range); - VkImageTransition transition1; - transition1.addImage(&mImage, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false); - transition1.execute(fb->GetCommands()->GetTransferCommands()); + VkImageTransition() + .AddImage(&mImage, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false) + .Execute(fb->GetCommands()->GetTransferCommands()); } } @@ -353,7 +352,7 @@ VulkanDescriptorSet* VkMaterial::GetDescriptorSet(const FMaterialState& state) MaterialLayerInfo *layer; auto systex = static_cast(GetLayer(0, state.mTranslation, &layer)); auto systeximage = systex->GetImage(layer->layerTexture, state.mTranslation, layer->scaleFlags); - update.addCombinedImageSampler(descriptor.get(), 0, systeximage->View.get(), sampler, systeximage->Layout); + update.AddCombinedImageSampler(descriptor.get(), 0, systeximage->View.get(), sampler, systeximage->Layout); if (!(layer->scaleFlags & CTF_Indexed)) { @@ -361,7 +360,7 @@ VulkanDescriptorSet* VkMaterial::GetDescriptorSet(const FMaterialState& state) { auto syslayer = static_cast(GetLayer(i, 0, &layer)); auto syslayerimage = syslayer->GetImage(layer->layerTexture, 0, layer->scaleFlags); - update.addCombinedImageSampler(descriptor.get(), i, syslayerimage->View.get(), sampler, syslayerimage->Layout); + update.AddCombinedImageSampler(descriptor.get(), i, syslayerimage->View.get(), sampler, syslayerimage->Layout); } } else @@ -370,7 +369,7 @@ VulkanDescriptorSet* VkMaterial::GetDescriptorSet(const FMaterialState& state) { auto syslayer = static_cast(GetLayer(i, translation, &layer)); auto syslayerimage = syslayer->GetImage(layer->layerTexture, 0, layer->scaleFlags); - update.addCombinedImageSampler(descriptor.get(), i, syslayerimage->View.get(), sampler, syslayerimage->Layout); + update.AddCombinedImageSampler(descriptor.get(), i, syslayerimage->View.get(), sampler, syslayerimage->Layout); } numLayers = 3; } @@ -378,10 +377,10 @@ VulkanDescriptorSet* VkMaterial::GetDescriptorSet(const FMaterialState& state) auto dummyImage = fb->GetTextureManager()->GetNullTextureView(); for (int i = numLayers; i < SHADER_MIN_REQUIRED_TEXTURE_LAYERS; i++) { - update.addCombinedImageSampler(descriptor.get(), i, dummyImage, sampler, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + update.AddCombinedImageSampler(descriptor.get(), i, dummyImage, sampler, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); } - update.updateSets(fb->device); + update.Execute(fb->device); mDescriptorSets.emplace_back(clampmode, translationp, std::move(descriptor)); return mDescriptorSets.back().descriptor.get(); } diff --git a/src/common/rendering/vulkan/textures/vk_imagetransition.cpp b/src/common/rendering/vulkan/textures/vk_imagetransition.cpp index a62cb3c2d..8876cb6a6 100644 --- a/src/common/rendering/vulkan/textures/vk_imagetransition.cpp +++ b/src/common/rendering/vulkan/textures/vk_imagetransition.cpp @@ -22,10 +22,10 @@ #include "vk_imagetransition.h" -void VkImageTransition::addImage(VkTextureImage *image, VkImageLayout targetLayout, bool undefinedSrcLayout, int baseMipLevel, int levelCount) +VkImageTransition& VkImageTransition::AddImage(VkTextureImage *image, VkImageLayout targetLayout, bool undefinedSrcLayout, int baseMipLevel, int levelCount) { if (image->Layout == targetLayout) - return; + return *this; VkAccessFlags srcAccess = 0; VkAccessFlags dstAccess = 0; @@ -91,15 +91,16 @@ void VkImageTransition::addImage(VkTextureImage *image, VkImageLayout targetLayo I_FatalError("Unimplemented dst image layout transition\n"); } - barrier.addImage(image->Image.get(), undefinedSrcLayout ? VK_IMAGE_LAYOUT_UNDEFINED : image->Layout, targetLayout, srcAccess, dstAccess, aspectMask, baseMipLevel, levelCount); + barrier.AddImage(image->Image.get(), undefinedSrcLayout ? VK_IMAGE_LAYOUT_UNDEFINED : image->Layout, targetLayout, srcAccess, dstAccess, aspectMask, baseMipLevel, levelCount); needbarrier = true; image->Layout = targetLayout; + return *this; } -void VkImageTransition::execute(VulkanCommandBuffer *cmdbuffer) +void VkImageTransition::Execute(VulkanCommandBuffer *cmdbuffer) { if (needbarrier) - barrier.execute(cmdbuffer, srcStageMask, dstStageMask); + barrier.Execute(cmdbuffer, srcStageMask, dstStageMask); } ///////////////////////////////////////////////////////////////////////////// @@ -111,10 +112,10 @@ void VkTextureImage::GenerateMipmaps(VulkanCommandBuffer *cmdbuffer) int i; for (i = 1; mipWidth > 1 || mipHeight > 1; i++) { - PipelineBarrier barrier0; - barrier0.addImage(Image.get(), Layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT, i - 1); - barrier0.addImage(Image.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT, i); - barrier0.execute(cmdbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); + PipelineBarrier() + .AddImage(Image.get(), Layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT, i - 1) + .AddImage(Image.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT, i) + .Execute(cmdbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); Layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; int nextWidth = max(mipWidth >> 1, 1); @@ -135,17 +136,17 @@ void VkTextureImage::GenerateMipmaps(VulkanCommandBuffer *cmdbuffer) blit.dstSubresource.layerCount = 1; cmdbuffer->blitImage(Image->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, Image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_LINEAR); - PipelineBarrier barrier1; - barrier1.addImage(Image.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT, i - 1); - barrier1.execute(cmdbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); + PipelineBarrier() + .AddImage(Image.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT, i - 1) + .Execute(cmdbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); mipWidth = nextWidth; mipHeight = nextHeight; } - PipelineBarrier barrier2; - barrier2.addImage(Image.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT, i - 1); - barrier2.execute(cmdbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); + PipelineBarrier() + .AddImage(Image.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT, i - 1) + .Execute(cmdbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); Layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; } diff --git a/src/common/rendering/vulkan/textures/vk_imagetransition.h b/src/common/rendering/vulkan/textures/vk_imagetransition.h index 11d6c4e43..c314bf3dc 100644 --- a/src/common/rendering/vulkan/textures/vk_imagetransition.h +++ b/src/common/rendering/vulkan/textures/vk_imagetransition.h @@ -38,8 +38,8 @@ public: class VkImageTransition { public: - void addImage(VkTextureImage *image, VkImageLayout targetLayout, bool undefinedSrcLayout, int baseMipLevel = 0, int levelCount = 1); - void execute(VulkanCommandBuffer *cmdbuffer); + VkImageTransition& AddImage(VkTextureImage *image, VkImageLayout targetLayout, bool undefinedSrcLayout, int baseMipLevel = 0, int levelCount = 1); + void Execute(VulkanCommandBuffer *cmdbuffer); private: PipelineBarrier barrier; diff --git a/src/common/rendering/vulkan/textures/vk_pptexture.cpp b/src/common/rendering/vulkan/textures/vk_pptexture.cpp index 0b954e794..d76ad38a1 100644 --- a/src/common/rendering/vulkan/textures/vk_pptexture.cpp +++ b/src/common/rendering/vulkan/textures/vk_pptexture.cpp @@ -40,35 +40,36 @@ VkPPTexture::VkPPTexture(VulkanFrameBuffer* fb, PPTexture *texture) : fb(fb) } ImageBuilder imgbuilder; - imgbuilder.setFormat(format); - imgbuilder.setSize(texture->Width, texture->Height); + imgbuilder.Format(format); + imgbuilder.Size(texture->Width, texture->Height); if (texture->Data) - imgbuilder.setUsage(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); + imgbuilder.Usage(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); else - imgbuilder.setUsage(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); - if (!imgbuilder.isFormatSupported(fb->device)) + imgbuilder.Usage(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); + imgbuilder.DebugName("VkPPTexture"); + if (!imgbuilder.IsFormatSupported(fb->device)) I_FatalError("Vulkan device does not support the image format required by a postprocess texture\n"); - TexImage.Image = imgbuilder.create(fb->device); - TexImage.Image->SetDebugName("VkPPTexture"); + TexImage.Image = imgbuilder.Create(fb->device); Format = format; - ImageViewBuilder viewbuilder; - viewbuilder.setImage(TexImage.Image.get(), format); - TexImage.View = viewbuilder.create(fb->device); - TexImage.View->SetDebugName("VkPPTextureView"); + TexImage.View = ImageViewBuilder() + .Image(TexImage.Image.get(), format) + .DebugName("VkPPTextureView") + .Create(fb->device); if (texture->Data) { size_t totalsize = texture->Width * texture->Height * pixelsize; - BufferBuilder stagingbuilder; - stagingbuilder.setSize(totalsize); - stagingbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY); - Staging = stagingbuilder.create(fb->device); - Staging->SetDebugName("VkPPTextureStaging"); - VkImageTransition barrier0; - barrier0.addImage(&TexImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true); - barrier0.execute(fb->GetCommands()->GetTransferCommands()); + Staging = BufferBuilder() + .Size(totalsize) + .Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY) + .DebugName("VkPPTextureStaging") + .Create(fb->device); + + VkImageTransition() + .AddImage(&TexImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true) + .Execute(fb->GetCommands()->GetTransferCommands()); void *data = Staging->Map(0, totalsize); memcpy(data, texture->Data.get(), totalsize); @@ -82,15 +83,15 @@ VkPPTexture::VkPPTexture(VulkanFrameBuffer* fb, PPTexture *texture) : fb(fb) region.imageExtent.height = texture->Height; fb->GetCommands()->GetTransferCommands()->copyBufferToImage(Staging->buffer, TexImage.Image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); - VkImageTransition barrier1; - barrier1.addImage(&TexImage, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false); - barrier1.execute(fb->GetCommands()->GetTransferCommands()); + VkImageTransition() + .AddImage(&TexImage, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false) + .Execute(fb->GetCommands()->GetTransferCommands()); } else { - VkImageTransition barrier; - barrier.addImage(&TexImage, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true); - barrier.execute(fb->GetCommands()->GetTransferCommands()); + VkImageTransition() + .AddImage(&TexImage, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true) + .Execute(fb->GetCommands()->GetTransferCommands()); } fb->GetTextureManager()->AddPPTexture(this); diff --git a/src/common/rendering/vulkan/textures/vk_renderbuffers.cpp b/src/common/rendering/vulkan/textures/vk_renderbuffers.cpp index f01a8a37a..aa49b0fde 100644 --- a/src/common/rendering/vulkan/textures/vk_renderbuffers.cpp +++ b/src/common/rendering/vulkan/textures/vk_renderbuffers.cpp @@ -93,21 +93,21 @@ void VkRenderBuffers::CreatePipeline(int width, int height) VkImageTransition barrier; for (int i = 0; i < NumPipelineImages; i++) { - ImageBuilder builder; - builder.setSize(width, height); - builder.setFormat(VK_FORMAT_R16G16B16A16_SFLOAT); - builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); - PipelineImage[i].Image = builder.create(fb->device); - PipelineImage[i].Image->SetDebugName("VkRenderBuffers.PipelineImage"); + PipelineImage[i].Image = ImageBuilder() + .Size(width, height) + .Format(VK_FORMAT_R16G16B16A16_SFLOAT) + .Usage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT) + .DebugName("VkRenderBuffers.PipelineImage") + .Create(fb->device); - ImageViewBuilder viewbuilder; - viewbuilder.setImage(PipelineImage[i].Image.get(), VK_FORMAT_R16G16B16A16_SFLOAT); - PipelineImage[i].View = viewbuilder.create(fb->device); - PipelineImage[i].View->SetDebugName("VkRenderBuffers.PipelineView"); + PipelineImage[i].View = ImageViewBuilder() + .Image(PipelineImage[i].Image.get(), VK_FORMAT_R16G16B16A16_SFLOAT) + .DebugName("VkRenderBuffers.PipelineView") + .Create(fb->device); - barrier.addImage(&PipelineImage[i], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true); + barrier.AddImage(&PipelineImage[i], VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true); } - barrier.execute(fb->GetCommands()->GetDrawCommands()); + barrier.Execute(fb->GetCommands()->GetDrawCommands()); } void VkRenderBuffers::CreateScene(int width, int height, VkSampleCountFlagBits samples) @@ -122,95 +122,98 @@ void VkRenderBuffers::CreateScene(int width, int height, VkSampleCountFlagBits s CreateSceneNormal(width, height, samples); CreateSceneFog(width, height, samples); - VkImageTransition barrier; - barrier.addImage(&SceneColor, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true); - barrier.addImage(&SceneDepthStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, true); - barrier.addImage(&SceneNormal, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true); - barrier.addImage(&SceneFog, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true); - barrier.execute(fb->GetCommands()->GetDrawCommands()); + VkImageTransition() + .AddImage(&SceneColor, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true) + .AddImage(&SceneDepthStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, true) + .AddImage(&SceneNormal, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true) + .AddImage(&SceneFog, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, true) + .Execute(fb->GetCommands()->GetDrawCommands()); } void VkRenderBuffers::CreateSceneColor(int width, int height, VkSampleCountFlagBits samples) { - ImageBuilder builder; - builder.setSize(width, height); - builder.setSamples(samples); - builder.setFormat(VK_FORMAT_R16G16B16A16_SFLOAT); - builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT); - SceneColor.Image = builder.create(fb->device); - SceneColor.Image->SetDebugName("VkRenderBuffers.SceneColor"); + SceneColor.Image = ImageBuilder() + .Size(width, height) + .Samples(samples) + .Format(VK_FORMAT_R16G16B16A16_SFLOAT) + .Usage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT) + .DebugName("VkRenderBuffers.SceneColor") + .Create(fb->device); - ImageViewBuilder viewbuilder; - viewbuilder.setImage(SceneColor.Image.get(), VK_FORMAT_R16G16B16A16_SFLOAT); - SceneColor.View = viewbuilder.create(fb->device); - SceneColor.View->SetDebugName("VkRenderBuffers.SceneColorView"); + SceneColor.View = ImageViewBuilder() + .Image(SceneColor.Image.get(), VK_FORMAT_R16G16B16A16_SFLOAT) + .DebugName("VkRenderBuffers.SceneColorView") + .Create(fb->device); } void VkRenderBuffers::CreateSceneDepthStencil(int width, int height, VkSampleCountFlagBits samples) { ImageBuilder builder; - builder.setSize(width, height); - builder.setSamples(samples); - builder.setFormat(SceneDepthStencilFormat); - builder.setUsage(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); - if (!builder.isFormatSupported(fb->device)) + builder.Size(width, height); + builder.Samples(samples); + builder.Format(SceneDepthStencilFormat); + builder.Usage(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); + if (!builder.IsFormatSupported(fb->device)) { SceneDepthStencilFormat = VK_FORMAT_D32_SFLOAT_S8_UINT; - builder.setFormat(SceneDepthStencilFormat); - if (!builder.isFormatSupported(fb->device)) + builder.Format(SceneDepthStencilFormat); + if (!builder.IsFormatSupported(fb->device)) { I_FatalError("This device does not support any of the required depth stencil image formats."); } } - SceneDepthStencil.Image = builder.create(fb->device); - SceneDepthStencil.Image->SetDebugName("VkRenderBuffers.SceneDepthStencil"); + builder.DebugName("VkRenderBuffers.SceneDepthStencil"); + + SceneDepthStencil.Image = builder.Create(fb->device); SceneDepthStencil.AspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; - ImageViewBuilder viewbuilder; - viewbuilder.setImage(SceneDepthStencil.Image.get(), SceneDepthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT); - SceneDepthStencil.View = viewbuilder.create(fb->device); - SceneDepthStencil.View->SetDebugName("VkRenderBuffers.SceneDepthStencilView"); + SceneDepthStencil.View = ImageViewBuilder() + .Image(SceneDepthStencil.Image.get(), SceneDepthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) + .DebugName("VkRenderBuffers.SceneDepthStencilView") + .Create(fb->device); - viewbuilder.setImage(SceneDepthStencil.Image.get(), SceneDepthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT); - SceneDepthStencil.DepthOnlyView = viewbuilder.create(fb->device); - SceneDepthStencil.DepthOnlyView->SetDebugName("VkRenderBuffers.SceneDepthView"); + SceneDepthStencil.DepthOnlyView = ImageViewBuilder() + .Image(SceneDepthStencil.Image.get(), SceneDepthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT) + .DebugName("VkRenderBuffers.SceneDepthView") + .Create(fb->device); } void VkRenderBuffers::CreateSceneFog(int width, int height, VkSampleCountFlagBits samples) { - ImageBuilder builder; - builder.setSize(width, height); - builder.setSamples(samples); - builder.setFormat(VK_FORMAT_R8G8B8A8_UNORM); - builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); - SceneFog.Image = builder.create(fb->device); - SceneFog.Image->SetDebugName("VkRenderBuffers.SceneFog"); + SceneFog.Image = ImageBuilder() + .Size(width, height) + .Samples(samples) + .Format(VK_FORMAT_R8G8B8A8_UNORM) + .Usage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT) + .DebugName("VkRenderBuffers.SceneFog") + .Create(fb->device); - ImageViewBuilder viewbuilder; - viewbuilder.setImage(SceneFog.Image.get(), VK_FORMAT_R8G8B8A8_UNORM); - SceneFog.View = viewbuilder.create(fb->device); - SceneFog.View->SetDebugName("VkRenderBuffers.SceneFogView"); + SceneFog.View = ImageViewBuilder() + .Image(SceneFog.Image.get(), VK_FORMAT_R8G8B8A8_UNORM) + .DebugName("VkRenderBuffers.SceneFogView") + .Create(fb->device); } void VkRenderBuffers::CreateSceneNormal(int width, int height, VkSampleCountFlagBits samples) { ImageBuilder builder; - builder.setSize(width, height); - builder.setSamples(samples); - builder.setFormat(SceneNormalFormat); - builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); - if (!builder.isFormatSupported(fb->device, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) + builder.Size(width, height); + builder.Samples(samples); + builder.Format(SceneNormalFormat); + builder.Usage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); + if (!builder.IsFormatSupported(fb->device, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { SceneNormalFormat = VK_FORMAT_R8G8B8A8_UNORM; - builder.setFormat(SceneNormalFormat); + builder.Format(SceneNormalFormat); } - SceneNormal.Image = builder.create(fb->device); - SceneNormal.Image->SetDebugName("VkRenderBuffers.SceneNormal"); + builder.DebugName("VkRenderBuffers.SceneNormal"); - ImageViewBuilder viewbuilder; - viewbuilder.setImage(SceneNormal.Image.get(), SceneNormalFormat); - SceneNormal.View = viewbuilder.create(fb->device); - SceneNormal.View->SetDebugName("VkRenderBuffers.SceneNormalView"); + SceneNormal.Image = builder.Create(fb->device); + + SceneNormal.View = ImageViewBuilder() + .Image(SceneNormal.Image.get(), SceneNormalFormat) + .DebugName("VkRenderBuffers.SceneNormalView") + .Create(fb->device); } VulkanFramebuffer* VkRenderBuffers::GetOutput(VkPPRenderPassSetup* passSetup, const PPOutput& output, bool stencilTest, int& framebufferWidth, int& framebufferHeight) @@ -223,10 +226,10 @@ VulkanFramebuffer* VkRenderBuffers::GetOutput(VkPPRenderPassSetup* passSetup, co if (tex) { VkImageTransition imageTransition; - imageTransition.addImage(tex, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, output.Type == PPTextureType::NextPipelineTexture); + imageTransition.AddImage(tex, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, output.Type == PPTextureType::NextPipelineTexture); if (stencilTest) - imageTransition.addImage(&fb->GetBuffers()->SceneDepthStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, false); - imageTransition.execute(fb->GetCommands()->GetDrawCommands()); + imageTransition.AddImage(&fb->GetBuffers()->SceneDepthStencil, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, false); + imageTransition.Execute(fb->GetCommands()->GetDrawCommands()); view = tex->View->view; w = tex->Image->width; @@ -245,12 +248,13 @@ VulkanFramebuffer* VkRenderBuffers::GetOutput(VkPPRenderPassSetup* passSetup, co if (!framebuffer) { FramebufferBuilder builder; - builder.setRenderPass(passSetup->RenderPass.get()); - builder.setSize(w, h); - builder.addAttachment(view); + builder.RenderPass(passSetup->RenderPass.get()); + builder.Size(w, h); + builder.AddAttachment(view); if (stencilTest) - builder.addAttachment(fb->GetBuffers()->SceneDepthStencil.View.get()); - framebuffer = builder.create(fb->device); + builder.AddAttachment(fb->GetBuffers()->SceneDepthStencil.View.get()); + builder.DebugName("PPOutputFB"); + framebuffer = builder.Create(fb->device); } framebufferWidth = w; diff --git a/src/common/rendering/vulkan/textures/vk_samplers.cpp b/src/common/rendering/vulkan/textures/vk_samplers.cpp index 2f762f119..d1d8a31bb 100644 --- a/src/common/rendering/vulkan/textures/vk_samplers.cpp +++ b/src/common/rendering/vulkan/textures/vk_samplers.cpp @@ -90,54 +90,53 @@ void VkSamplerManager::CreateHWSamplers() for (int i = CLAMP_NONE; i <= CLAMP_XY; i++) { SamplerBuilder builder; - builder.setMagFilter(TexFilter[filter].magFilter); - builder.setMinFilter(TexFilter[filter].minFilter); - builder.setAddressMode(TexClamp[i].clamp_u, TexClamp[i].clamp_v, VK_SAMPLER_ADDRESS_MODE_REPEAT); - builder.setMipmapMode(TexFilter[filter].mipfilter); + builder.MagFilter(TexFilter[filter].magFilter); + builder.MinFilter(TexFilter[filter].minFilter); + builder.AddressMode(TexClamp[i].clamp_u, TexClamp[i].clamp_v, VK_SAMPLER_ADDRESS_MODE_REPEAT); + builder.MipmapMode(TexFilter[filter].mipfilter); if (TexFilter[filter].mipmapping) { - builder.setAnisotropy(gl_texture_filter_anisotropic); - builder.setMaxLod(100.0f); // According to the spec this value is clamped so something high makes it usable for all textures. + builder.Anisotropy(gl_texture_filter_anisotropic); + builder.MaxLod(100.0f); // According to the spec this value is clamped so something high makes it usable for all textures. } else { - builder.setMaxLod(0.25f); + builder.MaxLod(0.25f); } - mSamplers[i] = builder.create(fb->device); - mSamplers[i]->SetDebugName("VkSamplerManager.mSamplers"); - } - { - SamplerBuilder builder; - builder.setMagFilter(TexFilter[filter].magFilter); - builder.setMinFilter(TexFilter[filter].magFilter); - builder.setAddressMode(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_REPEAT); - builder.setMipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST); - builder.setMaxLod(0.25f); - mSamplers[CLAMP_XY_NOMIP] = builder.create(fb->device); - mSamplers[CLAMP_XY_NOMIP]->SetDebugName("VkSamplerManager.mSamplers"); + builder.DebugName("VkSamplerManager.mSamplers"); + mSamplers[i] = builder.Create(fb->device); } + + mSamplers[CLAMP_XY_NOMIP] = SamplerBuilder() + .MagFilter(TexFilter[filter].magFilter) + .MinFilter(TexFilter[filter].magFilter) + .AddressMode(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_REPEAT) + .MipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST) + .MaxLod(0.25f) + .DebugName("VkSamplerManager.mSamplers") + .Create(fb->device); + for (int i = CLAMP_NOFILTER; i <= CLAMP_NOFILTER_XY; i++) { - SamplerBuilder builder; - builder.setMagFilter(VK_FILTER_NEAREST); - builder.setMinFilter(VK_FILTER_NEAREST); - builder.setAddressMode(TexClamp[i - CLAMP_NOFILTER].clamp_u, TexClamp[i - CLAMP_NOFILTER].clamp_v, VK_SAMPLER_ADDRESS_MODE_REPEAT); - builder.setMipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST); - builder.setMaxLod(0.25f); - mSamplers[i] = builder.create(fb->device); - mSamplers[i]->SetDebugName("VkSamplerManager.mSamplers"); + mSamplers[i] = SamplerBuilder() + .MagFilter(VK_FILTER_NEAREST) + .MinFilter(VK_FILTER_NEAREST) + .AddressMode(TexClamp[i - CLAMP_NOFILTER].clamp_u, TexClamp[i - CLAMP_NOFILTER].clamp_v, VK_SAMPLER_ADDRESS_MODE_REPEAT) + .MipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST) + .MaxLod(0.25f) + .DebugName("VkSamplerManager.mSamplers") + .Create(fb->device); } + // CAMTEX is repeating with texture filter and no mipmap - { - SamplerBuilder builder; - builder.setMagFilter(TexFilter[filter].magFilter); - builder.setMinFilter(TexFilter[filter].magFilter); - builder.setAddressMode(VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_REPEAT); - builder.setMipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST); - builder.setMaxLod(0.25f); - mSamplers[CLAMP_CAMTEX] = builder.create(fb->device); - mSamplers[CLAMP_CAMTEX]->SetDebugName("VkSamplerManager.mSamplers"); - } + mSamplers[CLAMP_CAMTEX] = SamplerBuilder() + .MagFilter(TexFilter[filter].magFilter) + .MinFilter(TexFilter[filter].magFilter) + .AddressMode(VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_REPEAT) + .MipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST) + .MaxLod(0.25f) + .DebugName("VkSamplerManager.mSamplers") + .Create(fb->device); } void VkSamplerManager::DeleteHWSamplers() @@ -156,34 +155,35 @@ VulkanSampler* VkSamplerManager::Get(PPFilterMode filter, PPWrapMode wrap) if (sampler) return sampler.get(); - SamplerBuilder builder; - builder.setMipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST); - builder.setMinFilter(filter == PPFilterMode::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR); - builder.setMagFilter(filter == PPFilterMode::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR); - builder.setAddressMode(wrap == PPWrapMode::Clamp ? VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE : VK_SAMPLER_ADDRESS_MODE_REPEAT); - sampler = builder.create(fb->device); - sampler->SetDebugName("VkPostprocess.mSamplers"); + sampler = SamplerBuilder() + .MipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST) + .MinFilter(filter == PPFilterMode::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR) + .MagFilter(filter == PPFilterMode::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR) + .AddressMode(wrap == PPWrapMode::Clamp ? VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE : VK_SAMPLER_ADDRESS_MODE_REPEAT) + .DebugName("VkPostprocess.mSamplers") + .Create(fb->device); + return sampler.get(); } void VkSamplerManager::CreateShadowmapSampler() { - SamplerBuilder samplerBuilder; - samplerBuilder.setMipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST); - samplerBuilder.setMinFilter(VK_FILTER_NEAREST); - samplerBuilder.setMagFilter(VK_FILTER_NEAREST); - samplerBuilder.setAddressMode(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE); - ShadowmapSampler = samplerBuilder.create(fb->device); - ShadowmapSampler->SetDebugName("VkRenderBuffers.ShadowmapSampler"); + ShadowmapSampler = SamplerBuilder() + .MipmapMode(VK_SAMPLER_MIPMAP_MODE_NEAREST) + .MinFilter(VK_FILTER_NEAREST) + .MagFilter(VK_FILTER_NEAREST) + .AddressMode(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE) + .DebugName("VkRenderBuffers.ShadowmapSampler") + .Create(fb->device); } void VkSamplerManager::CreateLightmapSampler() { - SamplerBuilder builder; - builder.setMipmapMode(VK_SAMPLER_MIPMAP_MODE_LINEAR); - builder.setMinFilter(VK_FILTER_LINEAR); - builder.setMagFilter(VK_FILTER_LINEAR); - builder.setAddressMode(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE); - LightmapSampler = builder.create(fb->device); - LightmapSampler->SetDebugName("VkRenderBuffers.LightmapSampler"); + LightmapSampler = SamplerBuilder() + .MipmapMode(VK_SAMPLER_MIPMAP_MODE_LINEAR) + .MinFilter(VK_FILTER_LINEAR) + .MagFilter(VK_FILTER_LINEAR) + .AddressMode(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE) + .DebugName("VkRenderBuffers.LightmapSampler") + .Create(fb->device); } diff --git a/src/common/rendering/vulkan/textures/vk_texture.cpp b/src/common/rendering/vulkan/textures/vk_texture.cpp index 406034525..ae5ed1027 100644 --- a/src/common/rendering/vulkan/textures/vk_texture.cpp +++ b/src/common/rendering/vulkan/textures/vk_texture.cpp @@ -143,40 +143,40 @@ VkPPTexture* VkTextureManager::GetVkTexture(PPTexture* texture) void VkTextureManager::CreateNullTexture() { - ImageBuilder imgbuilder; - imgbuilder.setFormat(VK_FORMAT_R8G8B8A8_UNORM); - imgbuilder.setSize(1, 1); - imgbuilder.setUsage(VK_IMAGE_USAGE_SAMPLED_BIT); - NullTexture = imgbuilder.create(fb->device); - NullTexture->SetDebugName("VkDescriptorSetManager.NullTexture"); + NullTexture = ImageBuilder() + .Format(VK_FORMAT_R8G8B8A8_UNORM) + .Size(1, 1) + .Usage(VK_IMAGE_USAGE_SAMPLED_BIT) + .DebugName("VkDescriptorSetManager.NullTexture") + .Create(fb->device); - ImageViewBuilder viewbuilder; - viewbuilder.setImage(NullTexture.get(), VK_FORMAT_R8G8B8A8_UNORM); - NullTextureView = viewbuilder.create(fb->device); - NullTextureView->SetDebugName("VkDescriptorSetManager.NullTextureView"); + NullTextureView = ImageViewBuilder() + .Image(NullTexture.get(), VK_FORMAT_R8G8B8A8_UNORM) + .DebugName("VkDescriptorSetManager.NullTextureView") + .Create(fb->device); - PipelineBarrier barrier; - barrier.addImage(NullTexture.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 0, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT); - barrier.execute(fb->GetCommands()->GetTransferCommands(), VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); + PipelineBarrier() + .AddImage(NullTexture.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 0, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT) + .Execute(fb->GetCommands()->GetTransferCommands(), VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); } void VkTextureManager::CreateShadowmap() { - ImageBuilder builder; - builder.setSize(gl_shadowmap_quality, 1024); - builder.setFormat(VK_FORMAT_R32_SFLOAT); - builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT); - Shadowmap.Image = builder.create(fb->device); - Shadowmap.Image->SetDebugName("VkRenderBuffers.Shadowmap"); + Shadowmap.Image = ImageBuilder() + .Size(gl_shadowmap_quality, 1024) + .Format(VK_FORMAT_R32_SFLOAT) + .Usage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT) + .DebugName("VkRenderBuffers.Shadowmap") + .Create(fb->device); - ImageViewBuilder viewbuilder; - viewbuilder.setImage(Shadowmap.Image.get(), VK_FORMAT_R32_SFLOAT); - Shadowmap.View = viewbuilder.create(fb->device); - Shadowmap.View->SetDebugName("VkRenderBuffers.ShadowmapView"); + Shadowmap.View = ImageViewBuilder() + .Image(Shadowmap.Image.get(), VK_FORMAT_R32_SFLOAT) + .DebugName("VkRenderBuffers.ShadowmapView") + .Create(fb->device); - VkImageTransition barrier; - barrier.addImage(&Shadowmap, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, true); - barrier.execute(fb->GetCommands()->GetDrawCommands()); + VkImageTransition() + .AddImage(&Shadowmap, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, true) + .Execute(fb->GetCommands()->GetDrawCommands()); } void VkTextureManager::CreateLightmap() @@ -198,28 +198,28 @@ void VkTextureManager::SetLightmap(int LMTextureSize, int LMTextureCount, const Lightmap.Reset(fb); - ImageBuilder builder; - builder.setSize(w, h, 1, count); - builder.setFormat(VK_FORMAT_R16G16B16A16_SFLOAT); - builder.setUsage(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); - Lightmap.Image = builder.create(fb->device); - Lightmap.Image->SetDebugName("VkRenderBuffers.Lightmap"); + Lightmap.Image = ImageBuilder() + .Size(w, h, 1, count) + .Format(VK_FORMAT_R16G16B16A16_SFLOAT) + .Usage(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT) + .DebugName("VkRenderBuffers.Lightmap") + .Create(fb->device); - ImageViewBuilder viewbuilder; - viewbuilder.setType(VK_IMAGE_VIEW_TYPE_2D_ARRAY); - viewbuilder.setImage(Lightmap.Image.get(), VK_FORMAT_R16G16B16A16_SFLOAT); - Lightmap.View = viewbuilder.create(fb->device); - Lightmap.View->SetDebugName("VkRenderBuffers.LightmapView"); + Lightmap.View = ImageViewBuilder() + .Type(VK_IMAGE_VIEW_TYPE_2D_ARRAY) + .Image(Lightmap.Image.get(), VK_FORMAT_R16G16B16A16_SFLOAT) + .DebugName("VkRenderBuffers.LightmapView") + .Create(fb->device); auto cmdbuffer = fb->GetCommands()->GetTransferCommands(); int totalSize = w * h * count * pixelsize; - BufferBuilder bufbuilder; - bufbuilder.setSize(totalSize); - bufbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY); - std::unique_ptr stagingBuffer = bufbuilder.create(fb->device); - stagingBuffer->SetDebugName("VkHardwareTexture.mStagingBuffer"); + auto stagingBuffer = BufferBuilder() + .Size(totalSize) + .Usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY) + .DebugName("VkHardwareTexture.mStagingBuffer") + .Create(fb->device); uint16_t one = 0x3c00; // half-float 1.0 const uint16_t* src = LMTextureData.Data(); @@ -233,9 +233,9 @@ void VkTextureManager::SetLightmap(int LMTextureSize, int LMTextureCount, const } stagingBuffer->Unmap(); - VkImageTransition imageTransition; - imageTransition.addImage(&Lightmap, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true, 0, count); - imageTransition.execute(cmdbuffer); + VkImageTransition() + .AddImage(&Lightmap, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, true, 0, count) + .Execute(cmdbuffer); VkBufferImageCopy region = {}; region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; @@ -245,9 +245,9 @@ void VkTextureManager::SetLightmap(int LMTextureSize, int LMTextureCount, const region.imageExtent.height = h; cmdbuffer->copyBufferToImage(stagingBuffer->buffer, Lightmap.Image->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); - VkImageTransition barrier; - barrier.addImage(&Lightmap, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false, 0, count); - barrier.execute(cmdbuffer); + VkImageTransition() + .AddImage(&Lightmap, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, false, 0, count) + .Execute(cmdbuffer); fb->GetCommands()->TransferDeleteList->Add(std::move(stagingBuffer)); }