qtopengl_camera.h

Go to the documentation of this file.

 
#ifndef QTOPENGL_CAMERA_H
#define QTOPENGL_CAMERA_H
 
namespace argos {
   class CQTOpenGLCamera;
}
 
class QPoint;
 
#include <QObject>
#include <argos3/core/utility/datatypes/datatypes.h>
#include <argos3/core/utility/math/ray3.h>
#include <argos3/core/utility/configuration/argos_configuration.h>
 
#ifdef __APPLE__
#include <gl.h>
#include <glu.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#endif
 
namespace argos {
 
   class CQTOpenGLCamera : public QObject {
 
      Q_OBJECT
 
   public:
 
      struct SPlacement {
         CVector3 Position;
         CVector3 Target;
         CVector3 Up;
         Real LensFocalLength;
         CDegrees YFieldOfView;
         void Init(TConfigurationNode& t_tree);
         void CalculateYFieldOfView();
      };
 
      struct SKeyframe {
         SKeyframe(UInt32 un_step,
                   UInt32 un_placement_index,
                   bool b_interpolate_to_next) :
            Step(un_step),
            PlacementIndex(un_placement_index),
            InterpolateToNext(b_interpolate_to_next) {}
         UInt32 Step;
         UInt32 PlacementIndex;
         bool InterpolateToNext;
      };
 
   public:
 
      CQTOpenGLCamera();
 
      ~CQTOpenGLCamera();
 
      void Init(TConfigurationNode& t_tree);
 
      void Reset();
 
      void Look();
 
      inline const CVector3& GetPosition() const {
         return m_sActivePlacement.Position;
      }
 
      inline const CVector3& GetTarget() const {
         return m_sActivePlacement.Target;
      }
 
      inline Real GetLensFocalLength() const {
         return m_sActivePlacement.LensFocalLength;
      }
 
      void Rotate(const QPoint& c_delta);
 
      void Rotate(const CRadians& c_up_down,
                  const CRadians& c_left_right);
 
      void Move(SInt32 n_forwards_backwards,
                SInt32 n_sideways,
                SInt32 n_up_down);
 
      void Interpolate(UInt32 un_start_placement,
                       UInt32 un_end_placement,
                       Real f_time_fraction);
 
      inline SPlacement& GetActivePlacement() {
         return m_sActivePlacement;
      }
 
      inline const SPlacement& GetActivePlacement() const {
         return m_sActivePlacement;
      }
 
      inline void SetActivePlacement(UInt32 n_index) {
         ARGOS_ASSERT(n_index < m_arrPlacements.size(),
            "CQTOpenGLCamera::SetActivePlacement():"
            " index out of bounds: n_index = " << n_index <<
            ", m_arrPlacements.size() = " << m_arrPlacements.size());
         m_sActivePlacement = m_arrPlacements[n_index];
      }
 
      inline SPlacement& GetPlacement(UInt32 n_index) {
         ARGOS_ASSERT(n_index < m_arrPlacements.size(),
            "CQTOpenGLCamera::GetPlacement():"
            " index out of bounds: n_index = " << n_index <<
            ", m_arrPlacements.size() = " << m_arrPlacements.size());
         return m_arrPlacements[n_index];
      }
 
      void UpdateTimeline();
 
   private:
      bool m_bEnableTimeline;
      bool m_bHasTimeline;
      UInt32 m_unLoop;
      SPlacement m_sActivePlacement;
      std::array<SPlacement, 12> m_arrPlacements;
      std::vector<SKeyframe> m_vecKeyframes;
   };
 
}
 
#endif