mesh_gfx.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_GFX_MESH_GFX
#define GEOGRAM_GFX_MESH_GFX
 
#include <geogram_gfx/basic/common.h>
#include <geogram_gfx/GLUP/GLUP.h>
#include <geogram_gfx/GLUP/GLUP_private.h>
#include <geogram/mesh/mesh.h>
 
namespace GEO {
 
    class MeshGfxImpl;
 
    class GEOGRAM_GFX_API MeshGfx {
    public:
 
    MeshGfx();
 
    ~MeshGfx();
 
    MeshGfx(const MeshGfx& rhs) = delete;
 
    MeshGfx& operator=(const MeshGfx& rhs) = delete;
 
    void draw_vertices();
 
    void draw_edges();
 
    void draw_surface();
 
    void draw_surface_borders();
 
    void draw_volume();
 
    bool get_show_mesh() const {
        return show_mesh_;
    }
 
    void set_show_mesh(bool x) {
        show_mesh_ = x;
    }
 
    index_t get_mesh_width() const {
        return mesh_width_;
    }
 
    void set_mesh_width(index_t x) {
        mesh_width_ = x;
    }
 
    index_t get_mesh_border_width() const {
        return mesh_border_width_;
    }
 
    void set_mesh_border_width(index_t x) {
        mesh_border_width_ = x;
    }
 
    double get_shrink() const {
        return shrink_;
    }
 
    void set_shrink(double x) {
        shrink_ = x;
        if(shrink_ < 0.0) {
            shrink_ = 0.0;
        } else if(shrink_ > 1.0) {
            shrink_ = 1.0;
        }
    }
 
 
    bool get_animate() const {
        return animate_;
    }
 
    void set_animate(bool x) {
        animate_ = x;
    }
 
    double get_time() const {
        return time_;
    }
 
    void set_time(double x) {
        time_ = x;
        if(time_ < 0.0) {
            time_ = 0.0;
        } else if(time_ > 1.0) {
            time_ = 1.0;
        }
    }
 
    bool get_draw_cells(MeshCellType type) const {
        return draw_cells_[type];
    }
 
 
    void set_draw_cells(MeshCellType type, bool x) {
        draw_cells_[type] = x;
    }
 
    void set_points_color(float r, float g, float b, float a=1.0f) {
        points_color_[0] = r;
        points_color_[1] = g;
        points_color_[2] = b;
        points_color_[3] = a;
    }
 
    void get_points_color(float& r, float& g, float& b, float& a) const {
        r = points_color_[0];
        g = points_color_[1];
        b = points_color_[2];
        a = points_color_[3];
    }
 
    void set_points_size(float x) {
        points_size_ = x;
    }
 
    float get_points_size() const {
        return points_size_;
    }
 
    void set_mesh_color(float r, float g, float b, float a=1.0f) {
        mesh_color_[0] = r;
        mesh_color_[1] = g;
        mesh_color_[2] = b;
        mesh_color_[3] = a;
    }
 
    void get_mesh_color(float& r, float& g, float& b, float& a) const {
        r = mesh_color_[0];
        g = mesh_color_[1];
        b = mesh_color_[2];
        a = mesh_color_[3];
    }
 
    void set_surface_color(float r, float g, float b, float a=1.0f) {
        surface_color_[0] = r;
        surface_color_[1] = g;
        surface_color_[2] = b;
        surface_color_[3] = a;
        backface_surface_color_[0] = r;
        backface_surface_color_[1] = g;
        backface_surface_color_[2] = b;
        backface_surface_color_[3] = a;
    }
 
    void get_surface_color(float& r, float& g, float& b, float& a) const {
        r = surface_color_[0];
        g = surface_color_[1];
        b = surface_color_[2];
        a = surface_color_[3];
    }
 
    void set_backface_surface_color(
        float r, float g, float b, float a=1.0f
    ) {
        backface_surface_color_[0] = r;
        backface_surface_color_[1] = g;
        backface_surface_color_[2] = b;
        backface_surface_color_[3] = a;
    }
 
    void set_cells_color(float r, float g, float b, float a=1.0f) {
        for(index_t i=0; i<MESH_NB_CELL_TYPES; ++i) {
            cells_color_[i][0] = r;
            cells_color_[i][1] = g;
            cells_color_[i][2] = b;
            cells_color_[i][3] = a;
        }
    }
 
