Does vsg::Layer work with PagedLODs?

[avilkinnick]

I am writing route editor and want to include gizmo support. Gizmo, that is always visible and always the same size.
Currently, it loos like this:

Here is the code:

void RouteEditor::create_scenegraph()
{
    ambient_light = vsg::AmbientLight::create();

    scene_group = vsg::Group::create();
    scene_group->addChild(ambient_light);
    auto layer1 = vsg::Layer::create(1, 1.0, scene_group);

    gui_group = vsg::Group::create();
    auto layer2 = vsg::Layer::create(2, 2.0, gui_group);

    scenegraph = vsg::Group::create();
    scenegraph->addChild(layer1);
    scenegraph->addChild(layer2);
}

bool RouteEditor::load_route()
{
    // ...
    for (auto& [label, transform] : route_map)
    {
        auto paged_lod_it = paged_lods.find(label);
        if (paged_lod_it == paged_lods.end())
        {
            continue;
        }

        const vsg::vec3& translation = transform.first;
        vsg::vec3& rotation = transform.second;

        ObjectProperties properties;
        properties.name = label;
        properties.translation = translation;
        properties.rotation = rotation;

        rotation.x = -vsg::radians(rotation.x);
        rotation.y = -vsg::radians(rotation.y);
        rotation.z = -vsg::radians(rotation.z);

        const vsg::mat4 rotate_x = vsg::rotate(rotation.x, vsg::vec3(1.0f, 0.0f, 0.0f));
        const vsg::mat4 rotate_y = vsg::rotate(rotation.y, vsg::vec3(0.0f, 1.0f, 0.0f));
        const vsg::mat4 rotate_z = vsg::rotate(rotation.z, vsg::vec3(0.0f, 0.0f, 1.0f));
        const vsg::mat4 translate = vsg::translate(translation);

        auto matrix_transform = vsg::MatrixTransform::create();
        matrix_transform->matrix = translate * rotate_z * rotate_y * rotate_x;
        matrix_transform->addChild(paged_lod_it->second);
        matrix_transform->setValue("properties", properties);

        {
            auto result = viewer->compileManager->compile(matrix_transform);
            scene_group->addChild(matrix_transform);
            vsg::updateViewer(*viewer, result);
        }
    }

    return true;
}

static vsg::ref_ptr<vsg::Node> create_arrow(vsg::vec3 pos, vsg::vec3 dir, vsg::vec4 color,
    float thickness, float length, vsg::ref_ptr<vsg::Options> options)
{
    auto arrow = vsg::Group::create();

    vsg::Builder builder;
    builder.options = options;
    builder.sharedObjects = options->sharedObjects;
    builder.shaderSet = vsg::createFlatShadedShaderSet(options);

    auto depthStencilState = vsg::DepthStencilState::create();
    depthStencilState->depthTestEnable = VK_FALSE;
    builder.shaderSet->defaultGraphicsPipelineStates.push_back(depthStencilState);

    vsg::box box;
    box.min = pos - vsg::vec3(thickness * 0.5f, thickness * 0.5f, 0.0);
    box.max = pos + vsg::vec3(thickness * 0.5f, thickness * 0.5f, length);

    vsg::GeometryInfo geometry_info;
    geometry_info.set(box);
    geometry_info.color = color;

    if (vsg::length(vsg::cross(vsg::vec3(0.0f, 0.0f, 1.0f), dir)) > 0.0001f)
    {
        const vsg::vec3 axis = vsg::cross(vsg::vec3(0.0f, 0.0f, 1.0f), dir);
        const float angle = std::acos(vsg::dot(vsg::vec3(0.0f, 0.0f, 1.0f), dir));
        geometry_info.transform = vsg::rotate(angle, axis);
    }

    auto node = builder.createCylinder(geometry_info);
    arrow->addChild(node);

    box.min = pos + vsg::vec3(-thickness * 1.5f, -thickness * 1.5f, length);
    box.max = pos + vsg::vec3(thickness * 1.5f, thickness * 1.5f, length + thickness * 7.0f);
    geometry_info.set(box);

    node = builder.createCone(geometry_info);
    arrow->addChild(node);

    return arrow;
}

