zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2025-02-17 17:41:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

- hooked up the debug names for objects, which was a bit of a waste of time since the validation layer is brain dead and doesn't use the information in its messages..

Browse source
This commit is contained in:
Magnus Norddahl 2019-03-09 21:34:29 +01:00
parent 02ed758447
commit ff68d2e651
11 changed files with 118 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/rendering/vulkan/renderer/vk_postprocess.cpp
View file

@ -229,6 +229,7 @@ void VkPostprocess::BeginFrame()
builder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 100);
builder.setMaxSets(100);
mDescriptorPool = builder.create(GetVulkanFrameBuffer()->device);
mDescriptorPool->SetDebugName("VkPostprocess.mDescriptorPool");
}
}
@ -277,11 +278,13 @@ void VkPostprocess::UpdateEffectTextures()
if (!imgbuilder.isFormatSupported(fb->device))
I_FatalError("Vulkan device does not support the image format required by %s\n", pair->Key.GetChars());
vktex->Image = imgbuilder.create(fb->device);
vktex->Image->SetDebugName(pair->Key.GetChars());
vktex->Format = format;
ImageViewBuilder viewbuilder;
viewbuilder.setImage(vktex->Image.get(), format);
vktex->View = viewbuilder.create(fb->device);
vktex->View->SetDebugName(pair->Key.GetChars());
if (desc.Data)
{
@ -290,6 +293,7 @@ void VkPostprocess::UpdateEffectTextures()
stagingbuilder.setSize(totalsize);
stagingbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY);
vktex->Staging = stagingbuilder.create(fb->device);
vktex->Staging->SetDebugName(pair->Key.GetChars());
PipelineBarrier barrier0;
barrier0.addImage(vktex->Image.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, VK_ACCESS_TRANSFER_WRITE_BIT);
@ -345,10 +349,12 @@ void VkPostprocess::CompileEffectShaders()
ShaderBuilder vertbuilder;
vertbuilder.setVertexShader(LoadShaderCode(desc.VertexShader, "", desc.Version));
vkshader->VertexShader = vertbuilder.create(fb->device);
vkshader->VertexShader->SetDebugName(desc.VertexShader.GetChars());
ShaderBuilder fragbuilder;
fragbuilder.setFragmentShader(LoadShaderCode(desc.FragmentShader, prolog, desc.Version));
vkshader->FragmentShader = fragbuilder.create(fb->device);
vkshader->FragmentShader->SetDebugName(desc.FragmentShader.GetChars());
}
}
}
@ -439,6 +445,7 @@ VulkanDescriptorSet *VkPostprocess::GetInput(VkPPRenderPassSetup *passSetup, con
{
auto fb = GetVulkanFrameBuffer();
auto descriptors = mDescriptorPool->allocate(passSetup->DescriptorLayout.get());
descriptors->SetDebugName("VkPostprocess.descriptors");
WriteDescriptors write;
PipelineBarrier barrier;
@ -521,6 +528,7 @@ VulkanFramebuffer *VkPostprocess::GetOutput(VkPPRenderPassSetup *passSetup, cons
builder.setSize(w, h);
builder.addAttachment(view);
framebuffer = builder.create(GetVulkanFrameBuffer()->device);
framebuffer->SetDebugName(tex.debugname);
}
return framebuffer.get();
@ -540,42 +548,49 @@ VkPostprocess::TextureImage VkPostprocess::GetTexture(const PPTextureType &type,
tex.image = fb->GetBuffers()->PipelineImage[idx].get();
tex.view = fb->GetBuffers()->PipelineView[idx].get();
tex.layout = &fb->GetBuffers()->PipelineLayout[idx];
tex.debugname = "PipelineTexture";
}
else if (type == PPTextureType::PPTexture)
{
tex.image = mTextures[name]->Image.get();
tex.view = mTextures[name]->View.get();
tex.layout = &mTextures[name]->Layout;
tex.debugname = name.GetChars();
}
else if (type == PPTextureType::SceneColor)
{
tex.image = fb->GetBuffers()->SceneColor.get();
tex.view = fb->GetBuffers()->SceneColorView.get();
tex.layout = &fb->GetBuffers()->SceneColorLayout;
tex.debugname = "SceneColor";
}
else if (type == PPTextureType::SceneNormal)
{
tex.image = fb->GetBuffers()->SceneNormal.get();
tex.view = fb->GetBuffers()->SceneNormalView.get();
tex.layout = &fb->GetBuffers()->SceneNormalLayout;
tex.debugname = "SceneNormal";
}
else if (type == PPTextureType::SceneFog)
{
tex.image = fb->GetBuffers()->SceneFog.get();
tex.view = fb->GetBuffers()->SceneFogView.get();
tex.layout = &fb->GetBuffers()->SceneFogLayout;
tex.debugname = "SceneFog";
}
else if (type == PPTextureType::SceneDepth)
{
tex.image = fb->GetBuffers()->SceneDepthStencil.get();
tex.view = fb->GetBuffers()->SceneDepthView.get();
tex.layout = &fb->GetBuffers()->SceneDepthStencilLayout;
tex.debugname = "SceneDepth";
}
else if (type == PPTextureType::SwapChain)
{
tex.image = nullptr;
tex.view = nullptr;
tex.layout = nullptr;
tex.debugname = "SwapChain";
}
else
{
@ -598,6 +613,7 @@ VulkanSampler *VkPostprocess::GetSampler(PPFilterMode filter, PPWrapMode wrap)
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(GetVulkanFrameBuffer()->device);
sampler->SetDebugName("VkPostprocess.mSamplers");
return sampler.get();
}
@ -621,6 +637,7 @@ void VkPPRenderPassSetup::CreateDescriptorLayout(const VkPPRenderPassKey &key)
for (int i = 0; i < key.InputTextures; i++)
builder.addBinding(i, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
DescriptorLayout = builder.create(GetVulkanFrameBuffer()->device);
DescriptorLayout->SetDebugName("VkPPRenderPassSetup.DescriptorLayout");
}
void VkPPRenderPassSetup::CreatePipelineLayout(const VkPPRenderPassKey &key)
@ -630,6 +647,7 @@ void VkPPRenderPassSetup::CreatePipelineLayout(const VkPPRenderPassKey &key)
if (key.Uniforms > 0)
builder.addPushConstantRange(VK_SHADER_STAGE_FRAGMENT_BIT, 0, key.Uniforms);
PipelineLayout = builder.create(GetVulkanFrameBuffer()->device);
PipelineLayout->SetDebugName("VkPPRenderPassSetup.PipelineLayout");
}
void VkPPRenderPassSetup::CreatePipeline(const VkPPRenderPassKey &key)
@ -648,6 +666,7 @@ void VkPPRenderPassSetup::CreatePipeline(const VkPPRenderPassKey &key)
builder.setLayout(PipelineLayout.get());
builder.setRenderPass(RenderPass.get());
Pipeline = builder.create(GetVulkanFrameBuffer()->device);
Pipeline->SetDebugName("VkPPRenderPassSetup.Pipeline");
}
void VkPPRenderPassSetup::CreateRenderPass(const VkPPRenderPassKey &key)
@ -662,4 +681,5 @@ void VkPPRenderPassSetup::CreateRenderPass(const VkPPRenderPassKey &key)
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT);
RenderPass = builder.create(GetVulkanFrameBuffer()->device);
RenderPass->SetDebugName("VkPPRenderPassSetup.RenderPass");
}

