Define placeholders for text

src/examples/cameras.cpp

@@ -14,7 +14,8 @@ class MyApp : public robot_dart::gui::magnum::GlfwApplication {
         // we synchronize by default if we have the graphics activated
         simu->scheduler().set_sync(true);
         // enable summary text when graphics activated
-        simu->enable_summary_text(true);
+        simu->enable_text_panel(true);
+        simu->enable_status_bar(true);
     }
 
 protected:

src/examples/talos.cpp

@@ -59,6 +59,7 @@ int main()
             Eigen::VectorXd commands = (init_positions + delta_pos) - robot->positions(dofs);
             robot->set_commands(commands, dofs);
         }
+
         simu.step_world();
     }
 

src/python/simu.cpp

@@ -51,14 +51,20 @@ namespace robot_dart {
             // TextData
             using simu::TextData;
             py::class_<TextData, std::shared_ptr<TextData>>(m, "TextData")
-                .def(py::init<const std::string&, const Eigen::Affine2d&, const Eigen::Vector4d&>(),
+                .def(py::init<const std::string&, const Eigen::Affine2d&, const Eigen::Vector4d&, std::uint8_t, bool, const Eigen::Vector4d&>(),
                     py::arg("text"),
                     py::arg("transformation") = Eigen::Affine2d::Identity(),
-                    py::arg("color") = Eigen::Vector4d(1, 1, 1, 1))
+                    py::arg("color") = Eigen::Vector4d(1, 1, 1, 1),
+                    py::arg("alignment") = (1 | 3 << 3),
+                    py::arg("draw_background") = false,
+                    py::arg("background_color") = Eigen::Vector4d(0, 0, 0, 0.75))
 
                 .def_readwrite("text", &TextData::text)
                 .def_readwrite("transformation", &TextData::transformation)
-                .def_readwrite("color", &TextData::color);
+                .def_readwrite("color", &TextData::color)
+                .def_readwrite("alignment", &TextData::alignment)
+                .def_readwrite("draw_background", &TextData::draw_background)
+                .def_readwrite("background_color", &TextData::background_color);
 
             // RobotDARTSimu class
             py::class_<RobotDARTSimu>(m, "RobotDARTSimu")
@@ -131,13 +137,23 @@ namespace robot_dart {
                 .def("remove_robot", (void (RobotDARTSimu::*)(size_t)) & RobotDARTSimu::remove_robot)
                 .def("clear_robots", &RobotDARTSimu::clear_robots)
 
-                .def("enable_summary_text", &RobotDARTSimu::enable_summary_text,
+                .def("enable_text_panel", &RobotDARTSimu::enable_text_panel,
                     py::arg("enable") = true)
+                .def("text_panel_text", &RobotDARTSimu::text_panel_text)
+                .def("set_text_panel", &RobotDARTSimu::set_text_panel,
+                    py::arg("str") = "")
+
+                .def("enable_status_bar", &RobotDARTSimu::enable_status_bar,
+                    py::arg("enable") = true)
+                .def("status_bar_text", &RobotDARTSimu::status_bar_text)
 
                 .def("add_text", &RobotDARTSimu::add_text, py::return_value_policy::reference,
                     py::arg("text"),
                     py::arg("transformation") = Eigen::Affine2d::Identity(),
-                    py::arg("color") = Eigen::Vector4d(1, 1, 1, 1))
+                    py::arg("color") = Eigen::Vector4d(1, 1, 1, 1),
+                    py::arg("alignment") = (1 | 3 << 3),
+                    py::arg("draw_bg") = false,
+                    py::arg("bg_color") = Eigen::Vector4d(0, 0, 0, 0.75))
 
                 .def("add_floor", &RobotDARTSimu::add_floor,
                     py::arg("floor_width") = 10.,

src/robot_dart/gui/magnum/base_application.cpp

@@ -19,6 +19,8 @@
 #include <Magnum/MeshTools/CompressIndices.h>
 #include <Magnum/MeshTools/Interleave.h>
 #include <Magnum/Primitives/Axis.h>
+#include <Magnum/Primitives/Square.h>
+
 #include <Magnum/Trade/MeshData.h>
 #include <Magnum/Trade/PhongMaterialData.h>
 
@@ -148,6 +150,9 @@ namespace robot_dart {
                 _3D_axis_shader.reset(new Magnum::Shaders::VertexColor3D);
                 _3D_axis_mesh.reset(new Magnum::GL::Mesh);
 
+                _background_shader.reset(new Magnum::Shaders::Flat2D);
+                _background_mesh.reset(new Magnum::GL::Mesh{Magnum::MeshTools::compile(Magnum::Primitives::squareSolid())});
+
                 Magnum::Trade::MeshData axis_data = Magnum::Primitives::axis3D();
 
                 Magnum::GL::Buffer axis_vertices;
@@ -174,12 +179,11 @@ namespace robot_dart {
                     _font->fillGlyphCache(*_glyph_cache,
                         "abcdefghijklmnopqrstuvwxyz"
                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                        "0123456789:-+,.!° ");
+                        "0123456789:-+*,.!° /|[]()_");
 
-                    /* Initialize dynamic text */
-                    _dynamic_text.reset(new Magnum::Text::Renderer2D(*_font, *_glyph_cache, 32.0f, Magnum::Text::Alignment::TopLeft));
-                    /* Reserve 100 characters for drawing debug text */
-                    _dynamic_text->reserve(100, Magnum::GL::BufferUsage::DynamicDraw, Magnum::GL::BufferUsage::StaticDraw);
+                    /* Initialize buffers for text */
+                    _text_vertices.reset(new Magnum::GL::Buffer);
+                    _text_indices.reset(new Magnum::GL::Buffer);
 
                     /* Initialize text shader */
                     _text_shader.reset(new Magnum::Shaders::DistanceFieldVector2D);
@@ -639,10 +643,13 @@ namespace robot_dart {
                 _shadow_color_cube_map.reset();
                 _3D_axis_shader.reset();
                 _3D_axis_mesh.reset();
+                _background_mesh.reset();
+                _background_shader.reset();
                 _text_shader.reset();
                 _glyph_cache.reset();
                 _font.reset();
-                _dynamic_text.reset();
+                _text_vertices.reset();
+                _text_indices.reset();
 
                 _camera.reset();
                 _shadow_camera.reset();

src/robot_dart/gui/magnum/base_application.hpp

@@ -28,7 +28,9 @@
 #include <Magnum/Platform/WindowlessCglApplication.h>
 #endif
 #include <Magnum/Shaders/DistanceFieldVector.h>
+#include <Magnum/Shaders/Flat.h>
 #include <Magnum/Shaders/VertexColor.h>
+
 #include <Magnum/Text/AbstractFont.h>
 #include <Magnum/Text/DistanceFieldGlyphCache.h>
 #include <Magnum/Text/Renderer.h>
@@ -106,6 +108,19 @@ namespace robot_dart {
                 bool draw_debug = true;
             };
 
+            struct DebugDrawData {
+                Magnum::Shaders::VertexColor3D* axes_shader;
+                Magnum::GL::Mesh* axes_mesh;
+                Magnum::Shaders::Flat2D* background_shader;
+                Magnum::GL::Mesh* background_mesh;
+
+                Magnum::Shaders::DistanceFieldVector2D* text_shader;
+                Magnum::GL::Buffer* text_vertices;
+                Magnum::GL::Buffer* text_indices;
+                Magnum::Text::AbstractFont* font;
+                Magnum::Text::DistanceFieldGlyphCache* cache;
+            };
+
             class BaseApplication {
             public:
                 BaseApplication(const GraphicsConfiguration& configuration = GraphicsConfiguration());
@@ -153,11 +168,22 @@ namespace robot_dart {
                 // Image filled with depth buffer values
                 GrayscaleImage raw_depth_image();
 
-                // Access to members
-                Magnum::Shaders::VertexColor3D& axes_shader() { return *_3D_axis_shader; }
-                Magnum::GL::Mesh& axes_mesh() { return *_3D_axis_mesh; }
-                Magnum::Shaders::DistanceFieldVector2D* text_shader() { return &*_text_shader; }
-                Magnum::Text::Renderer2D* text_renderer() { return &*_dynamic_text; }
+                // Access to debug data
+                DebugDrawData debug_draw_data()
+                {
+                    DebugDrawData data;
+                    data.axes_shader = &*_3D_axis_shader;
+                    data.background_shader = &*_background_shader;
+                    data.axes_mesh = &*_3D_axis_mesh;
+                    data.background_mesh = &*_background_mesh;
+                    data.text_shader = &*_text_shader;
+                    data.text_vertices = &*_text_vertices;
+                    data.text_indices = &*_text_indices;
+                    data.font = &*_font;
+                    data.cache = &*_glyph_cache;
+
+                    return data;
+                }
 
             protected:
                 /* Magnum */
@@ -194,12 +220,16 @@ namespace robot_dart {
                 /* Debug visualization */
                 std::unique_ptr<Magnum::GL::Mesh> _3D_axis_mesh;
                 std::unique_ptr<Magnum::Shaders::VertexColor3D> _3D_axis_shader;
+                std::unique_ptr<Magnum::GL::Mesh> _background_mesh;
+                std::unique_ptr<Magnum::Shaders::Flat2D> _background_shader;
+
                 /* Text visualization */
                 std::unique_ptr<Magnum::Shaders::DistanceFieldVector2D> _text_shader;
                 Corrade::PluginManager::Manager<Magnum::Text::AbstractFont> _font_manager;
                 Corrade::Containers::Pointer<Magnum::Text::DistanceFieldGlyphCache> _glyph_cache;
                 Corrade::Containers::Pointer<Magnum::Text::AbstractFont> _font;
-                Corrade::Containers::Pointer<Magnum::Text::Renderer2D> _dynamic_text;
+                Corrade::Containers::Pointer<Magnum::GL::Buffer> _text_vertices;
+                Corrade::Containers::Pointer<Magnum::GL::Buffer> _text_indices;
 
                 /* Importer */
                 Corrade::PluginManager::Manager<Magnum::Trade::AbstractImporter> _importer_manager;

src/robot_dart/gui/magnum/glfw_application.cpp

@@ -81,7 +81,7 @@ namespace robot_dart {
                     _camera->strafe(_speed_strafe);
 
                     /* Draw with main camera */
-                    _camera->draw(_drawables, Magnum::GL::defaultFramebuffer, Magnum::PixelFormat::RGB8Unorm, _simu, *_3D_axis_shader, *_3D_axis_mesh, &*_text_shader, &*_dynamic_text, _draw_debug);
+                    _camera->draw(_drawables, Magnum::GL::defaultFramebuffer, Magnum::PixelFormat::RGB8Unorm, _simu, debug_draw_data(), _draw_debug);
 
                     swapBuffers();
                 }

src/robot_dart/gui/magnum/graphics.cpp

@@ -8,7 +8,8 @@ namespace robot_dart {
                 // we synchronize by default if we have the graphics activated
                 simu->scheduler().set_sync(true);
                 // enable summary text when graphics activated
-                simu->enable_summary_text(true);
+                simu->enable_text_panel(true);
+                simu->enable_status_bar(true);
             }
         } // namespace magnum
     } // namespace gui

src/robot_dart/gui/magnum/gs/camera.cpp

@@ -251,7 +251,7 @@ namespace robot_dart {
 #endif
                 }
 
-                void Camera::draw(Magnum::SceneGraph::DrawableGroup3D& drawables, Magnum::GL::AbstractFramebuffer& framebuffer, Magnum::PixelFormat format, RobotDARTSimu* simu, Magnum::Shaders::VertexColor3D& axes_shader, Magnum::GL::Mesh& axes_mesh, Magnum::Shaders::DistanceFieldVector2D* text_shader, Magnum::Text::Renderer2D* text_renderer, bool draw_debug)
+                void Camera::draw(Magnum::SceneGraph::DrawableGroup3D& drawables, Magnum::GL::AbstractFramebuffer& framebuffer, Magnum::PixelFormat format, RobotDARTSimu* simu, const DebugDrawData& debug_data, bool draw_debug)
                 {
                     // TO-DO: Maybe check if world moved?
                     std::vector<std::pair<std::reference_wrapper<Magnum::SceneGraph::Drawable3D>, Magnum::Matrix4>>
@@ -287,29 +287,53 @@ namespace robot_dart {
                             Magnum::Matrix4 world_transform = Magnum::Matrix4(Magnum::Matrix4d(axis.first->getWorldTransform().matrix()));
                             Magnum::Matrix4 scaling = Magnum::Matrix4::scaling(Magnum::Vector3(axis.second, axis.second, axis.second));
 
-                            axes_shader.setTransformationProjectionMatrix(_camera->projectionMatrix() * _camera->cameraMatrix() * world_transform * scaling)
-                                .draw(axes_mesh);
+                            debug_data.axes_shader->setTransformationProjectionMatrix(_camera->projectionMatrix() * _camera->cameraMatrix() * world_transform * scaling)
+                                .draw(*debug_data.axes_mesh);
                         }
 
                         /* Draw text */
-                        if (text_shader && text_renderer) {
+                        if (debug_data.text_shader && debug_data.text_vertices) {
                             using namespace Magnum::Math::Literals;
                             Magnum::GL::Renderer::disable(Magnum::GL::Renderer::Feature::DepthTest);
                             Magnum::GL::Renderer::disable(Magnum::GL::Renderer::Feature::FaceCulling);
 
+                            // bind glyph texture
+                            debug_data.text_shader->bindVectorTexture(debug_data.cache->texture());
+
                             for (auto& text : simu->gui_data()->drawing_texts()) {
-                                text_renderer->render(text->text);
-                                // std::cout << text_renderer->rectangle().sizeX() << std::endl;
+                                if (text->text.empty()) // ignore empty strings
+                                    continue;
+
+                                Magnum::GL::Mesh mesh;
+                                Magnum::Range2D rectangle;
+                                std::tie(mesh, rectangle) = Magnum::Text::Renderer2D::render(*debug_data.font, *debug_data.cache, 28.f, text->text, *debug_data.text_vertices, *debug_data.text_indices, Magnum::GL::BufferUsage::StaticDraw, Magnum::Text::Alignment(text->alignment));
+
                                 auto viewport = Magnum::Vector2{_camera->viewport()};
                                 auto big = viewport.max();
-                                auto scaling = Magnum::Vector2{big / 1024.f};
-                                (*text_shader)
-                                    .setTransformationProjectionMatrix(Magnum::Matrix3::projection(viewport) * Magnum::Matrix3(Magnum::Matrix3d(text->transformation)) * Magnum::Matrix3::scaling(scaling))
+                                auto text_scaling = Magnum::Matrix3::scaling(Magnum::Vector2{big / 1024.f});
+                                auto extra_tr = Magnum::Matrix3(Magnum::Math::IdentityInit);
+                                if ((text->alignment & Magnum::Text::Implementation::AlignmentVertical) == Magnum::Text::Implementation::AlignmentLine) // if line (bottom) alignment, push the text a bit above
+                                    extra_tr = Magnum::Matrix3::translation({0.f, 0.25f * rectangle.sizeY()});
+
+                                auto text_tr = Magnum::Matrix3(Magnum::Matrix3d(text->transformation));
+
+                                if (text->draw_background) {
+                                    auto bg_scaling = Magnum::Matrix3::scaling(Magnum::Vector2{viewport[0], rectangle.sizeY()});
+
+                                    // draw the background
+                                    (*debug_data.background_shader)
+                                        .setTransformationProjectionMatrix(Magnum::Matrix3::projection(viewport) * text_tr * text_scaling * bg_scaling)
+                                        .setColor(Magnum::Vector4(Magnum::Vector4d(text->background_color)))
+                                        .draw(*debug_data.background_mesh);
+                                }
+
+                                (*debug_data.text_shader)
+                                    .setTransformationProjectionMatrix(Magnum::Matrix3::projection(viewport) * text_tr * extra_tr * text_scaling)
                                     // .setTransformationProjectionMatrix(Magnum::Matrix3::projection(Magnum::Vector2{_camera->viewport()}) * Magnum::Matrix3::translation(Magnum::Vector2{-text_renderer->rectangle().sizeX() / 2.f, -text_renderer->rectangle().sizeY() / 2.f}) * Magnum::Matrix3(Magnum::Matrix3d(text.transformation)))
                                     .setColor(Magnum::Vector4(Magnum::Vector4d(text->color)))
-                                    .setOutlineRange(0.5f, 1.0f)
+                                    .setOutlineRange(0.4f, 0.45f)
                                     .setSmoothness(0.075f)
-                                    .draw(text_renderer->mesh());
+                                    .draw(mesh);
                             }
 
                             Magnum::GL::Renderer::enable(Magnum::GL::Renderer::Feature::DepthTest);

src/robot_dart/gui/magnum/gs/camera.hpp

@@ -21,6 +21,8 @@
 namespace robot_dart {
     namespace gui {
         namespace magnum {
+            struct DebugDrawData;
+
             namespace gs {
                 // This is partly code from the ThirdPersonCameraController of https://github.com/alexesDev/magnum-tips
                 class Camera : public Object3D {
@@ -69,7 +71,7 @@ namespace robot_dart {
                     Corrade::Containers::Optional<Magnum::Image2D>& image() { return _image; }
                     Corrade::Containers::Optional<Magnum::Image2D>& depth_image() { return _depth_image; }
 
-                    void draw(Magnum::SceneGraph::DrawableGroup3D& drawables, Magnum::GL::AbstractFramebuffer& framebuffer, Magnum::PixelFormat format, RobotDARTSimu* simu, Magnum::Shaders::VertexColor3D& axes_shader, Magnum::GL::Mesh& axes_mesh, Magnum::Shaders::DistanceFieldVector2D* text_shader, Magnum::Text::Renderer2D* text_renderer, bool draw_debug = true);
+                    void draw(Magnum::SceneGraph::DrawableGroup3D& drawables, Magnum::GL::AbstractFramebuffer& framebuffer, Magnum::PixelFormat format, RobotDARTSimu* simu, const DebugDrawData& debug_data, bool draw_debug = true);
 
                 private:
                     Object3D* _yaw_object;

src/robot_dart/gui/magnum/sensor/camera.cpp

@@ -78,7 +78,7 @@ namespace robot_dart {
                     _framebuffer.clear(Magnum::GL::FramebufferClear::Color | Magnum::GL::FramebufferClear::Depth);
 
                     /* Draw with this camera */
-                    _camera->draw(_magnum_app->drawables(), _framebuffer, _format, _simu, _magnum_app->axes_shader(), _magnum_app->axes_mesh(), _magnum_app->text_shader(), _magnum_app->text_renderer(), _draw_debug);
+                    _camera->draw(_magnum_app->drawables(), _framebuffer, _format, _simu, _magnum_app->debug_draw_data(), _draw_debug);
                 }
 
                 std::string Camera::type() const { return "rgb_camera"; }

src/robot_dart/gui/magnum/windowless_gl_application.cpp

@@ -74,7 +74,7 @@ namespace robot_dart {
                     _framebuffer.clear(Magnum::GL::FramebufferClear::Color | Magnum::GL::FramebufferClear::Depth);
 
                     /* Draw with main camera */
-                    _camera->draw(_drawables, _framebuffer, _format, _simu, *_3D_axis_shader, *_3D_axis_mesh, &*_text_shader, &*_dynamic_text, _draw_debug);
+                    _camera->draw(_drawables, _framebuffer, _format, _simu, debug_draw_data(), _draw_debug);
 
                     // if (_index % 10 == 0) {
                     //     intptr_t tt = (intptr_t)_glx_context;

src/robot_dart/gui/magnum/windowless_graphics.cpp

@@ -8,7 +8,8 @@ namespace robot_dart {
                 // we should not synchronize by default if we want windowless graphics (usually used only for sensors)
                 simu->scheduler().set_sync(false);
                 // disable summary text when windowless graphics activated
-                simu->enable_summary_text(false);
+                simu->enable_text_panel(false);
+                simu->enable_status_bar(false);
             }
         } // namespace magnum
     } // namespace gui

src/robot_dart/gui_data.hpp

@@ -25,9 +25,9 @@ namespace robot_dart {
             std::vector<std::shared_ptr<simu::TextData>> text_drawings;
 
         public:
-            std::shared_ptr<simu::TextData> add_text(const std::string& text, const Eigen::Affine2d& tf = Eigen::Affine2d::Identity(), Eigen::Vector4d color = Eigen::Vector4d(1, 1, 1, 1))
+            std::shared_ptr<simu::TextData> add_text(const std::string& text, const Eigen::Affine2d& tf = Eigen::Affine2d::Identity(), Eigen::Vector4d color = Eigen::Vector4d(1, 1, 1, 1), std::uint8_t alignment = (1 | 3 << 3), bool draw_bg = false, Eigen::Vector4d bg_color = Eigen::Vector4d(0, 0, 0, 0.75))
             {
-                text_drawings.emplace_back(new TextData{text, tf, color});
+                text_drawings.emplace_back(new TextData{text, tf, color, alignment, draw_bg, bg_color});
 
                 return text_drawings.back();
             }