Camera.h

Go to the documentation of this file.

#pragma once
 
#include "Core.h"
#include "math_types.h"
 
#include <Eigen/Geometry>
 
namespace candlewick {
 
namespace math {
  inline Mat3f computeNormalMatrix(const Eigen::Affine3f &M) {
    return M.inverse().linear().transpose();
  }
} // namespace math
 
enum class CameraProjection { PERSPECTIVE, ORTHOGRAPHIC };

struct Camera {
  Mat4f projection;
  Eigen::Isometry3f view;

  Eigen::Isometry3f pose() const { return view.inverse(); }
  Float3 position() const { return pose().translation(); }

  auto viewProj() const { return projection * view.matrix(); }

  Float3 transformVector(const Float3 &v) const { return view.linear() * v; }

  Float3 transformPoint(const Float3 &p) const { return view * p; }

 
  Float3 right() const { return view.linear().row(0); }
  auto right() { return view.linear().row(0); }
  Float3 up() const { return view.linear().row(1); }
  auto up() { return view.linear().row(1); }
  Float3 forward() const { return -view.linear().row(2); }

};


Mat4f lookAt(const Float3 &eye, const Float3 &center,
             const Float3 &up = Float3::UnitZ());

Mat4f perspectiveMatrix(float left, float right, float bottom, float top,
                        float near, float far);

Mat4f perspectiveFromFov(Radf fovY, float aspectRatio, float nearZ, float farZ);

Mat4f orthographicMatrix(const Float2 &sizes, float nearZ, float farZ);

Mat4f orthographicMatrix(float left, float right, float bottom, float top,
                         float near, float far);
 
inline float orthoProjNear(const Mat4f &proj) {
  return (proj(2, 2) + 1.0f) / proj(2, 2);
}
 
inline float orthoProjFar(const Mat4f &proj) {
  return (proj(2, 3) - 1.0f) / proj(2, 2);
}
 
inline float perspectiveProjNear(const Mat4f &proj) {
  return proj(2, 3) / (proj(2, 2) - 1.f);
}
 
inline float perspectiveProjFar(const Mat4f &proj) {
  return std::abs(proj(2, 3) / (proj(2, 2) + 1.f));
}

inline FrustumCornersType frustumFromCameraProjection(const Mat4f &camProj) {
  auto invProj = camProj.inverse();
  FrustumCornersType out;
  for (Uint8 i = 0; i < 8; i++) {
    Uint8 j = i & 1;
    Uint8 k = (i >> 1) & 1;
    Uint8 l = (i >> 2) & 1;
    assert(j <= 1);
    assert(k <= 1);
    assert(l <= 1);
 
    Float4 ndc{2.f * j - 1.f, 2.f * k - 1.f, 2.f * l - 1.f, 1.f};
    Float4 viewSpace = invProj * ndc;
    out[i] = viewSpace.head<3>() / viewSpace.w();
  }
  return out;
}

inline FrustumCornersType frustumFromCamera(const Camera &camera) {
  return frustumFromCameraProjection(camera.viewProj());
}
 
inline std::pair<Float3, float>
frustumBoundingSphereCenterRadius(const FrustumCornersType &worldSpaceCorners) {
  Float3 frustumCenter = Float3::Zero();
  for (auto &c : worldSpaceCorners) {
    frustumCenter += c;
  }
  frustumCenter /= 8.f;
 
  float radius = 0.f;
  for (auto &c : worldSpaceCorners) {
    radius = std::max(radius, (c - frustumCenter).norm());
  }
  return {frustumCenter, radius};
}

 
} // namespace candlewick