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
{
public:
        typedef cgv::math::fvec<float, 3>      vec3;
        typedef cgv::math::fvec<double, 3>    dvec3;
        typedef cgv::math::fmat<double, 3, 3> dmat3;
        typedef cgv::math::fmat<double, 4, 4> dmat4;
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>