Sharing vertex arrays with multiple index buffers (each with a different pipeline/shader)?

[theodoregoetz]

I've been using the GraphicsPipelineConfigurator with VertexIndexDraw with great success so far (VSG is excellent by the way). I'm now exploring how to use the same vertex array with multiple index arrays.

As an example, I have quad corners as vertices and two triangles per quad described in the index buffer. I would like to additionally render the edges of the quad (not the triangles) by reusing the same corner vertex data, and only transferring a new set of indices (with a different shader) to the GPU, avoiding the need to transfer the vertex data twice which can be quite large.

It's not obvious to me if VSG's GraphicsPipelineConfigurator supports this case. Any suggestions on the general direction I should take would be most helpful, Thank you!

[timoore]

For your use case, which uses a different pipeline with the different index arrays, the simplest thing to do is to use GraphicsPipelineConfigurator for each pipeline, but with the same data arrays. The arrays will be only transferred to the GPU once; they are in buffers. Then, pass whatever index arrays you want to VertexIndexDraw.

[theodoregoetz]

Just to be clear, do you mean one DataList object with multiple GraphicsPipelineConfigurator objects, each with it's own corresponding VertexIndexDraw which all use the same DataList? Looks like the first configurator will call assignArray() to build up the DataList, then the subsequent configurators will call enableArray() so as to reuse the data. Do I have this right?

[timoore]

I was actually thinking of making the calls to assignArray again in the subsequent uses of GraphicsPipelineConfigurator; it does additional work on the CPU, but doesn't incur any GPU cost. What you describe could be an eventual optimization.

[theodoregoetz]

I found that using the VertexIndexDraw objects with GraphicsPipelineConfigurator::assignArray() and ref_ptr's to arrays always transfers the data and does not attempt to use an already-bound vertex buffer. You can see this by looking at VertexIndexDraw::record() which calls vkCmdBindVertexBuffers without checking to see if the data has already been bound.

To share the vertex array between two different sets of indices and pipelines, I had to break out the VertexIndexDraw into the BindIndexBuffer and DrawIndexed objects:

vsg::DataList vertexArrays{{vertices, colors}};
auto vertexBuffer = vsg::BindVertexBuffers::create(shadeGPC->baseAttributeBinding, vertexArrays);

auto shadeDrawCommands = vsg::Commands::create();
shadeDrawCommands->addChild(vertexBuffer);
shadeDrawCommands->addChild(vsg::BindIndexBuffer::create(indices));
shadeDrawCommands->addChild(vsg::DrawIndexed::create(static_cast<uint32_t>(indices->size()), 1, 0, 0, 0));
shadeStateGroup->addChild(shadeDrawCommands);

auto meshDrawCommands = vsg::Commands::create();
meshDrawCommands->addChild(vertexBuffer);  // shared vertex buffer
meshDrawCommands->addChild(vsg::BindIndexBuffer::create(meshIndices));  // different indices
meshDrawCommands->addChild(vsg::DrawIndexed::create(static_cast<uint32_t>(meshIndices->size()), 1, 0, 0, 0));
meshStateGroup->addChild(meshDrawCommands);  // different pipeline

To conclude with a use case, we are drawing a CAD-like mesh which consists of non-triangle primitives (quads mostly, but also many-sided polygons) and we want to show the surface panels using a triangle list and the polygon edges (not the triangle edges) using the same vertex data but with different connectivity (the indices) as a line list.