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_LIMITS  = 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;
    bool perspective(void) const;
    void set_dash(bool b);
    void set_perspective(bool b);
    void set_ignore_limits(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;
    vec2 clip_to_screen(vec3 p);
    vec3 screen_to_clip(vec2 p);
    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_fov_z(float z) { this->fov_z = z; }
    void set_screen(uvec2 s);
    void set_limits(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_limit = {-INFINITY, -INFINITY, -INFINITY};
    vec3 tr_limit = {+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 fov_z = {};
    float damp = {};
    uvec2 screen = {};
    mat4 proj = mat4{1};
    mat4 screen_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) {
    return 2.0f * std::atan(w / 2.0f / z);
}
 
inline bool Camera::dash(void) const {
    return this->flags.is_set(Flag::DASH);
}
 
inline bool Camera::perspective(void) const {
    return this->flags.is_set(Flag::PERSPECTIVE);
}
 
inline void Camera::set_dash(bool b) {
    this->flags.set(Flag::DASH, b);
}
 
inline void Camera::set_perspective(bool b) {
    this->flags.set(Flag::PERSPECTIVE, b);
    this->flags.set(Flag::UPDATED);
}
 
inline void Camera::set_ignore_limits(bool b) {
    this->flags.set(Flag::IGNORE_LIMITS, b);
    this->flags.set(Flag::UPDATED);
}
 
inline vec3 Camera::world_to_view(vec3 wp) const {
    return Math::perspective_transform(this->view, wp);
}
 
inline vec3 Camera::view_to_clip(vec3 vp) const {
    return Math::perspective_transform(this->proj, vp);
}
 
inline vec2 Camera::clip_to_screen(vec3 cp) {
    return (cp.xy() + vec2{1}) / 2.0f * static_cast<vec2>(this->screen);
}
 
inline vec3 Camera::screen_to_clip(vec2 sp) {
    return {2.0f * (sp / static_cast<vec2>(this->screen)) - vec2{1} , 0};
}
 
inline vec3 Camera::clip_to_view(vec3 cp) const {
    return Math::perspective_transform(this->inv_proj, cp);
}
 
inline vec3 Camera::view_to_world(vec3 vp) const {
    return Math::perspective_transform(this->inv_view, vp);
}
 
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_limits(vec3 bl, vec3 tr) {
    this->bl_limit = bl;
    this->tr_limit = tr;
    this->flags.set(Flag::UPDATED);
}
 
}
 
#endif