CGlCanvasBase.h

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 |
   +------------------------------------------------------------------------+ */
 
#pragma once
#include <mrpt/opengl/COpenGLScene.h>
 
namespace mrpt
{
namespace opengl
{
class CCamera;
}
}
 
namespace mrpt
{
namespace gui
{
/** This base class implements a working with opengl::Camera and a OpenGL
 * canvas, and it's used in gui::CWxGLCanvasBase and gui::CQtGlCanvasBase.
*/
class CGlCanvasBase
{
   public:
    struct CamaraParams
    {
        CamaraParams() {}
        void setElevationDeg(float deg);
 
        float cameraPointingX = .0f, cameraPointingY = .0f,
              cameraPointingZ = .0f;
        float cameraZoomDistance = 40.f;
        float cameraElevationDeg = 45.f, cameraAzimuthDeg = 45.f;
        bool cameraIsProjective = true;
        float cameraFOV = 30.f;
    };
 
    CGlCanvasBase() {}
    virtual ~CGlCanvasBase() {}
    /** Sets the minimum of the zoom
     * See also setMaximumZoom(float) */
    void setMinimumZoom(float zoom);
 
    /** Sets the maximum of the zoom
     * See also setMinimumZoom(float) */
    void setMaximumZoom(float zoom);
 
    /** Saves the click position of the mouse
     * See also setMouseClicked(bool) */
    void setMousePos(int x, int y);
 
    /** Sets the property mouseClicked
     * By default, this property is false.
     * See also setMousePos(int, int) */
    void setMouseClicked(bool is);
 
    /** Sets the last mouse position */
    void updateLastPos(int x, int y);
    /** Calls the glViewport function*/
    void resizeViewport(int w, int h);
    /** Calls the glClearColor function
     * See also setClearColors(float, float, float, float)*/
    void clearColors();
 
    /** This function for the mouse event
     * It gets a reference to CamaraParams, x, y
     * and updates the zoom of the CameraParams.
     * See also updateZoom(CamaraParams &, float)*/
    void updateZoom(CamaraParams& params, int x, int y) const;
    /** This function for the wheel event
     * It gets a reference to CamaraParams, delta
     * and updates the zoom of the CameraParams.
     * See also updateZoom(CamaraParams &, int, int)*/
    void updateZoom(CamaraParams& params, float delta) const;
    /** This function for the mouse event
     * It gets a reference to CamaraParams, x, y
     * and updates the elevation and azimuth.
     * See also getElevationDegrees(), getAzimuthDegrees()*/
    void updateRotate(CamaraParams& params, int x, int y) const;
    /** This function for the mouse event
     * It gets a reference to CamaraParams, x, y
     * and updates the elevation and azimuth.
     * See also getElevationDegrees(), getAzimuthDegrees()*/
    void updateOrbitCamera(CamaraParams& params, int x, int y) const;
    /** This function for the mouse event
     * It gets a reference to CamaraParams, x, y
     * and updates the pointing of the camera.
     * See also getCameraPointingX(), getCameraPointingY(),
     * getCameraPointingZ()*/
    void updatePan(CamaraParams& params, int x, int y) const;
 
    /** Returns a copy of CamaraParams
     * See also getRefCameraParams(), setCameraParams(const CamaraParams &)*/
    CamaraParams cameraParams() const;
    /** Returns a reference to CamaraParams
     * See also cameraParams(), setCameraParams(const CamaraParams &) */
    const CamaraParams& getRefCameraParams() const;
    /** Sets the CamaraParams
     * See also cameraParams(), getRefCameraParams()*/
    virtual void setCameraParams(const CamaraParams& params);
 
    /** This function gets a reference to mrpt::opengl::CCamera and
     * updates the camera parameters(pointing, zoom, azimuth, elevation,
     * IsProjective, FOV)
    */
    mrpt::opengl::CCamera& updateCameraParams(mrpt::opengl::CCamera& cam) const;
 
    /** If set to true (default=false), the cameraPointingX,... parameters are
     * ignored and the camera stored in the 3D scene is used instead.
     * See also void bool getUseCameraFromScene()
      */
    void setUseCameraFromScene(bool is);
 
    /** See also void setUseCameraFromScene(bool)
    */
    bool getUseCameraFromScene() const;
 
    // Visualization params:
    /** Saves the pointing of the camera
     * See also getCameraPointingX(), getCameraPointingY(), getCameraPointingZ()
    */
    virtual void setCameraPointing(float pointX, float pointY, float pointZ);
 
