Configure a scene graph with different pipelines

[PowerOfNames]

So, I'm curently struggling with the following setup:
I dynamically load models durign runtime (.slt format) using assimp/vsgxchange -> the render perfectly fine alone.
Also, I created a custom grid (just a quad), added a pipeline for a custom shader and got that to work individually as well.

The grid is wrapped ini a stategroup that contains the grid transfrom, vertex/index data and descriptor/pipeline binding calls + DrawIndexed.

The system breaks when I try to add both the model and the grid into the same scene. Checking what vsgXchanges assim produces, I found that that is a CullNOde nontaining a StateGroup node, so that is fine.
Both the grid and the model are just siblings to the scene. But, the system crashes inside vkDrawIndexed with a access violation. So I assume that the bound buffers do not fit the call.

Not sure if that is enough information, but maybe just answer me by telling what steps to be taken to achieve the wanted: Adding different models using different shaders (essentially) into the same scene.
I was under the impression, that just wrapping the different models into stateGroups and adding those as silblings to the scene should be fine, but maybe there is more to it?!

Thanks alot! :)

[robertosfield]

In principle what you are doing is perfectly well supported and done by many other applications. The question is what are doing that is causing the crash. Most likely it'll be related to the code setting up your own rendering subgraph rather than the one loaded from vsgXchange, but there simply isn't enough information to know what is going wrong.

The vsgdynamicload example might be a good one to review as this loads multiple models in a background thread, compiles the subgraph and then merges them with the main scene graph during the update phase. You might need the threading, but might need some of the other elements so it's worth learning about it.

[PowerOfNames]

Wow, thanks for the quick answer.

That example is one of which used as orientation. This is also doing the right things when adding more and more models of the same type to the scene.

It has most definitely something todo with my grid. I also have no experience with scene graphs in general.
It should be fine to post the code, as its still rather small, so maybe it helps:

This function creates the grid pipeline. This is called once during vsg-initialization.

void SetupGridPipeline()
{
	auto gridVertStage = vsg::read("C:\\Coding\\EvaRendererWPF\\Resources\\Shaders\\grid.vert", Options).cast<vsg::ShaderStage>();
	auto gridFragStage = vsg::read("C:\\Coding\\EvaRendererWPF\\Resources\\Shaders\\grid.frag", Options).cast<vsg::ShaderStage>();

	if (!gridVertStage || !gridFragStage)
	{
		std::cout << "Failed to read grid shaders" << std::endl;
		return;
	}
	auto& gridShaderSet /*= Options->shaderSets["pristineGrid"]*/ = vsg::ShaderSet::create();
	gridShaderSet->stages = { gridVertStage, gridFragStage };

	auto shaderCompiler = vsg::ShaderCompiler::create();
	if (shaderCompiler->supported())
	{
		size_t numShadersWithSource = 0;
		for (auto& stage : gridShaderSet->stages)
		{
			if (stage->module->code.empty() && !stage->module->source.empty())
				numShadersWithSource++;
		}

		if (numShadersWithSource == gridShaderSet->stages.size())
		{
			shaderCompiler->compile(gridShaderSet->stages, {}, Options);
		}

		for (auto& stage : gridShaderSet->stages)
		{
			stage->module->source.clear();
		}
	}

	auto descriptorBindings = vsg::DescriptorSetLayoutBindings{
		VkDescriptorSetLayoutBinding{0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr},
	};

	GridDSLayout = vsg::DescriptorSetLayout::create(descriptorBindings);

	//automatically provided by vsg
	vsg::PushConstantRanges pushConstantRanges{
	{VK_SHADER_STAGE_VERTEX_BIT, 0, 128} // projection, view, and model matrices, actual push constant calls automatically provided by the VSG's RecordTraversal
	};

	auto vertexBindingDescriptions = vsg::VertexInputState::Bindings{
		VkVertexInputBindingDescription{0, sizeof(vsg::vec3), VK_VERTEX_INPUT_RATE_VERTEX},		// Position
		VkVertexInputBindingDescription{1, sizeof(vsg::vec2), VK_VERTEX_INPUT_RATE_VERTEX}		// UV
	};
	auto vertexAttributeDescriptions = vsg::VertexInputState::Attributes{
		VkVertexInputAttributeDescription{0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0},
		VkVertexInputAttributeDescription{1, 1, VK_FORMAT_R32G32_SFLOAT, 0}
	};

	auto rasterizationState = vsg::RasterizationState::create();
	rasterizationState->cullMode = VK_CULL_MODE_NONE;

	vsg::GraphicsPipelineStates pipelineStates{
		vsg::VertexInputState::create(vertexBindingDescriptions, vertexAttributeDescriptions),
		vsg::InputAssemblyState::create(),
		rasterizationState,
		vsg::MultisampleState::create(),
		vsg::ColorBlendState::create(),
		vsg::DepthStencilState::create()
	};

	GridPipelineLayout = vsg::PipelineLayout::create(vsg::DescriptorSetLayouts{ GridDSLayout }, pushConstantRanges);
	auto gridPipeline = vsg::GraphicsPipeline::create(GridPipelineLayout, vsg::ShaderStages{ gridVertStage , gridFragStage }, pipelineStates);
	GridBindPipeline = vsg::BindGraphicsPipeline::create(gridPipeline);
}