    void get_cells_color(float& r, float& g, float& b, float& a) const {
        r = cells_color_[0][0];
        g = cells_color_[0][1];
        b = cells_color_[0][2];
        a = cells_color_[0][3];
    }
 
    void set_cells_colors_by_type() {
        cells_colors_by_type_ = true;
        set_cells_color(MESH_TET,       1.0f, 0.0f, 0.0f);
        set_cells_color(MESH_HEX,       0.9f, 0.9f, 0.9f);
        set_cells_color(MESH_PRISM,     0.0f, 1.0f, 0.0f);
        set_cells_color(MESH_PYRAMID,   0.0f, 0.0f, 1.0f);
        set_cells_color(MESH_CONNECTOR, 1.0f, 0.8f, 0.0f);
    }
 
    bool get_lighting() const {
        return lighting_;
    }
 
    void set_lighting(bool x) {
        lighting_ = x;
    }
 
    void set_mesh(const Mesh* M);
 
    const Mesh* mesh() const {
        return mesh_;
    }
 
    void set_picking_mode(MeshElementsFlags what) {
        picking_mode_ = what;
    }
 
    MeshElementsFlags get_picking_mode() const {
        return picking_mode_;
    }
 
 
    void set_object_picking_id(index_t id) {
        object_picking_id_ = id;
    }
 
    index_t get_object_picking_id() const {
        return object_picking_id_;
    }
 
    void set_vertices_selection(const std::string& name) {
        if(vertices_selection_ != name) {
            vertices_selection_ = name;
            vertices_selection_filter_.attribute_name = name;
            vertices_selection_filter_.dirty = true;
        }
    }
 
    const std::string& get_vertices_selection() const {
        return vertices_selection_;
    }
 
    void set_scalar_attribute(
        MeshElementsFlags subelements,
        const std::string& name,
        double attr_min, double attr_max,
        GLuint colormap_texture,
        index_t repeat = 1
    );
 
    void set_texturing(
        MeshElementsFlags subelements,
        const std::string& attribute_name,
        GLuint texture,
        index_t texture_dim,
        index_t repeat = 1
    );
 
 
    void unset_scalar_attribute() {
        attribute_subelements_ = MESH_NONE;
        attribute_min_ = 0.0;
        attribute_max_ = 0.0;
        attribute_texture_ = 0;
        attribute_repeat_ = 1;
        attribute_dim_ = 0;
    }
 
    void set_filter(
        MeshElementsFlags subelements,
        const std::string& name = "filter"
    );
 
    void unset_filters();
 
 
    void cleanup();
 
    protected:
 
    void draw_vertices_array();
    void draw_vertices_immediate_plain();
    void draw_vertices_immediate_attrib();
    void draw_vertices_selection();
 
    void draw_edges_array();
    void draw_edges_immediate_plain();
    void draw_edges_immediate_attrib();
    void draw_edges_picking_filter();
 
    void draw_triangles();
    void draw_triangles_array();
    void draw_triangles_immediate_plain();
    void draw_triangles_immediate_attrib();
 
    void draw_quads();
    void draw_quads_array();
    void draw_quads_immediate_plain();
    void draw_quads_immediate_attrib();
 
    void draw_triangles_and_quads();
    void draw_triangles_and_quads_array();
    void draw_triangles_and_quads_immediate_plain();
    void draw_triangles_and_quads_immediate_attrib();
 
    void draw_polygons();
    void draw_polygons_plain();
    void draw_polygons_attrib();
 
    void draw_tets();
    void draw_tets_array();
    void draw_tets_immediate_plain();
    void draw_tets_immediate_attrib();
 
    void draw_hybrid();
    void draw_hybrid_array();
    void draw_hybrid_immediate_plain();
    void draw_hybrid_immediate_attrib();
 
    void set_cells_color(MeshCellType type, float r, float g, float b) {
        cells_color_[type][0] = r;
        cells_color_[type][1] = g;
        cells_color_[type][2] = b;
    }
 
    void draw_attribute_as_tex_coord(index_t element) {
        if(picking_mode_ == MESH_NONE) {
            switch(attribute_dim_) {
            case 1:
                glupPrivateTexCoord1d(scalar_attribute_[element]);
                break;
            case 2:
                glupPrivateTexCoord2d(
                    tex_coord_attribute_[0][element],
                    tex_coord_attribute_[1][element]
                );
                break;
            case 3:
                glupPrivateTexCoord3d(
                    tex_coord_attribute_[0][element],
                    tex_coord_attribute_[1][element],
                    tex_coord_attribute_[2][element]
                );
                break;
            }
        }
    }
 
