Camera.hh

 
#ifndef GRAMODS_GRAPHICS_CAMERA
#define GRAMODS_GRAPHICS_CAMERA
 
#include <gmGraphics/config.hh>
 
#include <gmGraphics/Eye.hh>
#include <gmCore/Console.hh>
 
#include <Eigen/Eigen>
#include <functional>
#include <optional>
 
BEGIN_NAMESPACE_GMGRAPHICS;
 
class Camera {
 
public:
  Camera(size_t frame_number) : frame_number(frame_number) {}
 
  Camera(const Camera &other)
    : frame_number(other.frame_number),
      left(other.left),
      right(other.right),
      bottom(other.bottom),
      top(other.top),
      near(other.near),
      far(other.far),
      position(other.position),
      orientation(other.orientation),
      eye(other.eye) {}
 
  Camera &operator=(const Camera &other) {
    if (frame_number != other.frame_number)
      throw gmCore::InvalidArgument(
          GM_STR("Cannot assign with camera from different frame ("
                 << frame_number << " != " << other.frame_number << ")"));
 
    left = other.left;
    right = other.right;
    bottom = other.bottom;
    top = other.top;
    near = other.near;
    far = other.far;
    position = other.position;
    orientation = other.orientation;
    eye = other.eye;
 
    return *this;
  }
 
  template<class T>
  Camera(const T &object) : frame_number(object.frame_number) {}
 
  Eigen::Matrix4f getProjectionMatrix() const;
 
  Eigen::Affine3f getViewMatrix() const;
 
  Eigen::Vector3f getPosition() const { return position; }
 
  void setPosition(Eigen::Vector3f p) { position = p; }
 
  Eigen::Quaternionf getOrientation() const { return orientation; }
 
  void setOrientation(Eigen::Quaternionf q) { orientation = q; }
 
  void setClipPlanes(float l, float r, float b, float t) {
    left = l;
    right = r;
    top = t;
    bottom = b;
  }
 
  void getClipPlanes(float &l, float &r, float &b, float &t) const {
    l = left;
    r = right;
    t = top;
    b = bottom;
  }
 
  void setFieldOfView(float fov_h, float fov_v);
 
  void setClipAngles(float l, float r, float b, float t);
 
  void setPose(Eigen::Vector3f p, Eigen::Quaternionf r) {
    position = p;
    orientation = r;
  }
 
  bool setLookAtPoints(Eigen::Vector3f p,
                       const std::vector<Eigen::Vector3f> &pts,
                       bool symmetric = true,
                       Eigen::Vector3f up = Eigen::Vector3f::Zero());
 
  void setNearFar(float near, float far) {
    this->near = near;
    this->far = far;
  }
 
  void setEye(Eye e) { eye = e; }
 
  Eye getEye() const { return eye; }
 
  const size_t frame_number;
 
private:
  float left = -1.f, right = 1.f, bottom = -1.f, top = 1.f;
 
  std::optional<float> near, far;
 
  Eigen::Vector3f position = Eigen::Vector3f::Zero();
 
  Eigen::Quaternionf orientation = Eigen::Quaternionf::Identity();
 
  Eye eye = Eye::MONO;
};
 
END_NAMESPACE_GMGRAPHICS;
 
#endif