mesh_grob_shader.h

Go to the documentation of this file.

/*
 *  OGF/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000-2009 INRIA - Project ALICE
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy - levy@loria.fr
 *
 *     Project ALICE
 *     LORIA, INRIA Lorraine,
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs.
 *
 * As an exception to the GPL, Graphite can be linked with
 *  the following (non-GPL) libraries:
 *     Qt, SuperLU, WildMagic and CGAL
 */
 
 
#ifndef H_OGF_MESH_GFX_SHADERS_MESH_GROB_SHADER_H
#define H_OGF_MESH_GFX_SHADERS_MESH_GROB_SHADER_H
 
#include <OGF/mesh_gfx/common/common.h>
#include <OGF/mesh/grob/mesh_grob.h>
#include <OGF/scene_graph_gfx/shaders/shader.h>
#include <OGF/scene_graph/types/properties.h>
 
#include <geogram_gfx/mesh/mesh_gfx.h>
 
 
namespace GEO {
    class Image;
}
 
 
namespace OGF {
 
    /**********************************************************/
 
    class Builder;
    class Texture;
 
    enum CullingMode {NO_CULL, CULL_FRONT, CULL_BACK};
 
    enum PaintingMode {SOLID_COLOR, ATTRIBUTE, COLOR, TEXTURE};
 
    gom_attribute(abstract, "true")
    gom_class MESH_GFX_API MeshGrobShader : public Shader {
    public:
        MeshGrobShader(MeshGrob* grob);
 
        ~MeshGrobShader() override;
 
        void draw() override;
 
        virtual void pick(MeshElementsFlags what);
 
        void pick_object(index_t object_id) override;
 
        void blink() override;
 
        virtual void show_vertices();
 
        virtual void hide_vertices();
 
        virtual void show_vertices_selection();
 
        virtual void hide_vertices_selection();
 
        virtual void show_mesh();
 
        virtual void hide_mesh();
 
        virtual void show_borders();
 
        virtual void hide_borders();
 
    gom_properties:
 
        bool get_has_edges() const {
            return
                mesh_grob() != nullptr &&
                mesh_grob()->edges.nb() != 0;
        }
 
        bool get_has_facets() const {
            return
                mesh_grob() != nullptr &&
                mesh_grob()->facets.nb() != 0;
        }
 
        bool get_has_cells() const {
            return
                mesh_grob() != nullptr &&
                mesh_grob()->cells.nb() != 0;
        }
 
        bool get_is_hybrid() const {
            return
                mesh_grob() != nullptr &&
                mesh_grob()->cells.nb() != 0 &&
                !mesh_grob()->cells.are_simplices();
        }
 
        bool get_has_time() const {
            return
                mesh_grob() != nullptr &&
                mesh_grob()->vertices.dimension() >= 6;
        }
 
        bool get_has_vertices_selection() const {
            return mesh_grob() != nullptr &&
                mesh_grob()->vertices.attributes().is_defined("selection");
        }
 
 
        bool get_has_weird_cells() const {
            return mesh_grob() != nullptr &&
                mesh_grob()->cells.attributes().is_defined("weird");
        }
 
        std::string get_scalar_attributes() const {
            std::string result;
            if(mesh_grob() != nullptr) {
                result = mesh_grob()->get_scalar_attributes();
            }
            return result;
        }
 
        std::string get_vector_attributes() const {
            std::string result;
            if(mesh_grob() != nullptr) {
                result = mesh_grob()->get_vector_attributes(3);
            }
            return result;
        }
 
    protected:
        MeshGrob* mesh_grob() const {
            return static_cast<MeshGrob*>(grob());
        }
    };
 
    /****************************************************************/
 
