Different uniforms for different meshes?

[Anshi701]

Let's say i have a pipeline like this:

auto shaderSet = vsg::ShaderSet::create(vsg::ShaderStages{ vertexShader, fragmentShader });
string posName = "inPosition";
string texCoordName = "inTexCoord";
string texName = "texSampler";
string globSettingsName = "GlobalShaderSettings";
string dataPerTileName = "GlobalShaderSettings";
shaderSet->addPushConstantRange("pc", "", VK_SHADER_STAGE_VERTEX_BIT, 0, 128);

shaderSet->addAttributeBinding(posName, "", 0, VK_FORMAT_R64G64B64_SFLOAT, vsg::dvec3Array::create(1));
shaderSet->addAttributeBinding(texCoordName, "", 2, VK_FORMAT_R32G32_SFLOAT, vsg::vec2Array::create(1));

shaderSet->addUniformBinding(texName, "", 0, 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, textureData);
shaderSet->addUniformBinding(globSettingsName, "", 0, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, vsg::Value<GlobalShaderSettings>::create());

shaderSet->addUniformBinding(dataPerTileName, "", 1, 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, vsg::Value<DataPerTile>::create());


graphicsPipelineConfig = vsg::GraphicsPipelineConfigurator::create(shaderSet);
graphicsPipelineConfig->enableArray(posName, VK_VERTEX_INPUT_RATE_VERTEX, sizeof(vsg::dvec3));
graphicsPipelineConfig->enableArray(texCoordName, VK_VERTEX_INPUT_RATE_VERTEX, sizeof(vsg::vec2));
graphicsPipelineConfig->enableTexture(texName);
graphicsPipelineConfig->enableUniform(globSettingsName);
graphicsPipelineConfig->init();

And i have a Group of meshes, created like this:

auto drawCommands = vsg::Commands::create();
drawCommands->addChild(vsg::BindVertexBuffers::create(0, vsg::DataList{ vertices, texcoords }));
drawCommands->addChild(vsg::DrawIndexed::create(indexSize, 1, 0, 0, 0));
auto stateNode = vsg::StateGroup::create();
stateNode->addChild(drawCommands);

This Group have no predefined size and changes very often (adding and deleting meshes). For every mesh a want to have different uniforms (textures for example).
In example project "vsgtexturearray" i saw it's possible to create multiple descriptor bindings:

vsg::DescriptorSetLayoutBindings descriptorBindings{
    {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, numTiles, VK_SHADER_STAGE_VERTEX_BIT, nullptr},  // { binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers}
    {1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, numTiles, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr} // { binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers}
};

but it's not what i want with changing mesh count.
And i found this peace of code in that example:

auto uniformValue = vsg::uintValue::create(tileIndex);
auto uniformBuffer = vsg::DescriptorBuffer::create(uniformValue, 0);

auto uniformDescriptorSet = vsg::DescriptorSet::create(tileSettingsDescriptorSetLayout, vsg::Descriptors{uniformBuffer});
auto uniformBindDescriptorSet = vsg::BindDescriptorSet::create(VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 1, uniformDescriptorSet);

transform->addChild(uniformBindDescriptorSet);
transform->addChild(geometry);
 scenegraph->addChild(transform);

It looks like it doing work a want to achive - bind different uniforms for different meshes. Is code above a correct way of handling situation like this? Or maybee there is another way?
Thank you!

[robertosfield]

You appear to be mixing vsg::ShaderSet/GraphicsPipelneConfigurator usage with rolling your own state and scene graph elements. Normally one uses one or the other.

ShaderSet/GraphicsPipelineConfigurator provides an extensible way of setting up how shader combinations map the state and mesh setup, which is why you'll see it's usage in vsg::Builder and vsgXchange::assimp, you may find it useful to look at how they manage things as they do include sharing state where possible. The use of ShaderSet in these contexts somewhat decouples the shaders you want to use from the scene graph creation so you can inject your own shaders/layouts into scene graph creation code that knows nothing about your shaders.

It's also perfectly fine to just roll your own scene graph elements - I think it's helpful to know how to roll your own even if you eventually choose to use ShaderSet/GraphicsPipelinConfigurator as it provides users with an understanding of the scene graph and how different elements related to each other.

As for using different uniforms and mesh in different combinations, there are many ways to combine things, the best way will depend exactly upon your needs. Your topic starts with a general question then dives off in specific elements of possible implementations, but diving into specific implementations might be premature. It's hard for me to know exactly what you already understand and can do, so pitching an answer at the right level is hard.

In general one puts unfiroms in DescriptorBuffer that are assigned DescriptorSet that are bound to the graphics pipeline via BindDescriporSet(s), which can be placed directly into the scene graph as a child, but often the more flexible way to do so is to assign them to a StateGroup that decorates your mesh subgraphs.

For meshes I would recommend use VertexIndexDraw/VertexDraw as it has lower CPU overhead and more self contained than adding BindVertexBuffers/BindIndexBuffer/DrawIndex commands to a group. There are times when keeping things fine grained make sense but mostly using VertexIndexDraw/VertexDraw will be most convenient and efficient.

You can put multiple mesh subgraphs below a single StateGroup, or have multiple StateGroup that all share the same mesh subgraphs, or any combination.

Again I have to stress how helpful is is to state the task you are trying to achieve to give us context, the scene graph is very flexible and there are many different ways to achieve similar results, not knowing what the end goal is makes it hard from all the different combinations of usage is the one that will best suit your task. Jumping directly into here's the solution I've chosen and need help with is a hindrance to actually help you. It's far better to start with a short succinct post that gives us context to what you want to achieve, then follow up with specifics about what you've done.