drawable.cxx

#include <cgv/base/base.h>
#include <cgv/base/node.h>
#include <cgv/render/drawable.h>
#include <cgv/base/find_action.h>
 
namespace cgv {
    namespace render {
 
void drawable::set_context(context* _ctx)
{
    ctx = _ctx;
}
drawable::drawable() : base::traverse_policy(base::TP_ALL)
{
    ctx = 0;
}
 
 
void drawable::hide()
{
    active = false;
}
void drawable::show()
{
    active = true;
}
bool drawable::is_visible() const
{
    return active;
}
 
context* drawable::get_context() const
{
    return ctx;
}
 
void drawable::post_redraw()
{
    if(ctx)
        ctx->post_redraw();
}
 
view* drawable::find_view_as_node(size_t view_idx) const
{
    cgv::base::node* node_ptr = const_cast<cgv::base::node*>(dynamic_cast<const cgv::base::node*>(this));
    std::vector<view*> views;
    cgv::base::find_interface<view>(cgv::base::base_ptr(node_ptr), views);
    if (views.empty() || view_idx > views.size())
        return 0;
    return views[view_idx];
}
 
bool drawable::get_world_location(int x, int y, const view& V, dvec3& world_location, double* window_z_ptr) const
{
    if (!get_context())
        return false;
    // analyze the mouse location
    context& ctx = *get_context();
    const dmat4* DPV_ptr, *DPV_other_ptr;
    int x_other, y_other, vp_col_idx, vp_row_idx, vp_width, vp_height;
    int eye_panel = V.get_modelview_projection_window_matrices(x, y, ctx.get_width(), ctx.get_height(), &DPV_ptr, &DPV_other_ptr, &x_other, &y_other, &vp_col_idx, &vp_row_idx, &vp_width, &vp_height);
 
    // get the possibly two (if stereo is enabled) different device z-values
    double z = ctx.get_window_z(x, y);
    double z_other = ctx.get_window_z(x_other, y_other);
    //  unproject to world coordinates with smaller (closer to eye) z-value one 
    if (z <= z_other) {
        if (DPV_ptr->ncols() != 4)
            return false;
        // use conversion to (double*) operator to map cgv::math::vec<double> to cgv::math::fvec<float,3>
        world_location = ctx.get_model_point(x, y, z, *DPV_ptr);
        if (window_z_ptr)
            *window_z_ptr = z;
    }
    else {
        if (DPV_other_ptr->ncols() != 4)
            return false;
        world_location = ctx.get_model_point(x_other, y_other, z_other, *DPV_other_ptr);
        if (window_z_ptr)
            *window_z_ptr = z_other;
    }
    return true;
}
 
void drawable::force_redraw()
{
    if (ctx)
        ctx->force_redraw();
}
 
bool drawable::init(context&)
{
    return true;
}
void drawable::resize(unsigned int, unsigned int)
{
}
void drawable::init_frame(context&)
{
}
void drawable::draw(context&)
{
}
void drawable::finish_draw(context&)
{
}
void drawable::finish_frame(context&)
{
}
 
void drawable::after_finish(context&)
{
}
 
void drawable::clear(context&)
{
}
 
multi_pass_drawable::multi_pass_drawable()
{
    current_render_pass = -1;
    render_pass_recursion_depth = 0;
}
bool multi_pass_drawable::initiate_render_pass_recursion(context& ctx)
{
    if (current_render_pass != -1)
        return false;
    render_pass_recursion_depth = ctx.get_render_pass_recursion_depth();
    return true;
}
void multi_pass_drawable::perform_render_pass(context& ctx, int rp_idx, RenderPass rp, int excluded_flags, int included_flags)
{
    current_render_pass = rp_idx;
    unsigned rpf = (ctx.get_render_pass_flags() & ~excluded_flags) | included_flags;
    ctx.render_pass(rp, RenderPassFlags(rpf), this);
}
void multi_pass_drawable::initiate_terminal_render_pass(int rp_idx)
{
    current_render_pass = rp_idx;
}
bool multi_pass_drawable::multi_pass_ignore_finish(const context& ctx)
{
    if (current_render_pass == -1)
        return true;
    if (ctx.get_render_pass_user_data() != this)
        if (render_pass_recursion_depth != ctx.get_render_pass_recursion_depth())
            return true;
    return false;
}
bool multi_pass_drawable::multi_pass_terminate(const context& ctx)
{
    if (render_pass_recursion_depth != ctx.get_render_pass_recursion_depth())
        return false;
    current_render_pass = -1;
    return true;
}
 
    } // namespace render
} // namespace cgv