Dynamically submit color arrays and switch pipelines

[zhuzhiyong8679]

Hello everyone, when I created a StateGroup and added it to the scene, I want to change the color of the overall point cloud and use the corresponding FragShader, so can I dynamically change the drawCommand and bindGraphicsPipeline in the stateGroup? Although I find that there are similar cases vsgdynamicvertex, it seems that it is faster to call a higher color of each point and then call the dirty to resubmit the entire colorArray to the GPU. Do you have any better solutions ? QwQ

[robertosfield]

What do you mean by higher color? Could you mean a material property?

What shaders are you using? Your own or one of the built-in shaders? The later have a material structs that are passed via vsg::DescriptorBuffer, just like we arrays you can mark the associated data as dynamic and dirty the data in the same way.

[zhuzhiyong8679]

Hi Robert , About "higher color " was my mistake . I use my shaders like this.

std::string PointCloudVERT{ R"(
#version 450
#extension GL_ARB_separate_shader_objects : enable
#pragma enable_d3d11_debug_symbols 
layout(push_constant) uniform PushConstants {
    mat4 projection;
    mat4 modelview;
} pc;

layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 2) in float intensity;

layout(location = 1) out vec3 out_Color; 
layout(set = 0 ,binding = 0) uniform IntensityParam
{
	float showItensity; //0 show Intensity ,1  show Color ,2 show inPosition.z converted to color 
	float minIntensity;
	float maxIntensity;
	float maxZ; 
	float minZ;
	
}intensityParam;

out gl_PerVertex {
    vec4 gl_Position;
float gl_PointSize;
};

void main() {
    gl_Position = (pc.projection * pc.modelview) * vec4(inPosition, 1.0);
    gl_PointSize = 4.0;

	if(intensityParam.showItensity==0)
	{
		out_Color= vec3(intensity/intensityParam.maxIntensity,intensity/intensityParam.maxIntensity,intensity/intensityParam.maxIntensity);
	}else if(intensityParam.showItensity==1)
	{
		out_Color=inColor;
	}
	else
	{
                //usg inPosition.z convert to color
		float zToColor=(inPosition.z-intensityParam.minZ)/(intensityParam.maxZ-intensityParam.minZ);
		out_Color=vec3(zToColor,zToColor,zToColor);
	}
}
)" };

std::string PointCloudFRAG{ R"(
#version 450
#extension GL_ARB_separate_shader_objects : enable
layout(location = 1) in vec3 moutColor;
layout(location = 0) out vec4 outColor;
void main() { 
	outColor=vec4(moutColor,1.0);
}
)" };

In fact, I would like to dynamically change the color of the point cloud, such as displaying it by color, displaying it by intensity, or displaying it by converting the coordinate Z to color. What I am currently doing is passing a Uniform into the shader and using the intensityParam.showIntensity method to determine what to display. I use a loop to retrieve the intensityParam pointer and dirty the showIntensity variable to dynamically update it. The problem now is that I am not sure whether I should perform the operations of converting intensity or Z coordinate to color in the shader or only pass the coordinates and colors to the shader, and then calculate the color data and dirty the ColorArray (since the number of point clouds is large, this will definitely be slow). I cannot decide which approach would allow me to change the color of points in the scene faster.

[zhuzhiyong8679]

I have considered that when the amount of point cloud data is large, 1: using simple shaders and dynamic dirty data, the frame rate will decrease at the moment of rendering, but it will return to normal frame rate after a short period of time; 2: When using more complex shaders, passing in some control switches through uniform and using if else statements in shaders seems to waste more time. Under normal circumstances, in big data point clouds, although dynamic switching does not cause frame rate fluctuations, it seems that the frame rate will be lower than the first situation. I am not an expert, and I am not sure how much image a shader with a lot of judgment will produce when dealing with large amounts of data.

[robertosfield]

Looking at your shader, it looks to me like you could update the IntensityParam uniform per frame and should perform well. Having conditionals in the vertex shader might be performance bottleneck but I think modern hardware is so fast you'll be probably be limited more by memory bandwidth reading all the vertex data.

What you set up the vsg::DescriptorBuffer to pass the IntensityParam uniform you should just need to set up the data's property.dataVariance to vsg::DYNAMIC_DATA, then call dirty() on the data when you update it.

Have a look at the vsgExamples that set up DYNAMIC_DATA, they do it with different data, for vertex arrays, to textures to uniforms:

./examples/volume/vsgvolume/vsgvolume.cpp:        data->properties.dataVariance = vsg::DYNAMIC_DATA;
./examples/state/vsgcomputevertex/vsgcomputevertex.cpp:    computeScale->properties.dataVariance = vsg::DYNAMIC_DATA;
./examples/state/vsgdynamictexture_cs/vsgdynamictexture_cs.cpp:    textureData->properties.dataVariance = vsg::DYNAMIC_DATA;
./examples/state/vsgdynamictexture/vsgdynamictexture.cpp:    vsg::DataVariance dataVariance = vsg::DYNAMIC_DATA;
./examples/state/vsgdynamictexture/vsgdynamictexture.cpp:        dataVariance = vsg::STATIC_DATA;
./examples/state/vsgdynamictexture/vsgdynamictexture.cpp:        dataVariance = vsg::DYNAMIC_DATA_TRANSFER_AFTER_RECORD;
./examples/state/vsgdynamictexture/vsgdynamictexture.cpp:        textureData->properties.dataVariance = dataVariance;
./examples/state/vsgdynamictexture/vsgdynamictexture.cpp:        textureData->properties.dataVariance = dataVariance;
./examples/state/vsgdynamictexture/vsgdynamictexture.cpp:        textureData->properties.dataVariance = dataVariance;
./examples/state/vsgtexturearray/vsgtexturearray.cpp:        if (update) textureData->properties.dataVariance = vsg::DYNAMIC_DATA;
./examples/state/vsgdynamicvertex/vsgdynamicvertex.cpp:        vsg::DataVariance dataVariance = vsg::DYNAMIC_DATA;
./examples/state/vsgdynamicvertex/vsgdynamicvertex.cpp:            dataVariance = vsg::STATIC_DATA;
./examples/state/vsgdynamicvertex/vsgdynamicvertex.cpp:            dataVariance = vsg::DYNAMIC_DATA_TRANSFER_AFTER_RECORD;
./examples/state/vsgdynamicvertex/vsgdynamicvertex.cpp:            vertices->properties.dataVariance = dataVariance;
./examples/state/vsgdynamicvertex/vsgdynamicvertex.cpp:                if (dataVariance == vsg::STATIC_DATA)
./examples/state/vsgclip/vsgclip.cpp:        eyeClipSettings->properties.dataVariance = vsg::DYNAMIC_DATA;
./examples/raytracing/vsgraytracing/vsgraytracing.cpp:        raytracingUniform->properties.dataVariance = vsg::DataVariance::DYNAMIC_DATA;
./examples/nodes/vsgtextureprojection/vsgtextureprojection.cpp:    texgenMatrices->properties.dataVariance = vsg::DYNAMIC_DATA;

[zhuzhiyong8679]

Thanks for your answer, although I have tried both methods, I agree more with you that it is inefficient to use a traverser to change a large amount of data when there is a large amount of data.