Can Builder createQuad be used to create a general 4-sided shape?

[RKiserAL]

Is it possible to use Builder createQuad to create a planar 4-sided shape where the opposite sides are not necessarily parallel?

I see that the GeometryInfo class has a parameter named positions and wondered if that could be used to generate a general 4-sided shape.

Thanks in advance,

Bob Kiser

[robertosfield]

Builder::createQuad() builds a regular quad, it's not intended for general geometry creation. The current Builder is written for primitive shapes.

[RKiserAL]

I was wanting general purpose quad shape functionality as I am investigating porting a Finite Element Analysis (FEA) visualization program that I wrote in OSG over to VSG. I was hoping to render a general 3D quad, assigning a different color to each corner and having those colors blended across the element to represent variations in deflection. stress, etc.

I have tried a couple of things already: A) I looked into the post from Carl Sandstrom about a muilti-colored triangle and B) looked into modifying/simplifying the vsgdraw example. For A, I am not talented enough to fill in the gaps. For B, I tried to comment out the functionality that I didn't need but ended up with either a program that crashed or drew mostly black polygons (of the correct shape) with odd-looking triangles of a color I didn't want. They appeared to be invisible when viewed from the backside. Obviously, I don't have a good understanding of what is going on in that example. There's a lot to unpack, even in that short example.

I was hoping that you could guide me on this. Also, what do you think of the idea of adding a new example similar to the vsgdraw one that showed how to create a general 3D quad dithered with color, but without texturing? That might make a nice "building block" example for those who need something a bit more flexible than the standard primitive shapes already provided.

Thanks in advance,

Bob Kiser

[robertosfield]

Writing examples on demand for free would be lovely for everyone except I'd never have time do anything else/earn a living.

If the backside of your triangle is not visible then this will likely be back facing culling that is one by default. Face culling is controlled by the vsg::RasterizationState object that is used when setting up the vsg::GraphicsPipeline. The class is:

https://github.com/vsg-dev/VulkanSceneGraph/blob/master/include/vsg/state/RasterizationState.h

The Vulkan state this is associated with is:

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html

The cullingFlag propery is the one you'll want to set:

The available options are:

https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkCullModeFlagBits.html

You'll want to do something like:

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

If we you really want an example but can't get it working then perhaps create the example for vsgExamples and post it as a PR to vsgExamples. Then others in the community can have a look over it, fix the issues, then everyone can benefit for a usable example and you benefit from help from others.

[RobertKiser]

Hello again Mr. Osfield

I took your clue (from above) and married it to a very cut-down copy of the example: vsggraphicspipelineconfigurator.cpp to get much closer to my ultimate goal of an general planar quad with colors dithered from the 4 corners. I tried to remove everything that was not critical to getting the general quad shown. (My code is below.)

So now I can see the quad in 3D space where I want it and the front face is dithered like I want it and the back face is now visible, but black. I don't understand what I need to do to get the dithering to show up when viewed from the back side, like it is when viewed from the front side.

If I am not abusing your good nature, can you offer a clue about how to handle dithering on the back face?

When I get this working, perhaps a candidate for the Examples folder.

Thanks in advance,

Bob Kiser

Here is the code I have thus far:

