Camera.h

Go to the documentation of this file.

#ifndef VolViz_Camera_h
#define VolViz_Camera_h

#include "AtomicCache.h"
#include "AtomicWrapper.h"
#include "Types.h"

namespace VolViz {

namespace Private_ {
class CameraClient;
} // namespace Private_

class Camera {
  template <class T> using Property = AtomicWrapper<T, SetAndNotifyPolicy>;

public:
  Camera() noexcept;

  Property<Orientation> orientation{Orientation::Identity()};

  Property<PhysicalPosition> position{
      PhysicalPosition{0 * milli * meter, 0 * milli *meter, 0 * milli *meter}};

  Property<Angle> verticalFieldOfView{110 * degree_angle};

  Property<float> aspectRatio{4.f / 3.f};

  Private_::CameraClient client() const noexcept;

  inline DepthRange depthRange() const noexcept { return {1.f, 0.f}; }

private:
  friend class Private_::CameraClient;

  Matrix4 projectionMatrix() const noexcept;

  Matrix4 viewMatrix() const noexcept;

  Matrix4 viewProjectionMatrix() const noexcept;

  Position unproject(Position2 const &screenPos, float depth,
                     Length ambientScale) const noexcept;

  mutable AtomicCache<Matrix4> cachedProjectionMatrix_{
      [this]() { return projectionMatrix(); }};

  mutable AtomicCache<Matrix4> cachedViewMatrix_{
      [this]() { return viewMatrix(); }};

  mutable AtomicCache<Matrix4> cachedViewProjectionMatrix_{
      [this]() { return viewProjectionMatrix(); }};

  mutable AtomicCache<Angle> cachedVerticalFOV_{
      [this]() { return static_cast<Angle>(verticalFieldOfView); }};

  mutable Length cachedScale_;
};

namespace Private_ {
class VisualizerImpl;
class AxisAlignedPlane;
class Cube;
class Mesh;

class CameraClient {
  friend class VisualizerImpl;
  friend class ::VolViz::Camera;

  // All geometry subclasses should also have access. This smells like a dirty
  // workaround. TODO: find a better solution
  friend class AxisAlignedPlane;
  friend class Cube;
  friend class Mesh;

  CameraClient(Camera const &cam) : cam_(cam) {}

  inline Matrix4 projectionMatrix() const noexcept {
    return cam_.cachedProjectionMatrix_;
  }

  inline Matrix4 viewMatrix(Length ambientScale) const noexcept {
    using std::abs;
    using namespace literals;

    Expects(ambientScale > 0_mm);

    if (abs(ambientScale - cam_.cachedScale_) > 1e-3_nm) {
      cam_.cachedViewMatrix_.markAsDirty();
      cam_.cachedViewProjectionMatrix_.markAsDirty();
      cam_.cachedScale_ = ambientScale;
    }
    return cam_.cachedViewMatrix_;
  }

  inline Matrix4 viewProjectionMatrix(Length ambientScale) const noexcept {
    using std::abs;
    using namespace literals;

    Expects(ambientScale > 0_mm);

    if (abs(ambientScale - cam_.cachedScale_) > 1e-3_nm) {
      cam_.cachedViewMatrix_.markAsDirty();
      cam_.cachedViewProjectionMatrix_.markAsDirty();
      cam_.cachedScale_ = ambientScale;
    }
    return cam_.cachedViewProjectionMatrix_;
  }

  inline Position unproject(Position2 const &screenPos, float depth,
                            Length ambientScale) const noexcept {
    return cam_.unproject(screenPos, depth, ambientScale);
  }

  inline Position project(Position const &position, Length ambientScale) const
      noexcept {

    PositionH const projPos =
        viewProjectionMatrix(ambientScale) * position.homogeneous();

    auto const w = projPos.w();

    return projPos.head<3>() / w;
  }

  Camera const &cam_;
};

} // namespace Private_

} // namespace VolViz

#endif // VolViz_Camera_h