void IntersectionHandler::apply(vsg::ButtonPressEvent& buttonPress)
{
    if (buttonPress.handled || buttonPress.button != MOUSE_BUTTON_LEFT)
    {
        return;
    }

    auto intersector = vsg::LineSegmentIntersector::create(*camera, buttonPress.x, buttonPress.y);

    scene_group->accept(*intersector);

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

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

    auto& intersection = *intersector->intersections.front();
    for (const vsg::Node* node : intersection.nodePath)
    {
        vsg::MatrixTransform* const matrix_transform = const_cast<vsg::MatrixTransform*>(node->cast<vsg::MatrixTransform>());
        if (!matrix_transform)
        {
            continue;
        }

        vsg::PagedLOD* const paged_lod = matrix_transform->children[0]->cast<vsg::PagedLOD>();
        if (!paged_lod || !paged_lod->pending)
        {
            continue;
        }

        vsg::ComputeBounds compute_bounds;
        compute_bounds.useNodeBounds = false;
        paged_lod->pending->accept(compute_bounds);

        const vsg::dvec3 arrows_offset = (compute_bounds.bounds.min + compute_bounds.bounds.max) * 0.5;

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

        vsg::Builder builder;
        builder.options = options;
        builder.sharedObjects = options->sharedObjects;
        builder.shaderSet = vsg::createFlatShadedShaderSet(options);

        auto depthStencilState = vsg::DepthStencilState::create();
        depthStencilState->depthTestEnable = VK_FALSE;
        builder.shaderSet->defaultGraphicsPipelineStates.push_back(depthStencilState);

        vsg::GeometryInfo geometry_info(vsg::box(compute_bounds.bounds));
        geometry_info.color.set(1.0f, 0.65f, 0.0f, 1.0f);

        vsg::StateInfo state_info;
        state_info.wireframe = true;

        auto border = builder.createBox(geometry_info, state_info);
        group->addChild(border);

        auto axis_transform = vsg::MatrixTransform::create();
        axis_transform->matrix = vsg::translate(arrows_offset);

        constexpr vsg::vec3 vec3_zero = {0.0f, 0.0f, 0.0f};

        constexpr vsg::vec3 dirs[3] = {vsg::vec3{1.0f, 0.0f, 0.0f},
                                       vsg::vec3{0.0f, 1.0f, 0.0f},
                                       vsg::vec3{0.0f, 0.0f, 1.0f}};

        constexpr vsg::vec4 colors[3] = {vsg::vec4(1.0f, 0.0f, 0.0f, 1.0f),
                                         vsg::vec4(0.0f, 1.0f, 0.0f, 1.0f),
                                         vsg::vec4(0.0f, 0.0f, 1.0f, 1.0f)};

        for (int i = 0; i < 3; ++i)
        {
            axis_transform->addChild(create_arrow(vec3_zero, dirs[i], colors[i],
                settings.arrow_thickness, settings.arrow_width, options));
        }

        group->addChild(axis_transform);

        curr_matrix_transform = matrix_transform;

        gui_matrix_transform->matrix = curr_matrix_transform->matrix;

        {
            vsg::ref_ptr<vsg::Viewer> viewer = observer_viewer;
            auto result = viewer->compileManager->compile(group);
            gui_matrix_transform->children ={group};
            vsg::updateViewer(*viewer, result);
        }
    }
}

Depth test for GUI elements is disabled, but even though it is in another layer, some of the rail route models are rendering after GUI, so how can I handle it?

[robertosfield]

I don't know what might be going wrong in your case, but in principle that should be no issue with combining a paged database with overlays. Here's the result of running the vsgoverlay example with paged database:

vsgoverlay models/openstreetmap.vsgt

[AnyOldName3]

Have you checked in RenderDoc to make sure that the nodes are drawn in the order you expect and with the state you expect? It'd at least help narrow things down if you could work out which of your expectations is being violated.

[avilkinnick]

Oh, thanks, I solved it by adding separate vsg::View for GUI nodes, and adding it separately in renderGraph, after scenegraph and clearAttachments, just as in vsgoverlay example that Robert suggested. This way vsg::Layers were not required at all