How to make OffscreenRendergraph use a custom GraphicsPipeline.

[WdsPjm]

I saw in rendertotexture.cpp that the OffscreenRendergraph will end up creating a rendergraph, and the GraphicsPipeline will end up being saved in the stageGroup, but what if you tie them together.

[robertosfield]

I'm confused but what you've written so can't begin to suggest a solution.

It would be helpful to take a step back and explain what you are trying to achieve, then dive into an explanation of what you've tried so far.

[WdsPjm]

I used vulkan to implement a colorpick feature and now want to try to do the same with vsg.
Now what I'm doing is I'm coloring all the mesHids in the scene in the OffscreenRendergraph, using my own graphicsPipeline

[robertosfield]

What do you mean a "colorpick feature"?

What do you mean by "meshHids"?

What do you mean by "my own graphicsPipeline"?

You might understand what you mean but we're not omnipotent, we can't understand what you are trying to do and what issues you have without telling us.

[WdsPjm]

colorpick works: By assigning a unique color value (or the color corresponding to the object ID) to each mesh in the scene, these colors are then rendered on the OffscreenRendergraph. After the user clicks on a position on the screen, the color of the clicked position in the image rendered by the OffscreenRendergraph is detected, and the value of this color is parsed to determine the mesh selected by the user

And the question I asked to simplify is, what about the OffscreenRendergraph
Use the following code for recoloring the model with the OffscreenRendergraph
vsg::Paths searchPaths = vsg::getEnvPaths("VSG_FILE_PATH");

// load shaders
auto vertexShader = vsg::ShaderStage::read(VK_SHADER_STAGE_VERTEX_BIT, "main", vsg::findFile("shaders/vert_PushConstants.spv", searchPaths));
auto fragmentShader = vsg::ShaderStage::read(VK_SHADER_STAGE_FRAGMENT_BIT, "main", vsg::findFile("shaders/frag_PushConstants.spv", searchPaths));
if (! vertexShader || ! fragmentShader)
{
std::cout << "Could not create shaders." << std::endl;
//return vsg::ref_ptrvsg::Node();
}

// set up graphics pipeline
vsg::DescriptorSetLayoutBindings descriptorBindings{
{0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr} // { binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers}
};

...
...
auto drawCommands = vsg::Commands::create();
drawCommands->addChild(vsg::BindVertexBuffers::create(0, vsg::DataList{vertices, colors, texcoords}));
drawCommands->addChild(vsg::BindIndexBuffer::create(indices));
drawCommands->addChild(vsg::DrawIndexed::create(12, 1, 0, 0, 0));

[robertosfield]

Using colour coded meshes to do picking sounds really awkward and expensive. This type of approach is really old and even when it was first used by some apps it sill wasn't something I would have recommend.

So please take another step back and let us know exactly what you are wanting to achieve, with deciding upon the low level way you've decided to achieve it. Then we can point have more sensible discussion about how to achieve it rather than trying to cobble together something that works but for something shouldn't be done in first place.

[WdsPjm]

1. Go through all the mesh in the scene, assign a unique id to each mesh, and render according to VertexIndexDraw and the assigned unique Id (color) in the OffscreenRendergraph.
2. In the screen rendered by mainRendergraph, when the mouse clicks the model on the screen, the current screen coordinates will be obtained, and the corresponding color(ID) will be found in the image input by OffscreenRendergraph according to the coordinates.
3. According to the ID obtained in 2, the corresponding mesh can be deduced backwards.
4. Highlight the resulting mesh

I have now written a separate Rendergraph that will render according to the vertices in VertexIndexDraw and the assigned unique Id (color). But I don't know how to relate such rendering results to the OffscreenRendergraph.

[robertosfield]

OK, that's your algorithm, but what I'm interested is not the how, but what the end result you are trying to achieve. I believe the how is just heading off in the wrong direction, so I want to end result your application needs.

Clearly it's picking related but what result exactly is required? The node picked? The mesh? The vertex?

[WdsPjm]

Yes, what I want to achieve is picking picking node
Like the one below

[robertosfield]

I'm left guess exactly what you mean, do you mean "use a screen space rectangle to select objects in the scene?"

For that type of work I'd create a PolytopeIntersector class and do the test of the CPU along the lines of the LineSegmentIntersector class. The OSG's has a equivalent class which can be used for this type of operation and works well so implementing something equivalent for the VSG should be possible.

The way you convert a screen space rectangle into a Polytope is to create a Plane for each side of the rectangle with the plan extending into eye space, then transformed into world space/object space. The vsg::LineSegmentIntersector does the equivalent for a point - extending into a line for intersection testing.

One of the benefits of going this approach is that you don't need to modify the scene graph at all, you don't need to create an extra render passes or convoluted ways to encode information that is only used on the CPU, instead the Intersector traversal collects the complete NodePath during traversal and can pinpoint individual vertices/primitives.

It's a far better approach so worth investing the time into learning what is required. The color picking approach is not worth pursuing. Trying to help you do achieving something that is bad solution is a waste of both our time.

[WdsPjm]

I see what you mean. Thank you very much