    /** Returns the x pointing of the camera
     * See also setCameraPointing(float, float, float)
    */
    float getCameraPointingX() const;
 
    /** Returns the y pointing of the camera
     * See also setCameraPointing(float, float, float)
    */
    float getCameraPointingY() const;
 
    /** Returns the z pointing of the camera
     * See also setCameraPointing(float, float, float)
    */
    float getCameraPointingZ() const;
 
    /** Saves camera zooming
     * See also getZoomDistance()
    */
    virtual void setZoomDistance(float zoom);
 
    /** Returns a zoom
     * See also setZoomDistance(float)
    */
    float getZoomDistance() const;
 
    /** Saves the degrees of the azimuth camera
     * See also getAzimuthDegrees()
    */
    virtual void setAzimuthDegrees(float ang);
 
    /** Returns a azimuth degrees
     * See also setAzimuthDegrees(float)
    */
    float getAzimuthDegrees() const;
 
    /** Saves the degrees of the elevation camera
     * See also getElevationDegrees()
    */
    virtual void setElevationDegrees(float ang);
 
    /** Returns a elevation degrees
     * See also setElevationDegrees(float)
    */
    float getElevationDegrees() const;
 
    virtual void setCameraProjective(bool is);
    bool isCameraProjective() const;
 
    virtual void setCameraFOV(float FOV);
    float cameraFOV() const;
 
    /** Sets the RGBA colors for glClearColor
     * See also clearColors(), getClearColorR(),
     * getClearColorG(),getClearColorB(), getClearColorA()
    */
    void setClearColors(float r, float g, float b, float a = 1.0f);
    float getClearColorR() const;
    float getClearColorG() const;
    float getClearColorB() const;
    float getClearColorA() const;
 
    static float SENSIBILITY_DEG_PER_PIXEL;  // Default = 0.1
 
    /** Overload this method to limit the capabilities of the user to move the
     * camera using the mouse.
              *  For all these variables:
              *  - cameraPointingX
              *  - cameraPointingY
              *  - cameraPointingZ
              *  - cameraZoomDistance
              *  - cameraElevationDeg
              *  - cameraAzimuthDeg
              *
              *  A "new_NAME" variable will be passed with the temptative new
     * value after the user action.
              *   The default behavior should be to copy all the new variables
     * to the variables listed above
              *   but in the middle any find of user-defined filter can be
     * implemented.
              */
    virtual void OnUserManuallyMovesCamera(
        float new_cameraPointingX, float new_cameraPointingY,
        float new_cameraPointingZ, float new_cameraZoomDistance,
        float new_cameraElevationDeg, float new_cameraAzimuthDeg)
    {
        m_cameraParams.cameraPointingX = new_cameraPointingX;
        m_cameraParams.cameraPointingY = new_cameraPointingY;
        m_cameraParams.cameraPointingZ = new_cameraPointingZ;
        m_cameraParams.cameraZoomDistance = new_cameraZoomDistance;
        m_cameraParams.cameraElevationDeg = new_cameraElevationDeg;
        m_cameraParams.cameraAzimuthDeg = new_cameraAzimuthDeg;
    }
 
    inline void getLastMousePosition(int& x, int& y) const
    {
        x = m_mouseLastX;
        y = m_mouseLastY;
    }
 
    /**  At constructor an empty scene is created. The object is freed at GL
    canvas destructor.
     * This function returns a smart pointer to the opengl scene
    getOpenGLSceneRef         */
    mrpt::opengl::COpenGLScene::Ptr& getOpenGLSceneRef()
    {
        return m_openGLScene;
    }
    void setOpenGLSceneRef(mrpt::opengl::COpenGLScene::Ptr scene);
 
   protected:
    virtual void swapBuffers() = 0;
    virtual void preRender() = 0;
    virtual void postRender() = 0;
    virtual void renderError(const std::string& err_msg) = 0;
 
    virtual double renderCanvas(int width = -1, int height = -1);
 
   private:
    float clearColorR = .4f, clearColorG = .4f, clearColorB = .4f,
          clearColorA = 1.f;
    bool useCameraFromScene = false;
    mrpt::opengl::COpenGLScene::Ptr m_openGLScene =
        mrpt::make_aligned_shared<mrpt::opengl::COpenGLScene>();
    int m_mouseLastX = 0, m_mouseLastY = 0;
    int m_mouseClickX = 0, m_mouseClickY = 0;
    bool mouseClicked = false;
    float m_minZoom = 1.f;
    float m_maxZoom = 3200.f;
    CamaraParams m_cameraParams;
};  // end of class
}  // end namespace
}  // end namespace