Offscreen rendering onto ImGui window

[ankarako]

Hello,

Thanks for the great work so far. I am following the offscreen rendering example (rendertotexture) in order to display the rendered scene onto an imgui window, but it seems that I cannot get it to work. Are there any suggestions on how to get a descriptor set from the offscreen frame buffer attachments?

Thanks for your time!

[robertosfield]

I have never tried it, but my guess is that vsgImGui::Texture could be used with a bit of grafting.

The vsgImGui::Texture constructor is written to handle use of vsg::Data to enable images to be easily assigned, but in the render to texture case you'd need to create a vsgImGui::Texture without any data and just set the Texture::descriptorSet member directly yourself.

The vsgrendertexture example illustrates how you can render to a vsg::Framebuffer then create a DescriptorSet that uses the associated Image/ImageView to enable rendering with this texture in the final 3d window. In ImGui case you'd assign the DescriptorSet to the vsgImGui::Texture::descriptorSet member, then follow the vsgimgui's example code that uses vsgImGui::Texture.

As others might also want to try this in the future, and getting it to work might be a bit tricky what might be useful would be for you to create a new example for vsgExample that does what you want, but if it falls short then others in the community could review the code and make suggestions on how to fix it, then we could merge this new example so we could help future users.

[ankarako]

Thanks for your reply. So I added a piece of code inside the vsgrendertotexture example to create a descriptor set for the images/image views of the created framebuffer. Now, the createOffscreenRenderGraph() function looks like this:

