gl_utils.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, 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/gl_utils.h>  // Include these before windows.h!!
#include <mrpt/system/os.h>
#include "opengl_internals.h"

#include <map>

using namespace std;
using namespace mrpt;
using namespace mrpt::math;
using namespace mrpt::poses;
using namespace mrpt::system;
using namespace mrpt::opengl;
using namespace mrpt::utils;

/** For each object in the list:
*   - checks visibility of each object
*   - prepare the GL_MODELVIEW matrix according to its coordinates
*   - call its ::render()
*   - shows its name (if enabled).
*/
void gl_utils::renderSetOfObjects(const CListOpenGLObjects& objectsToRender)
{
#if MRPT_HAS_OPENGL_GLUT
        MRPT_PROFILE_FUNC_START  // Just the non-try/catch part of MRPT_START

                CListOpenGLObjects::const_iterator itP;
        try
        {
                for (itP = objectsToRender.begin(); itP != objectsToRender.end(); ++itP)
                {
                        if (!*itP) continue;
                        const CRenderizable* it =
                                itP->get();  // Use plain pointers, faster than smart pointers:
                        if (!it->isVisible()) continue;

                        // 3D coordinates transformation:
                        glMatrixMode(GL_MODELVIEW);
                        glPushMatrix();

                        glPushAttrib(GL_CURRENT_BIT);  // drawing color, etc
                        glPushAttrib(GL_LIGHTING_BIT);  // lighting
                        // gl_utils::checkOpenGLError();

                        // It's more efficient to prepare the 4x4 matrix ourselves and load
                        // it directly into opengl stack:
                        //  A homogeneous transformation matrix, in this order:
                        //
                        //     0  4  8  12
                        //     1  5  9  13
                        //     2  6  10 14
                        //     3  7  11 15
                        //
                        const CPose3D& pos = it->getPoseRef();
                        const CMatrixDouble33& R = pos.getRotationMatrix();
                        const GLdouble m[16] = {
                                R.coeff(0, 0),   R.coeff(1, 0),   R.coeff(2, 0),   0,
                                R.coeff(0, 1),   R.coeff(1, 1),   R.coeff(2, 1),   0,
                                R.coeff(0, 2),   R.coeff(1, 2),   R.coeff(2, 2),   0,
                                pos.m_coords[0], pos.m_coords[1], pos.m_coords[2], 1};
                        glMultMatrixd(m);  // Multiply so it's composed with the previous,
                        // current MODELVIEW matrix

                        // Do scaling after the other transformations!
                        if (it->getScaleX() != 1 || it->getScaleY() != 1 ||
                                it->getScaleZ() != 1)
                                glScalef(it->getScaleX(), it->getScaleY(), it->getScaleZ());

                        // Set color:
                        glColor4f(
                                it->getColorR(), it->getColorG(), it->getColorB(),
                                it->getColorA());

                        it->render();
                        gl_utils::checkOpenGLError();

                        if (it->isShowNameEnabled())
                        {
                                glDisable(GL_DEPTH_TEST);
                                glColor3f(
                                        1.f, 1.f, 1.f);  // Must be called BEFORE glRasterPos3f
                                glRasterPos3f(0.0f, 0.0f, 0.0f);

                                GLfloat raster_pos[4];
                                glGetFloatv(GL_CURRENT_RASTER_POSITION, raster_pos);
                                float eye_distance = raster_pos[3];

                                void* font = nullptr;
                                if (eye_distance < 2)
                                        font = GLUT_BITMAP_TIMES_ROMAN_24;
                                else if (eye_distance < 200)
                                        font = GLUT_BITMAP_TIMES_ROMAN_10;

                                if (font)
                                        CRenderizable::renderTextBitmap(
                                                it->getName().c_str(), font);

                                glEnable(GL_DEPTH_TEST);
                        }

                        glPopAttrib();
                        glPopAttrib();
                        //                      gl_utils::checkOpenGLError();

                        glPopMatrix();
                        gl_utils::checkOpenGLError();

                }  // end foreach object
        }
        catch (exception& e)
        {
                char str[1000];
                os::sprintf(
                        str, 1000, "Exception while rendering a class '%s'\n%s",
                        (*itP)->GetRuntimeClass()->className, e.what());
                THROW_EXCEPTION(str);
        }
        catch (...)
        {
                THROW_EXCEPTION("Runtime error!");
        }
#else
        MRPT_UNUSED_PARAM(objectsToRender);
#endif
}

