Implementing static HUD with vsg::Text

[frozenaccident]

I'm trying to learn how to use text, so I decided to prototype something resembling a HUD in the scene.
...And I failed miserably, even using the latest Claude and ChatGPT.
By studying vsgExamples I was able to add some text to the scene but obviously it's in the same node as the 3d model I load.
I tried to create a new camera and view, as well as nodes, graphs and couldn't achieve the result, I know I lack knowledge in the fundamentals but I'll catch up eventually.
Can I get a hint on how to make text static that sits on top of everything in the scene?
Thanks.

Click to see what I have at the moment based on 'hellovsg':

void Engine::load_scene() {                
        auto model = vsg::read_cast<vsg::Node>("glider.vsgt");         

        scene = vsg::Group::create();
        scene->addChild(model); 

        text_group = vsg::Group::create();       
        TextManager text_manager(window);
        text_manager.add_text("Hello VSG!",
                              vsg::vec3(2.0f, 2.0f, 0.0f),
                              vsg::vec4(1.0f, 1.0f, 1.0f, 1.0f),
                              true); // Billboard = true        
        text_manager.add_text("Hello HUD!",
                              vsg::vec3(0.0f, 0.0f, 0.0f),
                              vsg::vec4(1.0f, 1.0f, 1.0f, 1.0f),
                              true); // Billboard = true 

        text_group->addChild(text_manager.get_text_group());        
        
        scene->addChild(text_group);        

        vsg::ComputeBounds compute_bounds;
        scene->accept(compute_bounds);
        vsg::dvec3 centre = (compute_bounds.bounds.min + compute_bounds.bounds.max) * 0.5;
        double radius = vsg::length(compute_bounds.bounds.max - compute_bounds.bounds.min) * 0.6;
        double near_far_ratio = 0.001;
       
        auto look_at = vsg::LookAt::create(centre + vsg::dvec3(0.0, -radius * 2.5, 0.0), centre, vsg::dvec3(0.0, 0.0, 1.0));
        auto perspective = vsg::Perspective::create(30.0, static_cast<double>(window->extent2D().width) / static_cast<double>(window->extent2D().height), near_far_ratio * radius, radius * 4.5); 

        camera = vsg::Camera::create(perspective, look_at, vsg::ViewportState::create(window->extent2D()));
        
        viewer->addEventHandler(vsg::CloseHandler::create(viewer));
        viewer->addEventHandler(vsg::Trackball::create(camera));                               
    }    

    void Engine::render_loop() {        
        auto command_graph = vsg::createCommandGraphForView(window, camera, scene);               
        viewer->assignRecordAndSubmitTaskAndPresentation({command_graph});                
        viewer->compile();             

        while (viewer->advanceToNextFrame()) {
            viewer->handleEvents();
            viewer->update();
            viewer->recordAndSubmit();
            viewer->present();            
        }
    }
        
    //And I created a TextManager class for this:
   
    class TextManager {
    public:
        TextManager(vsg::ref_ptr<vsg::Window> window) : window(window) {
            text_container = vsg::Group::create();
        }

        void add_text(const std::string& text_string, const vsg::vec3& position, const vsg::vec4& color, bool billboard = false) {
            auto font = vsg::read_cast<vsg::Font>("times.vsgb");                       

            auto layout = vsg::StandardLayout::create();
            layout->position = position;
            layout->color = color;
            layout->billboard = billboard;

            auto text = vsg::Text::create();
            text->text = vsg::stringValue::create(text_string);
            text->font = font;
            text->layout = layout;
            text->setup(0, 0);
                                   
            text_container->addChild(text); 
        }        

        vsg::ref_ptr<vsg::Group> get_text_group() const {
            return text_container;
        }

        private:
            vsg::ref_ptr<vsg::Window> window;           
            vsg::ref_ptr<vsg::Group>  text_container;
            vsg::ref_ptr<vsg::Font>   font;
        };

Here's the result I get with this code.
Both strings are being transformed so when I move the camera, the text strings move with the glider model.

[frozenaccident]

Ok, as I continue studying this awesome library, I'm finally able to achieve what I wanted here - some static text on top of a 3D scene which I'm gonna turn into a HUD eventually, let me leave this piece of code here for those like me, who are just starting their journey and are a bit lost.