1
src/rendering/vulkan/renderer/vk_postprocess.h
View file

@ -64,6 +64,7 @@ private:
VulkanImage *image;
VulkanImageView *view;
VkImageLayout *layout;
const char *debugname;
};
TextureImage GetTexture(const PPTextureType &type, const PPTextureName &name);

11
src/rendering/vulkan/renderer/vk_renderbuffers.cpp
View file

@ -80,10 +80,12 @@ void VkRenderBuffers::CreatePipeline(int width, int 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);
PipelineImage[i] = builder.create(fb->device);
PipelineImage[i]->SetDebugName("VkRenderBuffers.PipelineImage");
ImageViewBuilder viewbuilder;
viewbuilder.setImage(PipelineImage[i].get(), VK_FORMAT_R16G16B16A16_SFLOAT);
PipelineView[i] = viewbuilder.create(fb->device);
PipelineView[i]->SetDebugName("VkRenderBuffers.PipelineView");
barrier.addImage(PipelineImage[i].get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 0, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
PipelineLayout[i] = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
@ -129,10 +131,12 @@ void VkRenderBuffers::CreateSceneColor(int width, int height, VkSampleCountFlagB
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 = builder.create(fb->device);
SceneColor->SetDebugName("VkRenderBuffers.SceneColor");
ImageViewBuilder viewbuilder;
viewbuilder.setImage(SceneColor.get(), VK_FORMAT_R16G16B16A16_SFLOAT);
SceneColorView = viewbuilder.create(fb->device);
SceneColorView->SetDebugName("VkRenderBuffers.SceneColorView");
}
void VkRenderBuffers::CreateSceneDepthStencil(int width, int height, VkSampleCountFlagBits samples)
@ -154,13 +158,16 @@ void VkRenderBuffers::CreateSceneDepthStencil(int width, int height, VkSampleCou
}
}
SceneDepthStencil = builder.create(fb->device);
SceneDepthStencil->SetDebugName("VkRenderBuffers.SceneDepthStencil");
ImageViewBuilder viewbuilder;
viewbuilder.setImage(SceneDepthStencil.get(), SceneDepthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
SceneDepthStencilView = viewbuilder.create(fb->device);
SceneDepthStencilView->SetDebugName("VkRenderBuffers.SceneDepthStencilView");
viewbuilder.setImage(SceneDepthStencil.get(), SceneDepthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT);
SceneDepthView = viewbuilder.create(fb->device);
SceneDepthView->SetDebugName("VkRenderBuffers.SceneDepthView");
}
void VkRenderBuffers::CreateSceneFog(int width, int height, VkSampleCountFlagBits samples)
@ -173,10 +180,12 @@ void VkRenderBuffers::CreateSceneFog(int width, int height, VkSampleCountFlagBit
builder.setFormat(VK_FORMAT_R8G8B8A8_UNORM);
builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
SceneFog = builder.create(fb->device);
SceneFog->SetDebugName("VkRenderBuffers.SceneFog");
ImageViewBuilder viewbuilder;
viewbuilder.setImage(SceneFog.get(), VK_FORMAT_R8G8B8A8_UNORM);
SceneFogView = viewbuilder.create(fb->device);
SceneFogView->SetDebugName("VkRenderBuffers.SceneFogView");
}
void VkRenderBuffers::CreateSceneNormal(int width, int height, VkSampleCountFlagBits samples)
@ -189,8 +198,10 @@ void VkRenderBuffers::CreateSceneNormal(int width, int height, VkSampleCountFlag
builder.setFormat(VK_FORMAT_A2R10G10B10_UNORM_PACK32);
builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
SceneNormal = builder.create(fb->device);
SceneNormal->SetDebugName("VkRenderBuffers.SceneNormal");
ImageViewBuilder viewbuilder;
viewbuilder.setImage(SceneNormal.get(), VK_FORMAT_A2R10G10B10_UNORM_PACK32);
SceneNormalView = viewbuilder.create(fb->device);
SceneNormalView->SetDebugName("VkRenderBuffers.SceneNormalView");
}

