lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-05-29 13:20:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use typeHint as a forced view cast on vulkan

Browse Source
This commit is contained in:
baldurk
2019-01-14 12:02:28 +00:00
parent 44da10be06
commit 465278c996
7 changed files with 700 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/vulkan/vk_info.cpp
-3
View File
@@ -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;
renderdoc/driver/vulkan/vk_info.h
-3
View File
@@ -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;
renderdoc/driver/vulkan/vk_rendertexture.cpp
+83 -78
View File
@@ -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<VkImage>(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;
}
renderdoc/driver/vulkan/vk_replay.cpp
+57 -61
View File
@@ -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<VkImage>(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<VkImage>(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<VkWriteDescriptorSet> 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;
renderdoc/driver/vulkan/vk_replay.h
+17 -3
View File
@@ -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<ResourceId, TextureDisplayViews> 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<uint32_t> *eventIDs);
vector<CounterResult> FetchCountersAMD(const vector<GPUCounter> &counters);
renderdoc/driver/vulkan/vk_resources.cpp
+542
View File
@@ -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);
renderdoc/driver/vulkan/vk_resources.h
+1
View File
@@ -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);