Click to see

   Engine::Engine() {}

    void Engine::run()
    {        
        initialize();
        load_scene();
        create_hud();
        draw();        
    } 


    void Engine::initialize()
    {
        window_traits = vsg::WindowTraits::create();
        window_traits->windowTitle = "test";
        window_traits->decoration = true; 
        window_traits->fullscreen = false;        
        window_traits->width = 1280;
        window_traits->height = 720;
        window_traits->swapchainPreferences.presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;  // probably doesn't switch                     
        
        viewer = vsg::Viewer::create();
        window = vsg::Window::create(window_traits);                      

        if (!window) {            
            exit(EXIT_FAILURE);
        }
        
        viewer->addWindow(window);              
    }


    void Engine::load_scene()
    {   
        scene = vsg::read_cast<vsg::Group>("glider.vsgt");
            
        INFO("Model loaded");                                                                  

        vsg::ComputeBounds compute_bounds;
        scene->accept(compute_bounds);
        vsg::dvec3 centre = (compute_bounds.bounds.min + compute_bounds.bounds.max) * 0.5;
        double radius = vsg::length(compute_bounds.bounds.max - compute_bounds.bounds.min) * 0.6;
        double near_far_ratio = 0.0001;

        auto look_at = vsg::LookAt::create(centre + vsg::dvec3(0.0, -radius * 2.5, 0.0),
                                           centre, vsg::dvec3(0.0, 0.0, 1.0));

        vsg::ref_ptr<vsg::ProjectionMatrix> perspective;        
        perspective = vsg::Perspective::create(30.0,
                                               static_cast<double>(window->extent2D().width) / 
                                               static_cast<double>(window->extent2D().height),
                                               near_far_ratio * radius, radius * 4.5);               

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

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


    void Engine::create_hud()
    {        
        std::string font_filename = "times.vsgb";

        auto options = vsg::Options::create();

        font = vsg::read_cast<vsg::Font>(font_filename, options);
        if (!font)
        {
            ERR("Failed to read font");
            return;
        }
        
        text_group = vsg::TextGroup::create();        
        {
            auto layout = vsg::StandardLayout::create();
            layout->horizontalAlignment = vsg::StandardLayout::CENTER_ALIGNMENT;
            layout->position = vsg::vec3(0.0, 0.0, 0.0); // Position in front of the camera
            layout->horizontal = vsg::vec3(1.0, 0.0, 0.0);
            layout->vertical = vsg::vec3(0.0, 1.0, 0.0);
            layout->color = vsg::vec4(1.0, 1.0, 1.0, 1.0);

            auto text = vsg::Text::create();
            text->text = vsg::stringValue::create("Hello, HUD!");
            text->font = font;
            text->layout = layout;
            text_group->addChild(text);
        }

        // Disable depth testing for the HUD text
        auto shader_set = options->shaderSets["text"] = vsg::createTextShaderSet(options);
        auto depth_stencil_state = vsg::DepthStencilState::create();
        depth_stencil_state->depthTestEnable = VK_FALSE;
        shader_set->defaultGraphicsPipelineStates.push_back(depth_stencil_state);

        // Setup text group
        text_group->setup(0, options);               

        // Create a new camera for the HUD
        // Eye position is (0.0, 0.0, 0.0), center is (0.0, 0.0, -1.0), up is (0.0, 1.0, 0.0)
        auto hud_camera = vsg::Camera::create(camera->projectionMatrix, 
                                            vsg::LookAt::create(vsg::dvec3(0.0, 0.0, 8.8), // Eye position
                                                                vsg::dvec3(0.0, 0.0, 0.0), // Center
                                                                vsg::dvec3(0.0, 1.0, 0.0)), // Up vector
                                            vsg::ViewportState::create(window->extent2D()));
        
        // Create a view for the HUD
        auto hud_view = vsg::View::create(hud_camera, text_group);

        // Create a render graph and add both scene and HUD views
        render_graph = vsg::RenderGraph::create(window);
        render_graph->addChild(vsg::View::create(camera, scene)); // Add main view
        render_graph->addChild(hud_view); // Add HUD view        
    }


    void Engine::draw()
    {  
        command_graph = vsg::CommandGraph::create(window);
        command_graph->addChild(render_graph);
        viewer->assignRecordAndSubmitTaskAndPresentation({command_graph});
        viewer->compile();

        while (viewer->advanceToNextFrame()) {
            viewer->handleEvents();
            viewer->update();
            viewer->recordAndSubmit();
            viewer->present();            
        }
    }

[AnyOldName3]

...And I failed miserably, even using the latest Claude and ChatGPT.

I wouldn't expect usable results from an LLM when asking VSG questions. They can be helpful for solutions to common problems with widely-used libraries and frameworks where there'll already be a StackOverflow post with the same or a very similar problem, but the VSG is relatively niche, so will barely feature in the training data, and you're more likely to hit hallucinations than real solutions.

[robertosfield]

Have a look at the vsgoverlay and vsgtext examples. The vsgoverlay example illustrates how to create two views, it uses two 3D ones, but a 2D one is just a 3D one from a fixed direction. The vsgtext example illustrates vsg::Text.