gl_implicit_surface_drawable_base.h

#pragma once
 
#include <cgv/render/drawable.h>
#include "mesh_render_info.h"
#include <cgv/math/mfunc.h>
#include <cgv/media/axis_aligned_box.h>
#include <cgv/media/mesh/simple_mesh.h>
#include <cgv/media/mesh/streaming_mesh.h>
#include <cgv/media/illum/surface_material.h>
#include <cgv_gl/box_renderer.h>
#include <cgv_gl/sphere_renderer.h>
#include <cgv_gl/arrow_renderer.h>
#include <cgv_gl/cone_renderer.h>
 
#include "lib_begin.h" // @<
 
namespace cgv { // @<
    namespace render { // @<
        namespace gl { // @<
 
enum ContouringType { MARCHING_CUBES, DUAL_CONTOURING };
enum NormalComputationType { GRADIENT_NORMALS, FACE_NORMALS, CORNER_NORMALS, CORNER_GRADIENTS };
 
class CGV_API gl_implicit_surface_drawable_base : 
    public drawable, 
    public cgv::media::mesh::streaming_mesh_callback_handler
{
public: //@<
    typedef cgv::math::v3_func<double,double> F;
private:
    bool renderers_reffed = false;
    bool outofdate;
    cgv::media::mesh::streaming_mesh<double>* sm_ptr;
 
    cgv::media::mesh::simple_mesh<float> mesh;
    mesh_render_info mri;
 
    std::vector<vec3> nml_gradient_geometry;
    std::vector<vec3> nml_mesh_geometry;
 
protected: //@<
    //@>
    unsigned int res;
    dbox3 box;
    F* func_ptr;
    //@>
    ContouringType contouring_type;
    //@>
    double normal_threshold;
    //@>
    double consistency_threshold;
    //@>
    unsigned int max_nr_iters;
    //@>
    NormalComputationType normal_computation_type;
    //@>
    unsigned int ix;
    //@>
    unsigned int iy;
    //@>
    unsigned int iz;
    //@>
    bool show_vertices;
    bool show_wireframe;
    bool show_surface;
    //@>
    bool show_sampling_locations;
    //@>
    bool show_sampling_grid;
    float sampling_grid_alpha;
    //@>
    bool show_box;
    //@>
    bool show_mini_box;
    //@>
    bool show_gradient_normals;
    //@>
    bool show_mesh_normals;
 
    box_render_style brs;
    sphere_render_style srs;
    cone_render_style crs;
    arrow_render_style ars;
 
    //@>
    double epsilon;
    //@>
    double grid_epsilon;
 
    //@>
    int nr_faces;
    //@>
    int nr_vertices;
    cgv::media::illum::surface_material material;
 
    void add_normal(const dvec3& p, const dvec3& n, std::vector<vec3>& nml_gradient_geometry) const;
 
    void new_vertex(unsigned int vi);
    void new_polygon(const std::vector<unsigned int>& vertex_indices);
    void before_drop_vertex(unsigned int vertex_index);
    bool triangulate;
    std::ostream* obj_out;
    unsigned normal_index;
    bool save(const std::string& file_name);
    virtual void surface_extraction();
    dvec3 compute_face_normal(const std::vector<unsigned int> &vis, dvec3* c = 0) const;
    virtual void extract_mesh();
    void draw_implicit_surface(context& ctx);
    dvec3 compute_corner_normal(const dvec3& pk, const dvec3& pi, const dvec3& pj, const dvec3& ni);
public:
    gl_implicit_surface_drawable_base();
 
    void set_function(F* _func_ptr);
    F* get_function() const;
 
    void set_resolution(unsigned int _res);
    unsigned int get_resolution() const;
 
    void enable_wireframe(bool do_enable = true);
    bool is_wireframe_enabled() const;
 
    void enable_sampling_grid(bool do_enable = true);
    bool is_sampling_grid_enabled() const;
 
    void enable_sampling_locations(bool do_enable = true);
    bool is_sampling_locations_enabled() const;
 
    void enable_box(bool do_enable = true);
    bool is_box_enabled() const;
 
    void enable_normals(bool do_enable = true);
    bool are_normals_enabled() const;
 
    void set_epsilon(double _epsilon);
    double get_epsilon() const;
 
    void set_grid_epsilon(double _grid_epsilon);
    double get_grid_epsilon() const;
 
    void set_box(const dbox3& _box);
    const dbox3& get_box() const;
 
    unsigned int get_nr_triangles_of_last_extraction() const;
    unsigned int get_nr_vertices_of_last_extraction() const;
 
    void post_rebuild();
    bool init(context& ctx);
    void clear(context& ctx);
    void draw(context& ctx);
    void finish_frame(context& ctx);
 
}; // @<
 
        } // @<
    } // @<
} // @<
 
#include <cgv/config/lib_end.h> // @<