Assign different shaders to the child nodes of the model

[WdsPjm]

In the vsgclip.cpp demo, I saw that a shader can be reassigned to the model. code show as below. model->accept(*replaceState);

If the model is a car, I want to assign another new shader to CarWheeel (change the color to red), you can execute CarWheeel->accept(*replaceStateRed);

Does this logic support in vsg?

[robertosfield]

One wouldn't normally replace a graphics pipeline state just to change colour, the proper way to do it would be to change the colour arrays associated with the geometry or change a material descriptor.

[WdsPjm]

I want to implement the mouse click on the node of the model to set the node to the highlighted state. As mentioned above, click on the wheel node of the car model and set the wheel to the highlighted state (red). I have tested that it is possible to switch the pipeline state (change the color) of the entire model.

[timoore]

I want to implement the mouse click on the node of the model to set the node to the highlighted state. As mentioned above, click on the wheel node of the car model and set the wheel to the highlighted state (red). I have tested that it is possible to switch the pipeline state (change the color) of the entire model.

A more idiomatic way to do that is to use a StateSwitch command, which lets you choose e.g. one of several BindGraphicsPipeline commands based on a mask value.

A more advanced way to implement highlighting is to build the highliting logic into your shader and store the hightlighting flag variable in a uniform buffer that's bound in a buffer above the whole model (in a StateGroup node).

[WdsPjm]

I have now implemented a module state switching model->accept(*replaceState), my question is whether this switching method supports the child nodes of the model, as above, whether it supports a certain child node of the model to do this state switching. For example node->accept(*replaceState)

[robertosfield]

The VSG supports state inheritance/overriding via the vsg::StateGroup class, so it should be possible to decorate just the children you want to change the state for by inserting a StateGroup above them.

A custom "Highlight" node might be the best way, and have this push/pope state or implement a multi-pass effect to do the highlighting.

[WdsPjm]

Hello, Robert Sfield

I'm not sure now if I did the right thing. I combined vsgintersection.cpp demo and clip.cpp demo. Then, after picking mesh, highlight (
auto tmpNode = vsg::Node::create(*node);
tmpNode->accept(*replaceStateGreen);
viewer->compile();) .

But it didn't work. Below is the code I tested, can you give me some comments?

#include <vsg/all.h>

#ifdef vsgXchange_FOUND

include <vsgXchange/all.h>

#endif

#include
#include<vsgXchange/all.h>

auto viewer = vsg::Viewer::create();
vsg::ref_ptrvsg::GraphicsPipeline graphicsPipelineOld;
bool testB = false;
auto options = vsg::Options::create();
vsg::ref_ptrvsg::Node model;
std::string pickName = "";
int indexNumber = 0;
int indextest = 0;
int indexVertex = 0;

class ReplaceState : public vsg::Inherit<vsg::Visitor, ReplaceState>
{
public:
vsg::ref_ptrvsg::GraphicsPipeline graphicsPipeline;

ReplaceState(vsg::ref_ptr<vsg::GraphicsPipeline> gp) :
    graphicsPipeline(gp) {}

void apply(vsg::Object& object) override
{
    object.traverse(*this);
}

void apply(vsg::StateGroup& sg) override
{
    for (auto& sc : sg.stateCommands) sc->accept(*this);

    sg.traverse(*this);
}

void apply(vsg::BindGraphicsPipeline& bgp) override
{
    if (!testB)
    {
        graphicsPipelineOld = bgp.pipeline;
        testB = true;
    }

    bgp.pipeline = graphicsPipeline;
}

};

void test(vsg::ref_ptr inReplaceState,vsg::ref_ptrvsg::Node inModel,vsg::ref_ptrvsg::Viewer inViewer)
{

// auto replaceStateTest = ReplaceState::create(graphicsPipelineOld);

inModel->accept(*inReplaceState);
inViewer->compile();

}

