camera.h

Go to the documentation of this file.

#ifndef NNGN_MATH_CAMERA_H
#define NNGN_MATH_CAMERA_H
 
#include "utils/def.h"
#include "utils/flags.h"
 
#include "mat4.h"
#include "math.h"
#include "vec2.h"
#include "vec3.h"
 
namespace nngn {
 
struct Timing;
 
struct Camera {
    enum Flag : u8 {
        UPDATED        = 1u << 0,
        SCREEN_UPDATED = 1u << 1,
        DASH           = 1u << 2,
        PERSPECTIVE    = 1u << 3,
        IGNORE_BOUNDS  = 1u << 4,
    };
    static constexpr float NEAR = 0.01f;
    static constexpr float FAR = 2048;
    static constexpr float FOVY = static_cast<float>(Math::pi() / 3);
    static constexpr float fov(float z, float w);
    // Flags
    bool dash(void) const { return this->flags.is_set(Flag::DASH); }
    bool perspective(void) const;
    void set_dash(bool b) { this->flags.set(Flag::DASH, b); }
    void set_perspective(bool b);
    void set_ignore_bounds(bool b);
    // Positions / vectors
    vec3 center(void) const;
    vec3 up(void) const;
    vec3 world_to_view(vec3 p) const;
    vec3 view_to_clip(vec3 p) const;
    vec3 clip_to_view(vec3 p) const;
    vec3 view_to_world(vec3 p) const;
    // Screen
    float z_for_fov(void) const;
    float scale_for_fov(void) const;
    // Mutators
    void set_pos(vec3 p);
    void set_rot(vec3 r);
    void set_zoom(float z);
    void set_fov_y(float f);
    void set_screen(uvec2 s);
    void set_bounds(vec3 bl, vec3 tr);
    void look_at(vec3 center, vec3 pos, vec3 up);
    bool update(const Timing &t);
    // Data
    vec3 p = {};
    vec3 v = {};
    vec3 a = {};
    vec3 rot = {};
    vec3 rot_v = {};
    vec3 rot_a = {};
    vec3 bl_bound = {-INFINITY, -INFINITY, -INFINITY};
    vec3 tr_bound = {+INFINITY, +INFINITY, +INFINITY};
    float zoom = 1;
    float zoom_v = {};
    float zoom_a = {};
    float max_v = INFINITY;
    float max_rot_v = INFINITY;
    float max_zoom_v = INFINITY;
    float fov_y = FOVY;
    float damp = {};
    uvec2 screen = {};
    mat4 proj = mat4{1};
    mat4 view = mat4{1};
    mat4 inv_proj = mat4{1};
    mat4 inv_view = mat4{1};
    Flags<Flag> flags = {};
};
 
inline constexpr float Camera::fov(float z, float w) {
    const auto a = w / 2.0f / z;
    return 2.0f * std::atan(a);
}
 
inline bool Camera::perspective(void) const {
    return this->flags.is_set(Flag::PERSPECTIVE);
}
 
inline void Camera::set_perspective(bool b) {
    this->flags.set(Flag::PERSPECTIVE, b);
    this->flags.set(Flag::UPDATED);
}
 
inline void Camera::set_ignore_bounds(bool b) {
    this->flags.set(Flag::IGNORE_BOUNDS, b);
    this->flags.set(Flag::UPDATED);
}
 
inline vec3 Camera::world_to_view(vec3 wp) const {
    const vec4 ret = this->view * vec4{wp, 1};
    return ret.xyz() / ret.w;
}
 
inline vec3 Camera::view_to_clip(vec3 vp) const {
    const vec4 ret = this->proj * vec4{vp, 1};
    return ret.xyz() / ret.w;
}
 
inline vec3 Camera::clip_to_view(vec3 cp) const {
    const vec4 ret = this->inv_proj * vec4{cp, 1};
    return ret.xyz() / ret.w;
}
 
inline vec3 Camera::view_to_world(vec3 vp) const {
    const vec4 ret = this->inv_view * vec4{vp, 1};
    return ret.xyz() / ret.w;
}
 
inline float Camera::z_for_fov(void) const {
    return static_cast<float>(this->screen.y)
        / 2.0f
        / std::tan(this->fov_y / 2);
}
 
inline float Camera::scale_for_fov(void) const {
    return this->zoom * this->z_for_fov() / this->p.z;
}
 
inline void Camera::set_pos(vec3 pos) {
    this->p = pos;
    this->flags.set(Flag::UPDATED);
}
 
inline void Camera::set_rot(vec3 r) {
    this->rot = r;
    this->flags.set(Flag::UPDATED);
}
 
inline void Camera::set_zoom(float z) {
    this->zoom = z;
    this->flags.set(Flag::UPDATED);
}
 
inline void Camera::set_fov_y(float f) {
    this->fov_y = f;
    this->flags.set(Flag::UPDATED);
}
 
inline void Camera::set_screen(uvec2 s) {
    this->screen = s;
    this->flags.set(Flag::SCREEN_UPDATED);
}
 
inline void Camera::set_bounds(vec3 bl, vec3 tr) {
    this->bl_bound = bl;
    this->tr_bound = tr;
    this->flags.set(Flag::UPDATED);
}
 
}
 
#endif