/*---------------------------------------------------------------
                                        checkOpenGLError
  ---------------------------------------------------------------*/
void gl_utils::checkOpenGLError()
{
#if MRPT_HAS_OPENGL_GLUT
        int openglErr;
        if ((openglErr = glGetError()) != GL_NO_ERROR)
        {
                const std::string sErr = std::string("OpenGL error: ") +
                                                                 std::string((char*)gluErrorString(openglErr));
                std::cerr << "[gl_utils::checkOpenGLError] " << sErr << std::endl;
                // THROW_EXCEPTION(sErr)
        }
#endif
}

void gl_utils::renderTriangleWithNormal(
        const mrpt::math::TPoint3D& p1, const mrpt::math::TPoint3D& p2,
        const mrpt::math::TPoint3D& p3)
{
#if MRPT_HAS_OPENGL_GLUT
        const float ax = p2.x - p1.x;
        const float ay = p2.y - p1.y;
        const float az = p2.z - p1.z;

        const float bx = p3.x - p1.x;
        const float by = p3.y - p1.y;
        const float bz = p3.z - p1.z;

        glNormal3f(ay * bz - az * by, -ax * bz + az * bx, ax * by - ay * bx);

        glVertex3f(p1.x, p1.y, p1.z);
        glVertex3f(p2.x, p2.y, p2.z);
        glVertex3f(p3.x, p3.y, p3.z);
#else
        MRPT_UNUSED_PARAM(p1);
        MRPT_UNUSED_PARAM(p2);
        MRPT_UNUSED_PARAM(p3);
#endif
}
void gl_utils::renderTriangleWithNormal(
        const mrpt::math::TPoint3Df& p1, const mrpt::math::TPoint3Df& p2,
        const mrpt::math::TPoint3Df& p3)
{
#if MRPT_HAS_OPENGL_GLUT
        const float ax = p2.x - p1.x;
        const float ay = p2.y - p1.y;
        const float az = p2.z - p1.z;

        const float bx = p3.x - p1.x;
        const float by = p3.y - p1.y;
        const float bz = p3.z - p1.z;

        glNormal3f(ay * bz - az * by, -ax * bz + az * bx, ax * by - ay * bx);

        glVertex3f(p1.x, p1.y, p1.z);
        glVertex3f(p2.x, p2.y, p2.z);
        glVertex3f(p3.x, p3.y, p3.z);
#else
        MRPT_UNUSED_PARAM(p1);
        MRPT_UNUSED_PARAM(p2);
        MRPT_UNUSED_PARAM(p3);
#endif
}
void gl_utils::renderQuadWithNormal(
        const mrpt::math::TPoint3Df& p1, const mrpt::math::TPoint3Df& p2,
        const mrpt::math::TPoint3Df& p3, const mrpt::math::TPoint3Df& p4)
{
        renderTriangleWithNormal(p1, p2, p3);
        renderTriangleWithNormal(p3, p4, p1);
}

/** Gather useful information on the render parameters.
  *  It can be called from within the render() method of derived classes.
  */
void gl_utils::getCurrentRenderingInfo(TRenderInfo& ri)
{
#if MRPT_HAS_OPENGL_GLUT
        // Viewport geometry:
        GLint win_dims[4];
        glGetIntegerv(GL_VIEWPORT, win_dims);
        ri.vp_x = win_dims[0];
        ri.vp_y = win_dims[1];
        ri.vp_width = win_dims[2];
        ri.vp_height = win_dims[3];

        // Get the inverse camera position:
        GLfloat mat_proj[16];
        glGetFloatv(GL_PROJECTION_MATRIX, mat_proj);
        ri.proj_matrix = Eigen::Matrix<float, 4, 4, Eigen::ColMajor>(mat_proj);

        // Extract the camera position:
        Eigen::Matrix<float, 4, 1> cam_pose_hm = ri.proj_matrix.inverse().col(3);
        if (cam_pose_hm[3] != 0)
        {
                ri.camera_position.x = cam_pose_hm[0] / cam_pose_hm[3];
                ri.camera_position.y = cam_pose_hm[1] / cam_pose_hm[3];
                ri.camera_position.z = cam_pose_hm[2] / cam_pose_hm[3];
        }
        else
                ri.camera_position = mrpt::math::TPoint3Df(0, 0, 0);

        // Get the model transformation:
        GLfloat mat_mod[16];
        glGetFloatv(GL_MODELVIEW_MATRIX, mat_mod);
        ri.model_matrix = Eigen::Matrix<float, 4, 4, Eigen::ColMajor>(mat_mod);

        // PROJ * MODEL
        ri.full_matrix = ri.proj_matrix * ri.model_matrix;
#else
        MRPT_UNUSED_PARAM(ri);
#endif
}