vsg::ref_ptr createHightLightPipline(vsg::ref_ptrvsg::Options& inOptions)
{
vsg::Path vertexShaderFilenameGreen("shaders/clipGreen.vert");
vsg::Path fragmentShaderFilenameGreen("shaders/clipGreen.frag");

auto vertexShaderGreen = vsg::read_cast<vsg::ShaderStage>(vertexShaderFilenameGreen, inOptions);
auto fragmentShaderGreen = vsg::read_cast<vsg::ShaderStage>(fragmentShaderFilenameGreen, inOptions);

auto shaderStagesGreen = vsg::ShaderStages{vertexShaderGreen, fragmentShaderGreen};

// set up graphics pipeline
vsg::DescriptorSetLayoutBindings baseTexture_descriptorBindings{
    {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr} // { binding, descriptorTpe, descriptorCount, stageFlags, pImmutableSamplers}
};

auto baseTexture_descriptorSetLayout = vsg::DescriptorSetLayout::create(baseTexture_descriptorBindings);

vsg::DescriptorSetLayoutBindings clipSettings_descriptorBindings{
    {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr}, // ClipSettings uniform
};

auto clipSettings_descriptorSetLayout = vsg::DescriptorSetLayout::create(clipSettings_descriptorBindings);

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 DispatchTraversal
};

vsg::VertexInputState::Bindings vertexBindingsDescriptions{
    VkVertexInputBindingDescription{0, sizeof(vsg::vec3), VK_VERTEX_INPUT_RATE_VERTEX}, // vertex data
    VkVertexInputBindingDescription{1, sizeof(vsg::vec3), VK_VERTEX_INPUT_RATE_VERTEX}, // colour data
    VkVertexInputBindingDescription{2, sizeof(vsg::vec2), VK_VERTEX_INPUT_RATE_VERTEX}  // tex coord data
};

vsg::VertexInputState::Attributes vertexAttributeDescriptions{
    VkVertexInputAttributeDescription{0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0}, // vertex data
    VkVertexInputAttributeDescription{1, 1, VK_FORMAT_R32G32B32_SFLOAT, 0}, // colour data
    VkVertexInputAttributeDescription{2, 2, VK_FORMAT_R32G32_SFLOAT, 0}     // tex coord data
};

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

auto pipelineLayout = vsg::PipelineLayout::create(vsg::DescriptorSetLayouts{baseTexture_descriptorSetLayout, clipSettings_descriptorSetLayout}, pushConstantRanges);
// auto graphicsPipeline = vsg::GraphicsPipeline::create(pipelineLayout, vsg::ShaderStages{vertexShader, fragmentShader}, pipelineStates);

auto graphicsPipelineGreen = vsg::GraphicsPipeline::create(pipelineLayout, vsg::ShaderStages{vertexShaderGreen, fragmentShaderGreen}, pipelineStates);
auto replaceStateGreen = ReplaceState::create(graphicsPipelineGreen);

return replaceStateGreen;

}

vsg::ref_ptr replaceStateGreen;

vsg::ref_ptr replaceStateTest;

//replaceStateGreen = createHightLightPipline(options);
//model->accept(*replaceStateGreen);

// replaceStateTest = ReplaceState::create(graphicsPipelineOld);

