camera.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
 
#include <base/basetypes.hpp>
#include <context/context.hpp>
#include <math/math.h>
#include <reflection/registration.h>
#include <serialization/serialization.h>
 
namespace unravel
{
enum class projection_mode : std::uint32_t
{
    perspective = 0,
    orthographic = 1
};
 
struct camera_storage
{
    rtti::context ctx; 
};
 
class camera : public crtp_meta_type<camera>
{
public:
    SERIALIZABLE(camera)
 
    
    void set_projection_mode(projection_mode mode);
 
    void set_fov(float degrees);
 
    void set_near_clip(float distance);
 
    void set_far_clip(float distance);
 
    void set_orthographic_size(float size);
 
    auto get_projection_mode() const -> projection_mode;
 
    auto get_fov() const -> float;
 
    auto get_near_clip() const -> float;
 
    auto get_far_clip() const -> float;
 
    auto get_ortho_size() const -> float;
 
    auto get_zoom_factor() const -> float;
 
    auto get_ppu() const -> float;
 
    void set_viewport_size(const usize32_t& viewportSize);
 
    void set_viewport_pos(const upoint32_t& viewportPos);
 
    auto get_viewport_size() const -> const usize32_t&;
 
    auto get_viewport_pos() const -> const upoint32_t&;
 
    void set_aspect_ratio(float aspect, bool locked = false);
 
    auto get_aspect_ratio() const -> float;
 
    auto is_aspect_locked() const -> bool;
 
    auto is_frustum_locked() const -> bool;
 
    void lock_frustum(bool locked);
 
    auto get_frustum() const -> const math::frustum&;
 
    auto get_clipping_volume() const -> const math::frustum&;
 
    auto get_projection() const -> const math::transform&;
    auto get_prev_projection() const -> const math::transform&;
 
    auto get_view() const -> const math::transform&;
    auto get_prev_view() const -> const math::transform&;
    auto get_view_inverse() const -> const math::transform&;
    auto get_view_relative() const -> const math::transform&;
    auto get_prev_view_relative() const -> const math::transform&;
    auto get_view_inverse_relative() const -> const math::transform&;
    auto get_prev_view_projection() const -> math::transform;
    auto get_prev_view_projection_relative() const -> math::transform;
    auto get_view_projection() const -> math::transform;
    auto get_view_projection_relative() const -> math::transform;
 
    void record_current_matrices();
 
    void set_aa_data(const usize32_t& viewportSize,
                     std::uint32_t currentSubpixelIndex,
                     std::uint32_t temporalAASamples);
 
    auto get_aa_data() const -> const math::vec4&;
 
    auto classify_aabb(const math::bbox& bounds) const -> math::volume_query;
 
    auto test_aabb(const math::bbox& bounds) const -> bool;
 
    auto classify_obb(const math::bbox& bounds, const math::transform& t) const -> math::volume_query;
 
    auto test_obb(const math::bbox& bounds, const math::transform& t) const -> bool;
 
    auto test_billboard(float size, const math::transform& t) const -> bool;
 
 
    auto viewport_to_ray(const math::vec2& point, math::vec3& vec_ray_start, math::vec3& vec_ray_dir) const -> bool;
 
    auto viewport_to_world(const math::vec2& point, const math::plane& plane, math::vec3& position_out, bool clip) const
        -> bool;
 
    auto viewport_to_major_axis(const math::vec2& point,
                                const math::vec3& axis_origin,
                                math::vec3& position_out,
                                math::vec3& major_axis_out) const -> bool;
 
    auto viewport_to_major_axis(const math::vec2& point,
                                const math::vec3& axis_origin,
                                const math::vec3& align_normal,
                                math::vec3& position_out,
                                math::vec3& major_axis_out) const -> bool;
 
    auto viewport_to_camera(const math::vec3& point, math::vec3& position_out) const -> bool;
 
    auto world_to_viewport(const math::vec3& pos) const -> math::vec3;
 
    auto estimate_zoom_factor(const math::plane& plane) const -> float;
 
    auto estimate_zoom_factor(const math::vec3& position) const -> float;
 
    auto estimate_zoom_factor(const math::plane& plane, float maximum_value) const -> float;
 
    auto estimate_zoom_factor(const math::vec3& position, float maximum_value) const -> float;
 
    auto estimate_pick_tolerance(float pixel_tolerance,
                                 const math::vec3& reference_position,
                                 const math::transform& object_transform) const -> math::vec3;
 
    void look_at(const math::vec3& eye, const math::vec3& at);
 
    void look_at(const math::vec3& eye, const math::vec3& at, const math::vec3& vUp);
 
    auto get_position() const -> const math::vec3&;
 
    auto x_unit_axis() const -> math::vec3;
 
    auto y_unit_axis() const -> math::vec3;
 
    auto z_unit_axis() const -> math::vec3;
 
    auto get_local_bounding_box() -> math::bbox;
 
    void touch();
 
    static auto get_face_camera(std::uint32_t face, const math::transform& transform) -> camera;
 
protected:
    math::vec4 aa_data_ = {0.0f, 0.0f, 0.0f, 0.0f};
    math::transform view_;
    math::transform view_inverse_;
 
    math::transform view_relative_;
    math::transform view_inverse_relative_;
 
    mutable math::transform projection_;
    math::transform last_view_;
    math::transform last_view_relative_;
 
    math::transform last_projection_;
    mutable math::frustum frustum_;
    mutable math::frustum clipping_volume_;
    projection_mode projection_mode_ = projection_mode::perspective;
    float fov_ = 60.0f;
    float near_clip_ = 0.1f;
    float far_clip_ = 1000.0f;
    float ortho_size_ = 5;
    float aspect_ratio_ = 1.0f;
    upoint32_t viewport_pos_ = {0, 0};
    usize32_t viewport_size_ = {0, 0};
    bool view_dirty_ = true;
    mutable bool projection_dirty_ = true;
    mutable bool aspect_dirty_ = true;
    mutable bool frustum_dirty_ = true;
    bool aspect_locked_ = false;
    bool frustum_locked_ = false;
};
} // namespace unravel