/*---------------------------------------------------------------
                                        renderTextBitmap
  ---------------------------------------------------------------*/
void gl_utils::renderTextBitmap(const char* str, void* fontStyle)
{
#if MRPT_HAS_OPENGL_GLUT
        while (*str) glutBitmapCharacter(fontStyle, *(str++));
#else
        MRPT_UNUSED_PARAM(str);
        MRPT_UNUSED_PARAM(fontStyle);
#endif
}

void* aux_mrptfont2glutfont(const TOpenGLFont font)
{
#if MRPT_HAS_OPENGL_GLUT
        switch (font)
        {
                default:
                case MRPT_GLUT_BITMAP_TIMES_ROMAN_10:
                        return GLUT_BITMAP_TIMES_ROMAN_10;
                        break;
                case MRPT_GLUT_BITMAP_TIMES_ROMAN_24:
                        return GLUT_BITMAP_TIMES_ROMAN_24;
                        break;

                case MRPT_GLUT_BITMAP_HELVETICA_10:
                        return GLUT_BITMAP_HELVETICA_10;
                        break;
                case MRPT_GLUT_BITMAP_HELVETICA_12:
                        return GLUT_BITMAP_HELVETICA_12;
                        break;
                case MRPT_GLUT_BITMAP_HELVETICA_18:
                        return GLUT_BITMAP_HELVETICA_18;
                        break;
        }
#else
        MRPT_UNUSED_PARAM(font);
        return nullptr;
#endif
}

/** Return the exact width in pixels for a given string, as will be rendered by
 * renderTextBitmap().
  * \sa renderTextBitmap
  */
int gl_utils::textBitmapWidth(
        const std::string& str, mrpt::opengl::TOpenGLFont font)
{
#if MRPT_HAS_OPENGL_GLUT
        if (str.empty()) return 0;
        return glutBitmapLength(
                aux_mrptfont2glutfont(font), (const unsigned char*)str.c_str());
#else
        MRPT_UNUSED_PARAM(str);
        MRPT_UNUSED_PARAM(font);
        return 10;
#endif
}

/*---------------------------------------------------------------
                                        renderTextBitmap
  ---------------------------------------------------------------*/
void CRenderizable::renderTextBitmap(
        int screen_x, int screen_y, const std::string& str, float color_r,
        float color_g, float color_b, TOpenGLFont font)
{
#if MRPT_HAS_OPENGL_GLUT
        glDisable(GL_DEPTH_TEST);

        // If (x,y) are negative, wrap to the opposite side:
        if (screen_x < 0 || screen_y < 0)
        {
                // Size of the viewport:
                GLint win_dims[4];  // [2]:width ,[3]:height
                glGetIntegerv(GL_VIEWPORT, win_dims);

                if (screen_x < 0) screen_x += win_dims[2];
                if (screen_y < 0) screen_y += win_dims[3];
        }

        // Draw text:
        glColor3f(color_r, color_g, color_b);

        // From: http://www.mesa3d.org/brianp/sig97/gotchas.htm
        GLfloat fx, fy;

        /* Push current matrix mode and viewport attributes */
        glPushAttrib(GL_TRANSFORM_BIT | GL_VIEWPORT_BIT);

        /* Setup projection parameters */
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();

        // glDepthRange( z, z );
        glViewport((int)screen_x - 1, (int)screen_y - 1, 2, 2);

        /* set the raster (window) position */
        fx = screen_x - (int)screen_x;
        fy = screen_y - (int)screen_y;
        // glRasterPos4f( fx, fy, 0.0, w );
        glRasterPos3f(fx, fy, 0.0);

        /* restore matrices, viewport and matrix mode */
        glPopMatrix();
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glPopAttrib();

        // Select font:
        void* glut_font_sel = aux_mrptfont2glutfont(font);

        for (size_t i = 0; i < str.size(); i++)
                glutBitmapCharacter(glut_font_sel, str[i]);

        glEnable(GL_DEPTH_TEST);
#else
        MRPT_UNUSED_PARAM(screen_x);
        MRPT_UNUSED_PARAM(screen_y);
        MRPT_UNUSED_PARAM(str);
        MRPT_UNUSED_PARAM(color_r);
        MRPT_UNUSED_PARAM(color_g);
        MRPT_UNUSED_PARAM(color_b);
        MRPT_UNUSED_PARAM(font);
#endif
}