    void draw_vertex_with_attribute(index_t vertex) {
        if(attribute_subelements_ == MESH_VERTICES) {
            draw_attribute_as_tex_coord(vertex);
        }
        draw_vertex(vertex);
    }
 
    void draw_surface_vertex_with_attribute(
        index_t vertex, index_t facet, index_t corner
    ) {
        if(attribute_subelements_ == MESH_VERTICES) {
            draw_attribute_as_tex_coord(vertex);
        } else if(attribute_subelements_ == MESH_FACETS) {
            draw_attribute_as_tex_coord(facet);
        } else if(attribute_subelements_ == MESH_FACET_CORNERS) {
            draw_attribute_as_tex_coord(corner);
        }
        draw_vertex(vertex);
    }
 
    void draw_volume_vertex_with_attribute(
        index_t vertex, index_t cell, index_t cell_corner
    ) {
        if(attribute_subelements_ == MESH_VERTICES) {
            draw_attribute_as_tex_coord(vertex);
        } else if(attribute_subelements_ == MESH_CELLS) {
            draw_attribute_as_tex_coord(cell);
        } else if(attribute_subelements_ == MESH_CELL_CORNERS) {
            draw_attribute_as_tex_coord(cell_corner);
        }
        draw_vertex(vertex);
    }
 
    void draw_vertex(index_t v) {
        if(do_animation_) {
            if(mesh_->vertices.single_precision()) {
                const GLUPfloat* p =
                    mesh_->vertices.single_precision_point_ptr(v);
                float t = float(time_);
                float s = 1.0f - float(time_);
                glupPrivateVertex3f(
                    s*p[0] + t*p[3],
                    s*p[1] + t*p[4],
                    s*p[2] + t*p[5]
                );
            } else {
                const GLUPdouble* p = mesh_->vertices.point_ptr(v);
                double s = 1.0 - time_;
                glupPrivateVertex3d(
                    s*p[0] + time_*p[3],
                    s*p[1] + time_*p[4],
                    s*p[2] + time_*p[5]
                );
            }
        } else {
            if(mesh_->vertices.single_precision()) {
                if(mesh_->vertices.dimension() < 3) {
                    glupPrivateVertex2fv(
                        mesh_->vertices.single_precision_point_ptr(v)
                    );
                } else {
                    glupPrivateVertex3fv(
                        mesh_->vertices.single_precision_point_ptr(v)
                    );
                }
            } else {
                if(mesh_->vertices.dimension() < 3) {
                    glupPrivateVertex2dv(
                        mesh_->vertices.point_ptr(v)
                    );
                } else {
                    glupPrivateVertex3dv(
                        mesh_->vertices.point_ptr(v)
                    );
                }
            }
        }
    }
 
    void draw_surface_mesh_with_lines();
 
    void set_GLUP_parameters();
 
    void set_GLUP_picking(MeshElementsFlags what);
 
 
    void set_GLUP_vertex_color_from_picking_id(index_t id);
 
 
    void update_buffer_objects_if_needed();
 
 
    void update_attribute_buffer_objects_if_needed();
 
 
    void bind_attribute_buffer_object(GLuint VAO);
 
 
    void unbind_attribute_buffer_object(GLuint VAO);
 
    void bind_vertices_VBO();
 
    void begin_attributes();
 
    void end_attributes();
 
 
    bool can_use_array_mode(GLUPprimitive prim) const;
 
    void update_surface_elements();
 
    void update_volume_elements();
 
    protected:
    bool show_mesh_;
    index_t mesh_width_;
    index_t mesh_border_width_;
    double shrink_;
    bool animate_;
    double time_;
    bool draw_cells_[MESH_NB_CELL_TYPES];
    float points_size_;
 
    float points_color_[4];
    float mesh_color_[4];
    float surface_color_[4];
    float backface_surface_color_[4];
    float cells_color_[MESH_NB_CELL_TYPES][4];
    bool cells_colors_by_type_;
 
    bool lighting_;
 
    MeshElementsFlags picking_mode_;
    index_t object_picking_id_;
 
    std::string vertices_selection_;
 
    bool do_animation_;
 
    const Mesh* mesh_;
    bool triangles_and_quads_;
    bool quads_;
    bool has_cells_[MESH_NB_CELL_TYPES];
 
    bool buffer_objects_dirty_;
    bool attributes_buffer_objects_dirty_;
    bool long_vector_attribute_;
 