7
src/rendering/vulkan/renderer/vk_renderpass.cpp
View file

@ -54,6 +54,7 @@ void VkRenderPassManager::BeginRenderPass(const VkRenderPassKey &key, VulkanComm
if (key.DepthTest || key.DepthWrite || key.StencilTest)
builder.addAttachment(buffers->SceneDepthStencilView.get());
framebuffer = builder.create(GetVulkanFrameBuffer()->device);
framebuffer->SetDebugName("VkRenderPassSetup.Framebuffer");
}
RenderPassBegin beginInfo;
@ -116,6 +117,7 @@ void VkRenderPassManager::CreateDynamicSetLayout()
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_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT);
DynamicSetLayout = builder.create(GetVulkanFrameBuffer()->device);
DynamicSetLayout->SetDebugName("VkRenderPassManager.DynamicSetLayout");
}
void VkRenderPassManager::CreateTextureSetLayout()
@ -127,6 +129,7 @@ void VkRenderPassManager::CreateTextureSetLayout()
}
builder.addBinding(16, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
TextureSetLayout = builder.create(GetVulkanFrameBuffer()->device);
TextureSetLayout->SetDebugName("VkRenderPassManager.TextureSetLayout");
}
void VkRenderPassManager::CreatePipelineLayout()
@ -136,6 +139,7 @@ void VkRenderPassManager::CreatePipelineLayout()
builder.addSetLayout(TextureSetLayout.get());
builder.addPushConstantRange(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants));
PipelineLayout = builder.create(GetVulkanFrameBuffer()->device);
PipelineLayout->SetDebugName("VkRenderPassManager.PipelineLayout");
}
void VkRenderPassManager::CreateDescriptorPool()
@ -146,6 +150,7 @@ void VkRenderPassManager::CreateDescriptorPool()
builder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 5000 * 6);
builder.setMaxSets(5000);
DescriptorPool = builder.create(GetVulkanFrameBuffer()->device);
DescriptorPool->SetDebugName("VkRenderPassManager.DescriptorPool");
}
void VkRenderPassManager::CreateDynamicSet()
@ -195,6 +200,7 @@ void VkRenderPassSetup::CreateRenderPass(const VkRenderPassKey &key)
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT);
}
RenderPass = builder.create(GetVulkanFrameBuffer()->device);
RenderPass->SetDebugName("VkRenderPassSetup.RenderPass");
}
void VkRenderPassSetup::CreatePipeline(const VkRenderPassKey &key)
@ -281,4 +287,5 @@ void VkRenderPassSetup::CreatePipeline(const VkRenderPassKey &key)
builder.setLayout(fb->GetRenderPassManager()->PipelineLayout.get());
builder.setRenderPass(RenderPass.get());
Pipeline = builder.create(fb->device);
Pipeline->SetDebugName("VkRenderPassSetup.Pipeline");
}