void gl_utils::renderMessageBox(
        const float msg_x, const float msg_y, const float msg_w, const float msg_h,
        const std::string& text, float text_scale,
        const mrpt::utils::TColor& back_col, const mrpt::utils::TColor& border_col,
        const mrpt::utils::TColor& text_col, const float border_width,
        const std::string& text_font, mrpt::opengl::TOpenGLFontStyle text_style,
        const double text_spacing, const double text_kerning)
{
#if MRPT_HAS_OPENGL_GLUT
        const int nLines = 1 + std::count(text.begin(), text.end(), '\n');

        GLint win_dims[4];
        glGetIntegerv(GL_VIEWPORT, win_dims);
        const int w = win_dims[2];
        const int h = win_dims[3];

        const int min_wh = std::min(w, h);
        const float vw_w = w / float(min_wh);
        const float vw_h = h / float(min_wh);

        glMatrixMode(GL_PROJECTION);
        glPushMatrix();

        glLoadIdentity();
        glOrtho(0, vw_w, 0, vw_h, -1, 1);

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();

        glLoadIdentity();

        glDisable(GL_DEPTH_TEST);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        // The center of the message box:
        const float msg_x0 = vw_w * msg_x;
        const float msg_y0 = vw_h * msg_y;

        const float msg_x1 = vw_w * (msg_x + msg_w);
        const float msg_y1 = vw_h * (msg_y + msg_h);

        const float msg_real_w = msg_x1 - msg_x0;
        const float msg_real_h = msg_y1 - msg_y0;

        const float msg_cx = .5 * (msg_x0 + msg_x1);
        const float msg_cy = .5 * (msg_y0 + msg_y1);

        // Background:
        glColor4ub(back_col.R, back_col.G, back_col.B, back_col.A);
        glBegin(GL_TRIANGLE_FAN);
        glVertex2f(msg_x0, msg_y0);
        glVertex2f(msg_x1, msg_y0);
        glVertex2f(msg_x1, msg_y1);
        glVertex2f(msg_x0, msg_y1);
        glEnd();

        // Border:
        glColor4ub(border_col.R, border_col.G, border_col.B, border_col.A);
        glLineWidth(border_width);
        glDisable(GL_LIGHTING);  // Disable lights when drawing lines
        glBegin(GL_LINE_LOOP);
        glVertex2f(msg_x0, msg_y0);
        glVertex2f(msg_x1, msg_y0);
        glVertex2f(msg_x1, msg_y1);
        glVertex2f(msg_x0, msg_y1);
        glEnd();
        glEnable(GL_LIGHTING);  // Disable lights when drawing lines

        // Draw text (centered):
        gl_utils::glSetFont(text_font);
        mrpt::utils::TPixelCoordf txtSize =
                gl_utils::glGetExtends(text, text_scale, text_spacing, text_kerning);

        // Adjust text size if it doesn't fit into the box:
        if (txtSize.x > msg_real_w)
        {
                const float K = 0.99f * msg_real_w / txtSize.x;
                text_scale *= K;
                txtSize.x *= K;
                txtSize.y *= K;
        }
        if (txtSize.y > msg_real_h)
        {
                const float K = 0.99f * msg_real_h / txtSize.y;
                text_scale *= K;
                txtSize.x *= K;
                txtSize.y *= K;
        }

        const float text_w = txtSize.x;
        const float text_h =
                (nLines > 1 ? -(nLines - 1) * txtSize.y / float(nLines) : txtSize.y);
        const float text_x0 = msg_cx - .5f * text_w;
        const float text_y0 = msg_cy - .5f * text_h;

        glTranslatef(text_x0, text_y0, 0);
        glColor4ub(text_col.R, text_col.G, text_col.B, text_col.A);
        gl_utils::glDrawText(
                text, text_scale, text_style, text_spacing, text_kerning);

        // Restore gl flags:
        glEnable(GL_DEPTH_TEST);
        glDisable(GL_BLEND);

        glPopMatrix();

        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
#else
        MRPT_UNUSED_PARAM(msg_x);
        MRPT_UNUSED_PARAM(msg_y);
        MRPT_UNUSED_PARAM(msg_w);
        MRPT_UNUSED_PARAM(msg_h);
        MRPT_UNUSED_PARAM(text);
        MRPT_UNUSED_PARAM(text_scale);
        MRPT_UNUSED_PARAM(back_col);
        MRPT_UNUSED_PARAM(border_col);
        MRPT_UNUSED_PARAM(text_col);
        MRPT_UNUSED_PARAM(border_width);
        MRPT_UNUSED_PARAM(text_font);
        MRPT_UNUSED_PARAM(text_style);
        MRPT_UNUSED_PARAM(text_spacing);
        MRPT_UNUSED_PARAM(text_kerning);
#endif
}