class IntersectionHandler : public vsg::Inherit<vsg::Visitor, IntersectionHandler>
{
public:
vsg::GeometryInfo geom;
vsg::StateInfo state;

vsg::ref_ptr<vsg::Builder> builder;
vsg::ref_ptr<vsg::Options> options;
vsg::ref_ptr<vsg::Camera> camera;
vsg::ref_ptr<vsg::Group> scenegraph;
vsg::ref_ptr<vsg::EllipsoidModel> ellipsoidModel;
double scale = 1.0;
bool verbose = true;

IntersectionHandler(vsg::ref_ptr<vsg::Builder> in_builder, vsg::ref_ptr<vsg::Camera> in_camera, vsg::ref_ptr<vsg::Group> in_scenegraph, vsg::ref_ptr<vsg::EllipsoidModel> in_ellipsoidModel, double in_scale, vsg::ref_ptr<vsg::Options> in_options) :
    builder(in_builder),
    options(in_options),
    camera(in_camera),
    scenegraph(in_scenegraph),
    ellipsoidModel(in_ellipsoidModel),
    scale(in_scale)
{
    builder->verbose = verbose;
    if (scale > 10.0) scale = 10.0;
}

void apply(vsg::KeyPressEvent& keyPress) override
{
    if (lastPointerEvent)
    {
        intersection(*lastPointerEvent);
        if (!lastIntersection) return;

        vsg::info("keyPress.keyModifier = ", keyPress.keyModifier, " keyPress.keyBase = ", keyPress.keyBase);

        geom.dx.set(scale, 0.0f, 0.0f);
        geom.dy.set(0.0f, scale, 0.0f);
        geom.dz.set(0.0f, 0.0f, scale);

        if (keyPress.keyModifier == vsg::MODKEY_Control)
        {
            // when we press the ctrl key we want to enable billboard of the created shapes
            state.billboard = true;

            // when billboard the position is pivot point in local cooridnates
            geom.position.set(0.0f, 0.0f, 0.0f);

            // the position is set by positions data, in this case just one poistion so use a vec4Value, but we can if need use a array of positions
            auto pos = vsg::vec3(lastIntersection->worldIntersection);
            geom.positions = vsg::vec4Value::create(vsg::vec4(pos.x, pos.y, pos.z, scale*5.0)); // x,y,z and scaleDistance
        }
        else
        {
            geom.position = vsg::vec3(lastIntersection->worldIntersection);
        }

        if (keyPress.keyBase == 'b')
        {
            scenegraph->addChild(builder->createBox(geom, state));
        }
        else if (keyPress.keyBase == 'q')
        {
            scenegraph->addChild(builder->createQuad(geom, state));
        }
        else if (keyPress.keyBase == 'c')
        {
            scenegraph->addChild(builder->createCylinder(geom, state));
        }
        else if (keyPress.keyBase == 'p')
        {
            scenegraph->addChild(builder->createCapsule(geom, state));
        }
        else if (keyPress.keyBase == 's')
        {
            scenegraph->addChild(builder->createSphere(geom, state));
        }
        else if (keyPress.keyBase == 'n')
        {
            scenegraph->addChild(builder->createCone(geom, state));
        }
        else if (keyPress.keyBase == 'o')
        {
            vsg::write(scenegraph, "builder.vsgt");
        }
    }

    if (state.billboard)
    {
        // switch off billboarding so other shapes aren't affected.
        state.billboard = false;
        geom.positions = {};
    }
}

void apply(vsg::ButtonPressEvent& buttonPressEvent) override
{
    lastPointerEvent = &buttonPressEvent;

    if (buttonPressEvent.button == 1)
    {
        intersection(buttonPressEvent);
    }
}

void apply(vsg::PointerEvent& pointerEvent) override
{
    lastPointerEvent = &pointerEvent;
}




void intersection(vsg::PointerEvent& pointerEvent)
{
    auto intersector = vsg::LineSegmentIntersector::create(*camera, pointerEvent.x, pointerEvent.y);
    scenegraph->accept(*intersector);

 //   if (verbose) std::cout << "intersection(" << pointerEvent.x << ", " << pointerEvent.y << ") " << intersector->intersections.size() << ")" << std::endl;

    if (intersector->intersections.empty()) return;

    // sort the intersectors front to back
    std::sort(intersector->intersections.begin(), intersector->intersections.end(), [](auto& lhs, auto& rhs) { return lhs->ratio < rhs->ratio; });

     bool findResult = false;
    for (auto& intersection : intersector->intersections)
    {
        if (verbose)
        {
            std::string name;
           
            for (auto& node : intersection->nodePath)
            {
                auto numbetest = intersection->nodePath.size();
              
                if (node->getValue("name", name) && (node->className() == "vsg::VertexIndexDraw"))
                {
                    std::cout << ":name=" << name<<std::endl;
                    findResult = true;
                    pickName = name;
                    

                    auto tmpNode = vsg::Node::create(*node);
                    tmpNode->accept(*replaceStateGreen);
                    viewer->compile();
        
                }
  
            }

        }
        if (findResult)
        {
            break;
        }
    }

    lastIntersection = intersector->intersections.front();
}

protected:
vsg::ref_ptrvsg::PointerEvent lastPointerEvent;
vsg::ref_ptrvsg::LineSegmentIntersector::Intersection lastIntersection;
};

