Dynamic delete node from group.

[HUSTWillHe]

Is your feature request related to a problem? Please describe.
I'm trying to remove some nodes from a group, but something went wrong. The deleted nodes still seem to be drawn, and their positions and colors are wrong.
I'm new to vsg, and I can only find examples of adding node to group dynamically. I would like to know if dynamically deleting nodes from a group is currently supported.

Describe the solution you'd like
Something like group->remove_if(function);

Describe alternatives you've considered
auto children = group->children;
auto itr = remove_if(children.begin(), children.end(), [](){ some judgment; });
children.erase(itr, children.end());
auto result = viewer->compileManager->compile(group);
updateViewer(*viewer, result);

Additional context

The green line in the picture appears incorrectly when I delete some outdated data.

[timoore]

This should work as expected, more or less, with a couple of caveats. You don't need to recompile the group after you modify it like this. Also, at the present time low-level Vulkan objects aren't protected from deletion while they are still in use rendering the current frame (I think?) Applications that delete nodes maintain a C++ list or a non-rendered VSG group to keep deleted objects around for 2 or three frames before deleting them.

[robertosfield]

I have moved this thread to the Discussion forum as it'll likely be something that would benefit wider discussion that will be useful for others down the line,

As Tim mentions you can delete children directly, but you need to mindful of subgraphs that have been rendered in the last few frames as Vulkan state associated with them may still be in use by one of these previous frames - the CPU and GPUs operate in a parallel, and the CPU frame may be several frames ahead of the current frame being rendered on the GPU.

To avoid deleting objects that are still currently being rendering you need to temporarily cache the subgraphs scheduled for deletion. The VSG doesn't currently provide this for you, but it's a on my TODO list. It may require an explicit mechanism but there is also a chance I may be able to leverage the way the scene graph object holds the Vulkan objects.

[rolandhill]

I use a vsg::Operation as a deffered delete. This needs to be added with the ALL_FRAMES flag, so I don't call it directly, but have opDetach and opMerge structures as well. The frameDelay probably only needs to be 3.

Robert, I won't send a PR because it's not obvious from the vsg code how you would like to implement something like this. I can't see any default Operations.

// NOTE: opDeferredDelete must be added to the operations queue using vsg::UpdateOperations::ALL_FRAMES
struct opDeferredDelete : public vsg::Inherit<vsg::Operation, opDeferredDelete>
{
    opDeferredDelete(vsg::ref_ptr<vsg::Node> node, int frameDelay = 4):
        _node(node),
        _frameDelay(frameDelay)
        {}

    vsg::ref_ptr<vsg::Node> _node;
    int _frameDelay;

    void run() override
    {
        if(_frameDelay <= 0)
        {
            _node = nullptr;
            siApp::get()->_vsg->_viewer->updateOperations->remove(vsg::ref_ptr<opDeferredDelete>(this));
        }
        _frameDelay--;
    }
};

struct opMerge : public vsg::Inherit<vsg::Operation, opMerge>
{
    opMerge(vsg::observer_ptr<vsg::Viewer> viewer, vsg::ref_ptr<vsg::Group> attachmentPoint, vsg::ref_ptr<vsg::Node> node, const vsg::CompileResult& compileResult):
        _viewer(viewer),
        _attachmentPoint(attachmentPoint),
        _node(node),
        _compileResult(compileResult)
        {}

    vsg::observer_ptr<vsg::Viewer> _viewer;
    vsg::ref_ptr<vsg::Group> _attachmentPoint;
    vsg::ref_ptr<vsg::Node> _node;
    vsg::CompileResult _compileResult;

    void run() override
    {
        vsg::ref_ptr<vsg::Viewer> ref_viewer = _viewer;
        
        if (ref_viewer)
        {
            updateViewer(*ref_viewer, _compileResult);
        }

        _attachmentPoint->addChild(_node);
    }
};

struct opDetach : public vsg::Inherit<vsg::Operation, opDetach>
{
    opDetach(vsg::ref_ptr<vsg::Group> detachmentPoint, vsg::ref_ptr<vsg::Node> node):
        _detachmentPoint(detachmentPoint),
        _node(node)
        {}

    vsg::ref_ptr<vsg::Group> _detachmentPoint;
    vsg::ref_ptr<vsg::Node> _node;

    void run() override
    {
        if (_detachmentPoint)
        {
            auto it = std::find(_detachmentPoint->children.begin(), _detachmentPoint->children.end(), _node);
            if(it != _detachmentPoint->children.end())
            {
                _detachmentPoint->children.erase(it);
                siApp::get()->_vsg->_viewer->addUpdateOperation(opDeferredDelete::create(_node), vsg::UpdateOperations::ALL_FRAMES);
            }
        }
    }
};

You can use it like this

void MyVsg::detachSubgraph(vsg::ref_ptr<vsg::Group> detachmentPoint, vsg::ref_ptr<vsg::Node> node)
{
    _viewer->addUpdateOperation(opDetach::create(detachmentPoint, node));
}

Hope this helps.

Regards,
Roland

[HUSTWillHe]

That helps a lot. Thank you!