abs_camera.hpp

浏览该文件的文档.

 
#pragma once
#include <xcal/public.h>
 
#include <xcal/camera/core/frame.hpp>
#include <xcal/property/color.hpp>
#include <xcal/property/vec.hpp>
#include <xcmath/xcmath.hpp>
 
namespace xcal::camera {
enum class CameraType {
    Perspective,  
    Orthogonal,   
};
#define XCAL_CAMERA_TYPE(tp)                                     \
   private:                                                      \
    ::xcal::camera::CameraType type_() const noexcept override { \
        return ::xcal::camera::CameraType::tp;                   \
    }
 
class XCAL_API AbsCamera {
    using vec = xcmath::vec<float_t, 3>;
 
   private:
    virtual CameraType type_() const noexcept = 0;  
   private:
    /* 视图参数 */
    property::Vec<float_t, 3> position_{0.f, 0.f, -1.f};  
    property::Vec<float_t, 3> target_{0.f, 0.f, 0.f};     
    property::Vec<float_t, 3> up_{0.f, 1.f, 0.f};
    property::Color background_color_{0.f, 0.f, 0.f, 1.f};  
    mutable bool_t view_or_projection_has_changed_{
        true};  
    mutable xcmath::mat<float_t, 4, 4> view_matrix_cache_{
        xcmath::mat<float_t, 4, 4>::eye()};  
    mutable xcmath::mat<float_t, 4, 4> pv_matrix_cache_{
        xcmath::mat<float_t, 4, 4>::eye()};  
 
   private:
    void update_view_matrix() const;
 
   public:
    /* 获取投影矩阵 P */
    property::Vec<float_t, 3>& position() { return position_; }
 
    const property::Vec<float_t, 3>& position() const { return position_; }
 
    property::Vec<float_t, 3>& target() { return target_; }
 
    const property::Vec<float_t, 3>& target() const { return target_; }
 
    property::Vec<float_t, 3>& up() { return up_; }
 
    const property::Vec<float_t, 3>& up() const { return up_; }
 
    property::Color& background_color() { return background_color_; }
 
    const property::Color& background_color() const {
        return background_color_;
    }
 
    CameraType type() const { return type_(); }
    template <typename... Args>
        requires(std::is_constructible_v<vec, Args...>)
    AbsCamera* set_position(Args&&... args) {
        position_ = vec{float_t(std::forward<Args>(args))...};
        return this;
    }
 
    template <typename... Args>
        requires(std::is_constructible_v<vec, Args...>)
    AbsCamera* set_target(Args&&... args) {
        target_ = vec{float_t(std::forward<Args>(args))...};
        return this;
    }
 
    template <typename... Args>
        requires(std::is_constructible_v<vec, Args...>)
    AbsCamera* set_up(Args&&... args) {
        up_ = vec{float_t(std::forward<Args>(args))...};
        return this;
    }
    template <typename... Args>
        requires(std::is_constructible_v<property::Color::data_t, Args...>)
    AbsCamera* set_background_color(Args&&... args) {
        background_color_ =
            property::Color::data_t{(float_t)std::forward<Args>(args)...};
        return this;
    }
 
    /* 获取视图矩阵 V */
    const xcmath::mat<float_t, 4, 4>& view_matrix() const;
 
   protected:
    void projection_has_changed() const;
 
   public:
    AbsCamera() {};
 
    virtual ~AbsCamera() = default;
 
    virtual const xcmath::mat<float_t, 4, 4>& projection_matrix() const = 0;
 
    virtual bool_t projection_should_update() const = 0;
 
    bool_t view_should_update() const;
 
    bool_t should_update() const;
 
    const xcmath::mat<float_t, 4, 4>& pv_matrix() const;
};
}  // namespace xcal::camera
template class XCAL_API xcal::property::Vec<float_t, 3>;
namespace xcal {
XCAL_API inline const char* to_string(xcal::camera::CameraType type) {
    switch (type) {
        case xcal::camera::CameraType::Perspective:
            return "Perspective";
        case xcal::camera::CameraType::Orthogonal:
            return "Orthogonal";
        default:
            return "Unknown";
    }
}
}  // namespace xcal