COpenGLViewport.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/COpenGLViewport.h>
#include <mrpt/opengl/COpenGLScene.h>
#include <mrpt/opengl/CSetOfObjects.h>
#include <mrpt/opengl/CTexturedPlane.h>
#include <mrpt/system/CTimeLogger.h>
#include <mrpt/serialization/CArchive.h>
#include <mrpt/serialization/stl_serialization.h>
#include <mrpt/serialization/metaprogramming_serialization.h>
#include <mrpt/opengl/gl_utils.h>
 
#include "opengl_internals.h"
 
using namespace mrpt;
using namespace mrpt::poses;
using namespace mrpt::opengl;
using namespace mrpt::math;
using namespace mrpt::serialization::metaprogramming;
using namespace std;
 
//// using namespace mrpt::utils::metaprogramming;
 
IMPLEMENTS_SERIALIZABLE(COpenGLViewport, CSerializable, mrpt::opengl)
 
//#define OPENGLVIEWPORT_ENABLE_TIMEPROFILING
 
#if defined(OPENGLVIEWPORT_ENABLE_TIMEPROFILING)
mrpt::system::CTimeLogger glv_timlog;
#endif
 
/*--------------------------------------------------------------
 
                        IMPLEMENTATION OF COpenGLViewport
 
  ---------------------------------------------------------------*/
 
/*--------------------------------------------------------------
                                        Constructor
  ---------------------------------------------------------------*/
COpenGLViewport::COpenGLViewport(COpenGLScene* parent, const string& name)
        : m_camera(),
          m_parent(parent),
          m_isCloned(false),
          m_isClonedCamera(false),
          m_clonedViewport(),
          m_name(name),
          m_isTransparent(false),
          m_borderWidth(0),
          m_view_x(0),
          m_view_y(0),
          m_view_width(1),
          m_view_height(1),
          m_clip_min(0.1),
          m_clip_max(10000),
          m_custom_backgb_color(false),
          m_background_color(0.6f, 0.6f, 0.6f),
          m_isImageView(false),
          m_imageview_img(),
          m_objects(),
          // OpenGL settings:
          m_OpenGL_enablePolygonNicest(true),
          m_lights()
{
        // Default: one light from default direction
        m_lights.push_back(CLight());
        m_lights.push_back(CLight());
 
        m_lights[0].setPosition(1, 1, 1, 0);
        m_lights[0].setDirection(-1, -1, -1);
 
        m_lights[1].light_ID = 1;
        m_lights[1].setPosition(1, 2, -1, 0);
        m_lights[1].setDirection(1, 2, 1);
 
        m_lights[1].color_diffuse[0] = 0.3f;
        m_lights[1].color_diffuse[1] = 0.3f;
        m_lights[1].color_diffuse[2] = 0.3f;
 
        m_lights[1].color_ambient[0] = 0.3f;
        m_lights[1].color_ambient[1] = 0.3f;
        m_lights[1].color_ambient[2] = 0.3f;
}
 
/*--------------------------------------------------------------
                                        Destructor
  ---------------------------------------------------------------*/
COpenGLViewport::~COpenGLViewport() { clear(); }
/*--------------------------------------------------------------
                                        setCloneView
  ---------------------------------------------------------------*/
void COpenGLViewport::setCloneView(const string& clonedViewport)
{
        clear();
        m_isCloned = true;
        m_clonedViewport = clonedViewport;
}
 
/*--------------------------------------------------------------
                                        setViewportPosition
  ---------------------------------------------------------------*/
void COpenGLViewport::setViewportPosition(
        const double x, const double y, const double width, const double height)
{
        MRPT_START
        ASSERT_(m_view_width > 0);
        ASSERT_(m_view_height > 0);
 
        m_view_x = x;
        m_view_y = y;
        m_view_width = width;
        m_view_height = height;
 
        MRPT_END
}
 
/*--------------------------------------------------------------
                                        getViewportPosition
  ---------------------------------------------------------------*/
void COpenGLViewport::getViewportPosition(
        double& x, double& y, double& width, double& height)
{
        x = m_view_x;
        y = m_view_y;
        width = m_view_width;
        height = m_view_height;
}
 
/*--------------------------------------------------------------
                                        clear
  ---------------------------------------------------------------*/
