CTextMessageCapable.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "opengl-precomp.h"  // Precompiled header
 
#include <mrpt/opengl/CTextMessageCapable.h>
#include <mrpt/opengl/gl_utils.h>
 
#include "opengl_internals.h"
 
using namespace std;
using namespace mrpt;
using namespace mrpt::opengl;
 
/** Renders the messages to the current opengl rendering context (to be called
 * OUT of MRPT mrpt::opengl render() methods ).
  *  (w,h) are the dimensions of the rendering area in pixels.
  */
void CTextMessageCapable::render_text_messages(const int w, const int h) const
{
#if MRPT_HAS_OPENGL_GLUT
    // Render text labels as opengl primitives (much faster):
    GLint old_matMode = 0;
    glGetIntegerv(GL_MATRIX_MODE, &old_matMode);
 
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
 
    glLoadIdentity();
    glOrtho(0, w, 0, h, -1, 1);
 
    glMatrixMode(GL_MODELVIEW);
 
    glDisable(GL_DEPTH_TEST);
 
    for (std::map<size_t, mrpt::opengl::T2DTextData>::const_iterator it =
             m_2D_texts.begin();
         it != m_2D_texts.end(); ++it)
    {
        // If (x,y) \in [0,1[, it's interpreted as a ratio, otherwise, as an
        // actual coordinate in pixels
        const int x = it->second.x >= 1
                          ? int(it->second.x)
                          : (it->second.x < 0 ? int(w + it->second.x)
                                              : int(it->second.x * w));
        const int y = it->second.y >= 1
                          ? int(it->second.y)
                          : (it->second.y < 0 ? int(h + it->second.y)
                                              : int(it->second.y * h));
 
        // Font size and family:
        double font_size = 10;
        string font_name = "sans";
        TOpenGLFontStyle font_style = mrpt::opengl::FILL;
        double font_spacing = 1.5;
        double font_kerning = 0.1;
 
        switch (it->second.font)
        {
            case MRPT_GLUT_BITMAP_TIMES_ROMAN_10:
                font_size = 10;
                font_name = "sans";
                break;
            case MRPT_GLUT_BITMAP_TIMES_ROMAN_24:
                font_size = 24;
                font_name = "sans";
                break;
            case MRPT_GLUT_BITMAP_HELVETICA_10:
                font_size = 10;
                font_name = "mono";
                break;
            case MRPT_GLUT_BITMAP_HELVETICA_12:
                font_size = 12;
                font_name = "mono";
                break;
            case MRPT_GLUT_BITMAP_HELVETICA_18:
                font_size = 18;
                font_name = "mono";
                break;
 
            // This means this is a vectorized font, so just copy the parameters
            // set by the user:
            case MRPT_GLUT_BITMAP_NONE:
                font_size = it->second.vfont_scale;
                font_name = it->second.vfont_name;
                font_style = it->second.vfont_style;
                font_spacing = it->second.vfont_spacing;
                font_kerning = it->second.vfont_kerning;
                break;
 
            default:
                std::cerr << "[CTextMessageCapable::render_text_messages] "
                             "Invalid value for TOpenGLFont\n";
                break;
        };
 
        if (it->second.draw_shadow)
        {
            // Draw shadow:
            glPushMatrix();
 
            glTranslatef(x + 1, y - 1, 0.0);
            glColor3f(
                it->second.shadow_color.R, it->second.shadow_color.G,
                it->second.shadow_color.B);
            mrpt::opengl::gl_utils::glSetFont(font_name);
            mrpt::opengl::gl_utils::glDrawText(
                it->second.text, font_size, font_style, font_spacing,
                font_kerning);
 
            glPopMatrix();
        }
 
        // Draw text:
        glPushMatrix();
 
        glTranslatef(x, y, 0.0);
        glColor3f(it->second.color.R, it->second.color.G, it->second.color.B);
        mrpt::opengl::gl_utils::glSetFont(font_name);
        mrpt::opengl::gl_utils::glDrawText(
            it->second.text, font_size, font_style, font_spacing, font_kerning);
 
        glPopMatrix();
    }
 
    glEnable(GL_DEPTH_TEST);
 
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
 
    if (old_matMode != GL_PROJECTION) glMatrixMode(old_matMode);
 
#else
    MRPT_UNUSED_PARAM(w);
    MRPT_UNUSED_PARAM(h);
#endif
}
 
void CTextMessageCapable::clearTextMessages() { m_2D_texts.clear(); }
void CTextMessageCapable::addTextMessage(
    const double x_frac, const double y_frac, const std::string& text,
    const mrpt::img::TColorf& color, const size_t unique_index,
    const mrpt::opengl::TOpenGLFont font)
{
    mrpt::opengl::T2DTextData d;
    d.text = text;
    d.color = color;
    d.x = x_frac;
    d.y = y_frac;
    d.font = font;
 
    m_2D_texts[unique_index] = d;
}
 
/** Just updates the text of a given text message, without touching the other
 * parameters.
  * \return false if given ID doesn't exist.
  */
bool CTextMessageCapable::updateTextMessage(
    const size_t unique_index, const std::string& text)
{
    std::map<size_t, mrpt::opengl::T2DTextData>::iterator it =
        m_2D_texts.find(unique_index);
    if (it == m_2D_texts.end())
        return false;
    else
    {
        it->second.text = text;
        return true;
    }
}
 
/// overload with more font parameters - refer to
/// mrpt::opengl::gl_utils::glDrawText()
void CTextMessageCapable::addTextMessage(
    const double x_frac, const double y_frac, const std::string& text,
    const mrpt::img::TColorf& color, const std::string& font_name,
    const double font_size, const mrpt::opengl::TOpenGLFontStyle font_style,
    const size_t unique_index, const double font_spacing,
    const double font_kerning, const bool has_shadow,
    const mrpt::img::TColorf& shadow_color)
{
    mrpt::opengl::T2DTextData d;
    d.text = text;
    d.color = color;
    d.draw_shadow = has_shadow;
    d.shadow_color = shadow_color;
    d.x = x_frac;
    d.y = y_frac;
    d.font = MRPT_GLUT_BITMAP_NONE;  // It's not a bitmapped font
    d.vfont_name = font_name;
    d.vfont_scale = font_size;
    d.vfont_style = font_style;
    d.vfont_spacing = font_spacing;
    d.vfont_kerning = font_kerning;
 
    m_2D_texts[unique_index] = d;
}