    GLuint vertices_VAO_;
    GLuint edges_VAO_;
    GLuint facets_VAO_;
    GLuint cells_VAO_;
 
    GLuint vertices_VBO_;
    GLuint edge_indices_VBO_;
    GLuint facet_indices_VBO_;
    GLuint cell_indices_VBO_;
    GLuint vertices_attribute_VBO_;
 
    MeshElementsFlags attribute_subelements_;
    std::string attribute_name_;
    index_t attribute_dim_;
    double attribute_min_;
    double attribute_max_;
    GLuint attribute_texture_;
    index_t attribute_texture_dim_;
    index_t attribute_repeat_;
    ReadOnlyScalarAttributeAdapter scalar_attribute_;
    ReadOnlyScalarAttributeAdapter tex_coord_attribute_[3];
    bool ES_profile_;
 
    struct Filter {
        Filter();
        ~Filter();
 
        bool begin(
            AttributesManager& attributes_manager,
            bool hw_primitive_filtering=true
        );
 
        void end();
 
        void deallocate();
 
        bool test(index_t primitive_id) const {
            return (
                !attribute.is_bound() ||
                attribute[primitive_id] != 0
            );
        }
 
        std::string attribute_name;
        Attribute<Numeric::uint8> attribute;
        GLuint VBO;
        GLuint texture;
        bool dirty;
    };
 
    Filter vertices_filter_;
    Filter edges_filter_;
    Filter facets_filter_;
    Filter cells_filter_;
    Filter vertices_selection_filter_;
 
    bool hw_filtering_supported() const;
 
    void draw_sequences(
        const MeshSubElementsStore& elements,
        std::function<void(index_t, index_t)> draw
    ) {
        // GLUP hardware primitive filtering.
        // Not supported in all profiles.
        // If supported, primitives are filtered by the GPU,
        // else, they are filtered here explicitly.
        const bool hw_filtering = hw_filtering_supported();
 
        Filter* filter = nullptr;
        if(&elements == &mesh_->vertices) {
            filter = &vertices_filter_;
        } else if(&elements == &mesh_->edges) {
            filter = &edges_filter_;
        } else if(&elements == &mesh_->facets) {
            filter = &facets_filter_;
        } else if(&elements == &mesh_->cells) {
            filter = &cells_filter_;
        }
        geo_assert(filter != nullptr) ;
 
        filter->begin(elements.attributes(), hw_filtering);
        index_t e = 0;
        while(e < elements.nb()) {
            while(e<elements.nb() && !(hw_filtering||filter->test(e))) {
                ++e;
            }
            if(e<elements.nb()) {
                index_t begin = e;
                while(e<elements.nb() && (hw_filtering||filter->test(e))) {
                    ++e;
                }
                index_t end = e;
                glupBasePickingId(GLUPuint64(begin));
                draw(begin,end);
            }
        }
        filter->end();
        glupBasePickingId(0);
    }
 
    void draw_sequences_if(
        const MeshSubElementsStore& elements,
        std::function<bool(index_t)> predicate,
        std::function<void(index_t, index_t)> draw
    ) {
        // GLUP hardware primitive filtering.
        // Not supported in all profiles.
        // If supported, primitives are filtered by the GPU,
        // else, they are filtered here explicitly.
        const bool hw_filtering = hw_filtering_supported();
 
        Filter* filter = nullptr;
        if(&elements == &mesh_->vertices) {
            filter = &vertices_filter_;
        } else if(&elements == &mesh_->edges) {
            filter = &edges_filter_;
        } else if(&elements == &mesh_->facets) {
            filter = &facets_filter_;
        } else if(&elements == &mesh_->cells) {
            filter = &cells_filter_;
        }
        geo_assert(filter != nullptr) ;
        filter->begin(elements.attributes(), hw_filtering);
 
        index_t e = 0;
        while(e < elements.nb()) {
            while(
                e<elements.nb() && (
                    !(hw_filtering || filter->test(e)) || !predicate(e))
            ) {
                ++e;
            }
            if(e<elements.nb()) {
                index_t begin = e;
                while(
                    e<elements.nb() &&
                    (hw_filtering || filter->test(e)) &&
                    predicate(e)
                ) {
                    ++e;
                }
                index_t end = e;
                glupBasePickingId(GLUPuint64(begin));
                draw(begin,end);
            }
        }
        filter->end();
        glupBasePickingId(0);
    }
 
    };
 
}
 
#endif