view.h

#pragma once
 
#include <cgv/math/fvec.h>
#include <cgv/math/fmat.h>
#include <cgv/defines/deprecated.h>
#include "lib_begin.h"
 
namespace cgv {
    namespace render {
 
        class context;
 
class CGV_API view
{
protected:
    dvec3 focus;
    dvec3 view_up_dir;
    dvec3 view_dir;
    double y_view_angle;
    double y_extent_at_focus;
public:
    view();
 
 
    const dvec3& get_focus() const;
    virtual void set_focus(const dvec3& foc);
    void set_focus(const vec3& foc) { set_focus(dvec3(foc)); }
    void set_focus(double x, double y, double z);
    dvec3& ref_focus();
 
    const dvec3& get_view_dir() const;
    virtual void set_view_dir(const dvec3& vd);
    void set_view_dir(const vec3& vd) { set_view_dir(dvec3(vd)); }
    void set_view_dir(double x, double y, double z);
    dvec3& ref_view_dir();
 
    const dvec3& get_view_up_dir() const;
    virtual void set_view_up_dir(const dvec3& vud);
    void set_view_up_dir(const vec3& vud) { set_view_up_dir(dvec3(vud)); }
    void set_view_up_dir(double x, double y, double z);
    dvec3& ref_view_up_dir();
    double& ref_y_extent_at_focus();
 
    double get_y_view_angle() const;
    virtual void set_y_view_angle(double angle);
    double get_y_extent_at_focus() const;
    virtual void set_y_extent_at_focus(double ext);
    double& ref_y_view_angle();
 
    double get_tan_of_half_of_fovy(bool ensure_non_zero) const;
    double get_y_extent_at_depth(double depth, bool ensure_non_zero) const;
    double get_depth_of_focus() const;
 
    void put_coordinate_system(dvec3& x, dvec3& y, dvec3& z) const;
    void put_coordinate_system(vec3& x, vec3& y, vec3& z) const;
 
    int compute_axis_and_angle(const dvec3& target_view_dir, const dvec3& target_view_up_dir, dvec3& axis, double& angle);
    bool is_parallel() const;
 
    const dvec3 get_eye() const;
 
    bool set_eye_keep_extent(const dvec3& eye);
 
    bool set_eye_keep_view_angle(const dvec3& eye);
    void view_look_at_keep_view_angle(const dvec3& eye, const dvec3& foc, const dvec3& vud);
    void view_look_at_keep_extent(const dvec3& eye, const dvec3& foc, const dvec3& vud);
 
    void roll(double angle);
 
    void rotate(double axis_direction_x, double axis_direction_y, double axis_point_depth);
    void move(double step);
    void pan(double step_x, double step_y);
    void zoom(double factor);
 
    virtual void enable_viewport_splitting(unsigned nr_cols, unsigned nr_rows);
    virtual bool is_viewport_splitting_enabled(unsigned* nr_cols_ptr = 0, unsigned* nr_rows_ptr = 0) const;
    virtual void disable_viewport_splitting();
    virtual void activate_split_viewport(context& ctx, unsigned col_index, unsigned row_index);
    virtual void deactivate_split_viewport(context& ctx);
    virtual void enable_viewport_individual_view(unsigned col_index, unsigned row_index, bool enable = true);
    virtual bool does_viewport_use_individual_view(unsigned col_index, unsigned row_index) const;
    virtual view& ref_viewport_view(unsigned col_index, unsigned row_index);
 
    virtual int get_modelview_projection_window_matrices(int x, int y, int width, int height,
        const dmat4** MPW_pptr,
        const dmat4** MPW_other_pptr = 0, int* x_other_ptr = 0, int* y_other_ptr = 0,
        int* vp_col_idx_ptr = 0, int* vp_row_idx_ptr = 0,
        int* vp_width_ptr = 0, int *vp_height_ptr = 0,
        int* vp_center_x_ptr = 0, int* vp_center_y_ptr = 0,
        int* vp_center_x_other_ptr = 0, int* vp_center_y_other_ptr = 0) const;
 
    DEPRECATED("deprecated, use get_modelview_projection_window_matrices() instead.") virtual int get_modelview_projection_device_matrices(int x, int y, int width, int height,
        const dmat4** MVPD_pptr,
        const dmat4** MVPD_other_pptr = 0, int* x_other_ptr = 0, int* y_other_ptr = 0,
        int* vp_col_idx_ptr = 0, int* vp_row_idx_ptr = 0,
        int* vp_width_ptr = 0, int *vp_height_ptr = 0,
        int* vp_center_x_ptr = 0, int* vp_center_y_ptr = 0,
        int* vp_center_x_other_ptr = 0, int* vp_center_y_other_ptr = 0) const {
        return get_modelview_projection_window_matrices(x,y,width,height,MVPD_pptr,MVPD_other_pptr,
            x_other_ptr,y_other_ptr,vp_col_idx_ptr, vp_row_idx_ptr, vp_width_ptr, vp_height_ptr, 
            vp_center_x_ptr, vp_center_y_ptr, vp_center_x_other_ptr, vp_center_y_other_ptr);
    }
 
    virtual double get_z_and_unproject(context& ctx, int x, int y, dvec3& p);
    double get_z_and_unproject(context& ctx, int x, int y, vec3& p);
    void compute_screen_rectangle(std::vector<dvec3>& rect, double depth, double aspect) const;
    void compute_screen_rectangle(std::vector<vec3>& rect, double depth, double aspect) const;
 
};
    }
}
 
#include <cgv/config/lib_end.h>