18
src/rendering/vulkan/system/vk_device.cpp
View file

@ -353,6 +353,8 @@ void VulkanDevice::CreateInstance()
result = vkCreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger);
if (result != VK_SUCCESS)
throw std::runtime_error("vkCreateDebugUtilsMessengerEXT failed");
DebugLayerActive = true;
}
}
@ -367,10 +369,22 @@ VkBool32 VulkanDevice::DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT mess
std::unique_lock<std::mutex> lock(mtx);
FString msg = callbackData->pMessage;
// For patent-pending reasons the validation layer apparently can't do this itself..
for (uint32_t i = 0; i < callbackData->objectCount; i++)
{
if (callbackData->pObjects[i].pObjectName)
{
FString hexname;
hexname.Format("0x%x", callbackData->pObjects[i].objectHandle);
msg.Substitute(hexname.GetChars(), callbackData->pObjects[i].pObjectName);
}
}
bool found = seenMessages.find(msg) != seenMessages.end();
if (!found)
{
if (totalMessages < 100)
if (totalMessages < 20)
{
totalMessages++;
seenMessages.insert(msg);
@ -399,7 +413,7 @@ VkBool32 VulkanDevice::DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT mess
Printf("\n");
Printf(TEXTCOLOR_RED "[%s] ", typestr);
Printf(TEXTCOLOR_WHITE "%s\n", callbackData->pMessage);
Printf(TEXTCOLOR_WHITE "%s\n", msg.GetChars());
}
}

13
src/rendering/vulkan/system/vk_device.h
View file

@ -44,6 +44,18 @@ public:
void BeginFrame();
void PresentFrame();
void SetDebugObjectName(const char *name, uint64_t handle, VkObjectType type)
{
if (!DebugLayerActive) return;
VkDebugUtilsObjectNameInfoEXT info = {};
info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
info.objectHandle = handle;
info.objectType = type;
info.pObjectName = name;
vkSetDebugUtilsObjectNameEXT(device, &info);
}
uint32_t FindMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);
// Instance setup
@ -56,6 +68,7 @@ public:
VkPhysicalDeviceFeatures UsedDeviceFeatures = {};
std::vector<const char *> EnabledDeviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
VulkanPhysicalDevice PhysicalDevice;
bool DebugLayerActive = false;
VkInstance instance = VK_NULL_HANDLE;
VkSurfaceKHR surface = VK_NULL_HANDLE;

2
src/rendering/vulkan/system/vk_framebuffer.cpp
View file

@ -574,6 +574,7 @@ VulkanCommandBuffer *VulkanFrameBuffer::GetUploadCommands()
if (!mUploadCommands)
{
mUploadCommands = mGraphicsCommandPool->createBuffer();
mUploadCommands->SetDebugName("VulkanFrameBuffer.mUploadCommands");
mUploadCommands->begin();
}
return mUploadCommands.get();
@ -584,6 +585,7 @@ VulkanCommandBuffer *VulkanFrameBuffer::GetDrawCommands()
if (!mDrawCommands)
{
mDrawCommands = mGraphicsCommandPool->createBuffer();
mDrawCommands->SetDebugName("VulkanFrameBuffer.mDrawCommands");
mDrawCommands->begin();
}
return mDrawCommands.get();

37
src/rendering/vulkan/system/vk_objects.h
View file