    gom_class MESH_GFX_API PlainMeshGrobShader : public MeshGrobShader {
    public:
        PlainMeshGrobShader(MeshGrob* grob);
 
         ~PlainMeshGrobShader() override;
 
        void draw() override;
 
        void pick(MeshElementsFlags what) override;
 
        void pick_object(index_t object_id) override;
 
        void blink() override;
 
        void show_vertices() override;
 
        void hide_vertices() override;
 
        void show_vertices_selection() override;
 
        void hide_vertices_selection() override;
 
         void show_mesh() override;
 
         void hide_mesh() override;
 
         void show_borders() override;
 
         void hide_borders() override;
 
    gom_properties:
 
        bool get_attributes() const {
            return (painting_mode_ == ATTRIBUTE);
        }
 
    gom_slots:
 
        gom_attribute(visible_if, "attributes")
        void autorange();
 
 
        void set_time_smooth(double x) {
            time_ = x;
            update();
        }
 
        double get_time_smooth() const {
            return time_;
        }
 
    gom_properties:
 
        void set_painting(PaintingMode value);
 
        PaintingMode get_painting() const {
            return painting_mode_;
        }
 
        gom_attribute(visible_if, "attributes")
        void set_attribute_min(double value) {
            attribute_min_ = value;
            update();
        }
 
        double get_attribute_min() const {
            return attribute_min_;
        }
 
        gom_attribute(visible_if, "attributes")
        void set_attribute_max(double value) {
            attribute_max_ = value;
            update();
        }
 
        double get_attribute_max() const {
            return attribute_max_;
        }
 
 
        gom_attribute(visible_if, "attributes")
        gom_attribute(handler, "combo_box")
        gom_attribute(values, "$scalar_attributes")
        void set_attribute(const std::string& value);
 
        const std::string& get_attribute() const {
            return attribute_;
        }
 
        gom_attribute(visible_if, "attributes")
        void set_colormap(const ColormapStyle& value) {
            colormap_style_ = value;
            colormap_texture_.reset();
            update();
        }
 
        const ColormapStyle& get_colormap() const {
            return colormap_style_;
        }
 
        bool get_texturing() const {
            return (painting_mode_ == TEXTURE);
        }
 
        bool get_coloring() const {
            return (painting_mode_ == COLOR);
        }
 
 
        gom_attribute(visible_if, "texturing")
        void set_tex_image(const ImageFileName& value) {
            texture_filename_ = value;
            texture_.reset();
            update();
        }
 
        const ImageFileName& get_tex_image() const {
            return texture_filename_;
        }
 
        gom_attribute(visible_if, "texturing")
        gom_attribute(handler, "combo_box")
        gom_attribute(values, "$vector_attributes")
        void set_tex_coords(const std::string& value);
 
        const std::string& get_tex_coords() const {
            return tex_coord_attribute_;
        }
 
 
        gom_attribute(visible_if, "coloring")
        gom_attribute(handler, "combo_box")
        gom_attribute(values, "$vector_attributes")
        void set_colors(const std::string& value) {
            // It is an alias of tex_coord, because we use
            // 3D texturing internally to display colors
            // (it is stupid, but makes code simpler for now.
            set_tex_coords(value);
        }
 
        const std::string& get_colors() const {
            // It is an alias of tex_coord, because we use
            // 3D texturing internally to display colors
            // (it is stupid, but makes code simpler for now.
            return get_tex_coords();
        }
 
        gom_attribute(visible_if, "texturing")
        void set_tex_repeat(index_t value) {
            tex_coord_repeat_ = value;
            update();
        }
 
        index_t get_tex_repeat() const {
            return tex_coord_repeat_;
        }
 
 
 
        gom_attribute(visible_if, "texturing")
        void set_normal_map(bool value) {
            tex_normal_mapping_ = value;
            update();
        }
 
        bool get_normal_map() const {
            return tex_normal_mapping_;
        }
 
        void set_lighting(bool value) {
            gfx_.set_lighting(value);
            update();
        }
 
        bool get_lighting() const {
            return gfx_.get_lighting();
        }
 
 
        void set_clipping(bool value) {
            clipping_ = value;
            update();
        }
 
        bool get_clipping() const {
            return clipping_;
        }
 
 
        gom_attribute(visible_if, "has_facets")
        void set_surface_style(const SurfaceStyle& value) {
            surface_style_ = value;
            update();
        }
 
        const SurfaceStyle& get_surface_style() const {
            return surface_style_;
        }
 
        gom_attribute(visible_if, "has_facets")
        void set_facets_filter(bool value) {
            facets_filter_ = value;
            gfx_.set_filter(
                MESH_FACETS, value ? "filter" : ""
            );
            update();
        }
 
        bool get_facets_filter() const {
            return facets_filter_;
        }
 
        gom_attribute(visible_if, "has_facets")
        void set_culling_mode(const CullingMode value) {
            culling_mode_ = value;
            update();
        }
 
        CullingMode get_culling_mode() const {
            return culling_mode_;
        }
 
        gom_attribute(visible_if, "has_facets or has_cells")
        void set_specular(index_t x) {
            specular_ = x;
            update();
        }
 
        index_t get_specular() const {
            return specular_;
        }
 
        gom_attribute(visible_if, "has_facets")
        void set_two_sided(bool value) {
            two_sided_ = value;
            update();
        }
 
        bool get_two_sided() const {
            return two_sided_;
        }
 
        gom_attribute(visible_if, "has_cells")
        void set_volume_style(const SurfaceStyle& value) {
            volume_style_ = value;
            update();
        }
 
        const SurfaceStyle& get_volume_style() const {
            return volume_style_;
        }
 
 
        gom_attribute(visible_if, "has_cells")
        void set_cells_filter(bool value) {
            gfx_.set_filter(
                MESH_CELLS, value ? "filter" : ""
            );
            cells_filter_ = value;
            update();
        }
 
        bool get_cells_filter() const {
            return cells_filter_;
        }
 
 
        gom_attribute(visible_if, "is_hybrid")
        void set_colored_cells(bool value) {
            colored_cells_ = value;
            update();
        }
 
        bool get_colored_cells() const {
            return colored_cells_;
        }
 
 
        gom_attribute(visible_if, "is_hybrid")
        void set_tets(bool value) {
            tets_ = value;
            update();
        }
 
        bool get_tets() const {
            return tets_;
        }
 
        gom_attribute(visible_if, "is_hybrid")
        void set_hexes(bool value) {
            hexes_ = value;
            update();
        }
 
        bool get_hexes() const {
            return hexes_;
        }
 
 
        gom_attribute(visible_if, "is_hybrid")
        void set_prisms(bool value) {
            prisms_ = value;
            update();
        }
 
        bool get_prisms() const {
            return prisms_;
        }
 
 
        gom_attribute(visible_if, "is_hybrid")
        void set_pyramids(bool value) {
            pyramids_ = value;
            update();
        }
 
        bool get_pyramids() const {
            return pyramids_;
        }
 
 
        gom_attribute(visible_if, "is_hybrid")
        void set_connectors(bool value) {
            connectors_ = value;
            update();
        }
 
        bool get_connectors() const {
            return connectors_;
        }
 
        gom_attribute(visible_if, "has_edges")
        void set_edges_style(const EdgeStyle& value) {
            edges_style_ = value;
            update();
        }
 
        const EdgeStyle& get_edges_style() const {
            return edges_style_;
        }
 
 
        gom_attribute(visible_if, "has_facets or has_cells")
        void set_mesh_style(const EdgeStyle& value) {
            mesh_style_ = value;
            update();
        }
 
        const EdgeStyle& get_mesh_style() const {
            return mesh_style_;
        }
 
 
        gom_attribute(visible_if, "has_facets")
        void set_border_style(const EdgeStyle& value) {
            border_style_ = value;
            update();
        }
 
        const EdgeStyle& get_border_style() const {
            return border_style_;
        }
 
        void set_vertices_style(const PointStyle& value) {
            vertices_style_ = value;
            update();
        }
 
        const PointStyle& get_vertices_style() const {
            return vertices_style_;
        }
 
 
        void set_vertices_filter(bool value) {
            gfx_.set_filter(
                MESH_VERTICES, value ? "filter" : ""
            );
            vertices_filter_ = value;
            update();
        }
 
        bool get_vertices_filter() const {
            return vertices_filter_;
        }
 
        void set_vertices_transparency(double value) {
            vertices_transparency_ = value;
            update();
        }
 
        double get_vertices_transparency() const {
            return vertices_transparency_;
        }
 
        gom_attribute(visible_if, "has_vertices_selection")
        void set_vert_select_style(const PointStyle& value) {
            vertices_selection_style_ = value;
            update();
        }
 
        const PointStyle& get_vert_select_style() const {
            return vertices_selection_style_;
        }
 
        gom_attribute(visible_if, "has_cells")
        void set_shrink(index_t value) {
            gfx_.set_shrink(double(value)/10.0);
            update();
        }
 
        index_t get_shrink() const {
            return index_t(gfx_.get_shrink()*10.0);
        }
 
 
        gom_attribute(visible_if, "has_time")
        void set_animate(bool value) {
            animate_ = value;
            update();
        }
 
        bool get_animate() const {
            return animate_;
        }
 
        gom_attribute(visible_if, "has_time and animate")
        gom_attribute(handler, "slider_int")
        gom_attribute(min, "0")
        gom_attribute(max, "20")
        void set_time(index_t value) {
            time_ = double(value) / 20.0;
            update();
        }
 
        index_t get_time() const {
            return index_t(time_ * 20.0);
        }
 
 
        gom_attribute(visible_if, "has_cells")
        void set_slivers(double value) {
            slivers_ = value;
            update();
        }
 
        double get_slivers() const {
            return slivers_;
        }
 
        gom_attribute(visible_if, "has_weird_cells")
        void set_weird_cells(bool x) {
            weird_cells_ = x;
            update();
        }
 
        bool get_weird_cells() const {
            return weird_cells_;
        }
 
        bool get_glsl_source_visible() const {
            return false;
        }
 
        gom_attribute(visible_if, "glsl_source_visible")
        void set_glsl_source(const std::string& value) {
            glsl_source_ = value;
            update_glsl_program();
        }
 
        const std::string& get_glsl_source() const {
            return glsl_source_;
        }
 
    protected:
        void draw_slivers();
        void draw_weird_cells();
        void draw_surface_with_glsl_shader();
        void update_glsl_program();
 
    protected:
        GEO::MeshGfx gfx_;
 
        PaintingMode      painting_mode_;
 
        std::string       attribute_;
        MeshElementsFlags attribute_subelements_;
        std::string       attribute_name_;
        double            attribute_min_;
        double            attribute_max_;
        ColormapStyle     colormap_style_;
        Texture_var       colormap_texture_;
 
        MeshElementsFlags tex_coord_subelements_;
        std::string       tex_coord_attribute_;
        std::string       tex_coord_name_;
        index_t           tex_coord_repeat_;
        bool              tex_normal_mapping_;
        Texture_var       texture_;
        ImageFileName     texture_filename_;
 
        SurfaceStyle surface_style_;
        bool         facets_filter_;
        CullingMode  culling_mode_;
 
        index_t      specular_;
        bool         two_sided_;
        SurfaceStyle volume_style_;
        bool         cells_filter_;
        bool         colored_cells_;
        bool         tets_;
        bool         hexes_;
        bool         prisms_;
        bool         pyramids_;
        bool         connectors_;
        index_t      shrink_;
        EdgeStyle    edges_style_;
        EdgeStyle    mesh_style_;
        EdgeStyle    border_style_;
        PointStyle   vertices_style_;
        bool         vertices_filter_;
        double       vertices_transparency_;
        PointStyle   vertices_selection_style_;
        bool         animate_;
        double       time_;
        bool         picking_;
        double       slivers_;
        bool         weird_cells_;
        bool         clipping_;
 
        bool         glsl_program_changed_;
        double       glsl_start_time_;
        index_t      glsl_frame_;
        std::string  glsl_source_;
        GLuint       glsl_program_;
    };
 
    /**********************************************************/
 
    gom_class MESH_GFX_API ExplodedViewMeshGrobShader :
        public PlainMeshGrobShader {
    public:
         ExplodedViewMeshGrobShader(MeshGrob* grob);
 
         ~ExplodedViewMeshGrobShader() override;
 
    gom_properties:
 
         gom_attribute(handler, "combo_box")
         gom_attribute(values, "$scalar_attributes")
         void set_region(const std::string& value) {
             region_ = value;
             dirty_ = true;
             update();
         }
 
         const std::string& get_region() const {
             return region_;
         }
 
         void set_amount(index_t value) {
             amount_ = value;
             update();
         }
 
         index_t get_amount() const {
             return amount_;
         }
 
    public:
         void draw() override;
 
    protected:
         bool dirty_;
         std::string region_;
         index_t amount_;
         int rgn_min_;
         int rgn_max_;
         vec3 bary_;
         vector<vec3> region_bary_;
    };
 
    /**********************************************************/
 
}
 
#endif