//  ===============  START OF CODE FROM "libcvd -> gltext.cpp" ===============
//    License: LGPL
#if MRPT_HAS_OPENGL_GLUT
namespace Internal
{
struct Point
{
        float x, y;
};

struct Font
{
        typedef unsigned short Index;

        struct Char
        {
                Index vertexOffset;
                Index triangleOffset;
                Index outlineOffset;
                GLsizei numTriangles;
                GLsizei numOutlines;
                float advance;
        };

        Point* vertices;
        Index* triangles;
        Index* outlines;
        Char* characters;
        string glyphs;

        const Char* findChar(const char c) const
        {
                size_t ind = glyphs.find(c);
                if (ind == string::npos) return nullptr;
                return characters + ind;
        }

        float getAdvance(const char c) const
        {
                const Char* ch = findChar(c);
                if (!ch) return 0;
                return ch->advance;
        }

        void fill(const char c) const
        {
                const Char* ch = findChar(c);
                if (!ch || !ch->numTriangles) return;
                glVertexPointer(2, GL_FLOAT, 0, vertices + ch->vertexOffset);
                glDisable(GL_LIGHTING);  // Disable lights when drawing lines
                glDrawElements(
                        GL_TRIANGLES, ch->numTriangles, GL_UNSIGNED_SHORT,
                        triangles + ch->triangleOffset);
                glEnable(GL_LIGHTING);
        }

        void outline(const char c) const
        {
                const Char* ch = findChar(c);
                if (!ch || !ch->numOutlines) return;
                glVertexPointer(2, GL_FLOAT, 0, vertices + ch->vertexOffset);
                glDisable(GL_LIGHTING);  // Disable lights when drawing lines
                glDrawElements(
                        GL_LINES, ch->numOutlines, GL_UNSIGNED_SHORT,
                        outlines + ch->outlineOffset);
                glEnable(GL_LIGHTING);
        }

        void draw(const char c) const
        {
                const Char* ch = findChar(c);
                if (!ch || !ch->numTriangles || !ch->numOutlines) return;
                glVertexPointer(2, GL_FLOAT, 0, vertices + ch->vertexOffset);
                glDisable(GL_LIGHTING);  // Disable lights when drawing lines
                glDrawElements(
                        GL_TRIANGLES, ch->numTriangles, GL_UNSIGNED_SHORT,
                        triangles + ch->triangleOffset);
                glDrawElements(
                        GL_LINES, ch->numOutlines, GL_UNSIGNED_SHORT,
                        outlines + ch->outlineOffset);
                glEnable(GL_LIGHTING);  // Disable lights when drawing lines
        }
};

// the fonts defined in these headers are derived from Bitstream Vera fonts. See
// http://www.gnome.org/fonts/ for license and details
#include "glfont_sans.h"
#include "glfont_mono.h"
#include "glfont_serif.h"

struct FontData
{
        typedef map<string, Font*> FontMap;

        FontData()
        {
                fonts["sans"] = &sans_font;
                fonts["mono"] = &mono_font;
                fonts["serif"] = &serif_font;
                gl_utils::glSetFont("sans");
        }
        inline Font* currentFont() { return fonts[currentFontName]; }
        string currentFontName;
        FontMap fonts;
};

static struct FontData data;
}  // namespace Internal
#endif

void gl_utils::glSetFont(const std::string& fontname)
{
#if MRPT_HAS_OPENGL_GLUT
        if (Internal::data.fonts.count(fontname) > 0)
                Internal::data.currentFontName = fontname;
#else
        MRPT_UNUSED_PARAM(fontname);
#endif
}

const std::string& gl_utils::glGetFont()
{
#if MRPT_HAS_OPENGL_GLUT
        return Internal::data.currentFontName;
#else
        THROW_EXCEPTION("MRPT built without OpenGL")
#endif
}

