From 465278c9963126777925e2390a1d49047ebc58dc Mon Sep 17 00:00:00 2001 From: baldurk Date: Mon, 14 Jan 2019 12:02:28 +0000 Subject: [PATCH] Use typeHint as a forced view cast on vulkan --- renderdoc/driver/vulkan/vk_info.cpp | 3 - renderdoc/driver/vulkan/vk_info.h | 3 - renderdoc/driver/vulkan/vk_rendertexture.cpp | 161 +++--- renderdoc/driver/vulkan/vk_replay.cpp | 118 ++-- renderdoc/driver/vulkan/vk_replay.h | 20 +- renderdoc/driver/vulkan/vk_resources.cpp | 542 +++++++++++++++++++ renderdoc/driver/vulkan/vk_resources.h | 1 + 7 files changed, 700 insertions(+), 148 deletions(-) diff --git a/renderdoc/driver/vulkan/vk_info.cpp b/renderdoc/driver/vulkan/vk_info.cpp index 821baa6ea..c6ea9db5e 100644 --- a/renderdoc/driver/vulkan/vk_info.cpp +++ b/renderdoc/driver/vulkan/vk_info.cpp @@ -686,9 +686,6 @@ void VulkanCreationInfo::BufferView::Init(VulkanResourceManager *resourceMan, void VulkanCreationInfo::Image::Init(VulkanResourceManager *resourceMan, VulkanCreationInfo &info, const VkImageCreateInfo *pCreateInfo) { - view = VK_NULL_HANDLE; - altViews[0] = altViews[1] = VK_NULL_HANDLE; - type = pCreateInfo->imageType; format = pCreateInfo->format; extent = pCreateInfo->extent; diff --git a/renderdoc/driver/vulkan/vk_info.h b/renderdoc/driver/vulkan/vk_info.h index c3ad211d7..fac9341fe 100644 --- a/renderdoc/driver/vulkan/vk_info.h +++ b/renderdoc/driver/vulkan/vk_info.h @@ -354,9 +354,6 @@ struct VulkanCreationInfo void Init(VulkanResourceManager *resourceMan, VulkanCreationInfo &info, const VkImageCreateInfo *pCreateInfo); - VkImageView view; - VkImageView altViews[2]; - VkImageType type; VkFormat format; VkExtent3D extent; diff --git a/renderdoc/driver/vulkan/vk_rendertexture.cpp b/renderdoc/driver/vulkan/vk_rendertexture.cpp index 826417a90..878134f80 100644 --- a/renderdoc/driver/vulkan/vk_rendertexture.cpp +++ b/renderdoc/driver/vulkan/vk_rendertexture.cpp @@ -31,37 +31,51 @@ #define VULKAN 1 #include "data/glsl/debuguniforms.h" -void VulkanReplay::CreateTexImageView(VkImageAspectFlags aspectFlags, VkImage liveIm, - VulkanCreationInfo::Image &iminfo) +void VulkanReplay::CreateTexImageView(VkImage liveIm, const VulkanCreationInfo::Image &iminfo, + CompType typeHint, TextureDisplayViews &views) { VkDevice dev = m_pDriver->GetDev(); - if(aspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT) + if(views.typeHint != typeHint) { - if(iminfo.altViews[0] != VK_NULL_HANDLE) - return; - } - else - { - if(iminfo.view != VK_NULL_HANDLE) - return; + // if the type hint has changed, recreate the image views + for(size_t i = 0; i < ARRAY_COUNT(views.views); i++) + { + m_pDriver->vkDestroyImageView(dev, views.views[i], NULL); + views.views[i] = VK_NULL_HANDLE; + } } + views.typeHint = typeHint; + + VkFormat fmt = views.castedFormat = GetViewCastedFormat(iminfo.format, typeHint); + + // all types have at least views[0] populated, so if it's still there, we can just return + if(views.views[0] != VK_NULL_HANDLE) + return; + VkImageViewCreateInfo viewInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, NULL, 0, - Unwrap(liveIm), + liveIm, VK_IMAGE_VIEW_TYPE_2D_ARRAY, - iminfo.format, + fmt, {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY}, { - aspectFlags, 0, RDCMAX(1U, (uint32_t)iminfo.mipLevels), 0, + VK_IMAGE_ASPECT_COLOR_BIT, 0, RDCMAX(1U, (uint32_t)iminfo.mipLevels), 0, RDCMAX(1U, (uint32_t)iminfo.arrayLayers), }, }; + // for the stencil-only format, the first view is stencil only + if(fmt == VK_FORMAT_S8_UINT) + viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; + // otherwise for depth or stencil formats, the first view is depth. + else if(IsDepthOrStencilFormat(fmt)) + viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; + if(iminfo.type == VK_IMAGE_TYPE_1D) viewInfo.viewType = VK_IMAGE_VIEW_TYPE_1D; else if(iminfo.type == VK_IMAGE_TYPE_3D) @@ -70,48 +84,37 @@ void VulkanReplay::CreateTexImageView(VkImageAspectFlags aspectFlags, VkImage li viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; VkResult vkr = VK_SUCCESS; - ResourceId viewid; - if(IsYUVFormat(iminfo.format)) + if(IsYUVFormat(fmt)) { - VkImageView views[3] = {}; - - const uint32_t planeCount = GetYUVPlaneCount(iminfo.format); + const uint32_t planeCount = GetYUVPlaneCount(fmt); for(uint32_t i = 0; i < planeCount; i++) { - viewInfo.format = GetYUVViewPlaneFormat(iminfo.format, i); + viewInfo.format = GetYUVViewPlaneFormat(fmt, i); if(planeCount > 1) viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT << i; - vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &views[i]); + // create as wrapped + vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &views.views[i]); RDCASSERTEQUAL(vkr, VK_SUCCESS); - - viewid = m_pDriver->GetResourceManager()->WrapResource(Unwrap(dev), views[i]); - // register as a live-only resource, so it is cleaned up properly - m_pDriver->GetResourceManager()->AddLiveResource(viewid, views[i]); } - - iminfo.view = views[0]; - iminfo.altViews[0] = views[1]; - iminfo.altViews[1] = views[2]; } else { - VkImageView view; - - vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &view); + // create first view + vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &views.views[0]); RDCASSERTEQUAL(vkr, VK_SUCCESS); - viewid = m_pDriver->GetResourceManager()->WrapResource(Unwrap(dev), view); - // register as a live-only resource, so it is cleaned up properly - m_pDriver->GetResourceManager()->AddLiveResource(viewid, view); + // for depth-stencil images, create a second view for stencil only + if(IsDepthAndStencilFormat(fmt)) + { + viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; - if(aspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT) - iminfo.altViews[0] = view; - else - iminfo.view = view; + vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &views.views[1]); + RDCASSERTEQUAL(vkr, VK_SUCCESS); + } } } @@ -161,19 +164,20 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn ImageLayouts &layouts = m_pDriver->m_ImageLayouts[cfg.resourceId]; VulkanCreationInfo::Image &iminfo = m_pDriver->m_CreationInfo.m_Image[cfg.resourceId]; + TextureDisplayViews &texviews = m_TexRender.TextureViews[cfg.resourceId]; VkImage liveIm = m_pDriver->GetResourceManager()->GetCurrentHandle(cfg.resourceId); - VkImageAspectFlags aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT; + CreateTexImageView(liveIm, iminfo, cfg.typeHint, texviews); int displayformat = 0; uint32_t descSetBinding = 0; - if(IsUIntFormat(iminfo.format)) + if(IsUIntFormat(texviews.castedFormat)) { descSetBinding = 10; displayformat |= TEXDISPLAY_UINT_TEX; } - else if(IsSIntFormat(iminfo.format)) + else if(IsSIntFormat(texviews.castedFormat)) { descSetBinding = 15; displayformat |= TEXDISPLAY_SINT_TEX; @@ -183,33 +187,30 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn descSetBinding = 5; } - if(IsDepthOnlyFormat(layouts.format)) - { - aspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT; - } - else if(IsDepthOrStencilFormat(layouts.format)) - { - aspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT; - if(layouts.format == VK_FORMAT_S8_UINT || (!cfg.red && cfg.green)) - { - aspectFlags = VK_IMAGE_ASPECT_STENCIL_BIT; - descSetBinding = 10; - displayformat |= TEXDISPLAY_UINT_TEX; + // by default we use view 0 + int viewIndex = 0; - // rescale the range so that stencil seems to fit to 0-1 - cfg.rangeMin *= 255.0f; - cfg.rangeMax *= 255.0f; + // if we're displaying the stencil, set up for stencil display + if(layouts.format == VK_FORMAT_S8_UINT || + (IsStencilFormat(layouts.format) && !cfg.red && cfg.green)) + { + descSetBinding = 10; + displayformat |= TEXDISPLAY_UINT_TEX; - // shuffle the channel selection, since stencil comes back in red - cfg.red = true; - cfg.green = false; - } + // for stencil we use view 1 as long as it's a depth-stencil texture + if(IsDepthAndStencilFormat(layouts.format)) + viewIndex = 1; + + // rescale the range so that stencil seems to fit to 0-1 + cfg.rangeMin *= 255.0f; + cfg.rangeMax *= 255.0f; + + // shuffle the channel selection, since stencil comes back in red + cfg.red = true; + cfg.green = false; } - CreateTexImageView(aspectFlags, liveIm, iminfo); - - VkImageView liveImView = - (aspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT ? iminfo.altViews[0] : iminfo.view); + VkImageView liveImView = texviews.views[viewIndex]; RDCASSERT(liveImView != VK_NULL_HANDLE); @@ -230,7 +231,7 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn Vec4u YUVDownsampleRate = {}; Vec4u YUVAChannels = {}; - GetYUVShaderParameters(iminfo.format, YUVDownsampleRate, YUVAChannels); + GetYUVShaderParameters(texviews.castedFormat, YUVDownsampleRate, YUVAChannels); data->YUVDownsampleRate = YUVDownsampleRate; data->YUVAChannels = YUVAChannels; @@ -305,10 +306,14 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn int textype = 0; if(iminfo.type == VK_IMAGE_TYPE_1D) + { textype = RESTYPE_TEX1D; - if(iminfo.type == VK_IMAGE_TYPE_3D) + } + else if(iminfo.type == VK_IMAGE_TYPE_3D) + { textype = RESTYPE_TEX3D; - if(iminfo.type == VK_IMAGE_TYPE_2D) + } + else if(iminfo.type == VK_IMAGE_TYPE_2D) { textype = RESTYPE_TEX2D; if(iminfo.samples != VK_SAMPLE_COUNT_1_BIT) @@ -319,7 +324,7 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn descSetBinding += textype; - if(!IsSRGBFormat(iminfo.format) && cfg.linearDisplayAsGamma) + if(!IsSRGBFormat(texviews.castedFormat) && cfg.linearDisplayAsGamma) displayformat |= TEXDISPLAY_GAMMA_CURVE; if(cfg.overlay == DebugOverlay::NaN) @@ -401,14 +406,14 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn imdesc.sampler = Unwrap(m_TexRender.LinearSampler); VkDescriptorImageInfo altimdesc[2] = {}; - for(uint32_t i = 0; i < GetYUVPlaneCount(iminfo.format) - 1; i++) + for(uint32_t i = 1; i < GetYUVPlaneCount(texviews.castedFormat); i++) { - RDCASSERT(iminfo.altViews[i] != VK_NULL_HANDLE); - altimdesc[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - altimdesc[i].imageView = Unwrap(iminfo.altViews[i]); - altimdesc[i].sampler = Unwrap(m_General.PointSampler); + RDCASSERT(texviews.views[i] != VK_NULL_HANDLE); + altimdesc[i - 1].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + altimdesc[i - 1].imageView = Unwrap(texviews.views[i]); + altimdesc[i - 1].sampler = Unwrap(m_General.PointSampler); if(cfg.mip == 0 && cfg.scale < 1.0f) - altimdesc[i].sampler = Unwrap(m_TexRender.LinearSampler); + altimdesc[i - 1].sampler = Unwrap(m_TexRender.LinearSampler); } VkDescriptorSet descset = m_TexRender.GetDescSet(); @@ -423,8 +428,8 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imdesc, NULL, NULL}, // YUV secondary planes (if needed) {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, Unwrap(descset), 10, 0, - GetYUVPlaneCount(iminfo.format) - 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, altimdesc, - NULL, NULL}, + GetYUVPlaneCount(texviews.castedFormat) - 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + altimdesc, NULL, NULL}, // UBOs {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, Unwrap(descset), 0, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, NULL, &ubodesc, NULL}, @@ -450,9 +455,9 @@ bool VulkanReplay::RenderTextureInternal(TextureDisplay cfg, VkRenderPassBeginIn // don't overwrite YUV texture slots if it's a YUV planar format if(write.dstBinding == 10) { - if(write.dstArrayElement == 0 && GetYUVPlaneCount(iminfo.format) >= 2) + if(write.dstArrayElement == 0 && GetYUVPlaneCount(texviews.castedFormat) >= 2) continue; - if(write.dstArrayElement == 1 && GetYUVPlaneCount(iminfo.format) >= 3) + if(write.dstArrayElement == 1 && GetYUVPlaneCount(texviews.castedFormat) >= 3) continue; } diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 39cc07cc9..6d08a581a 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -1707,26 +1707,19 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, ImageLayouts &layouts = m_pDriver->m_ImageLayouts[texid]; VulkanCreationInfo::Image &iminfo = m_pDriver->m_CreationInfo.m_Image[texid]; + TextureDisplayViews &texviews = m_TexRender.TextureViews[texid]; VkImage liveIm = m_pDriver->GetResourceManager()->GetCurrentHandle(texid); - VkImageAspectFlags aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT; - if(IsStencilOnlyFormat(layouts.format)) - { - aspectFlags = VK_IMAGE_ASPECT_STENCIL_BIT; - } - else if(IsDepthOrStencilFormat(layouts.format)) - { - aspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT; + if(!IsStencilFormat(iminfo.format)) + stencil = false; - // do a stencil min/max if stencil is selected - if(stencil) - aspectFlags = VK_IMAGE_ASPECT_STENCIL_BIT; - } + CreateTexImageView(liveIm, iminfo, typeHint, texviews); - CreateTexImageView(aspectFlags, liveIm, iminfo); + VkImageView liveImView = texviews.views[0]; - VkImageView liveImView = - (aspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT ? iminfo.altViews[0] : iminfo.view); + // if it's not stencil-only and we're displaying stencil, use view 1 + if(texviews.castedFormat != VK_FORMAT_S8_UINT && stencil) + liveImView = texviews.views[1]; RDCASSERT(liveImView != VK_NULL_HANDLE); @@ -1738,12 +1731,12 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, uint32_t descSetBinding = 0; uint32_t intTypeIndex = 0; - if(IsUIntFormat(iminfo.format)) + if(IsUIntFormat(texviews.castedFormat)) { descSetBinding = 10; intTypeIndex = 1; } - else if(IsSIntFormat(iminfo.format)) + else if(IsSIntFormat(texviews.castedFormat)) { descSetBinding = 15; intTypeIndex = 2; @@ -1756,17 +1749,21 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, int textype = 0; if(iminfo.type == VK_IMAGE_TYPE_1D) + { textype = RESTYPE_TEX1D; - if(iminfo.type == VK_IMAGE_TYPE_3D) + } + else if(iminfo.type == VK_IMAGE_TYPE_3D) + { textype = RESTYPE_TEX3D; - if(iminfo.type == VK_IMAGE_TYPE_2D) + } + else if(iminfo.type == VK_IMAGE_TYPE_2D) { textype = RESTYPE_TEX2D; if(iminfo.samples != VK_SAMPLE_COUNT_1_BIT) textype = RESTYPE_TEX2DMS; } - if(aspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT) + if(stencil) { descSetBinding = 10; intTypeIndex = 1; @@ -1784,12 +1781,12 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, m_Histogram.m_HistogramUBO.FillDescriptor(bufdescs[2]); VkDescriptorImageInfo altimdesc[2] = {}; - for(uint32_t i = 0; i < GetYUVPlaneCount(iminfo.format) - 1; i++) + for(uint32_t i = 1; i < GetYUVPlaneCount(texviews.castedFormat); i++) { - RDCASSERT(iminfo.altViews[i] != VK_NULL_HANDLE); - altimdesc[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - altimdesc[i].imageView = Unwrap(iminfo.altViews[i]); - altimdesc[i].sampler = Unwrap(m_General.PointSampler); + RDCASSERT(texviews.views[i] != VK_NULL_HANDLE); + altimdesc[i - 1].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + altimdesc[i - 1].imageView = Unwrap(texviews.views[i]); + altimdesc[i - 1].sampler = Unwrap(m_General.PointSampler); } VkWriteDescriptorSet writeSet[] = { @@ -1813,8 +1810,8 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, descSetBinding, 0, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imdesc, NULL, NULL}, // YUV secondary planes (if needed) {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, Unwrap(m_Histogram.m_HistogramDescSet[0]), 10, - 0, GetYUVPlaneCount(iminfo.format) - 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, altimdesc, - NULL, NULL}, + 0, GetYUVPlaneCount(texviews.castedFormat) - 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + altimdesc, NULL, NULL}, // second pass from tiles to result { @@ -1849,9 +1846,9 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, // don't overwrite YUV texture slots if it's a YUV planar format if(write.dstBinding == 10) { - if(write.dstArrayElement == 0 && GetYUVPlaneCount(iminfo.format) >= 2) + if(write.dstArrayElement == 0 && GetYUVPlaneCount(texviews.castedFormat) >= 2) continue; - if(write.dstArrayElement == 1 && GetYUVPlaneCount(iminfo.format) >= 3) + if(write.dstArrayElement == 1 && GetYUVPlaneCount(texviews.castedFormat) >= 3) continue; } @@ -1882,7 +1879,7 @@ bool VulkanReplay::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, Vec4u YUVDownsampleRate = {}; Vec4u YUVAChannels = {}; - GetYUVShaderParameters(iminfo.format, YUVDownsampleRate, YUVAChannels); + GetYUVShaderParameters(texviews.castedFormat, YUVDownsampleRate, YUVAChannels); data->HistogramYUVDownsampleRate = YUVDownsampleRate; data->HistogramYUVAChannels = YUVAChannels; @@ -2027,33 +2024,25 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m ImageLayouts &layouts = m_pDriver->m_ImageLayouts[texid]; VulkanCreationInfo::Image &iminfo = m_pDriver->m_CreationInfo.m_Image[texid]; + TextureDisplayViews &texviews = m_TexRender.TextureViews[texid]; VkImage liveIm = m_pDriver->GetResourceManager()->GetCurrentHandle(texid); - VkImageAspectFlags aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT; - if(IsStencilOnlyFormat(layouts.format)) - { - aspectFlags = VK_IMAGE_ASPECT_STENCIL_BIT; - } - else if(IsDepthOrStencilFormat(layouts.format)) - { - aspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT; + bool stencil = false; + // detect if stencil is selected + if(IsStencilFormat(iminfo.format) && !channels[0] && channels[1] && !channels[2] && !channels[3]) + stencil = true; - // detect if stencil is selected - if(!channels[0] && channels[1] && !channels[2] && !channels[3]) - aspectFlags = VK_IMAGE_ASPECT_STENCIL_BIT; - } - - CreateTexImageView(aspectFlags, liveIm, iminfo); + CreateTexImageView(liveIm, iminfo, typeHint, texviews); uint32_t descSetBinding = 0; uint32_t intTypeIndex = 0; - if(IsUIntFormat(iminfo.format)) + if(IsUIntFormat(texviews.castedFormat)) { descSetBinding = 10; intTypeIndex = 1; } - else if(IsSIntFormat(iminfo.format)) + else if(IsSIntFormat(texviews.castedFormat)) { descSetBinding = 15; intTypeIndex = 2; @@ -2066,17 +2055,21 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m int textype = 0; if(iminfo.type == VK_IMAGE_TYPE_1D) + { textype = RESTYPE_TEX1D; - if(iminfo.type == VK_IMAGE_TYPE_3D) + } + else if(iminfo.type == VK_IMAGE_TYPE_3D) + { textype = RESTYPE_TEX3D; - if(iminfo.type == VK_IMAGE_TYPE_2D) + } + else if(iminfo.type == VK_IMAGE_TYPE_2D) { textype = RESTYPE_TEX2D; if(iminfo.samples != VK_SAMPLE_COUNT_1_BIT) textype = RESTYPE_TEX2DMS; } - if(aspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT) + if(stencil) { descSetBinding = 10; intTypeIndex = 1; @@ -2099,8 +2092,11 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m return false; } - VkImageView liveImView = - (aspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT ? iminfo.altViews[0] : iminfo.view); + VkImageView liveImView = texviews.views[0]; + + // if it's not stencil-only and we're displaying stencil, use view 1 + if(stencil && texviews.castedFormat != VK_FORMAT_S8_UINT) + liveImView = texviews.views[1]; RDCASSERT(liveImView != VK_NULL_HANDLE); @@ -2115,12 +2111,12 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m m_Histogram.m_HistogramUBO.FillDescriptor(bufdescs[1]); VkDescriptorImageInfo altimdesc[2] = {}; - for(uint32_t i = 0; i < GetYUVPlaneCount(iminfo.format) - 1; i++) + for(uint32_t i = 1; i < GetYUVPlaneCount(texviews.castedFormat); i++) { - RDCASSERT(iminfo.altViews[i] != VK_NULL_HANDLE); - altimdesc[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - altimdesc[i].imageView = Unwrap(iminfo.altViews[i]); - altimdesc[i].sampler = Unwrap(m_General.PointSampler); + RDCASSERT(texviews.views[i] != VK_NULL_HANDLE); + altimdesc[i - 1].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + altimdesc[i - 1].imageView = Unwrap(texviews.views[i]); + altimdesc[i - 1].sampler = Unwrap(m_General.PointSampler); } VkWriteDescriptorSet writeSet[] = { @@ -2143,8 +2139,8 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m descSetBinding, 0, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imdesc, NULL, NULL}, // YUV secondary planes (if needed) {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, Unwrap(m_Histogram.m_HistogramDescSet[0]), 10, - 0, GetYUVPlaneCount(iminfo.format) - 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, altimdesc, - NULL, NULL}, + 0, GetYUVPlaneCount(texviews.castedFormat) - 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + altimdesc, NULL, NULL}, }; vector writeSets; @@ -2165,9 +2161,9 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m // don't overwrite YUV texture slots if it's a YUV planar format if(write.dstBinding == 10) { - if(write.dstArrayElement == 0 && GetYUVPlaneCount(iminfo.format) >= 2) + if(write.dstArrayElement == 0 && GetYUVPlaneCount(texviews.castedFormat) >= 2) continue; - if(write.dstArrayElement == 1 && GetYUVPlaneCount(iminfo.format) >= 3) + if(write.dstArrayElement == 1 && GetYUVPlaneCount(texviews.castedFormat) >= 3) continue; } @@ -2214,7 +2210,7 @@ bool VulkanReplay::GetHistogram(ResourceId texid, uint32_t sliceFace, uint32_t m Vec4u YUVDownsampleRate = {}; Vec4u YUVAChannels = {}; - GetYUVShaderParameters(iminfo.format, YUVDownsampleRate, YUVAChannels); + GetYUVShaderParameters(texviews.castedFormat, YUVDownsampleRate, YUVAChannels); data->HistogramYUVDownsampleRate = YUVDownsampleRate; data->HistogramYUVAChannels = YUVAChannels; diff --git a/renderdoc/driver/vulkan/vk_replay.h b/renderdoc/driver/vulkan/vk_replay.h index 036a08257..ff19dddae 100644 --- a/renderdoc/driver/vulkan/vk_replay.h +++ b/renderdoc/driver/vulkan/vk_replay.h @@ -352,9 +352,6 @@ private: bool GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t mip, uint32_t sample, CompType typeHint, bool stencil, float *minval, float *maxval); - void CreateTexImageView(VkImageAspectFlags aspectFlags, VkImage liveIm, - VulkanCreationInfo::Image &iminfo); - VulkanDebugManager *GetDebugManager(); VulkanResourceManager *GetResourceManager(); @@ -442,6 +439,18 @@ private: VkSampler PointSampler = VK_NULL_HANDLE; } m_General; + struct TextureDisplayViews + { + CompType typeHint; + VkFormat castedFormat; // the format after applying the above type hint + + // for a color/depth-only textures, views[0] is the view and views[1] and views[2] are NULL + // for stencil-only textures similarly, views[0] is the view and views[1] and views[2] are NULL + // for a depth-stencil texture, views[0] is depth, views[1] is stencil and views[2] is NULL + // for a YUV texture, each views[i] is a plane, and the remainder are NULL + VkImageView views[3]; + }; + struct TextureRendering { void Init(WrappedVulkan *driver, VkDescriptorPool descriptorPool); @@ -475,6 +484,8 @@ private: VkDeviceMemory DummyMemory = VK_NULL_HANDLE; VkSampler DummySampler = VK_NULL_HANDLE; + std::map TextureViews; + VkDescriptorSet GetDescSet() { NextSet = (NextSet + 1) % ARRAY_COUNT(DescSet); @@ -614,6 +625,9 @@ private: DriverInformation m_DriverInfo; + void CreateTexImageView(VkImage liveIm, const VulkanCreationInfo::Image &iminfo, + CompType typeHint, TextureDisplayViews &views); + void FillTimersAMD(uint32_t *eventStartID, uint32_t *sampleIndex, vector *eventIDs); vector FetchCountersAMD(const vector &counters); diff --git a/renderdoc/driver/vulkan/vk_resources.cpp b/renderdoc/driver/vulkan/vk_resources.cpp index a0c38467c..8c1a51928 100644 --- a/renderdoc/driver/vulkan/vk_resources.cpp +++ b/renderdoc/driver/vulkan/vk_resources.cpp @@ -646,6 +646,548 @@ VkFormat GetDepthOnlyFormat(VkFormat f) return f; } +VkFormat GetViewCastedFormat(VkFormat f, CompType typeHint) +{ + if(typeHint == CompType::Typeless) + return f; + + switch(f) + { + case VK_FORMAT_R64G64B64A64_UINT: + case VK_FORMAT_R64G64B64A64_SINT: + case VK_FORMAT_R64G64B64A64_SFLOAT: + { + if(typeHint == CompType::UInt) + return VK_FORMAT_R64G64B64A64_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R64G64B64A64_SINT; + else + return VK_FORMAT_R64G64B64A64_SFLOAT; + } + case VK_FORMAT_R64G64B64_UINT: + case VK_FORMAT_R64G64B64_SINT: + case VK_FORMAT_R64G64B64_SFLOAT: + { + if(typeHint == CompType::UInt) + return VK_FORMAT_R64G64B64_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R64G64B64_SINT; + else + return VK_FORMAT_R64G64B64_SFLOAT; + } + case VK_FORMAT_R64G64_UINT: + case VK_FORMAT_R64G64_SINT: + case VK_FORMAT_R64G64_SFLOAT: + { + if(typeHint == CompType::UInt) + return VK_FORMAT_R64G64_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R64G64_SINT; + else + return VK_FORMAT_R64G64_SFLOAT; + } + case VK_FORMAT_R64_UINT: + case VK_FORMAT_R64_SINT: + case VK_FORMAT_R64_SFLOAT: + { + if(typeHint == CompType::UInt) + return VK_FORMAT_R64_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R64_SINT; + else + return VK_FORMAT_R64_SFLOAT; + } + case VK_FORMAT_R32G32B32A32_UINT: + case VK_FORMAT_R32G32B32A32_SINT: + case VK_FORMAT_R32G32B32A32_SFLOAT: + { + if(typeHint == CompType::UInt) + return VK_FORMAT_R32G32B32A32_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R32G32B32A32_SINT; + else + return VK_FORMAT_R32G32B32A32_SFLOAT; + } + case VK_FORMAT_R32G32B32_UINT: + case VK_FORMAT_R32G32B32_SINT: + case VK_FORMAT_R32G32B32_SFLOAT: + { + if(typeHint == CompType::UInt) + return VK_FORMAT_R32G32B32_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R32G32B32_SINT; + else + return VK_FORMAT_R32G32B32_SFLOAT; + } + case VK_FORMAT_R32G32_UINT: + case VK_FORMAT_R32G32_SINT: + case VK_FORMAT_R32G32_SFLOAT: + { + if(typeHint == CompType::UInt) + return VK_FORMAT_R32G32_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R32G32_SINT; + else + return VK_FORMAT_R32G32_SFLOAT; + } + case VK_FORMAT_R32_UINT: + case VK_FORMAT_R32_SINT: + case VK_FORMAT_R32_SFLOAT: + case VK_FORMAT_D32_SFLOAT: + { + if(typeHint == CompType::UInt) + return VK_FORMAT_R32_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R32_SINT; + else if(typeHint == CompType::Depth) + return VK_FORMAT_D32_SFLOAT; + else + return VK_FORMAT_R32_SFLOAT; + } + case VK_FORMAT_R16G16B16A16_UNORM: + case VK_FORMAT_R16G16B16A16_SNORM: + case VK_FORMAT_R16G16B16A16_USCALED: + case VK_FORMAT_R16G16B16A16_SSCALED: + case VK_FORMAT_R16G16B16A16_UINT: + case VK_FORMAT_R16G16B16A16_SINT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_R16G16B16A16_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_R16G16B16A16_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_R16G16B16A16_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_R16G16B16A16_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_R16G16B16A16_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R16G16B16A16_SINT; + else + return VK_FORMAT_R16G16B16A16_SFLOAT; + } + case VK_FORMAT_R16G16B16_UNORM: + case VK_FORMAT_R16G16B16_SNORM: + case VK_FORMAT_R16G16B16_USCALED: + case VK_FORMAT_R16G16B16_SSCALED: + case VK_FORMAT_R16G16B16_UINT: + case VK_FORMAT_R16G16B16_SINT: + case VK_FORMAT_R16G16B16_SFLOAT: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_R16G16B16_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_R16G16B16_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_R16G16B16_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_R16G16B16_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_R16G16B16_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R16G16B16_SINT; + else + return VK_FORMAT_R16G16B16_SFLOAT; + } + case VK_FORMAT_R16G16_UNORM: + case VK_FORMAT_R16G16_SNORM: + case VK_FORMAT_R16G16_USCALED: + case VK_FORMAT_R16G16_SSCALED: + case VK_FORMAT_R16G16_UINT: + case VK_FORMAT_R16G16_SINT: + case VK_FORMAT_R16G16_SFLOAT: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_R16G16_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_R16G16_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_R16G16_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_R16G16_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_R16G16_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R16G16_SINT; + else + return VK_FORMAT_R16G16_SFLOAT; + } + case VK_FORMAT_R16_UNORM: + case VK_FORMAT_R16_SNORM: + case VK_FORMAT_R16_USCALED: + case VK_FORMAT_R16_SSCALED: + case VK_FORMAT_R16_UINT: + case VK_FORMAT_R16_SINT: + case VK_FORMAT_R16_SFLOAT: + case VK_FORMAT_D16_UNORM: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_R16_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_R16_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_R16_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_R16_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_R16_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R16_SINT; + else if(typeHint == CompType::Depth) + return VK_FORMAT_D16_UNORM; + else + return VK_FORMAT_R16_SFLOAT; + } + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SNORM: + case VK_FORMAT_R8G8B8A8_USCALED: + case VK_FORMAT_R8G8B8A8_SSCALED: + case VK_FORMAT_R8G8B8A8_UINT: + case VK_FORMAT_R8G8B8A8_SINT: + case VK_FORMAT_R8G8B8A8_SRGB: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_R8G8B8A8_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_R8G8B8A8_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_R8G8B8A8_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_R8G8B8A8_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_R8G8B8A8_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R8G8B8A8_SINT; + else if(typeHint == CompType::UNormSRGB) + return VK_FORMAT_R8G8B8A8_SRGB; + else + return VK_FORMAT_R8G8B8A8_UNORM; + } + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SNORM: + case VK_FORMAT_B8G8R8A8_USCALED: + case VK_FORMAT_B8G8R8A8_SSCALED: + case VK_FORMAT_B8G8R8A8_UINT: + case VK_FORMAT_B8G8R8A8_SINT: + case VK_FORMAT_B8G8R8A8_SRGB: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_B8G8R8A8_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_B8G8R8A8_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_B8G8R8A8_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_B8G8R8A8_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_B8G8R8A8_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_B8G8R8A8_SINT; + else if(typeHint == CompType::UNormSRGB) + return VK_FORMAT_B8G8R8A8_SRGB; + else + return VK_FORMAT_B8G8R8A8_UNORM; + } + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_A8B8G8R8_UNORM_PACK32; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_A8B8G8R8_SNORM_PACK32; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_A8B8G8R8_USCALED_PACK32; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_A8B8G8R8_SSCALED_PACK32; + else if(typeHint == CompType::UInt) + return VK_FORMAT_A8B8G8R8_UINT_PACK32; + else if(typeHint == CompType::SInt) + return VK_FORMAT_A8B8G8R8_SINT_PACK32; + else if(typeHint == CompType::UNormSRGB) + return VK_FORMAT_A8B8G8R8_SRGB_PACK32; + else + return VK_FORMAT_A8B8G8R8_UNORM_PACK32; + } + case VK_FORMAT_R8G8B8_UNORM: + case VK_FORMAT_R8G8B8_SNORM: + case VK_FORMAT_R8G8B8_USCALED: + case VK_FORMAT_R8G8B8_SSCALED: + case VK_FORMAT_R8G8B8_UINT: + case VK_FORMAT_R8G8B8_SINT: + case VK_FORMAT_R8G8B8_SRGB: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_R8G8B8_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_R8G8B8_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_R8G8B8_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_R8G8B8_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_R8G8B8_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R8G8B8_SINT; + else if(typeHint == CompType::UNormSRGB) + return VK_FORMAT_R8G8B8_SRGB; + else + return VK_FORMAT_R8G8B8_UNORM; + } + case VK_FORMAT_B8G8R8_UNORM: + case VK_FORMAT_B8G8R8_SNORM: + case VK_FORMAT_B8G8R8_USCALED: + case VK_FORMAT_B8G8R8_SSCALED: + case VK_FORMAT_B8G8R8_UINT: + case VK_FORMAT_B8G8R8_SINT: + case VK_FORMAT_B8G8R8_SRGB: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_B8G8R8_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_B8G8R8_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_B8G8R8_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_B8G8R8_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_B8G8R8_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_B8G8R8_SINT; + else if(typeHint == CompType::UNormSRGB) + return VK_FORMAT_B8G8R8_SRGB; + else + return VK_FORMAT_B8G8R8_UNORM; + } + case VK_FORMAT_R8G8_UNORM: + case VK_FORMAT_R8G8_SNORM: + case VK_FORMAT_R8G8_USCALED: + case VK_FORMAT_R8G8_SSCALED: + case VK_FORMAT_R8G8_UINT: + case VK_FORMAT_R8G8_SINT: + case VK_FORMAT_R8G8_SRGB: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_R8G8_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_R8G8_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_R8G8_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_R8G8_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_R8G8_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R8G8_SINT; + else if(typeHint == CompType::UNormSRGB) + return VK_FORMAT_R8G8_SRGB; + else + return VK_FORMAT_R8G8_UNORM; + } + case VK_FORMAT_R8_UNORM: + case VK_FORMAT_R8_SNORM: + case VK_FORMAT_R8_USCALED: + case VK_FORMAT_R8_SSCALED: + case VK_FORMAT_R8_UINT: + case VK_FORMAT_R8_SINT: + case VK_FORMAT_R8_SRGB: + case VK_FORMAT_S8_UINT: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_R8_UNORM; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_R8_SNORM; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_R8_USCALED; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_R8_SSCALED; + else if(typeHint == CompType::UInt) + return VK_FORMAT_R8_UINT; + else if(typeHint == CompType::SInt) + return VK_FORMAT_R8_SINT; + else if(typeHint == CompType::UNormSRGB) + return VK_FORMAT_R8_SRGB; + else if(typeHint == CompType::Depth) + return VK_FORMAT_S8_UINT; + else + return VK_FORMAT_R8_UNORM; + } + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + case VK_FORMAT_A2B10G10R10_UINT_PACK32: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_A2B10G10R10_UNORM_PACK32; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_A2B10G10R10_SNORM_PACK32; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_A2B10G10R10_USCALED_PACK32; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_A2B10G10R10_SSCALED_PACK32; + else if(typeHint == CompType::UInt) + return VK_FORMAT_A2B10G10R10_UINT_PACK32; + else if(typeHint == CompType::SInt) + return VK_FORMAT_A2B10G10R10_SINT_PACK32; + else + return VK_FORMAT_A2B10G10R10_UNORM_PACK32; + } + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + { + if(typeHint == CompType::UNorm) + return VK_FORMAT_A2R10G10B10_UNORM_PACK32; + else if(typeHint == CompType::SNorm) + return VK_FORMAT_A2R10G10B10_SNORM_PACK32; + else if(typeHint == CompType::UScaled) + return VK_FORMAT_A2R10G10B10_USCALED_PACK32; + else if(typeHint == CompType::SScaled) + return VK_FORMAT_A2R10G10B10_SSCALED_PACK32; + else if(typeHint == CompType::UInt) + return VK_FORMAT_A2R10G10B10_UINT_PACK32; + else if(typeHint == CompType::SInt) + return VK_FORMAT_A2R10G10B10_SINT_PACK32; + else + return VK_FORMAT_A2R10G10B10_UNORM_PACK32; + } + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_BC1_RGB_SRGB_BLOCK + : VK_FORMAT_BC1_RGB_UNORM_BLOCK; + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_BC1_RGBA_SRGB_BLOCK + : VK_FORMAT_BC1_RGBA_UNORM_BLOCK; + case VK_FORMAT_BC4_UNORM_BLOCK: + case VK_FORMAT_BC4_SNORM_BLOCK: + return (typeHint == CompType::SNorm) ? VK_FORMAT_BC4_SNORM_BLOCK : VK_FORMAT_BC4_UNORM_BLOCK; + case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK + : VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; + case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK + : VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK; + case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK + : VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; + case VK_FORMAT_EAC_R11_UNORM_BLOCK: + case VK_FORMAT_EAC_R11_SNORM_BLOCK: + return (typeHint == CompType::SNorm) ? VK_FORMAT_EAC_R11_SNORM_BLOCK + : VK_FORMAT_EAC_R11_UNORM_BLOCK; + case VK_FORMAT_BC2_UNORM_BLOCK: + case VK_FORMAT_BC2_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_BC2_SRGB_BLOCK : VK_FORMAT_BC2_UNORM_BLOCK; + case VK_FORMAT_BC3_UNORM_BLOCK: + case VK_FORMAT_BC3_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_BC3_SRGB_BLOCK : VK_FORMAT_BC3_UNORM_BLOCK; + case VK_FORMAT_BC5_UNORM_BLOCK: + case VK_FORMAT_BC5_SNORM_BLOCK: + return (typeHint == CompType::SNorm) ? VK_FORMAT_BC5_SNORM_BLOCK : VK_FORMAT_BC5_UNORM_BLOCK; + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + case VK_FORMAT_BC6H_SFLOAT_BLOCK: + return (typeHint == CompType::SNorm) ? VK_FORMAT_BC6H_SFLOAT_BLOCK + : VK_FORMAT_BC6H_UFLOAT_BLOCK; + case VK_FORMAT_BC7_UNORM_BLOCK: + case VK_FORMAT_BC7_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK; + case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: + case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: + return (typeHint == CompType::SNorm) ? VK_FORMAT_EAC_R11G11_SNORM_BLOCK + : VK_FORMAT_EAC_R11G11_UNORM_BLOCK; + case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_4x4_SRGB_BLOCK + : VK_FORMAT_ASTC_4x4_UNORM_BLOCK; + case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_5x4_SRGB_BLOCK + : VK_FORMAT_ASTC_5x4_UNORM_BLOCK; + case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_5x5_SRGB_BLOCK + : VK_FORMAT_ASTC_5x5_UNORM_BLOCK; + case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_6x5_SRGB_BLOCK + : VK_FORMAT_ASTC_6x5_UNORM_BLOCK; + case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_6x6_SRGB_BLOCK + : VK_FORMAT_ASTC_6x6_UNORM_BLOCK; + case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_8x5_SRGB_BLOCK + : VK_FORMAT_ASTC_8x5_UNORM_BLOCK; + case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_8x6_SRGB_BLOCK + : VK_FORMAT_ASTC_8x6_UNORM_BLOCK; + case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_8x8_SRGB_BLOCK + : VK_FORMAT_ASTC_8x8_UNORM_BLOCK; + case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_10x5_SRGB_BLOCK + : VK_FORMAT_ASTC_10x5_UNORM_BLOCK; + case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_10x6_SRGB_BLOCK + : VK_FORMAT_ASTC_10x6_UNORM_BLOCK; + case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_10x8_SRGB_BLOCK + : VK_FORMAT_ASTC_10x8_UNORM_BLOCK; + case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_10x10_SRGB_BLOCK + : VK_FORMAT_ASTC_10x10_UNORM_BLOCK; + case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_12x10_SRGB_BLOCK + : VK_FORMAT_ASTC_12x10_UNORM_BLOCK; + case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_ASTC_12x12_SRGB_BLOCK + : VK_FORMAT_ASTC_12x12_UNORM_BLOCK; + case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG + : VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG; + case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG + : VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG; + case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG + : VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; + case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: + return (typeHint == CompType::UNormSRGB) ? VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG + : VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG; + + // all other formats have no aliases so nothing to typecast + default: break; + } + + return f; +} + uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat Format, uint32_t mip) { uint32_t w = RDCMAX(Width >> mip, 1U); diff --git a/renderdoc/driver/vulkan/vk_resources.h b/renderdoc/driver/vulkan/vk_resources.h index 5ce1bc95a..c507b9f2e 100644 --- a/renderdoc/driver/vulkan/vk_resources.h +++ b/renderdoc/driver/vulkan/vk_resources.h @@ -1230,6 +1230,7 @@ uint32_t GetYUVPlaneCount(VkFormat f); uint32_t GetYUVNumRows(VkFormat f, uint32_t height); VkFormat GetYUVViewPlaneFormat(VkFormat f, uint32_t plane); VkFormat GetDepthOnlyFormat(VkFormat f); +VkFormat GetViewCastedFormat(VkFormat f, CompType typeHint); void GetYUVShaderParameters(VkFormat f, Vec4u &YUVDownsampleRate, Vec4u &YUVAChannels);