40#ifndef GEOGRAM_GFX_MESH_GFX
41#define GEOGRAM_GFX_MESH_GFX
170 return mesh_border_width_;
180 mesh_border_width_ = x;
207 }
else if(shrink_ > 1.0) {
264 }
else if(time_ > 1.0) {
278 return draw_cells_[type];
291 draw_cells_[type] = x;
302 points_color_[0] = r;
303 points_color_[1] = g;
304 points_color_[2] = b;
305 points_color_[3] = a;
315 r = points_color_[0];
316 g = points_color_[1];
317 b = points_color_[2];
318 a = points_color_[3];
377 surface_color_[0] = r;
378 surface_color_[1] = g;
379 surface_color_[2] = b;
380 surface_color_[3] = a;
381 backface_surface_color_[0] = r;
382 backface_surface_color_[1] = g;
383 backface_surface_color_[2] = b;
384 backface_surface_color_[3] = a;
394 r = surface_color_[0];
395 g = surface_color_[1];
396 b = surface_color_[2];
397 a = surface_color_[3];
409 float r,
float g,
float b,
float a=1.0f
411 backface_surface_color_[0] = r;
412 backface_surface_color_[1] = g;
413 backface_surface_color_[2] = b;
414 backface_surface_color_[3] = a;
424 for(
index_t i=0; i<MESH_NB_CELL_TYPES; ++i) {
425 cells_color_[i][0] = r;
426 cells_color_[i][1] = g;
427 cells_color_[i][2] = b;
428 cells_color_[i][3] = a;
439 r = cells_color_[0][0];
440 g = cells_color_[0][1];
441 b = cells_color_[0][2];
442 a = cells_color_[0][3];
455 cells_colors_by_type_ =
true;
456 set_cells_color(MESH_TET, 1.0f, 0.0f, 0.0f);
457 set_cells_color(MESH_HEX, 0.9f, 0.9f, 0.9f);
458 set_cells_color(MESH_PRISM, 0.0f, 1.0f, 0.0f);
459 set_cells_color(MESH_PYRAMID, 0.0f, 0.0f, 1.0f);
460 set_cells_color(MESH_CONNECTOR, 1.0f, 0.8f, 0.0f);
508 picking_mode_ = what;
518 return picking_mode_;
530 object_picking_id_ = id;
539 return object_picking_id_;
551 vertices_selection_ = name;
560 return vertices_selection_;
582 MeshElementsFlags subelements,
583 const std::string& name,
584 double attr_min,
double attr_max,
585 GLuint colormap_texture,
600 MeshElementsFlags subelements,
601 const std::string& attribute_name,
612 attribute_subelements_ = MESH_NONE;
613 attribute_min_ = 0.0;
614 attribute_max_ = 0.0;
615 attribute_texture_ = 0;
616 attribute_repeat_ = 1;
632 MeshElementsFlags subelements,
633 const std::string& name =
"filter"
649 void draw_vertices_array();
650 void draw_vertices_immediate_plain();
651 void draw_vertices_immediate_attrib();
652 void draw_vertices_selection();
654 void draw_edges_array();
655 void draw_edges_immediate_plain();
656 void draw_edges_immediate_attrib();
658 void draw_triangles();
659 void draw_triangles_array();
660 void draw_triangles_immediate_plain();
661 void draw_triangles_immediate_attrib();
664 void draw_quads_array();
665 void draw_quads_immediate_plain();
666 void draw_quads_immediate_attrib();
668 void draw_triangles_and_quads();
669 void draw_triangles_and_quads_array();
670 void draw_triangles_and_quads_immediate_plain();
671 void draw_triangles_and_quads_immediate_attrib();
673 void draw_polygons();
674 void draw_polygons_plain();
675 void draw_polygons_attrib();
678 void draw_tets_array();
679 void draw_tets_immediate_plain();
680 void draw_tets_immediate_attrib();
683 void draw_hybrid_array();
684 void draw_hybrid_immediate_plain();
685 void draw_hybrid_immediate_attrib();
687 void set_cells_color(MeshCellType type,
float r,
float g,
float b) {
688 cells_color_[type][0] = r;
689 cells_color_[type][1] = g;
690 cells_color_[type][2] = b;
693 void draw_attribute_as_tex_coord(
index_t element) {
694 if(picking_mode_ == MESH_NONE) {
695 switch(attribute_dim_) {
697 glupPrivateTexCoord1d(scalar_attribute_[element]);
700 glupPrivateTexCoord2d(
701 tex_coord_attribute_[0][element],
702 tex_coord_attribute_[1][element]
706 glupPrivateTexCoord3d(
707 tex_coord_attribute_[0][element],
708 tex_coord_attribute_[1][element],
709 tex_coord_attribute_[2][element]
716 void draw_vertex_with_attribute(index_t vertex) {
717 if(attribute_subelements_ == MESH_VERTICES) {
718 draw_attribute_as_tex_coord(vertex);
723 void draw_surface_vertex_with_attribute(
724 index_t vertex, index_t facet, index_t corner
726 if(attribute_subelements_ == MESH_VERTICES) {
727 draw_attribute_as_tex_coord(vertex);
728 }
else if(attribute_subelements_ == MESH_FACETS) {
729 draw_attribute_as_tex_coord(facet);
730 }
else if(attribute_subelements_ == MESH_FACET_CORNERS) {
731 draw_attribute_as_tex_coord(corner);
736 void draw_volume_vertex_with_attribute(
737 index_t vertex, index_t cell, index_t cell_corner
739 if(attribute_subelements_ == MESH_VERTICES) {
740 draw_attribute_as_tex_coord(vertex);
741 }
else if(attribute_subelements_ == MESH_CELLS) {
742 draw_attribute_as_tex_coord(cell);
743 }
else if(attribute_subelements_ == MESH_CELL_CORNERS) {
744 draw_attribute_as_tex_coord(cell_corner);
749 void draw_vertex(index_t v) {
751 if(mesh_->vertices.single_precision()) {
753 mesh_->vertices.single_precision_point_ptr(v);
754 float t = float(time_);
755 float s = 1.0f - float(time_);
762 const GLUPdouble* p = mesh_->vertices.point_ptr(v);
763 double s = 1.0 - time_;
771 if(mesh_->vertices.single_precision()) {
772 if(mesh_->vertices.dimension() < 3) {
773 glupPrivateVertex2fv(
774 mesh_->vertices.single_precision_point_ptr(v)
777 glupPrivateVertex3fv(
778 mesh_->vertices.single_precision_point_ptr(v)
782 if(mesh_->vertices.dimension() < 3) {
783 glupPrivateVertex2dv(
784 mesh_->vertices.point_ptr(v)
787 glupPrivateVertex3dv(
788 mesh_->vertices.point_ptr(v)
795 void draw_surface_mesh_with_lines();
884 void update_surface_elements();
886 void update_volume_elements();
895 bool draw_cells_[MESH_NB_CELL_TYPES];
898 float points_color_[4];
899 float mesh_color_[4];
900 float surface_color_[4];
901 float backface_surface_color_[4];
902 float cells_color_[MESH_NB_CELL_TYPES][4];
903 bool cells_colors_by_type_;
907 MeshElementsFlags picking_mode_;
910 std::string vertices_selection_;
915 bool triangles_and_quads_;
917 bool has_cells_[MESH_NB_CELL_TYPES];
919 bool buffer_objects_dirty_;
920 bool attributes_buffer_objects_dirty_;
921 bool long_vector_attribute_;
923 GLuint vertices_VAO_;
928 GLuint vertices_VBO_;
929 GLuint edge_indices_VBO_;
930 GLuint facet_indices_VBO_;
931 GLuint cell_indices_VBO_;
932 GLuint vertices_attribute_VBO_;
934 MeshElementsFlags attribute_subelements_;
935 std::string attribute_name_;
937 double attribute_min_;
938 double attribute_max_;
939 GLuint attribute_texture_;
940 index_t attribute_texture_dim_;
969 bool hw_primitive_filtering=
true
990 !attribute.is_bound() ||
991 attribute[primitive_id] != 0
995 std::string attribute_name;
1002 Filter vertices_filter_;
1003 Filter facets_filter_;
1004 Filter cells_filter_;
1035 const bool hw_filtering = hw_filtering_supported();
1037 Filter* filter =
nullptr;
1038 if(&elements == &mesh_->vertices) {
1039 filter = &vertices_filter_;
1040 }
else if(&elements == &mesh_->facets) {
1041 filter = &facets_filter_;
1042 }
else if(&elements == &mesh_->cells) {
1043 filter = &cells_filter_;
1049 while(e < elements.
nb()) {
1050 while(e<elements.
nb() && !(hw_filtering||filter->
test(e))) {
1053 if(e<elements.
nb()) {
1055 while(e<elements.
nb() && (hw_filtering||filter->
test(e))) {
1059 glupBasePickingId(GLUPuint64(begin));
1064 glupBasePickingId(0);
1083 std::function<
bool(
index_t)> predicate,
1090 const bool hw_filtering = hw_filtering_supported();
1092 Filter* filter =
nullptr;
1093 if(&elements == &mesh_->vertices) {
1094 filter = &vertices_filter_;
1095 }
else if(&elements == &mesh_->facets) {
1096 filter = &facets_filter_;
1097 }
else if(&elements == &mesh_->cells) {
1098 filter = &cells_filter_;
1104 while(e < elements.
nb()) {
1106 e<elements.
nb() && (
1107 !(hw_filtering || filter->
test(e)) || !predicate(e))
1111 if(e<elements.
nb()) {
1115 (hw_filtering || filter->
test(e)) &&
1121 glupBasePickingId(GLUPuint64(begin));
1126 glupBasePickingId(0);
GLUP: GL Useful Primitives.
GLUPprimitive
Symbolic values corresponding to GLUP primitive types.
Slightly faster GLUP functions, not part of the API (do not use in client code).
#define geo_assert(x)
Verifies that a condition is met.
Manages an attribute attached to a set of object.
Managers a set of attributes attached to an object.
Draws a mesh using OpenGL.
void draw_surface()
Draws the surfacic part of the mesh.
void get_mesh_color(float &r, float &g, float &b, float &a) const
Gets the mesh color.
void get_points_color(float &r, float &g, float &b, float &a) const
Gets the points color.
void bind_attribute_buffer_object(GLuint VAO)
Binds the attribute buffer object to a Vertex Array Object.
void cleanup()
Deallocates OpenGL objects.
const std::string & get_vertices_selection() const
Gets the vertices selection.
void set_GLUP_parameters()
Sets GLUP drawing parameters.
void set_lighting(bool x)
Sets the lighting flag.
void set_shrink(double x)
Sets the cells shrink coefficient.
void update_attribute_buffer_objects_if_needed()
Updates the buffer objects used to display attributes.
void set_cells_colors_by_type()
Sets a different color for each mesh cell type.
void end_attributes()
Deactivates drawing for attributes.
void begin_attributes()
Setups drawing for attributes.
void set_draw_cells(MeshCellType type, bool x)
Sets the cell visibility flag.
void set_cells_color(float r, float g, float b, float a=1.0f)
Sets the color used to display mesh cells.
double get_shrink() const
Gets the cells shrink coefficient.
void set_texturing(MeshElementsFlags subelements, const std::string &attribute_name, GLuint texture, index_t texture_dim, index_t repeat=1)
Sets the parameters for texture mapping.
void set_points_size(float x)
Sets the point size.
void draw_volume()
Draws the volumetric part of the mesh.
void get_cells_color(float &r, float &g, float &b, float &a) const
Gets the cells color.
index_t get_object_picking_id() const
Gets the object-wide picking id.
MeshGfx()
MeshGfx constructor.
void set_picking_mode(MeshElementsFlags what)
Sets picking mode.
bool get_draw_cells(MeshCellType type) const
Gets the cell visibility flag.
void set_object_picking_id(index_t id)
Sets the object-wide picking id.
float get_points_size() const
Gets the point size.
bool get_lighting() const
Gets the lighing flag.
bool can_use_array_mode(GLUPprimitive prim) const
Tests whether array mode can be used to draw a specified GLUP primitive.
void set_GLUP_vertex_color_from_picking_id(index_t id)
Encodes an id as the current vertex color.
void set_GLUP_picking(MeshElementsFlags what)
Sets GLUP picking mode for drawing primitives of a given type, or deactivates GLUP picking if MeshGfx...
void set_surface_color(float r, float g, float b, float a=1.0f)
Sets the surface color.
void set_points_color(float r, float g, float b, float a=1.0f)
Sets the points color.
void draw_edges()
Draws the edges of the mesh.
void set_mesh(const Mesh *M)
Sets the mesh.
void set_mesh_width(index_t x)
Sets the mesh width.
void set_time(double x)
Gets the time of the animation.
void set_vertices_selection(const std::string &name)
Sets the vertices selection.
~MeshGfx()
MeshGfx destructor.
index_t get_mesh_width() const
Gets the mesh width.
bool get_show_mesh() const
Gets the mesh visibility flag.
const Mesh * mesh() const
Gets the mesh.
void set_backface_surface_color(float r, float g, float b, float a=1.0f)
Sets the surface color for backfacing faces.
bool get_animate() const
Gets the animate flag.
void set_mesh_border_width(index_t x)
Sets the mesh border width.
void unset_filters()
Unset primitive filtering.
index_t get_mesh_border_width() const
Gets the mesh border width.
void set_show_mesh(bool x)
Sets the mesh visibility flag.
void get_surface_color(float &r, float &g, float &b, float &a) const
Gets the surface color.
void draw_sequences_if(const MeshSubElementsStore &elements, std::function< bool(index_t)> predicate, std::function< void(index_t, index_t)> draw)
Generic function to extract element sequences to draw.
void draw_vertices()
Draws the vertices of the mesh.
void update_buffer_objects_if_needed()
Updates the Vertex Buffer Objects and Vertex Array Objects.
MeshGfx(const MeshGfx &rhs)=delete
Forbids MeshGfx copy..
void draw_surface_borders()
Draws the borders of the surfacic part of the mesh.
double get_time() const
Gets the time of the animation.
void set_animate(bool x)
Gets the animate flag.
void set_scalar_attribute(MeshElementsFlags subelements, const std::string &name, double attr_min, double attr_max, GLuint colormap_texture, index_t repeat=1)
Sets the parameters for displaying a scalar attribute using texture mapping.
void bind_vertices_VBO()
Binds the vertices VBO to the current VAO.
void set_filter(MeshElementsFlags subelements, const std::string &name="filter")
Sets primitive filtering.
MeshGfx & operator=(const MeshGfx &rhs)=delete
Forbids MeshGfx copy..
void unset_scalar_attribute()
Unsets scalar attribute display.
MeshElementsFlags get_picking_mode() const
Gets the current picking mode.
bool hw_filtering_supported() const
Tests whether hardware primitive filtering is supported.
void set_mesh_color(float r, float g, float b, float a=1.0f)
Sets the mesh color.
void draw_sequences(const MeshSubElementsStore &elements, std::function< void(index_t, index_t)> draw)
Generic function to extract element sequences to draw.
void unbind_attribute_buffer_object(GLuint VAO)
Unbinds the attribute buffer object from a Vertex Array Object.
Base class for mesh sub-element storage.
AttributesManager & attributes() const
Gets the attributes manager.
index_t nb() const
Gets the number of (sub-)elements.
Readonly access to an attribute as a double regardless its type.
#define GEOGRAM_GFX_API
Linkage declaration for geogram symbols.
Common include file, providing basic definitions. Should be included before anything else by all head...
The class that represents a mesh.
Global Vorpaline namespace.
geo_index_t index_t
The type for storing and manipulating indices.
Filters primitives based on their id and on an attribute.
bool begin(AttributesManager &attributes_manager, bool hw_primitive_filtering=true)
Begins rendering with primitive filtering.
void end()
Needs to be called after rendering.
bool test(index_t primitive_id) const
Tests an individual primitive.
void deallocate()
Deallocates GPU objects.