view.cxx

#include <cgv/render/view.h>
#include <cgv/math/geom.h>
 
using namespace cgv::math;
 
namespace cgv {
    namespace render {
 
view::view() 
    : focus(0,0,0), view_up_dir(0,1,0), view_dir(0,0,-1), y_view_angle(0), y_extent_at_focus(2)
{
}
 
dvec3& view::ref_focus() { return focus; }
dvec3& view::ref_view_up_dir() { return view_up_dir; }
dvec3& view::ref_view_dir() { return view_dir; }
double& view::ref_y_view_angle() { return y_view_angle; }
double& view::ref_y_extent_at_focus() { return y_extent_at_focus; }
 
int view::compute_axis_and_angle(const dvec3& target_view_dir, const dvec3& target_view_up_dir, 
    dvec3& axis, double& angle)
{
    dmat3 R = cgv::math::build_orthogonal_frame(view_dir, view_up_dir);
    R.transpose();
    R = cgv::math::build_orthogonal_frame(target_view_dir, target_view_up_dir)*R;
    dvec3 daxis;
    double dangle;
    int res = cgv::math::decompose_rotation_to_axis_and_angle(R, daxis, dangle);
    axis = daxis;
    angle = dangle;
    return res;
}
 
double view::get_tan_of_half_of_fovy(bool ensure_non_zero) const
{
    return tan(.008726646260*((ensure_non_zero && (y_view_angle <= 0.01)) ? 0.01 : y_view_angle));
}
 
const dvec3& view::get_focus() const
{
    return focus;
}
const dvec3& view::get_view_up_dir() const
{
    return view_up_dir;
}
const dvec3& view::get_view_dir() const
{
    return view_dir;
}
double view::get_y_view_angle() const
{
    return y_view_angle;
}
double view::get_y_extent_at_focus() const
{
    return y_extent_at_focus;
}
double view::get_depth_of_focus() const
{
    return 0.5f*y_extent_at_focus / get_tan_of_half_of_fovy(true);
}
 
double view::get_y_extent_at_depth(double depth, bool ensure_non_zero) const
{
    return 2.0f*depth*get_tan_of_half_of_fovy(ensure_non_zero);
}
 
void view::set_focus(const dvec3& foc) 
{
    focus = foc;
}
void view::set_focus(double x, double y, double z) { set_focus(dvec3(x,y,z)); }
 
void view::set_view_up_dir(const dvec3& vud)
{
    view_up_dir = normalize(vud);
}
void view::set_view_up_dir(double x, double y, double z) { set_view_up_dir(dvec3(x,y,z)); }
void view::set_view_dir(const dvec3& vd)
{
    view_dir = normalize(vd);
}
void view::set_view_dir(double x, double y, double z) { set_view_dir(dvec3(x,y,z)); }
void view::set_y_extent_at_focus(double ext)
{
    y_extent_at_focus = ext;
}
void view::set_y_view_angle(double angle)
{
    y_view_angle = angle;
}
 
bool view::is_parallel() const
{
    return y_view_angle == 0;
}
 
 
const dvec3 view::get_eye() const
{
    return focus - (0.5f*y_extent_at_focus / get_tan_of_half_of_fovy(true))*view_dir;
}
 
 
bool view::set_eye_keep_view_angle(const dvec3& eye)
{
    dvec3 new_view_dir = focus - eye;
    dvec3::value_type l = new_view_dir.length();
    if (l < 10 * std::numeric_limits<dvec3::value_type>::epsilon())
        return false;
    dvec3::value_type inv_l = dvec3::value_type(1) / l;
    view_dir = inv_l*new_view_dir;
    y_extent_at_focus = get_y_extent_at_depth(l, true);
    return true;
}
 
 
bool view::set_eye_keep_extent(const dvec3& eye)
{
    dvec3 new_view_dir = focus - eye;
    dvec3::value_type l = new_view_dir.length();
    if (l < 10 * std::numeric_limits<dvec3::value_type>::epsilon())
        return false;
    dvec3::value_type inv_l = dvec3::value_type(1) / l;
    view_dir = inv_l*new_view_dir;
    y_view_angle = atan(0.5*y_extent_at_focus*inv_l)*114.5915590;
    return true;
}
 
void view::view_look_at_keep_extent(const dvec3& e, const dvec3& foc, const dvec3& vud)
{
    set_focus(foc);
    set_view_up_dir(vud);
    set_eye_keep_extent(e);
}
 
void view::view_look_at_keep_view_angle(const dvec3& e, const dvec3& foc, const dvec3& vud)
{
    set_focus(foc);
    set_view_up_dir(vud);
    set_eye_keep_view_angle(e);
}
 
void view::enable_viewport_splitting(unsigned nr_cols, unsigned nr_rows)
{}
bool view::is_viewport_splitting_enabled(unsigned* nr_cols_ptr, unsigned* nr_rows_ptr) const
{
    return false;
}
void view::disable_viewport_splitting()
{}
void view::activate_split_viewport(context& ctx, unsigned col_index, unsigned row_index)
{}
void view::deactivate_split_viewport(context& ctx)
{}
 
void view::enable_viewport_individual_view(unsigned col_index, unsigned row_index, bool enable)
{
}
 
bool view::does_viewport_use_individual_view(unsigned col_index, unsigned row_index) const
{
    return false;
}
 
view& view::ref_viewport_view(unsigned col_index, unsigned row_index)
{
    return *this;
}
 
void view::put_coordinate_system(dvec3& x, dvec3& y, dvec3& z) const
{
    z = -view_dir;
    z.normalize();
    x = cross(view_up_dir, z);
    x.normalize();
    y = cross(z, x);
}
 
 
void view::put_coordinate_system(vec3& x, vec3& y, vec3& z) const
{
    dvec3 dx, dy, dz;
    put_coordinate_system(dx, dy, dz);
    x = dx;
    y = dy;
    z = dz;
}
 
void view::roll(double angle)
{
    view_up_dir = normalize(cgv::math::rotate(view_up_dir, view_dir, angle));
}
 
 
void view::rotate(double axis_direction_x, double axis_direction_y, double axis_point_depth)
{
    dvec3 x, y, z;
    put_coordinate_system(x, y, z);
    dvec3 axis_dir = axis_direction_x*x + axis_direction_y*y;
    double angle = axis_dir.length();
    if (angle < 10 * std::numeric_limits<double>::epsilon())
        return;
    axis_dir *= 1.0 / angle;
    dvec3 axis_point = get_eye() + axis_point_depth*view_dir;
    focus = cgv::math::rotate(focus - axis_point, axis_dir, angle) + axis_point;
    view_dir = normalize(cgv::math::rotate(view_dir, axis_dir, angle));
    view_up_dir = normalize(cgv::math::rotate(view_up_dir, axis_dir, angle));
}
 
void view::move(double step)
{
    focus += step*view_dir;
}
 
void view::pan(double step_x, double step_y)
{
    dvec3 x, y, z;
    put_coordinate_system(x, y, z);
    focus += step_x*x + step_y* y;
}
 
void view::zoom(double factor)
{
    y_extent_at_focus *= factor;
}
 
int view::get_modelview_projection_window_matrices(int x, int y, int width, int height,
    const dmat4** DPV_pptr,
    const dmat4** DPV_other_pptr, int* x_other_ptr, int* y_other_ptr,
    int* vp_col_idx_ptr, int* vp_row_idx_ptr,
    int* vp_width_ptr, int *vp_height_ptr,
    int* vp_center_x_ptr, int* vp_center_y_ptr,
    int* vp_center_x_other_ptr, int* vp_center_y_other_ptr) const
{
    return 0;
}
 
double view::get_z_and_unproject(context& ctx, int x, int y, dvec3& p)
{
    return 0.0;
}
 
double view::get_z_and_unproject(context& ctx, int x, int y, vec3& p) 
{
    dvec3 dp(p);
    double res = get_z_and_unproject(ctx, x, y, dp);
    p = dp;
    return res;
}
 
void view::compute_screen_rectangle(std::vector<dvec3>& rect, double depth, double aspect) const
{
    // compute view aligned coordinate system
    dvec3 x, y, z;
    put_coordinate_system(x, y, z);
 
    // compute center of screen covering rectangle
    dvec3 c = get_eye() - z*depth;
 
    // scale x- and y-direction vectors to cover screen rectangle
    double y_scale = 0.5*get_y_extent_at_depth(depth, true);
    y *= y_scale;
    x *= y_scale*aspect;
 
    // construct rectangle corners
    rect.push_back(c + x + y);
    rect.push_back(c - x + y);
    rect.push_back(c - x - y);
    rect.push_back(c + x - y);
}
 
void view::compute_screen_rectangle(std::vector<vec3>& rect, double depth, double aspect) const
{
    std::vector<dvec3> drect;
    compute_screen_rectangle(drect, depth, aspect);
    rect.clear();
    for (const auto& p : drect)
        rect.push_back(vec3(p));
}
 
 
    }
}