@ -11,6 +11,8 @@ public:
VulkanSemaphore(VulkanDevice *device);
~VulkanSemaphore();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)semaphore, VK_OBJECT_TYPE_SEMAPHORE); }
VulkanDevice *device = nullptr;
VkSemaphore semaphore = VK_NULL_HANDLE;
@ -25,6 +27,8 @@ public:
VulkanFence(VulkanDevice *device);
~VulkanFence();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)fence, VK_OBJECT_TYPE_FENCE); }
VulkanDevice *device = nullptr;
VkFence fence = VK_NULL_HANDLE;
@ -39,6 +43,8 @@ public:
VulkanBuffer(VulkanDevice *device, VkBuffer buffer, VmaAllocation allocation, size_t size);
~VulkanBuffer();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER); }
VulkanDevice *device = nullptr;
VkBuffer buffer;
@ -59,6 +65,8 @@ public:
VulkanFramebuffer(VulkanDevice *device, VkFramebuffer framebuffer);
~VulkanFramebuffer();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)framebuffer, VK_OBJECT_TYPE_FRAMEBUFFER); }
VulkanDevice *device;
VkFramebuffer framebuffer;
@ -73,6 +81,8 @@ public:
VulkanImage(VulkanDevice *device, VkImage image, VmaAllocation allocation, int width, int height, int mipLevels);
~VulkanImage();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)image, VK_OBJECT_TYPE_IMAGE); }
VkImage image = VK_NULL_HANDLE;
int width = 0;
int height = 0;
@ -95,6 +105,8 @@ public:
VulkanImageView(VulkanDevice *device, VkImageView view);
~VulkanImageView();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)view, VK_OBJECT_TYPE_IMAGE_VIEW); }
VkImageView view = VK_NULL_HANDLE;
private:
@ -110,6 +122,8 @@ public:
VulkanSampler(VulkanDevice *device, VkSampler sampler);
~VulkanSampler();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)sampler, VK_OBJECT_TYPE_SAMPLER); }
VkSampler sampler = VK_NULL_HANDLE;
private:
@ -125,6 +139,8 @@ public:
VulkanShader(VulkanDevice *device, VkShaderModule module);
~VulkanShader();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)module, VK_OBJECT_TYPE_SHADER_MODULE); }
VkShaderModule module = VK_NULL_HANDLE;
private:
@ -140,6 +156,8 @@ public:
VulkanDescriptorSetLayout(VulkanDevice *device, VkDescriptorSetLayout layout);
~VulkanDescriptorSetLayout();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)layout, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT); }
VulkanDevice *device;
VkDescriptorSetLayout layout;
@ -154,6 +172,8 @@ public:
VulkanDescriptorSet(VulkanDevice *device, VulkanDescriptorPool *pool, VkDescriptorSet set);
~VulkanDescriptorSet();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)set, VK_OBJECT_TYPE_DESCRIPTOR_SET); }
VulkanDevice *device;
VulkanDescriptorPool *pool;
VkDescriptorSet set;
@ -169,6 +189,8 @@ public:
VulkanDescriptorPool(VulkanDevice *device, VkDescriptorPool pool);
~VulkanDescriptorPool();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)pool, VK_OBJECT_TYPE_DESCRIPTOR_POOL); }
std::unique_ptr<VulkanDescriptorSet> allocate(VulkanDescriptorSetLayout *layout);
VulkanDevice *device;
@ -185,6 +207,8 @@ public:
VulkanPipeline(VulkanDevice *device, VkPipeline pipeline);
~VulkanPipeline();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)pipeline, VK_OBJECT_TYPE_PIPELINE); }
VulkanDevice *device;
VkPipeline pipeline;
@ -199,6 +223,8 @@ public:
VulkanPipelineLayout(VulkanDevice *device, VkPipelineLayout layout);
~VulkanPipelineLayout();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)layout, VK_OBJECT_TYPE_PIPELINE_LAYOUT); }
VulkanDevice *device;
VkPipelineLayout layout;
@ -213,6 +239,8 @@ public:
VulkanRenderPass(VulkanDevice *device, VkRenderPass renderPass);
~VulkanRenderPass();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)renderPass, VK_OBJECT_TYPE_RENDER_PASS); }
VulkanDevice *device;
VkRenderPass renderPass;
@ -246,6 +274,8 @@ public:
VulkanCommandBuffer(VulkanCommandPool *pool);
~VulkanCommandBuffer();
void SetDebugName(const char *name);
void begin();
void end();
@ -316,6 +346,8 @@ public:
VulkanCommandPool(VulkanDevice *device, int queueFamilyIndex);
~VulkanCommandPool();
void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)pool, VK_OBJECT_TYPE_COMMAND_POOL); }
std::unique_ptr<VulkanCommandBuffer> createBuffer();
VkCommandPool pool = VK_NULL_HANDLE;
@ -802,6 +834,11 @@ inline void VulkanCommandBuffer::executeCommands(uint32_t commandBufferCount, co
vkCmdExecuteCommands(buffer, commandBufferCount, pCommandBuffers);
}
inline void VulkanCommandBuffer::SetDebugName(const char *name)
{
pool->device->SetDebugObjectName(name, (uint64_t)buffer, VK_OBJECT_TYPE_COMMAND_BUFFER);
}
/////////////////////////////////////////////////////////////////////////////
inline VulkanShader::VulkanShader(VulkanDevice *device, VkShaderModule module) : module(module), device(device)