This function is called during runtime to add a grid to th scene of one window (supporting multi-windows with one scene-per window)

`DLL_EXPORT void AddPristineGrid(WINDOW_HANDLE windowPtr, double scale/* = 1.0*/, double x/* = 0.0*/, double y/* = 0.0*/, double z/* = 0.0*/)
{
	//.. windowData query

	windowData->GridUniform = EvaVSG::GridUniform::create();
	windowData->GridUniform->value().LineWidth = 0.1f;
	windowData->GridUniform->dirty();

	auto gridDescriptor = vsg::DescriptorBuffer::create(windowData->GridUniform, 0, 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
	auto gridDescriptorSet = vsg::DescriptorSet::create(GridDSLayout, vsg::Descriptors{ gridDescriptor });
	auto bindDescriptor = vsg::BindDescriptorSet::create(VK_PIPELINE_BIND_POINT_GRAPHICS, GridPipelineLayout, 0, gridDescriptorSet);

	auto gridStateGroup = vsg::StateGroup::create();
	gridStateGroup->add(GridBindPipeline);
	gridStateGroup->add(bindDescriptor);
	
	auto gridTransform = vsg::MatrixTransform::create();
	gridTransform->matrix = vsg::translate(x, y, z) * vsg::scale(scale);
	gridTransform->addChild(gridStateGroup);
	windowData->GridTransform = gridTransform;

	auto vertices = vsg::vec3Array::create(
		{
			{-0.5f, 0.0f, -0.5f},
			{-0.5f, 0.0f, 0.5f},
			{0.5f, 0.0f, 0.5f},
			{0.5f, 0.0f, -0.5f}
		});
	
	auto normals = vsg::vec3Array::create(
		{
			{0.0f, 1.0f, 0.0f},
			{0.0f, 1.0f, 0.0f},
			{0.0f, 1.0f, 0.0f},
			{0.0f, 1.0f, 0.0f}
		});
	auto texCoords = vsg::vec2Array::create(
	{
		{0.0f, 0.0f},
		{0.0f, 1.0f},
		{1.0f, 1.0f},
		{1.0f, 0.0f}
	});

	auto indices = vsg::ushortArray::create(
		{
			0, 1, 2, 0, 2, 3
		});

	auto drawCommands = vsg::Commands::create();
	drawCommands->addChild(vsg::BindVertexBuffers::create(0, vsg::DataList{ vertices, normals, texCoords }));
	drawCommands->addChild(vsg::BindIndexBuffer::create(indices));
	drawCommands->addChild(vsg::DrawIndexed::create(6, 1, 0, 0, 0));
	
	gridStateGroup->addChild(drawCommands);

	auto result = Viewer->compileManager->compile(gridStateGroup);
	
	if (!result)
	{
		std::cout << "Failed to compile pristine grid state node" << std::endl;
		return;
	}

	Viewer->addUpdateOperation(AddChildOperation::create(Viewer, windowData->GetScene(), gridTransform, result));
}

As I'm still learning how vsg works, so most of my code is just patchwork of the different vsg examples... The issue could lie somewhere else...

PS: scene is just a group node, the setup of one window scene is:
root(vsg::Group)->Scene(vsg::Group)->models

[AnyOldName3]

If you have a multi-line code block, it needs three backticks on the line before and after (with an optional language identifier after the opening backticks). A single backtick on the same line only works for inline code without any line breaks. E.g.

```cpp
int main()
{
    return 0;
}
```

turns into

int main()
{
    return 0;
}

[robertosfield]

I've fixed @PowerOfNames's markdown so the example should be easier to read.

At this point I have too many other tasks to get on with to do fine grained support, I can point folks in the right direction but not hand hold each step of the way.