lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-05-04 17:10:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add test to parameter zoo to catch descriptor referencing resources

Browse Source
This commit is contained in:
baldurk
2020-01-27 14:29:39 +00:00
parent 1899b5ffc3
commit 83f0398aa6
5 changed files with 643 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files
util/test/demos/vk/vk_helpers.cpp
+11 -3
View File
@@ -115,10 +115,18 @@ void cmdBindVertexBuffers(VkCommandBuffer cmd, uint32_t firstBinding,
void cmdBindDescriptorSets(VkCommandBuffer cmd, VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout, uint32_t firstSet,
std::vector<VkDescriptorSet> bufs, std::vector<uint32_t> dynamicOffsets)
std::vector<VkDescriptorSet> sets, std::vector<uint32_t> dynamicOffsets)
{
vkCmdBindDescriptorSets(cmd, pipelineBindPoint, layout, firstSet, (uint32_t)bufs.size(),
bufs.data(), (uint32_t)dynamicOffsets.size(), dynamicOffsets.data());
vkCmdBindDescriptorSets(cmd, pipelineBindPoint, layout, firstSet, (uint32_t)sets.size(),
sets.data(), (uint32_t)dynamicOffsets.size(), dynamicOffsets.data());
}
void cmdPushDescriptorSets(VkCommandBuffer cmd, VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout, uint32_t set,
std::vector<VkWriteDescriptorSet> writes)
{
vkCmdPushDescriptorSetKHR(cmd, pipelineBindPoint, layout, set, (uint32_t)writes.size(),
writes.data());
}
GraphicsPipelineCreateInfo::GraphicsPipelineCreateInfo()
util/test/demos/vk/vk_helpers.h
+5 -1
View File
@@ -164,7 +164,11 @@ void cmdBindVertexBuffers(VkCommandBuffer cmd, uint32_t firstBinding,
void cmdBindDescriptorSets(VkCommandBuffer cmd, VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout, uint32_t firstSet,
std::vector<VkDescriptorSet> bufs, std::vector<uint32_t> dynamicOffsets);
std::vector<VkDescriptorSet> sets, std::vector<uint32_t> dynamicOffsets);
void cmdPushDescriptorSets(VkCommandBuffer cmd, VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout, uint32_t set,
std::vector<VkWriteDescriptorSet> writes);
struct ApplicationInfo : public VkApplicationInfo
{
util/test/demos/vk/vk_parameter_zoo.cpp
+521 -52
View File
@@ -89,6 +89,88 @@ void main()
)EOSHADER";
const std::string refpixel = R"EOSHADER(
#version 450 core
#extension GL_EXT_samplerless_texture_functions : enable
layout(location = 0, index = 0) out vec4 Color;
layout(binding = 0) uniform texture2D tex;
void main()
{
Color = vec4(0, 1, 0, 1) * texelFetch(tex, ivec2(0), 0);
}
)EOSHADER";
struct refdatastruct
{
VkDescriptorImageInfo sampler;
VkDescriptorImageInfo combined;
VkDescriptorImageInfo sampled;
VkDescriptorImageInfo storage;
VkBufferView unitexel;
VkBufferView storetexel;
VkDescriptorBufferInfo unibuf;
VkDescriptorBufferInfo storebuf;
VkDescriptorBufferInfo unibufdyn;
VkDescriptorBufferInfo storebufdyn;
};
VkSampler refsamp[4];
VkSampler refcombinedsamp[4];
AllocatedImage refcombinedimg[4];
VkImageView refcombinedimgview[4];
AllocatedImage refsampled[4];
VkImageView refsampledview[4];
AllocatedImage refstorage[4];
VkImageView refstorageview[4];
AllocatedBuffer refunitexel[4];
VkBufferView refunitexelview[4];
AllocatedBuffer refstoretexel[4];
VkBufferView refstoretexelview[4];
AllocatedBuffer refunibuf[4];
AllocatedBuffer refstorebuf[4];
AllocatedBuffer refunibufdyn[4];
AllocatedBuffer refstorebufdyn[4];
refdatastruct GetData(uint32_t idx)
{
return {
// sampler
vkh::DescriptorImageInfo(VK_NULL_HANDLE, VK_IMAGE_LAYOUT_UNDEFINED, refsamp[idx]),
// combined
vkh::DescriptorImageInfo(refcombinedimgview[idx], VK_IMAGE_LAYOUT_GENERAL,
refcombinedsamp[idx]),
// sampled
vkh::DescriptorImageInfo(refsampledview[idx], VK_IMAGE_LAYOUT_GENERAL, VK_NULL_HANDLE),
// storage
vkh::DescriptorImageInfo(refstorageview[idx], VK_IMAGE_LAYOUT_GENERAL, VK_NULL_HANDLE),
// unitexel
refunitexelview[idx],
// storetexel
refstoretexelview[idx],
// unibuf
vkh::DescriptorBufferInfo(refunibuf[idx].buffer),
// storebuf
vkh::DescriptorBufferInfo(refstorebuf[idx].buffer),
// unibufdyn
vkh::DescriptorBufferInfo(refunibufdyn[idx].buffer),
// storebufdyn
vkh::DescriptorBufferInfo(refstorebufdyn[idx].buffer),
};
}
int main()
{
optDevExts.push_back(VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
@@ -118,6 +200,20 @@ void main()
{10, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, VK_SHADER_STAGE_VERTEX_BIT},
}));
VkDescriptorSetLayout refsetlayout =
createDescriptorSetLayout(vkh::DescriptorSetLayoutCreateInfo({
{0, VK_DESCRIPTOR_TYPE_SAMPLER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_VERTEX_BIT},
{3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_VERTEX_BIT},
{4, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{5, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{6, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{8, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT},
{9, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT},
}));
VkSampler invalidSampler = (VkSampler)0x1234;
VkSampler validSampler = VK_NULL_HANDLE;
VkSamplerCreateInfo sampInfo = {VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
@@ -130,12 +226,11 @@ void main()
{99, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_VERTEX_BIT, &invalidSampler},
}));
VkDescriptorSetLayout pushlayout = VK_NULL_HANDLE;
VkPipelineLayout layout;
VkPipelineLayout layout, reflayout;
if(KHR_push_descriptor)
{
pushlayout = createDescriptorSetLayout(vkh::DescriptorSetLayoutCreateInfo(
VkDescriptorSetLayout pushlayout = createDescriptorSetLayout(vkh::DescriptorSetLayoutCreateInfo(
{
{5, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{10, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
@@ -144,10 +239,36 @@ void main()
VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
layout = createPipelineLayout(vkh::PipelineLayoutCreateInfo({setlayout, pushlayout}));
VkDescriptorSetLayout refpushlayout =
createDescriptorSetLayout(vkh::DescriptorSetLayoutCreateInfo(
{
{0, VK_DESCRIPTOR_TYPE_SAMPLER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_SHADER_STAGE_VERTEX_BIT},
{3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_VERTEX_BIT},
{4, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{5, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{6, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
{7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT},
},
VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
if(KHR_descriptor_update_template)
reflayout = createPipelineLayout(
vkh::PipelineLayoutCreateInfo({refsetlayout, refsetlayout, refpushlayout}));
else
reflayout =
createPipelineLayout(vkh::PipelineLayoutCreateInfo({refsetlayout, refpushlayout}));
}
else
{
layout = createPipelineLayout(vkh::PipelineLayoutCreateInfo({setlayout}));
if(KHR_descriptor_update_template)
reflayout = createPipelineLayout(vkh::PipelineLayoutCreateInfo({refsetlayout, refsetlayout}));
else
reflayout = createPipelineLayout(vkh::PipelineLayoutCreateInfo({refsetlayout}));
}
VkPipelineLayout immutlayout =
@@ -184,6 +305,10 @@ void main()
VkPipeline immutpipe = createGraphicsPipeline(pipeCreateInfo);
pipeCreateInfo.layout = reflayout;
VkPipeline refpipe = createGraphicsPipeline(pipeCreateInfo);
pipeCreateInfo.stages = {
CompileShaderModule(common + vertex, ShaderLang::glsl, ShaderStage::vert, "main"),
CompileShaderModule(pixel2, ShaderLang::glsl, ShaderStage::frag, "main"),
@@ -254,6 +379,8 @@ void main()
vb.upload(DefaultTri);
VkDescriptorSet descset = allocateDescriptorSet(setlayout);
VkDescriptorSet refdescset = allocateDescriptorSet(refsetlayout);
VkDescriptorSet reftempldescset = allocateDescriptorSet(refsetlayout);
VkDescriptorSet immutdescset = allocateDescriptorSet(immutsetlayout);
@@ -290,11 +417,11 @@ void main()
vkh::ClearColorValue(1.0f, 1.0f, 1.0f, 1.0f), 1,
vkh::ImageSubresourceRange());
vkh::cmdPipelineBarrier(
cmd, {
vkh::ImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, img.image),
});
cmd,
{
vkh::ImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, img.image),
});
vkEndCommandBuffer(cmd);
Submit(99, 99, {cmd});
}
@@ -423,6 +550,8 @@ void main()
vkh::updateDescriptorSets(device, writes);
VkDescriptorUpdateTemplateKHR reftempl = VK_NULL_HANDLE;
if(KHR_descriptor_update_template)
{
struct datastruct
@@ -476,6 +605,31 @@ void main()
vkUpdateDescriptorSetWithTemplateKHR(device, descset, templ, &data);
vkDestroyDescriptorUpdateTemplateKHR(device, templ, NULL);
entries = {
{0, 0, 1, VK_DESCRIPTOR_TYPE_SAMPLER, offsetof(refdatastruct, sampler), sizeof(data)},
{1, 0, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, offsetof(refdatastruct, combined),
sizeof(data)},
{2, 0, 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, offsetof(refdatastruct, sampled), sizeof(data)},
{3, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, offsetof(refdatastruct, storage), sizeof(data)},
{4, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, offsetof(refdatastruct, unitexel),
sizeof(data)},
{5, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, offsetof(refdatastruct, storetexel),
sizeof(data)},
{6, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, offsetof(refdatastruct, unibuf), sizeof(data)},
{7, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, offsetof(refdatastruct, storebuf),
sizeof(data)},
{8, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, offsetof(refdatastruct, unibufdyn),
sizeof(data)},
{9, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, offsetof(refdatastruct, storebufdyn),
sizeof(data)},
};
createInfo.descriptorSetLayout = refsetlayout;
createInfo.descriptorUpdateEntryCount = (uint32_t)entries.size();
createInfo.pDescriptorUpdateEntries = entries.data();
vkCreateDescriptorUpdateTemplateKHR(device, &createInfo, NULL, &reftempl);
}
struct pushdatastruct
@@ -485,7 +639,7 @@ void main()
pushdata.buf = validBufInfos[0];
VkDescriptorUpdateTemplateKHR pushtempl = VK_NULL_HANDLE;
VkDescriptorUpdateTemplateKHR pushtempl = VK_NULL_HANDLE, refpushtempl = VK_NULL_HANDLE;
if(KHR_descriptor_update_template && KHR_push_descriptor)
{
std::vector<VkDescriptorUpdateTemplateEntryKHR> entries = {
@@ -503,6 +657,35 @@ void main()
createInfo.pipelineLayout = layout;
createInfo.set = 1;
vkCreateDescriptorUpdateTemplateKHR(device, &createInfo, NULL, &pushtempl);
entries = {
{0, 0, 1, VK_DESCRIPTOR_TYPE_SAMPLER, offsetof(refdatastruct, sampler),
sizeof(refdatastruct)},
{1, 0, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, offsetof(refdatastruct, combined),
sizeof(refdatastruct)},
{2, 0, 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, offsetof(refdatastruct, sampled),
sizeof(refdatastruct)},
{3, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, offsetof(refdatastruct, storage),
sizeof(refdatastruct)},
{4, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, offsetof(refdatastruct, unitexel),
sizeof(refdatastruct)},
{5, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, offsetof(refdatastruct, storetexel),
sizeof(refdatastruct)},
{6, 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, offsetof(refdatastruct, unibuf),
sizeof(refdatastruct)},
{7, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, offsetof(refdatastruct, storebuf),
sizeof(refdatastruct)},
};
createInfo.descriptorUpdateEntryCount = (uint32_t)entries.size();
createInfo.pDescriptorUpdateEntries = entries.data();
// set 0 = normal
// set 1 = template
// set 2 = push
createInfo.pipelineLayout = reflayout;
createInfo.set = 2;
vkCreateDescriptorUpdateTemplateKHR(device, &createInfo, NULL, &refpushtempl);
}
// check that stale views in descriptors don't cause problems if the handle is re-used
@@ -516,14 +699,15 @@ void main()
NULL, &view2));
vkh::updateDescriptorSets(
device, {
// bind view1 to binding 0, we will override this
vkh::WriteDescriptorSet(descset2, 0, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{vkh::DescriptorImageInfo(view1)}),
// we bind view2 to binding 1. This will become stale
vkh::WriteDescriptorSet(descset2, 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{vkh::DescriptorImageInfo(view2)}),
});
device,
{
// bind view1 to binding 0, we will override this
vkh::WriteDescriptorSet(descset2, 0, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{vkh::DescriptorImageInfo(view1, VK_IMAGE_LAYOUT_GENERAL)}),
// we bind view2 to binding 1. This will become stale
vkh::WriteDescriptorSet(descset2, 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{vkh::DescriptorImageInfo(view2, VK_IMAGE_LAYOUT_GENERAL)}),
});
vkDestroyImageView(device, view2, NULL);
@@ -545,61 +729,343 @@ void main()
// bind view3 to 0. This means the same handle is now in both binding but only binding 0
// is valid, binding 1 refers to the 'old' version of this handle.
vkh::WriteDescriptorSet(descset2, 0, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{vkh::DescriptorImageInfo(view3)}),
{vkh::DescriptorImageInfo(view3, VK_IMAGE_LAYOUT_GENERAL)}),
// this unbinds the stale view2. Nothing should happen, but if we're comparing by handle
// this may remove a reference to view3 since it will have the same handle
vkh::WriteDescriptorSet(descset2, 1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{vkh::DescriptorImageInfo(view1)}),
{vkh::DescriptorImageInfo(view1, VK_IMAGE_LAYOUT_GENERAL)}),
});
refdatastruct resetrefdata = {};
resetrefdata.sampler.sampler = resetrefdata.combined.sampler = validSampler;
resetrefdata.sampled.imageView = resetrefdata.combined.imageView =
resetrefdata.storage.imageView = validImgView;
resetrefdata.sampled.imageLayout = resetrefdata.combined.imageLayout =
resetrefdata.storage.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
resetrefdata.unitexel = resetrefdata.storetexel = validBufView;
resetrefdata.unibuf.buffer = resetrefdata.storebuf.buffer = resetrefdata.unibufdyn.buffer =
resetrefdata.storebufdyn.buffer = validBuffer;
resetrefdata.unibuf.range = resetrefdata.storebuf.range = resetrefdata.unibufdyn.range =
resetrefdata.storebufdyn.range = VK_WHOLE_SIZE;
{
VkCommandBuffer cmd = GetCommandBuffer();
vkBeginCommandBuffer(cmd, vkh::CommandBufferBeginInfo());
vkh::cmdPipelineBarrier(cmd, {
vkh::ImageMemoryBarrier(0, 0, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_GENERAL, img.image),
});
// create the specific resources that will only be referenced through descriptor updates
for(int i = 0; i < 4; i++)
{
vkCreateSampler(device, &sampInfo, NULL, &refsamp[i]);
setName(refsamp[i], "refsamp" + std::to_string(i));
vkCreateSampler(device, &sampInfo, NULL, &refcombinedsamp[i]);
setName(refcombinedsamp[i], "refcombinedsamp" + std::to_string(i));
VkFormat fmt = VK_FORMAT_R32G32B32A32_SFLOAT;
VmaAllocationCreateInfo allocInfo = {0, VMA_MEMORY_USAGE_GPU_ONLY};
refcombinedimg[i] = AllocatedImage(
this, vkh::ImageCreateInfo(2, 2, 0, fmt, VK_IMAGE_USAGE_SAMPLED_BIT), allocInfo);
refcombinedimgview[i] = createImageView(
vkh::ImageViewCreateInfo(refcombinedimg[i].image, VK_IMAGE_VIEW_TYPE_2D, fmt));
setName(refcombinedimg[i].image, "refcombinedimg" + std::to_string(i));
vkh::cmdPipelineBarrier(
cmd, {
vkh::ImageMemoryBarrier(0, 0, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_GENERAL, refcombinedimg[i].image),
});
refsampled[i] = AllocatedImage(
this, vkh::ImageCreateInfo(2, 2, 0, fmt, VK_IMAGE_USAGE_SAMPLED_BIT), allocInfo);
refsampledview[i] = createImageView(
vkh::ImageViewCreateInfo(refsampled[i].image, VK_IMAGE_VIEW_TYPE_2D, fmt));
setName(refsampled[i].image, "refsampled" + std::to_string(i));
vkh::cmdPipelineBarrier(
cmd, {
vkh::ImageMemoryBarrier(0, 0, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_GENERAL, refsampled[i].image),
});
refstorage[i] = AllocatedImage(
this, vkh::ImageCreateInfo(2, 2, 0, fmt, VK_IMAGE_USAGE_STORAGE_BIT), allocInfo);
refstorageview[i] = createImageView(
vkh::ImageViewCreateInfo(refstorage[i].image, VK_IMAGE_VIEW_TYPE_2D, fmt));
setName(refstorage[i].image, "refstorage" + std::to_string(i));
vkh::cmdPipelineBarrier(
cmd, {
vkh::ImageMemoryBarrier(0, 0, VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_GENERAL, refstorage[i].image),
});
refunitexel[i] = AllocatedBuffer(
this, vkh::BufferCreateInfo(256, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT), allocInfo);
refunitexelview[i] = createBufferView(vkh::BufferViewCreateInfo(refunitexel[i].buffer, fmt));
setName(refunitexel[i].buffer, "refunitexel" + std::to_string(i));
refstoretexel[i] = AllocatedBuffer(
this, vkh::BufferCreateInfo(256, VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT), allocInfo);
refstoretexelview[i] =
createBufferView(vkh::BufferViewCreateInfo(refstoretexel[i].buffer, fmt));
setName(refstoretexel[i].buffer, "refstoretexel" + std::to_string(i));
refunibuf[i] = AllocatedBuffer(
this, vkh::BufferCreateInfo(256, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), allocInfo);
setName(refunibuf[i].buffer, "refunibuf" + std::to_string(i));
refstorebuf[i] = AllocatedBuffer(
this, vkh::BufferCreateInfo(256, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), allocInfo);
setName(refstorebuf[i].buffer, "refstorebuf" + std::to_string(i));
refunibufdyn[i] = AllocatedBuffer(
this, vkh::BufferCreateInfo(256, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), allocInfo);
setName(refunibufdyn[i].buffer, "refunibufdyn" + std::to_string(i));
refstorebufdyn[i] = AllocatedBuffer(
this, vkh::BufferCreateInfo(256, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), allocInfo);
setName(refstorebufdyn[i].buffer, "refstorebufdyn" + std::to_string(i));
}
vkEndCommandBuffer(cmd);
Submit(99, 99, {cmd});
}
while(Running())
{
VkCommandBuffer cmd = GetCommandBuffer();
// acquire and clear the backbuffer
{
VkCommandBuffer cmd = GetCommandBuffer();
vkBeginCommandBuffer(cmd, vkh::CommandBufferBeginInfo());
vkBeginCommandBuffer(cmd, vkh::CommandBufferBeginInfo());
VkImage swapimg =
StartUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
VkImage swapimg =
StartUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
vkCmdClearColorImage(cmd, swapimg, VK_IMAGE_LAYOUT_GENERAL,
vkh::ClearColorValue(0.4f, 0.5f, 0.6f, 1.0f), 1,
vkh::ImageSubresourceRange());
vkCmdClearColorImage(cmd, swapimg, VK_IMAGE_LAYOUT_GENERAL,
vkh::ClearColorValue(0.4f, 0.5f, 0.6f, 1.0f), 1,
vkh::ImageSubresourceRange());
vkCmdBeginRenderPass(
cmd, vkh::RenderPassBeginInfo(mainWindow->rp, mainWindow->GetFB(), mainWindow->scissor),
VK_SUBPASS_CONTENTS_INLINE);
vkEndCommandBuffer(cmd);
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe);
vkCmdSetViewport(cmd, 0, 1, &mainWindow->viewport);
vkCmdSetScissor(cmd, 0, 1, &mainWindow->scissor);
vkh::cmdBindVertexBuffers(cmd, 0, {vb.buffer}, {0});
vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, {descset}, {0, 0});
vkCmdPushDescriptorSetKHR(
cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 1, 1,
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 20, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
validBufInfos));
if(KHR_descriptor_update_template && KHR_push_descriptor)
vkCmdPushDescriptorSetWithTemplateKHR(cmd, pushtempl, layout, 1, &pushdata);
vkCmdDraw(cmd, 3, 1, 0, 0);
Submit(0, 4, {cmd});
}
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, immutpipe);
vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, immutlayout, 0,
{immutdescset}, {});
// reference some resources through different descriptor types to ensure that they are
// properly included
{
vkDeviceWaitIdle(device);
vkCmdDraw(cmd, 3, 1, 0, 0);
refdatastruct refdata = GetData(0);
refdatastruct reftempldata = GetData(1);
refdatastruct refpushdata = GetData(2);
refdatastruct refpushtempldata = GetData(3);
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe2);
vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, layout2, 0, {descset2}, {});
vkh::updateDescriptorSets(
device,
{
vkh::WriteDescriptorSet(refdescset, 0, VK_DESCRIPTOR_TYPE_SAMPLER, {refdata.sampler}),
vkh::WriteDescriptorSet(refdescset, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
{refdata.combined}),
vkh::WriteDescriptorSet(refdescset, 2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{refdata.sampled}),
vkh::WriteDescriptorSet(refdescset, 3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
{refdata.storage}),
vkh::WriteDescriptorSet(refdescset, 4, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
{refdata.unitexel}),
vkh::WriteDescriptorSet(refdescset, 5, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
{refdata.storetexel}),
vkh::WriteDescriptorSet(refdescset, 6, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
{refdata.unibuf}),
vkh::WriteDescriptorSet(refdescset, 7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
{refdata.storebuf}),
vkh::WriteDescriptorSet(refdescset, 8, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
{refdata.unibufdyn}),
vkh::WriteDescriptorSet(refdescset, 9, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
{refdata.storebufdyn}),
});
vkCmdDraw(cmd, 3, 1, 0, 0);
if(KHR_descriptor_update_template)
vkUpdateDescriptorSetWithTemplateKHR(device, reftempldescset, reftempl, &reftempldata);
vkCmdEndRenderPass(cmd);
VkCommandBuffer cmd = GetCommandBuffer();
FinishUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
vkBeginCommandBuffer(cmd, vkh::CommandBufferBeginInfo());
vkEndCommandBuffer(cmd);
if(KHR_descriptor_update_template)
setMarker(cmd, "KHR_descriptor_update_template");
if(KHR_push_descriptor)
setMarker(cmd, "KHR_push_descriptor");
Submit(0, 1, {cmd});
vkCmdBeginRenderPass(
cmd, vkh::RenderPassBeginInfo(mainWindow->rp, mainWindow->GetFB(), mainWindow->scissor),
VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, refpipe);
uint32_t set = 0;
// set 0 is always the normal one
vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, reflayout, set++,
{refdescset}, {0, 0});
// if we have update templates, set 1 is always the template one
if(KHR_descriptor_update_template)
vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, reflayout, set++,
{reftempldescset}, {0, 0});
// push set comes after the ones above. Note that because we can't have more than one push
// set, we test with the first set of refs here then do a template update (if supported) and
// draw again to test the second set of refs.
if(KHR_push_descriptor)
{
vkh::cmdPushDescriptorSets(
cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, reflayout, set,
{
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 0, VK_DESCRIPTOR_TYPE_SAMPLER,
{refpushdata.sampler}),
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
{refpushdata.combined}),
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{refpushdata.sampled}),
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
{refpushdata.storage}),
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 4, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
{refpushdata.unitexel}),
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 5, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
{refpushdata.storetexel}),
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 6, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
{refpushdata.unibuf}),
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
{refpushdata.storebuf}),
});
}
VkViewport view = {128, 0, 128, 128, 0, 1};
vkCmdSetViewport(cmd, 0, 1, &view);
vkCmdSetScissor(cmd, 0, 1, &mainWindow->scissor);
vkh::cmdBindVertexBuffers(cmd, 0, {vb.buffer}, {0});
setMarker(cmd, "References");
vkCmdDraw(cmd, 1, 1, 0, 0);
if(KHR_descriptor_update_template && KHR_push_descriptor)
{
setMarker(cmd, "PushTemplReferences");
vkCmdPushDescriptorSetWithTemplateKHR(cmd, refpushtempl, reflayout, set, &refpushtempldata);
vkCmdDraw(cmd, 1, 1, 0, 0);
}
vkCmdEndRenderPass(cmd);
vkEndCommandBuffer(cmd);
Submit(1, 4, {cmd});
vkDeviceWaitIdle(device);
// scribble over the descriptor contents so that initial contents fetch never gets these
// resources that way
vkh::updateDescriptorSets(
device,
{
vkh::WriteDescriptorSet(refdescset, 0, VK_DESCRIPTOR_TYPE_SAMPLER,
{resetrefdata.sampler}),
vkh::WriteDescriptorSet(refdescset, 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
{resetrefdata.combined}),
vkh::WriteDescriptorSet(refdescset, 2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
{resetrefdata.sampled}),
vkh::WriteDescriptorSet(refdescset, 3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
{resetrefdata.storage}),
vkh::WriteDescriptorSet(refdescset, 4, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
{resetrefdata.unitexel}),
vkh::WriteDescriptorSet(refdescset, 5, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
{resetrefdata.storetexel}),
vkh::WriteDescriptorSet(refdescset, 6, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
{resetrefdata.unibuf}),
vkh::WriteDescriptorSet(refdescset, 7, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
{resetrefdata.storebuf}),
vkh::WriteDescriptorSet(refdescset, 8, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
{resetrefdata.unibufdyn}),
vkh::WriteDescriptorSet(refdescset, 9, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
{resetrefdata.storebufdyn}),
});
if(KHR_descriptor_update_template)
vkUpdateDescriptorSetWithTemplateKHR(device, reftempldescset, reftempl, &resetrefdata);
}
// check the rendering with our parameter tests is OK
{
vkDeviceWaitIdle(device);
VkCommandBuffer cmd = GetCommandBuffer();
vkBeginCommandBuffer(cmd, vkh::CommandBufferBeginInfo());
VkImage swapimg =
StartUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
vkCmdClearColorImage(cmd, swapimg, VK_IMAGE_LAYOUT_GENERAL,
vkh::ClearColorValue(0.4f, 0.5f, 0.6f, 1.0f), 1,
vkh::ImageSubresourceRange());
vkCmdBeginRenderPass(
cmd, vkh::RenderPassBeginInfo(mainWindow->rp, mainWindow->GetFB(), mainWindow->scissor),
VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe);
vkCmdSetViewport(cmd, 0, 1, &mainWindow->viewport);
vkCmdSetScissor(cmd, 0, 1, &mainWindow->scissor);
vkh::cmdBindVertexBuffers(cmd, 0, {vb.buffer}, {0});
vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, {descset},
{0, 0});
if(KHR_push_descriptor)
vkCmdPushDescriptorSetKHR(
cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 1, 1,
vkh::WriteDescriptorSet(VK_NULL_HANDLE, 20, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
validBufInfos));
if(KHR_descriptor_update_template && KHR_push_descriptor)
vkCmdPushDescriptorSetWithTemplateKHR(cmd, pushtempl, layout, 1, &pushdata);
vkCmdDraw(cmd, 3, 1, 0, 0);
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, immutpipe);
vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, immutlayout, 0,
{immutdescset}, {});
vkCmdDraw(cmd, 3, 1, 0, 0);
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe2);
vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, layout2, 0, {descset2}, {});
setMarker(cmd, "Color Draw");
vkCmdDraw(cmd, 3, 1, 0, 0);
vkCmdEndRenderPass(cmd);
vkEndCommandBuffer(cmd);
Submit(2, 4, {cmd});
}
// finish with the backbuffer
{
vkDeviceWaitIdle(device);
VkCommandBuffer cmd = GetCommandBuffer();
vkBeginCommandBuffer(cmd, vkh::CommandBufferBeginInfo());
FinishUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
vkEndCommandBuffer(cmd);
Submit(3, 4, {cmd});
}
Present();
}
@@ -614,6 +1080,9 @@ void main()
if(KHR_descriptor_update_template && KHR_push_descriptor)
vkDestroyDescriptorUpdateTemplateKHR(device, pushtempl, NULL);
if(KHR_descriptor_update_template)
vkDestroyDescriptorUpdateTemplateKHR(device, reftempl, NULL);
return 0;
}
};
util/test/demos/vk/vk_test.cpp
+6
View File
@@ -712,6 +712,12 @@ void VulkanGraphicsTest::setName(VkSampler obj, const std::string &name)
setName(VK_OBJECT_TYPE_SAMPLER, (uint64_t)obj, name);
}
template <>
void VulkanGraphicsTest::setName(VkBuffer obj, const std::string &name)
{
setName(VK_OBJECT_TYPE_BUFFER, (uint64_t)obj, name);
}
void VulkanGraphicsTest::setName(VkObjectType objType, uint64_t obj, const std::string &name)
{
if(vkSetDebugUtilsObjectNameEXT)
util/test/tests/Vulkan/VK_Parameter_Zoo.py
+100 -2
View File
@@ -6,14 +6,112 @@ class VK_Parameter_Zoo(rdtest.TestCase):
demos_test_name = 'VK_Parameter_Zoo'
def check_capture(self):
draw = self.get_last_draw()
draw = self.find_draw("Color Draw")
self.check(draw is not None)
draw = draw.previous
draw = draw.next
self.controller.SetFrameEvent(draw.eventId, False)
pipe: rd.PipeState = self.controller.GetPipelineState()
self.check_pixel_value(pipe.GetOutputTargets()[0].resourceId, 0.5, 0.5, [0.0, 1.0, 0.0, 1.0])
# Readback reported extension support
descriptor_update_template = self.find_draw("KHR_descriptor_update_template") is not None
push_descriptor = self.find_draw("KHR_push_descriptor") is not None
# Find the draw that contains resource references
draw = self.find_draw("References")
self.check(draw is not None)
draw = draw.next
self.controller.SetFrameEvent(draw.eventId, False)
vkpipe: rd.VKState = self.controller.GetVulkanPipelineState()
res_names = {}
for res in self.controller.GetResources():
res: rd.ResourceDescription
res_names[res.resourceId] = res.name
expected_binds = [
{'sampname': 'refsamp'},
{'resname': 'refcombinedimg', 'sampname': 'refcombinedsamp'},
{'resname': 'refsampled'},
{'resname': 'refstorage'},
{'resname': 'refunitexel'},
{'resname': 'refstoretexel'},
{'resname': 'refunibuf'},
{'resname': 'refstorebuf'},
{'resname': 'refunibufdyn'},
{'resname': 'refstorebufdyn'},
]
setidx = 0
for descset in vkpipe.graphics.descriptorSets:
descset: rd.VKDescriptorSet
if setidx == 2 and not descset.pushDescriptor:
raise rdtest.TestFailureException("Expected set {} to be a push set",
setidx)
if setidx != 2 and descset.pushDescriptor:
raise rdtest.TestFailureException("Expected set {} to be a non-push set",
setidx)
for bindidx in range(len(descset.bindings)):
sampname = res_names.get(descset.bindings[bindidx].binds[0].samplerResourceId, '!' + str(setidx))
resname = res_names.get(descset.bindings[bindidx].binds[0].resourceResourceId, '!' + str(setidx))
expected_samp = expected_binds[bindidx].get('sampname', '!') + str(setidx)
expected_res = expected_binds[bindidx].get('resname', '!') + str(setidx)
if not sampname == expected_samp:
raise rdtest.TestFailureException(
"Expected binding {} in set {} to have sampler {} but got {}".format(
bindidx, setidx, expected_samp, sampname))
if not resname == expected_res:
raise rdtest.TestFailureException(
"Expected binding {} in set {} to have resource {} but got {}".format(
bindidx, setidx, expected_res, resname))
rdtest.log.success("Resources in set {} were found as expected".format(setidx))
setidx = setidx + 1
# Since we can only have one push descriptor set we have a second draw for push AND template updates
if descriptor_update_template and push_descriptor:
draw = self.find_draw("PushTemplReferences")
self.check(draw is not None)
draw = draw.next
self.controller.SetFrameEvent(draw.eventId, False)
vkpipe: rd.VKState = self.controller.GetVulkanPipelineState()
descset: rd.VKDescriptorSet = vkpipe.graphics.descriptorSets[2]
if not descset.pushDescriptor:
raise rdtest.TestFailureException("Expected set 2 to be a push set")
for bindidx in range(len(descset.bindings)):
sampname = res_names.get(descset.bindings[bindidx].binds[0].samplerResourceId, '!' + str(setidx))
resname = res_names.get(descset.bindings[bindidx].binds[0].resourceResourceId, '!' + str(setidx))
expected_samp = expected_binds[bindidx].get('sampname', '!') + str(setidx)
expected_res = expected_binds[bindidx].get('resname', '!') + str(setidx)
if not sampname == expected_samp:
raise rdtest.TestFailureException(
"Expected binding {} in set {} to have sampler {} but got {}".format(
bindidx, setidx, expected_samp, sampname))
if not resname == expected_res:
raise rdtest.TestFailureException(
"Expected binding {} in set {} to have resource {} but got {}".format(
bindidx, setidx, expected_res, resname))
rdtest.log.success("Resources in push template set were found as expected")
rdtest.log.success("All resources were found as expected")