4
src/rendering/vulkan/system/vk_swapchain.cpp
View file

@ -125,6 +125,8 @@ VulkanSwapChain::VulkanSwapChain(VulkanDevice *device, int width, int height, bo
swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); i++)
{
device->SetDebugObjectName("SwapChainImage", (uint64_t)swapChainImages[i], VK_OBJECT_TYPE_IMAGE);
VkImageViewCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
@ -138,6 +140,8 @@ VulkanSwapChain::VulkanSwapChain(VulkanDevice *device, int width, int height, bo
result = vkCreateImageView(device->device, &createInfo, nullptr, &swapChainImageViews[i]);
if (result != VK_SUCCESS)
throw std::runtime_error("Could not create image view for swapchain image");
device->SetDebugObjectName("SwapChainImageView", (uint64_t)swapChainImageViews[i], VK_OBJECT_TYPE_IMAGE_VIEW);
}
}
catch (...)

6
src/rendering/vulkan/textures/vk_hwtexture.cpp
View file

@ -85,6 +85,7 @@ VulkanDescriptorSet *VkHardwareTexture::GetDescriptorSet(const FMaterialState &s
auto fb = GetVulkanFrameBuffer();
descriptorSet = fb->GetRenderPassManager()->DescriptorPool->allocate(fb->GetRenderPassManager()->TextureSetLayout.get());
descriptorSet->SetDebugName("VkHardwareTexture.mDescriptorSets");
VulkanSampler *sampler = fb->GetSamplerManager()->Get(clampmode);
int numLayers = mat->GetLayers();
@ -149,6 +150,7 @@ void VkHardwareTexture::CreateTexture(int w, int h, int pixelsize, VkFormat form
bufbuilder.setSize(totalSize);
bufbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY);
mStagingBuffer = bufbuilder.create(fb->device);
mStagingBuffer->SetDebugName("VkHardwareTexture.mStagingBuffer");
uint8_t *data = (uint8_t*)mStagingBuffer->Map(0, totalSize);
memcpy(data, pixels, totalSize);
@ -159,10 +161,12 @@ void VkHardwareTexture::CreateTexture(int w, int h, int pixelsize, VkFormat form
imgbuilder.setSize(w, h, GetMipLevels(w, h));
imgbuilder.setUsage(VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
mImage = imgbuilder.create(fb->device);
mImage->SetDebugName("VkHardwareTexture.mImage");
ImageViewBuilder viewbuilder;
viewbuilder.setImage(mImage.get(), format);
mImageView = viewbuilder.create(fb->device);
mImageView->SetDebugName("VkHardwareTexture.mImageView");
auto cmdbuffer = fb->GetUploadCommands();
@ -250,12 +254,14 @@ void VkHardwareTexture::AllocateBuffer(int w, int h, int texelsize)
imgbuilder.setUsage(VK_IMAGE_USAGE_SAMPLED_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT);
imgbuilder.setLinearTiling();
mImage = imgbuilder.create(fb->device);
mImage->SetDebugName("VkHardwareTexture.mImage");
mImageLayout = VK_IMAGE_LAYOUT_GENERAL;
mTexelsize = texelsize;
ImageViewBuilder viewbuilder;
viewbuilder.setImage(mImage.get(), format);
mImageView = viewbuilder.create(fb->device);
mImageView->SetDebugName("VkHardwareTexture.mImageView");
auto cmdbuffer = fb->GetUploadCommands();

1
src/rendering/vulkan/textures/vk_samplers.cpp
View file

@ -102,6 +102,7 @@ void VkSamplerManager::Create()
builder.setMaxLod(0.25f);
}
mSamplers[i] = builder.create(vDevice);
mSamplers[i]->SetDebugName("VkSamplerManager.mSamplers");
}
}