void COpenGLViewport::clear() { m_objects.clear(); }
/*--------------------------------------------------------------
                                        insert
  ---------------------------------------------------------------*/
void COpenGLViewport::insert(const CRenderizable::Ptr& newObject)
{
        m_objects.push_back(newObject);
}
 
/*---------------------------------------------------------------
                                                render
 ---------------------------------------------------------------*/
void COpenGLViewport::render(
        const int render_width, const int render_height) const
{
#if MRPT_HAS_OPENGL_GLUT
        const CRenderizable* it =
                nullptr;  // Declared here for usage in the "catch"
        try
        {
                // Change viewport:
                // -------------------------------------------
                const GLint vx = m_view_x > 1
                                                         ? GLint(m_view_x)
                                                         : (m_view_x < 0 ? GLint(render_width + m_view_x)
                                                                                         : GLint(render_width * m_view_x));
                const GLint vy = m_view_y > 1
                                                         ? GLint(m_view_y)
                                                         : (m_view_y < 0 ? GLint(render_height + m_view_y)
                                                                                         : GLint(render_height * m_view_y));
 
                GLint vw;
                if (m_view_width > 1)  // >1 -> absolute pixels:
                        vw = GLint(m_view_width);
                else if (m_view_width < 0)
                {  // Negative numbers: Specify the right side coordinates instead of
                        // the width:
                        if (m_view_width >= -1)
                                vw = GLint(-render_width * m_view_width - vx + 1);
                        else
                                vw = GLint(-m_view_width - vx + 1);
                }
                else  // A factor:
                {
                        vw = GLint(render_width * m_view_width);
                }
 
                GLint vh;
                if (m_view_height > 1)  // >1 -> absolute pixels:
                        vh = GLint(m_view_height);
                else if (m_view_height < 0)
                {  // Negative numbers: Specify the right side coordinates instead of
                        // the width:
                        if (m_view_height >= -1)
                                vh = GLint(-render_height * m_view_height - vy + 1);
                        else
                                vh = GLint(-m_view_height - vy + 1);
                }
                else  // A factor:
                        vh = GLint(render_height * m_view_height);
 
                glViewport(vx, vy, vw, vh);
 
                // Clear depth&/color buffers:
                // -------------------------------------------
                m_lastProjMat.viewport_width = vw;
                m_lastProjMat.viewport_height = vh;
 
                glScissor(vx, vy, vw, vh);
 
                glEnable(GL_SCISSOR_TEST);
                if (!m_isTransparent)
                {  // Clear color & depth buffers:
                        // Save?
                        GLdouble old_colors[4];
                        if (m_custom_backgb_color)
                        {
                                glGetDoublev(GL_COLOR_CLEAR_VALUE, old_colors);
                                glClearColor(
                                        m_background_color.R, m_background_color.G,
                                        m_background_color.B, m_background_color.A);
                        }
 
                        glClear(
                                GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT |
                                GL_ACCUM_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
                        // Restore old colors:
                        if (m_custom_backgb_color)
                                glClearColor(
                                        old_colors[0], old_colors[1], old_colors[2], old_colors[3]);
                }
                else
                {  // Clear depth buffer only:
                        glClear(GL_DEPTH_BUFFER_BIT);
                }
                glDisable(GL_SCISSOR_TEST);
 
                // If we are in "image mode", rendering is much simpler: just set
                //  ortho projection and render the image quad:
                if (m_isImageView)
                {
#if defined(OPENGLVIEWPORT_ENABLE_TIMEPROFILING)
                        glv_timlog.enter("COpenGLViewport::render imageview");
#endif
                        // "Image mode" rendering:
                        // -----------------------------------
                        if (m_imageview_img)  // should be ALWAYS true, but just in case!
                        {
                                // Note: The following code is inspired in the implementations:
                                //  - libcvd, by Edward Rosten http://www.edwardrosten.com/cvd/
                                //  - PTAM, by Klein & Murray
                                //  http://www.robots.ox.ac.uk/~gk/PTAM/
 
                                const mrpt::img::CImage* img = m_imageview_img.get();
 
                                const int img_w = img->getWidth();
                                const int img_h = img->getHeight();
 
                                if (img_w != 0 && img_h != 0)
                                {
                                        // Prepare an ortho projection:
                                        glMatrixMode(GL_PROJECTION);
                                        glLoadIdentity();
 
                                        // Need to adjust the aspect ratio?
                                        const double ratio = vw * img_h / double(vh * img_w);
                                        double ortho_w = img_w;
                                        double ortho_h = img_h;
                                        if (ratio > 1)
                                                ortho_w *= ratio;
                                        else if (ratio != 0)
                                                ortho_h /= ratio;
 
                                        glOrtho(-0.5, ortho_h - 0.5, ortho_w - 0.5, -0.5, -1, 1);
 
                                        // Prepare raster pos & pixel copy direction in -Y.
                                        glRasterPos2f(-0.5f, -0.5f);
                                        glPixelZoom(vw / float(ortho_w), -vh / float(ortho_h));
 
                                        // Prepare image data types:
                                        const GLenum img_type = GL_UNSIGNED_BYTE;
                                        const int nBytesPerPixel = img->isColor() ? 3 : 1;
                                        const bool is_RGB_order =
                                                (!::strcmp(
                                                        img->getChannelsOrder(),
                                                        "RGB"));  // Reverse RGB <-> BGR order?
                                        const GLenum img_format =
                                                nBytesPerPixel == 3 ? (is_RGB_order ? GL_RGB : GL_BGR)
                                                                                        : GL_LUMINANCE;
 
                                        // Send image data to OpenGL:
                                        glPixelStorei(
                                                GL_UNPACK_ROW_LENGTH,
                                                img->getRowStride() / nBytesPerPixel);
                                        glDrawPixels(
                                                img_w, img_h, img_format, img_type,
                                                img->get_unsafe(0, 0));
                                        glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);  // Reset
                                        CRenderizable::checkOpenGLError();
                                }
                        }
// done.
#if defined(OPENGLVIEWPORT_ENABLE_TIMEPROFILING)
                        glv_timlog.leave("COpenGLViewport::render imageview");
#endif
                }
                else
                {
                        // Non "image mode" rendering:
 
                        // Set camera:
                        // -------------------------------------------
                        glMatrixMode(GL_PROJECTION);
                        glLoadIdentity();
 
                        const CListOpenGLObjects* objectsToRender;
                        COpenGLViewport* viewForGetCamera;
 
                        if (m_isCloned)
                        {  // Clone: render someone's else objects.
                                ASSERT_(m_parent.get() != nullptr);
 
                                COpenGLViewport::Ptr view =
                                        m_parent->getViewport(m_clonedViewport);
                                if (!view)
                                        THROW_EXCEPTION_FMT(
                                                "Cloned viewport '%s' not found in parent COpenGLScene",
                                                m_clonedViewport.c_str());
 
                                objectsToRender = &view->m_objects;
                                viewForGetCamera = m_isClonedCamera
                                                                           ? view.get()
                                                                           : const_cast<COpenGLViewport*>(this);
                        }
                        else
                        {  // Normal case: render our own objects:
                                objectsToRender = &m_objects;
                                viewForGetCamera = const_cast<COpenGLViewport*>(this);
                        }
 
                        // Get camera:
                        // 1st: if there is a CCamera in the scene:
                        CRenderizable::Ptr cam_ptr =
                                viewForGetCamera->getByClass<CCamera>();
 
                        CCamera* myCamera = nullptr;
                        if (cam_ptr)
                        {
                                myCamera = dynamic_cast<CCamera*>(cam_ptr.get());
                        }
 
                        // 2nd: the internal camera of all viewports:
                        if (!myCamera) myCamera = &viewForGetCamera->m_camera;
 
                        ASSERT_(m_camera.m_distanceZoom > 0);
 
                        m_lastProjMat.azimuth = DEG2RAD(myCamera->m_azimuthDeg);
                        m_lastProjMat.elev = DEG2RAD(myCamera->m_elevationDeg);
 
                        const float dis = max(0.01f, myCamera->m_distanceZoom);
                        m_lastProjMat.eye.x =
                                myCamera->m_pointingX +
                                dis * cos(m_lastProjMat.azimuth) * cos(m_lastProjMat.elev);
                        m_lastProjMat.eye.y =
                                myCamera->m_pointingY +
                                dis * sin(m_lastProjMat.azimuth) * cos(m_lastProjMat.elev);
                        m_lastProjMat.eye.z =
                                myCamera->m_pointingZ + dis * sin(m_lastProjMat.elev);
 
                        if (fabs(fabs(myCamera->m_elevationDeg) - 90) > 1e-6)
                        {
                                m_lastProjMat.up.x = 0;
                                m_lastProjMat.up.y = 0;
                                m_lastProjMat.up.z = 1;
                        }
                        else
                        {
                                float sgn = myCamera->m_elevationDeg > 0 ? 1 : -1;
                                m_lastProjMat.up.x =
                                        -cos(DEG2RAD(myCamera->m_azimuthDeg)) * sgn;
                                m_lastProjMat.up.y =
                                        -sin(DEG2RAD(myCamera->m_azimuthDeg)) * sgn;
                                m_lastProjMat.up.z = 0;
                        }
 
                        m_lastProjMat.is_projective = myCamera->m_projectiveModel;
                        m_lastProjMat.FOV = myCamera->m_projectiveFOVdeg;
                        m_lastProjMat.pointing.x = myCamera->m_pointingX;
                        m_lastProjMat.pointing.y = myCamera->m_pointingY;
                        m_lastProjMat.pointing.z = myCamera->m_pointingZ;
                        m_lastProjMat.zoom = myCamera->m_distanceZoom;
 
                        if (myCamera->m_projectiveModel)
                        {
                                gluPerspective(
                                        myCamera->m_projectiveFOVdeg, vw / double(vh), m_clip_min,
                                        m_clip_max);
                                CRenderizable::checkOpenGLError();
                        }
                        else
                        {
                                const double ratio = vw / double(vh);
                                double Ax = myCamera->m_distanceZoom * 0.5;
                                double Ay = myCamera->m_distanceZoom * 0.5;
 
                                if (ratio > 1)
                                        Ax *= ratio;
                                else
                                {
                                        if (ratio != 0) Ay /= ratio;
                                }
 
                                glOrtho(-Ax, Ax, -Ay, Ay, -0.5 * m_clip_max, 0.5 * m_clip_max);
                                CRenderizable::checkOpenGLError();
                        }
 
                        if (myCamera->is6DOFMode())
                        {
                                // In 6DOFMode eye is set viewing towards the direction of the
                                // positive Z axis
                                // Up is set as Y axis
                                mrpt::poses::CPose3D viewDirection, pose, at;
                                viewDirection.z(+1);
                                pose = mrpt::poses::CPose3D(myCamera->getPose());
                                at = pose + viewDirection;
                                gluLookAt(
                                        pose.x(), pose.y(), pose.z(), at.x(), at.y(), at.z(),
                                        pose.getRotationMatrix()(0, 1),
                                        pose.getRotationMatrix()(1, 1),
                                        pose.getRotationMatrix()(2, 1));
                                CRenderizable::checkOpenGLError();
                        }
                        else
                        {
                                // This command is common to ortho and perspective:
                                gluLookAt(
                                        m_lastProjMat.eye.x, m_lastProjMat.eye.y,
                                        m_lastProjMat.eye.z, m_lastProjMat.pointing.x,
                                        m_lastProjMat.pointing.y, m_lastProjMat.pointing.z,
                                        m_lastProjMat.up.x, m_lastProjMat.up.y, m_lastProjMat.up.z);
                                CRenderizable::checkOpenGLError();
                        }
 
                        // Optional pre-Render user code:
                        if (hasSubscribers())
                        {
                                mrptEventGLPreRender ev(this);
                                this->publishEvent(ev);
                        }
 
                        // Global OpenGL settings:
                        // ---------------------------------
                        glHint(
                                GL_POLYGON_SMOOTH_HINT,
                                m_OpenGL_enablePolygonNicest ? GL_NICEST : GL_FASTEST);
                        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
                        // Render objects:
                        // -------------------------------------------
                        glMatrixMode(GL_MODELVIEW);
                        glLoadIdentity();
 
                        glEnable(GL_DEPTH_TEST);
                        glDepthFunc(GL_LEQUAL);  // GL_LESS
 
                        // Setup lights
                        // -------------------------------------------
                        glEnable(GL_LIGHTING);
                        glEnable(GL_COLOR_MATERIAL);
                        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
                        glShadeModel(GL_SMOOTH);
                        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
 
                        for (size_t i = 0; i < m_lights.size(); i++)
                                m_lights[i].sendToOpenGL();
 
                        // Render all the objects:
                        // -------------------------------------------
                        mrpt::opengl::gl_utils::renderSetOfObjects(*objectsToRender);
 
                }  // end of non "image mode" rendering
 
                // Finally, draw the border:
                // --------------------------------
                if (m_borderWidth > 0)
                {
                        glLineWidth(2 * m_borderWidth);
                        glColor4f(0, 0, 0, 1);
                        glDisable(GL_DEPTH_TEST);
 
                        glMatrixMode(GL_MODELVIEW);
                        glLoadIdentity();
                        glMatrixMode(GL_PROJECTION);
                        glLoadIdentity();
 
                        glDisable(GL_LIGHTING);  // Disable lights when drawing lines
                        glBegin(GL_LINE_LOOP);
                        glVertex2f(-1, -1);
                        glVertex2f(-1, 1);
                        glVertex2f(1, 1);
                        glVertex2f(1, -1);
                        glEnd();
                        glEnable(GL_LIGHTING);  // Disable lights when drawing lines
 
                        glEnable(GL_DEPTH_TEST);
                }
 
                // Optional post-Render user code:
                if (hasSubscribers())
                {
                        mrptEventGLPostRender ev(this);
                        this->publishEvent(ev);
                }
        }
        catch (exception& e)
        {
                string msg;
                if (it != nullptr)
                        msg = format(
                                "Exception while rendering a class '%s'\n%s",
                                it->GetRuntimeClass()->className, e.what());
                else
                        msg = format("Exception while rendering:\n%s", e.what());
 
                THROW_EXCEPTION(msg);
        }
        catch (...)
        {
                THROW_EXCEPTION("Runtime error!");
        }
#else
        MRPT_UNUSED_PARAM(render_width);
        MRPT_UNUSED_PARAM(render_height);
        THROW_EXCEPTION(
                "The MRPT has been compiled with MRPT_HAS_OPENGL_GLUT=0! OpenGL "
                "functions are not implemented");
#endif
}
 