int main(int argc, char** argv)
{
// set up defaults and read command line arguments to override them
/* auto options = vsg::Options::create();*/
options->paths = vsg::getEnvPaths("VSG_FILE_PATH");
options->sharedObjects = vsg::SharedObjects::create();

auto windowTraits = vsg::WindowTraits::create();
windowTraits->windowTitle = "vsginteresction";

auto builder = vsg::Builder::create();
builder->options = options;

// set up defaults and read command line arguments to override them
vsg::CommandLine arguments(&argc, argv);
windowTraits->debugLayer = arguments.read({"--debug", "-d"});
windowTraits->apiDumpLayer = arguments.read({"--api", "-a"});
if (arguments.read({"--fullscreen", "--fs"})) windowTraits->fullscreen = true;
if (arguments.read({"--window", "-w"}, windowTraits->width, windowTraits->height)) { windowTraits->fullscreen = false; }
auto pointOfInterest = arguments.value(vsg::dvec3(0.0, 0.0, std::numeric_limits<double>::max()), "--poi");
auto horizonMountainHeight = arguments.value(0.0, "--hmh");
vsg::Path textureFile = arguments.value<std::string>("", "-t");

if (arguments.errors()) return arguments.writeErrorMessages(std::cerr);
windowTraits->width = 200;
windowTraits->height = 200;

#ifdef vsgXchange_all
// add vsgXchange's support for reading and writing 3rd party file formats
options->add(vsgXchange::all::create());
#endif

auto scene = vsg::Group::create();
vsg::ref_ptr<vsg::EllipsoidModel> ellipsoidModel;

// if (argc > 1)
// {
vsg::Path filename = "E:\vsg\vsgExamples\data\models\Buggy.gltf";// arguments[1];
//vsg::Path filename = "E:\vsg\vsgExamples\data\models\cube.gltf"; // arguments[1];
model = vsg::read_castvsg::Node(filename, options);
if (model)
{
scene->addChild(model);
ellipsoidModel = model->getRefObjectvsg::EllipsoidModel("EllipsoidModel");
}
// }

vsg::StateInfo stateInfo;

if (textureFile)
{
    stateInfo.image = vsg::read_cast<vsg::Data>(textureFile, options);
}

if (scene->children.empty())
{
    vsg::GeometryInfo info;
    info.dx.set(100.0f, 0.0f, 0.0f);
    info.dy.set(0.0f, 100.0f, 0.0f);
    info.dz.set(0.0f, 0.0f, 100.0f);
    scene->addChild(builder->createBox(info, stateInfo));
}

// 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::ref_ptr<vsg::LookAt> lookAt;

// compute the bounds of the scene graph to help position camera
vsg::ComputeBounds computeBounds;
scene->accept(computeBounds);
double radius = vsg::length(computeBounds.bounds.max - computeBounds.bounds.min) * 0.6;
if (pointOfInterest[2] != std::numeric_limits<double>::max())
{
    if (ellipsoidModel)
    {
        auto ecef = ellipsoidModel->convertLatLongAltitudeToECEF({pointOfInterest[0], pointOfInterest[1], 0.0});
        auto ecef_normal = vsg::normalize(ecef);

        vsg::dvec3 centre = ecef;
        vsg::dvec3 eye = centre + ecef_normal * pointOfInterest[2];
        vsg::dvec3 up = vsg::normalize(vsg::cross(ecef_normal, vsg::cross(vsg::dvec3(0.0, 0.0, 1.0), ecef_normal)));

        // set up the camera
        lookAt = vsg::LookAt::create(eye, ecef, up);
    }
    else
    {
        vsg::dvec3 eye = pointOfInterest;
        vsg::dvec3 centre = eye - vsg::dvec3(0.0, -radius * 3.5, 0.0);
        vsg::dvec3 up = vsg::dvec3(0.0, 0.0, 1.0);

        // set up the camera
        lookAt = vsg::LookAt::create(eye, centre, up);
    }
}
else
{
    // set up the camera
    vsg::dvec3 centre = (computeBounds.bounds.min + computeBounds.bounds.max) * 0.5;
    lookAt = vsg::LookAt::create(centre + vsg::dvec3(0.0, -radius * 3.5, 0.0), centre, vsg::dvec3(0.0, 0.0, 1.0));
}

double nearFarRatio = 0.001;
vsg::ref_ptr<vsg::ProjectionMatrix> perspective;
if (ellipsoidModel)
{
    perspective = vsg::EllipsoidPerspective::create(lookAt, ellipsoidModel, 30.0, static_cast<double>(window->extent2D().width) / static_cast<double>(window->extent2D().height), nearFarRatio, horizonMountainHeight);
}
else
{
    perspective = vsg::Perspective::create(30.0, static_cast<double>(window->extent2D().width) / static_cast<double>(window->extent2D().height), nearFarRatio * radius, radius * 4.5);
}

auto camera = vsg::Camera::create(perspective, lookAt, vsg::ViewportState::create(window->extent2D()));

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

// add close handler to respond the close window button and pressing escape
viewer->addEventHandler(vsg::CloseHandler::create(viewer));

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

auto intersectionHandler = IntersectionHandler::create(builder, camera, scene, ellipsoidModel, radius * 0.1, options);
intersectionHandler->state = stateInfo;
viewer->addEventHandler(intersectionHandler);

// assign a CompileTraversal to the Builder that will compile for all the views assigned to the viewer,
// must be done after Viewer.assignRecordAndSubmitTasksAndPresentations();
builder->assignCompileTraversal(vsg::CompileTraversal::create(*viewer));

viewer->compile();

//auto replaceStateGreen = createHightLightPipline(options);
////model->accept(*replaceStateGreen);

// auto replaceStateTest = ReplaceState::create(graphicsPipelineOld);
// model->accept(*replaceStateTest);
 //viewer->compile();
replaceStateGreen = createHightLightPipline(options);
replaceStateTest = ReplaceState::create(graphicsPipelineOld);
//test(replaceStateGreen,model, viewer);


// rendering main 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 afraid I'm just too over stretched right now to review long blocks of code and try to figure out end user problems. Perhaps others can chip in.

As a general note, I think it would probably be use to have a highlight example in vsgExamples, but alas I'm just way too busy to be able to do it right now.

[WdsPjm]

I followed your suggestion and inserted StateGroup above the child object to decorate the child object whose state you want to change. On the basis of vsgintersection, try to implement Highlight. Now I pick up a node and set the Highlight color. The Highlight node needs to make the same matrix change as the original node. I try to get the matrix of node directly and apply it to Highlight node as follows: transform->matrix = node->castvsg::MatrixTransform()->matrix;

But the size and bit of the model after the Highlight is incorrect, am I missing something

Green is the Highlight state I set after picking.

[robertosfield]

I wouldn't normally expect a highlight technique to need to use transforms.

As a general note doing a dynamic_cast<> or vsg::Object::cast<> should not be assumed to always return a valid pointer - if the object is not of the type being cast to a nullptr will returned so code could easily crash if you start operating on it.

I can't help but feel that you are tackling this task in a more complicated way that it need be. Could you provide an example of the highlighting effect that you are after?

[WdsPjm]

For now, I'm only testing in a special way, using the test.glb model that I provided myself

https://github.com/WdsPjm/vsgPickNodeHighlight-/blob/59ac66b0045cf59fd70969321b273472342d4b2b/vsgintersection.cpp

[robertosfield]

Sorry, I should have been more clear, could you provide a screenshot or link to webpage that shows the type of highlighting your are trying to achieve.

[WdsPjm]

Desktop.2023.12.03.-.16.47.51.02.online-video-cutter.com.mp4