std::tuple<vsg::ref_ptr<vsg::RenderGraph>, vsg::ref_ptr<vsg::DescriptorSet>> create_offscreen_render_graph(vsg::Context& context, const VkExtent2D& extent, vsg::ImageInfo& color_image_info, vsg::ImageInfo& depth_image_info)
{
	auto device = context.device;

	VkExtent3D attachment_extent{ extent.width, extent.height, 1 };

	// Attachments
	// create image for color attachment
	auto color_image = vsg::Image::create();
	color_image->imageType = VK_IMAGE_TYPE_2D;
	color_image->format = VK_FORMAT_R8G8B8A8_UNORM;
	color_image->extent = attachment_extent;
	color_image->mipLevels = 1;
	color_image->arrayLayers = 1;
	color_image->samples = VK_SAMPLE_COUNT_1_BIT;
	color_image->tiling = VK_IMAGE_TILING_OPTIMAL;
	color_image->usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
	color_image->initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	color_image->flags = 0;
	color_image->sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	auto color_image_view = vsg::createImageView(context, color_image, VK_IMAGE_ASPECT_COLOR_BIT);

	// sampler for accessing attachment as a texture
	auto color_sampler = vsg::Sampler::create();
	color_sampler->flags = 0;
	color_sampler->magFilter = VK_FILTER_LINEAR;
	color_sampler->minFilter = VK_FILTER_LINEAR;
	color_sampler->mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
	color_sampler->addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
	color_sampler->addressModeV = color_sampler->addressModeU;
	color_sampler->addressModeW = color_sampler->addressModeU;
	color_sampler->mipLodBias = 0.0f;
	color_sampler->maxAnisotropy = 1.0f;
	color_sampler->borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;

	color_image_info.imageView = color_image_view;
	color_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
	color_image_info.sampler = color_sampler;

	// create depth buffer
	VkFormat depth_format = VK_FORMAT_D32_SFLOAT;
	auto depth_image = vsg::Image::create();
	depth_image->imageType = VK_IMAGE_TYPE_2D;
	depth_image->extent = attachment_extent;
	depth_image->mipLevels = 1;
	depth_image->arrayLayers = 1;
	depth_image->samples = VK_SAMPLE_COUNT_1_BIT;
	depth_image->format = depth_format;
	depth_image->tiling = VK_IMAGE_TILING_OPTIMAL;
	depth_image->usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
	depth_image->initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	depth_image->flags = 0;
	depth_image->sharingMode = VK_SHARING_MODE_EXCLUSIVE;

	// XXX Does layout matter?
	depth_image_info.sampler = nullptr;
	depth_image_info.imageView = vsg::createImageView(context, depth_image, VK_IMAGE_ASPECT_DEPTH_BIT);
	depth_image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;

	// attachment descriptions
	vsg::RenderPass::Attachments attachments(2);

	// color attachment
	attachments[0].format = VK_FORMAT_R8G8B8A8_UNORM;
	attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
	attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
	attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
	attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	attachments[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	attachments[0].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

	// depth attachment
	attachments[1].format = depth_format;
	attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
	attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
	attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
	attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
	attachments[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
	attachments[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

	vsg::AttachmentReference color_reference = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
	vsg::AttachmentReference depth_reference = { 1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL };
	vsg::RenderPass::Subpasses subpass_desc(1);
	subpass_desc[0].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
	subpass_desc[0].colorAttachments.emplace_back(color_reference);
	subpass_desc[0].depthStencilAttachments.emplace_back(depth_reference);

	vsg::RenderPass::Dependencies dependencies(2);

	// XXX This dependency is copied from the 
	dependencies[0].srcSubpass = VK_SUBPASS_EXTERNAL;
	dependencies[0].dstSubpass = 0;
	dependencies[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
	dependencies[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
	dependencies[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
	dependencies[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
	dependencies[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;

	// This is the heart of what make Vulkan offscreen rendering
	// work: render passes that follow are blocked from using this
	// passes' color attachment in their fragment shaders until all
	// this pass' color writes are finished
	dependencies[1].srcSubpass = 0;
	dependencies[1].dstSubpass = VK_SUBPASS_EXTERNAL;
	dependencies[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
	dependencies[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
	dependencies[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
	dependencies[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
	dependencies[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;

	auto offscreen_render_pass = vsg::RenderPass::create(device, attachments, subpass_desc, dependencies);

	// Framebuffer
	auto fbuf = vsg::Framebuffer::create(offscreen_render_pass, vsg::ImageViews{ color_image_info.imageView, depth_image_info.imageView }, extent.width, extent.height, 1);
	auto offscreen_render_graph = vsg::RenderGraph::create();
	offscreen_render_graph->renderArea.offset = VkOffset2D{ 0, 0 };
	offscreen_render_graph->renderArea.extent = extent;
	offscreen_render_graph->framebuffer = fbuf;
	offscreen_render_graph->clearValues.resize(2);
	offscreen_render_graph->clearValues[0].color = { {0.0f, 0.0f, 0.0f} };
	offscreen_render_graph->clearValues[1].depthStencil = VkClearDepthStencilValue{ 0.0f, 0 };

	// This descriptor will be used as the Viewports texture id
	// for imgui.
	// create descriptor set for framebuffer color image
	color_image_info.sampler->compile(context);
	VkSampler vk_sampler = color_image_info.sampler->vk(context.deviceID);

	vsg::DescriptorSetLayoutBindings descriptor_bindings{
		{ 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, &vk_sampler} // {binding, descriptorType, descriptorCount, stageFlages, pImmutableSamplers}
	};

	auto descriptor_set_layout = vsg::DescriptorSetLayout::create(descriptor_bindings);

	auto image_info = vsg::ImageInfo::create(color_image_info.sampler, color_image_info.imageView, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
	auto texture = vsg::DescriptorImage::create(image_info, 0, 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);

	// for some reason ::create() doesn't work here and we explicit use 'new;
	vsg::DescriptorSet* desc_set = new vsg::DescriptorSet(); /* vsg::DescriptorSet::create();*/

	desc_set->setLayout = descriptor_set_layout;
	desc_set->descriptors = vsg::Descriptors{ texture };
	desc_set->compile(context);

	return std::make_tuple(offscreen_render_graph, vsg::ref_ptr<vsg::DescriptorSet>(desc_set));
}

I am using the returned descriptor set as the TextureID for showing the rendered image on an imgui window. However, (apart from the fact that I cannot even see an image corresponding to the clearColor values. I get a validation error about the descriptor set, which I cannot seem to understand why it gets triggered.

VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358(ERROR / SPEC): msgNum: -507995293 - Validation Error: [ VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358 ] Object 0: handle = 0x908683000000001d, type = VK_OBJECT_TYPE_DESCRIPTOR_SET; | MessageID = 0xe1b89b63 | vkCmdBindDescriptorSets(): descriptorSet #0 being bound is not compatible with overlapping descriptorSetLayout at index 0 of VkPipelineLayout 0xf443490000000006[] due to: Immutable samplers from binding 0 in pipeline layout VkDescriptorSetLayout 0xe7f79a0000000005[] do not match the immutable samplers in the layout currently bound (VkDescriptorSetLayout 0xcb1c7c000000001b[]). The Vulkan spec states: Each element of pDescriptorSets must have been allocated with a VkDescriptorSetLayout that matches (is the same as, or identically defined as) the VkDescriptorSetLayout at set n in layout, where n is the sum of firstSet and the index into pDescriptorSets (https://vulkan.lunarg.com/doc/view/1.3.250.0/windows/1.3-extensions/vkspec.html#VUID-vkCmdBindDescriptorSets-pDescriptorSets-00358)
    Objects: 1
        [0] 0x908683000000001d, type: 23, name: NULL

D:\_dev\_projects\immersion-build\volcap\x64\vc19\bin\Debug\volcap.exe (process 50108) exited with code -1.
To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.
Press any key to close this window . . .VUID-vkCmdDrawIndexed-None-02697(ERROR / SPEC): msgNum: -1735852301 - Validation Error: [ VUID-vkCmdDrawIndexed-None-02697 ] Object 0: handle = 0x908683000000001d, type = VK_OBJECT_TYPE_DESCRIPTOR_SET; Object 1: handle = 0xf443490000000006, type = VK_OBJECT_TYPE_PIPELINE_LAYOUT; | MessageID = 0x9888fef3 | vkCmdDrawIndexed(): VkDescriptorSet 0x908683000000001d[] bound as set #0 is not compatible with overlapping VkPipelineLayout 0xf443490000000006[] due to: Immutable samplers from binding 0 in pipeline layout VkDescriptorSetLayout 0xe7f79a0000000005[] do not match the immutable samplers in the layout currently bound (VkDescriptorSetLayout 0xcb1c7c000000001b[]) The Vulkan spec states: For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility (https://vulkan.lunarg.com/doc/view/1.3.250.0/windows/1.3-extensions/vkspec.html#VUID-vkCmdDrawIndexed-None-02697)
    Objects: 2
        [0] 0x908683000000001d, type: 23, name: NULL
        [1] 0xf443490000000006, type: 17, name: NULL

Any suggestions about that?

[robertosfield]

It's hard to debug big blocks of code which are only a portion of whole application, we are left having to guess lots of unknowns. As I said the easiest way to resolve this type of things would be to create a complete vsgExample and post that so others can help see it all and help debug it.

From the code I see a few oddities - passing the Sampler::vk(deviceID) to the DescriptorSetLayoutBindings looks problematic, you are passing the Sampler via the ImageInfo, there isn't any reason to attempt to pass it via the bindings.

The new vsg::DescriptorSet() is bizarre, when you say it doesn't work you'll need to explain what you mean be "doesn't work", it's likely you've got some mis-conception of how things work.

[ankarako]

I definitely have some misconception about some things here and there. Ok i'll keep trying. thanks again.

[robertosfield]

Just following up. Have you made any further progress?

I am thinking that a new example for vsgExamples would be useful as I'm sure others will want to do try something similar to what you want. If you have something suitable to be made into an example, even if it doesn't work fully yet could be a starting place for this example, and such an example could be used to help debug code to get it working. which would in turn help you. Thanks.

[ankarako]

As time is pressing, I moved my project back to OpenGL, as I wouldn't meet my deadline with the learning curve introduced by Vulkan. Maybe I will take up on this again when I need to extend the rendering capabilities of the project I am working on.