`#include
#include <vsg/all.h>

int main(int argc, char** argv)
{
auto options = vsg::Options::create();
options->paths = vsg::getEnvPaths("VSG_FILE_PATH");

auto windowTraits = vsg::WindowTraits::create();

vsg::ref_ptr<vsg::ShaderSet> shaderSet = vsg::createPhongShaderSet(options);

auto scenegraph = vsg::Group::create();

auto graphicsPipelineConfig = vsg::GraphicsPipelineConfigurator::create(shaderSet);


// set up pass of material
auto mat = vsg::PhongMaterialValue::create();

// mat->value().diffuse.set(1.0f, 1.0f, 1.0f, 1.0f);

vsg::Descriptors descriptors;
graphicsPipelineConfig->assignUniform(descriptors, "material", mat);

//********************************
//	describe the looks of the quad
//********************************

auto vertices = vsg::vec3Array::create(
	{ 
	{1.0f, 1.0f, 1.0f},
	{2.0f, 1.0f, 1.0f},
	{3.0f, 2.0f, 2.0f},
	{0.0f, 2.0f, 2.0f}
	});

auto normals = vsg::vec3Array::create(
	{
	{0.0f, -0.7017f, 0.7071f},
	{0.0f, -0.7071f, 0.7071f},
	{0.0f, -0.7071f, 0.7071f},
	{0.0f, -0.7071f, 0.7071f}
	});

auto colors = vsg::vec4Array::create(
	{
	{0.0f, 0.0f, 1.0f, 1.0f},
	{1.0f, 0.0f, 0.0f, 1.0f},
	{0.0f, 1.0f, 0.0f, 1.0f},
	{1.0f, 1.0f, 1.0f, 1.0f}
	});

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

//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
auto rasterizationState = vsg::RasterizationState::create();
rasterizationState->cullMode = VK_CULL_MODE_NONE; // added as per Mr. Osfield so rendering is visible from behind

graphicsPipelineConfig->rasterizationState = rasterizationState;

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

vsg::DataList vertexArrays;

graphicsPipelineConfig->assignArray(vertexArrays, "vsg_Vertex", VK_VERTEX_INPUT_RATE_VERTEX, vertices);
graphicsPipelineConfig->assignArray(vertexArrays, "vsg_Normal", VK_VERTEX_INPUT_RATE_VERTEX, normals);
graphicsPipelineConfig->assignArray(vertexArrays, "vsg_Color", VK_VERTEX_INPUT_RATE_VERTEX, colors);

// setup geometry
auto drawCommands = vsg::Commands::create();
drawCommands->addChild(vsg::BindVertexBuffers::create(graphicsPipelineConfig->baseAttributeBinding, vertexArrays));
drawCommands->addChild(vsg::BindIndexBuffer::create(indices));
drawCommands->addChild(vsg::DrawIndexed::create(8, 1, 0, 0, 0));

// register the ViewDescriptorSetLayout.
vsg::ref_ptr<vsg::ViewDescriptorSetLayout> vdsl = vsg::ViewDescriptorSetLayout::create();

graphicsPipelineConfig->additionalDescriptorSetLayout = vdsl;

graphicsPipelineConfig->init();

auto descriptorSet = vsg::DescriptorSet::create(graphicsPipelineConfig->descriptorSetLayout, descriptors);

auto bindDescriptorSet = vsg::BindDescriptorSet::create(VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipelineConfig->layout, 0, descriptorSet);

auto bindViewDescriptorSets = vsg::BindViewDescriptorSets::create(VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipelineConfig->layout, 1);

// create StateGroup as the root of the scene/command graph to hold the GraphicsProgram, and binding of Descriptors to decorate the whole graph
auto stateGroup = vsg::StateGroup::create();

stateGroup->add(graphicsPipelineConfig->bindGraphicsPipeline);
stateGroup->add(bindDescriptorSet);
stateGroup->add(bindViewDescriptorSets);


// set up model transformation node
auto transform = vsg::MatrixTransform::create();

// add drawCommands to StateGroup
stateGroup->addChild(drawCommands);

transform->addChild(stateGroup);

scenegraph->addChild(transform);



// create the viewer and assign window(s) to it
auto viewer = vsg::Viewer::create();

auto window = vsg::Window::create(windowTraits);
if (!window)
{
	std::cout << "Could not create windows." << std::endl;
	return 1;
}

viewer->addWindow(window);

vsg::ComputeBounds computeBounds;
scenegraph->accept(computeBounds);

vsg::dvec3 centre = (computeBounds.bounds.min + computeBounds.bounds.max) * 0.5;

// camera related details
auto viewport = vsg::ViewportState::create(0, 0, window->extent2D().width, window->extent2D().height);
auto perspective = vsg::Perspective::create(60.0, static_cast<double>(window->extent2D().width) / static_cast<double>(window->extent2D().height), 0.01, 100.0);
auto lookAt = vsg::LookAt::create(centre + vsg::dvec3(0.0, -10.0, 0.0), centre, vsg::dvec3(0.0, 0.0, 1.0));
auto camera = vsg::Camera::create(perspective, lookAt, viewport);

auto commandGraph = vsg::createCommandGraphForView(window, camera, scenegraph);
viewer->assignRecordAndSubmitTaskAndPresentation({ commandGraph });

// compile the Vulkan objects
viewer->compile();

// assign a CloseHandler to the Viewer to respond to pressing Escape or press the window close button
viewer->addEventHandlers({ vsg::CloseHandler::create(viewer) });

viewer->addEventHandler(vsg::Trackball::create(camera));

// main frame loop
while (viewer->advanceToNextFrame())
{
	// pass any events into EventHandlers assigned to the Viewer
	viewer->handleEvents();

	viewer->update();

	viewer->recordAndSubmit();

	viewer->present();
}

// clean up done automatically thanks to ref_ptr<>
return 0;

}`

[robertosfield]

I am away from my dev system so can't test the example. but my best guess for the back face appearing black is that it's not lit because the normal is facing away from the light source. The Pbr & Phong shaders have two sided lighting code paths that you can enable by setting the appropriate #define when configuring the use of the SHaderSet. I can't provide an example of this/exact naming of the define off the top of my head, so will have to wait till tomorrow when I'm back at my dev system.