mrpt::utils::TPixelCoordf gl_utils::glDrawText(
        const std::string& text, const double textScale,
        enum TOpenGLFontStyle style, double spacing, double kerning)
{
#if MRPT_HAS_OPENGL_GLUT
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        if (style == NICE)
        {
                glPushAttrib(GL_COLOR_BUFFER_BIT | GL_LINE_BIT);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                glEnable(GL_LINE_SMOOTH);
                glLineWidth(1);
        }
        glEnableClientState(GL_VERTEX_ARRAY);

        // figure out which operation to do on the Char (yes, this is a pointer to
        // member function :)
        void (Internal::Font::*operation)(const char c) const;
        operation = nullptr;
        switch (style)
        {
                case FILL:
                        operation = &Internal::Font::fill;
                        break;
                case OUTLINE:
                        operation = &Internal::Font::outline;
                        break;
                case NICE:
                        operation = &Internal::Font::draw;
                        break;
                default:
                        THROW_EXCEPTION("Invalid text style value.");
        }

        // Scale of the text:
        glScaled(textScale, textScale, textScale);

        int lines = 0;
        double max_total = 0;
        double total = 0;
        const Internal::Font* font = Internal::data.currentFont();
        const Internal::Font::Char* space = font->findChar(' ');
        const double tab_width = 8 * ((space) ? (space->advance) : 1);
        for (size_t i = 0; i < text.length(); ++i)
        {
                char c = text[i];
                if (c == '\n')
                {
                        glTranslated(-total, -spacing, 0);
                        max_total = std::max(max_total, total);
                        total = 0;
                        ++lines;
                        continue;
                }
                if (c == '\t')
                {
                        const float advance = tab_width - std::fmod(total, tab_width);
                        total += advance;
                        glTranslated(advance, 0, 0);
                        continue;
                }
                const Internal::Font::Char* ch = font->findChar(c);
                if (!ch)
                {
                        c = toupper(c);
                        ch = font->findChar(c);
                        if (!ch)
                        {
                                c = '?';
                                ch = font->findChar(c);
                        }
                }
                if (!ch) continue;
                (font->*operation)(c);

                double w = ch->advance + kerning;
                glTranslated(w, 0, 0);
                total += w;
        }

        glDisableClientState(GL_VERTEX_ARRAY);
        if (style == NICE)
        {
                glPopAttrib();
        }
        glPopMatrix();

        max_total = std::max(total, max_total);

        return mrpt::utils::TPixelCoordf(
                textScale * max_total, textScale * (lines + 1) * spacing);
#else
        MRPT_UNUSED_PARAM(text);
        MRPT_UNUSED_PARAM(textScale);
        MRPT_UNUSED_PARAM(style);
        MRPT_UNUSED_PARAM(spacing);
        MRPT_UNUSED_PARAM(kerning);
        THROW_EXCEPTION("MRPT built without OpenGL")
#endif
}

mrpt::utils::TPixelCoordf gl_utils::glGetExtends(
        const std::string& text, const double textScale, double spacing,
        double kerning)
{
#if MRPT_HAS_OPENGL_GLUT
        int lines = 0;
        double max_total = 0;
        double total = 0;
        const Internal::Font* font = Internal::data.currentFont();
        for (size_t i = 0; i < text.length(); ++i)
        {
                char c = text[i];
                if (c == '\n')
                {
                        max_total = std::max(max_total, total);
                        total = 0;
                        ++lines;
                        continue;
                }
                const Internal::Font::Char* ch = font->findChar(c);
                if (!ch)
                {
                        c = toupper(c);
                        ch = font->findChar(c);
                        if (!ch)
                        {
                                c = '?';
                                ch = font->findChar(c);
                        }
                }
                if (!ch) continue;
                total += ch->advance + kerning;
        }
        max_total = std::max(total, max_total);
        return mrpt::utils::TPixelCoordf(
                textScale * max_total, textScale * (lines + 1) * spacing);
#else
        MRPT_UNUSED_PARAM(text);
        MRPT_UNUSED_PARAM(textScale);
        MRPT_UNUSED_PARAM(spacing);
        MRPT_UNUSED_PARAM(kerning);
        THROW_EXCEPTION("MRPT built without OpenGL")
#endif
}
//  ===============  END OF CODE FROM "libcvd -> gltext.cpp" ===============