uint8_t COpenGLViewport::serializeGetVersion() const { return 3; }
void COpenGLViewport::serializeTo(mrpt::serialization::CArchive& out) const
{
        // Save data:
        out << m_camera << m_isCloned << m_isClonedCamera << m_clonedViewport
                << m_name << m_isTransparent << m_borderWidth << m_view_x << m_view_y
                << m_view_width << m_view_height;
 
        // Added in v1:
        out << m_custom_backgb_color << m_background_color.R << m_background_color.G
                << m_background_color.B << m_background_color.A;
 
        // Save objects:
        uint32_t n;
        n = (uint32_t)m_objects.size();
        out << n;
        for (CListOpenGLObjects::const_iterator it = m_objects.begin();
                 it != m_objects.end(); ++it)
                out << **it;
 
        // Added in v2: Global OpenGL settings:
        out << m_OpenGL_enablePolygonNicest;
 
        // Added in v3: Lights
        out << m_lights;
}
 
void COpenGLViewport::serializeFrom(
        mrpt::serialization::CArchive& in, uint8_t version)
{
        switch (version)
        {
                case 0:
                case 1:
                case 2:
                case 3:
                {
                        // Load data:
                        in >> m_camera >> m_isCloned >> m_isClonedCamera >>
                                m_clonedViewport >> m_name >> m_isTransparent >>
                                m_borderWidth >> m_view_x >> m_view_y >> m_view_width >>
                                m_view_height;
 
                        // in v1:
                        if (version >= 1)
                        {
                                in >> m_custom_backgb_color >> m_background_color.R >>
                                        m_background_color.G >> m_background_color.B >>
                                        m_background_color.A;
                        }
                        else
                        {
                                m_custom_backgb_color = false;
                        }
 
                        // Load objects:
                        uint32_t n;
                        in >> n;
                        clear();
                        m_objects.resize(n);
 
                        for_each(
                                m_objects.begin(), m_objects.end(), ObjectReadFromStream(&in));
 
                        // Added in v2: Global OpenGL settings:
                        if (version >= 2)
                        {
                                in >> m_OpenGL_enablePolygonNicest;
                        }
                        else
                        {
                                // Defaults
                        }
 
                        // Added in v3: Lights
                        if (version >= 3)
                                in >> m_lights;
                        else
                        {
                                // Default: one light from default direction
                                m_lights.clear();
                                m_lights.push_back(CLight());
                        }
                }
                break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
}
 
/*---------------------------------------------------------------
                                                        getByName
  ---------------------------------------------------------------*/
CRenderizable::Ptr COpenGLViewport::getByName(const string& str)
{
        for (CListOpenGLObjects::iterator it = m_objects.begin();
                 it != m_objects.end(); ++it)
        {
                if ((*it)->m_name == str)
                        return *it;
                else if (
                        (*it)->GetRuntimeClass() ==
                        CLASS_ID_NAMESPACE(CSetOfObjects, opengl))
                {
                        CRenderizable::Ptr ret =
                                std::dynamic_pointer_cast<CSetOfObjects>(*it)->getByName(str);
                        if (ret) return ret;
                }
        }
        return CRenderizable::Ptr();
}
 
/*---------------------------------------------------------------
                                        initializeAllTextures
  ---------------------------------------------------------------*/
void COpenGLViewport::initializeAllTextures()
{
#if MRPT_HAS_OPENGL_GLUT
        for (CListOpenGLObjects::iterator it = m_objects.begin();
                 it != m_objects.end(); ++it)
        {
                if (IS_DERIVED(*it, CTexturedObject))
                        std::dynamic_pointer_cast<CTexturedObject>(*it)
                                ->loadTextureInOpenGL();
                else if (IS_CLASS(*it, CSetOfObjects))
                        std::dynamic_pointer_cast<CSetOfObjects>(*it)
                                ->initializeAllTextures();
        }
#endif
}
 
void COpenGLViewport::dumpListOfObjects(std::vector<std::string>& lst)
{
        for (CListOpenGLObjects::iterator it = m_objects.begin();
                 it != m_objects.end(); ++it)
        {
                // Single obj:
                string s((*it)->GetRuntimeClass()->className);
                if ((*it)->m_name.size())
                        s += string(" (") + (*it)->m_name + string(")");
                lst.emplace_back(s);
 
                if ((*it)->GetRuntimeClass() ==
                        CLASS_ID_NAMESPACE(CSetOfObjects, mrpt::opengl))
                {
                        std::vector<std::string> auxLst;
 
                        dynamic_cast<CSetOfObjects*>(it->get())->dumpListOfObjects(auxLst);
 
                        for (size_t i = 0; i < auxLst.size(); i++)
                                lst.emplace_back(string(" ") + auxLst[i]);
                }
        }
}
 
/*--------------------------------------------------------------
                                        removeObject
  ---------------------------------------------------------------*/
void COpenGLViewport::removeObject(const CRenderizable::Ptr& obj)
{
        for (CListOpenGLObjects::iterator it = m_objects.begin();
                 it != m_objects.end(); ++it)
                if (*it == obj)
                {
                        m_objects.erase(it);
                        return;
                }
                else if (
                        (*it)->GetRuntimeClass() ==
                        CLASS_ID_NAMESPACE(CSetOfObjects, opengl))
                        dynamic_cast<CSetOfObjects*>(it->get())->removeObject(obj);
}
 
/*--------------------------------------------------------------
                                        setViewportClipDistances
  ---------------------------------------------------------------*/
void COpenGLViewport::setViewportClipDistances(
        const double clip_min, const double clip_max)
{
        ASSERT_(clip_max > clip_min);
 
        m_clip_min = clip_min;
        m_clip_max = clip_max;
}
 
/*--------------------------------------------------------------
                                        getViewportClipDistances
  ---------------------------------------------------------------*/
void COpenGLViewport::getViewportClipDistances(
        double& clip_min, double& clip_max) const
{
        clip_min = m_clip_min;
        clip_max = m_clip_max;
}
 
/*--------------------------------------------------------------
                                        get3DRayForPixelCoord
  ---------------------------------------------------------------*/
void COpenGLViewport::get3DRayForPixelCoord(
        const double x_coord, const double y_coord, mrpt::math::TLine3D& out_ray,
        mrpt::poses::CPose3D* out_cameraPose) const
{
        ASSERTDEB_(
                m_lastProjMat.viewport_height > 0 && m_lastProjMat.viewport_width > 0);
 
        const double ASPECT =
                m_lastProjMat.viewport_width / double(m_lastProjMat.viewport_height);
 
        // unitary vector between (eye) -> (pointing):
        TPoint3D pointing_dir;
        pointing_dir.x = -cos(m_lastProjMat.azimuth) * cos(m_lastProjMat.elev);
        pointing_dir.y = -sin(m_lastProjMat.azimuth) * cos(m_lastProjMat.elev);
        pointing_dir.z = -sin(m_lastProjMat.elev);
 
        // The camera X vector (in 3D) can be computed from the camera azimuth
        // angle:
        TPoint3D cam_x_3d;
        cam_x_3d.x = -sin(m_lastProjMat.azimuth);
        cam_x_3d.y = cos(m_lastProjMat.azimuth);
        cam_x_3d.z = 0;
 
        // The camera real UP vector (in 3D) is the cross product:
        //     X3d x pointing_dir:
        TPoint3D cam_up_3d;
        crossProduct3D(cam_x_3d, pointing_dir, cam_up_3d);
 
        if (!m_lastProjMat.is_projective)
        {
                // Ortho projection:
                // -------------------------------
                double Ax = m_lastProjMat.zoom * 0.5;
                double Ay = Ax;
 
                if (ASPECT > 1)
                        Ax *= ASPECT;
                else
                {
                        if (ASPECT != 0) Ay /= ASPECT;
                }
 
                const double point_lx =
                        (-0.5 + x_coord / m_lastProjMat.viewport_width) * 2 * Ax;
                const double point_ly =
                        -(-0.5 + y_coord / m_lastProjMat.viewport_height) * 2 * Ay;
 
                const TPoint3D ray_origin(
                        m_lastProjMat.eye.x + point_lx * cam_x_3d.x +
                                point_ly * cam_up_3d.x,
                        m_lastProjMat.eye.y + point_lx * cam_x_3d.y +
                                point_ly * cam_up_3d.y,
                        m_lastProjMat.eye.z + point_lx * cam_x_3d.z +
                                point_ly * cam_up_3d.z);
 
                out_ray.pBase = ray_origin;
                out_ray.director[0] = pointing_dir.x;
                out_ray.director[1] = pointing_dir.y;
                out_ray.director[2] = pointing_dir.z;
        }
        else
        {
                // Perspective camera
                // -------------------------------
 
                // JL: This can derived from:
                // http://www.opengl.org/sdk/docs/man/xhtml/gluPerspective.xml
                //  where one arrives to:
                //    tan(FOVx/2) = ASPECT_RATIO * tan(FOVy/2)
                //
                const double FOVy = DEG2RAD(m_lastProjMat.FOV);
                const double FOVx = 2.0 * atan(ASPECT * tan(FOVy * 0.5));
 
                const double ang_horz =
                        (-0.5 + x_coord / m_lastProjMat.viewport_width) * FOVx;
                const double ang_vert =
                        -(-0.5 + y_coord / m_lastProjMat.viewport_height) * FOVy;
 
                const TPoint3D l(
                        tan(ang_horz), tan(ang_vert),
                        1.0);  // Point in camera local reference frame
 
                const TPoint3D ray_director(
                        l.x * cam_x_3d.x + l.y * cam_up_3d.x + l.z * pointing_dir.x,
                        l.x * cam_x_3d.y + l.y * cam_up_3d.y + l.z * pointing_dir.y,
                        l.x * cam_x_3d.z + l.y * cam_up_3d.z + l.z * pointing_dir.z);
 
                // Set out ray:
                out_ray.pBase = m_lastProjMat.eye;
                out_ray.director[0] = ray_director.x;
                out_ray.director[1] = ray_director.y;
                out_ray.director[2] = ray_director.z;
 
        }  // end projective
 
        // Camera pose:
        if (out_cameraPose)
        {
                mrpt::math::CMatrixDouble44 M(UNINITIALIZED_MATRIX);
                M.get_unsafe(0, 0) = cam_x_3d.x;
                M.get_unsafe(1, 0) = cam_x_3d.y;
                M.get_unsafe(2, 0) = cam_x_3d.z;
                M.get_unsafe(3, 0) = 0;
 
                M.get_unsafe(0, 1) = cam_up_3d.x;
                M.get_unsafe(1, 1) = cam_up_3d.y;
                M.get_unsafe(2, 1) = cam_up_3d.z;
                M.get_unsafe(3, 1) = 0;
 
                M.get_unsafe(0, 2) = pointing_dir.x;
                M.get_unsafe(1, 2) = pointing_dir.y;
                M.get_unsafe(2, 2) = pointing_dir.z;
                M.get_unsafe(3, 2) = 0;
 
                M.get_unsafe(0, 3) = m_lastProjMat.eye.x;
                M.get_unsafe(1, 3) = m_lastProjMat.eye.y;
                M.get_unsafe(2, 3) = m_lastProjMat.eye.z;
                M.get_unsafe(3, 3) = 1;
 
                *out_cameraPose = CPose3D(M);
        }
}
 
MRPT_TODO("Implement a setCurrentCameraFromPose() method")
 
void COpenGLViewport::getCurrentCameraPose(
        mrpt::poses::CPose3D& out_cameraPose) const
{
        mrpt::math::TLine3D dum;
        get3DRayForPixelCoord(0, 0, dum, &out_cameraPose);
}
 
/** Resets the viewport to a normal 3D viewport \sa setCloneView, setImageView
 */
void COpenGLViewport::setNormalMode()
{
        // If this was a m_isImageView, remove the quad object:
        if (m_isImageView && m_imageview_img) m_imageview_img.reset();
 
        m_isCloned = false;
        m_isClonedCamera = false;
        m_isImageView = false;
}
 
void COpenGLViewport::setImageView(const mrpt::img::CImage& img)
{
        internal_setImageView_fast(img, false);
}
void COpenGLViewport::setImageView_fast(mrpt::img::CImage& img)
{
        internal_setImageView_fast(img, true);
}
 
void COpenGLViewport::internal_setImageView_fast(
        const mrpt::img::CImage& img, bool is_fast)
{
        // If this is the first time, we have to create the quad object:
        if (!m_isImageView || !m_imageview_img)
                m_imageview_img = mrpt::make_aligned_shared<mrpt::img::CImage>();
        m_isImageView = true;
 
        // Update texture image:
        mrpt::img::CImage* my_img = m_imageview_img.get();
 
        if (!is_fast)
                *my_img = img;
        else
                my_img->copyFastFrom(*const_cast<mrpt::img::CImage*>(&img));
}
 
/** Evaluates the bounding box of this object (including possible children) in
 * the coordinate frame of the object parent. */
void COpenGLViewport::getBoundingBox(
        mrpt::math::TPoint3D& bb_min, mrpt::math::TPoint3D& bb_max) const
{
        bb_min = TPoint3D(
                std::numeric_limits<double>::max(), std::numeric_limits<double>::max(),
                std::numeric_limits<double>::max());
        bb_max = TPoint3D(
                -std::numeric_limits<double>::max(),
                -std::numeric_limits<double>::max(),
                -std::numeric_limits<double>::max());
 
        for (CListOpenGLObjects::const_iterator it = m_objects.begin();
                 it != m_objects.end(); ++it)
        {
                TPoint3D child_bbmin(
                        std::numeric_limits<double>::max(),
                        std::numeric_limits<double>::max(),
                        std::numeric_limits<double>::max());
                TPoint3D child_bbmax(
                        -std::numeric_limits<double>::max(),
                        -std::numeric_limits<double>::max(),
                        -std::numeric_limits<double>::max());
                (*it)->getBoundingBox(child_bbmin, child_bbmax);
 
                keep_min(bb_min.x, child_bbmin.x);
                keep_min(bb_min.y, child_bbmin.y);
                keep_min(bb_min.z, child_bbmin.z);
 
                keep_max(bb_max.x, child_bbmax.x);
                keep_max(bb_max.y, child_bbmax.y);
                keep_max(bb_max.z, child_bbmax.z);
        }
}