mesh_grob_paint_tools.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_TOOLS_MESH_GROB_PAINT_TOOLS_H
#define H_OGF_MESH_GFX_TOOLS_MESH_GROB_PAINT_TOOLS_H
 
#include <OGF/mesh_gfx/common/common.h>
#include <OGF/mesh_gfx/tools/mesh_grob_tool.h>
 
namespace OGF {
 
    enum PaintOp {
        PAINT_SET,   
        PAINT_RESET, 
        PAINT_INC,   
        PAINT_DEC    
    };
 
    gom_class MESH_GFX_API MeshGrobPaintTool : public MeshGrobTool {
    public:
        MeshGrobPaintTool(ToolsManager* parent);
 
        void reset() override;
 
    gom_properties:
         void set_value(double value);
 
         double get_value() const {
            return value_;
         }
 
         void set_value2(double value);
 
         double get_value2() const {
            return value2_;
         }
 
         void set_accumulate(bool value);
 
         bool get_accumulate() const {
            return accumulate_;
         }
 
         void set_autorange(bool value);
 
         bool get_autorange() const {
             return autorange_;
         }
 
         void set_pick_vertices_only(bool value);
 
         bool get_pick_vertices_only() const {
             return pick_vertices_only_;
         }
 
        void set_xray_mode(bool value);
 
        bool get_xray_mode() const {
            return xray_mode_;
        }
 
    public:
        void grab(const RayPick& p_ndc) override;
 
        void drag(const RayPick& p_ndc) override;
 
        void release(const RayPick& p_ndc) override;
 
    public:
         void set_value_for_this_tool(double value) {
             value_ = value;
         }
 
         void set_value2_for_this_tool(double value) {
             value2_ = value;
         }
 
         void set_accumulate_for_this_tool(bool value) {
            accumulate_ = value;
         }
 
         void set_autorange_for_this_tool(bool value) {
             autorange_ = value;
         }
 
         void set_pick_vertices_for_this_tool(bool value) {
             pick_vertices_only_ = value;
         }
 
         void set_xray_mode_for_this_tool(bool value) {
             xray_mode_ = value;
         }
 
         static void get_paint_tools(
             ToolsManager* manager, vector<MeshGrobPaintTool*>& paint_tools
         );
 
    protected:
 
         bool get_painting_parameters(
             const RayPick& raypick,
             PaintOp& op,
             MeshElementsFlags& where,
             std::string& attribute_name,
             index_t& component
         );
 
         void paint(const RayPick& p_ndc);
 
    protected:
         double value_;
         double value2_;
         bool accumulate_;
         bool autorange_;
         bool pick_vertices_only_;
         bool xray_mode_;
         index_t picked_element_;
         Tool_var probe_tool_; // For middle button
         MeshGrob* prev_mesh_grob_; // See reset()
    };
 
    /**********************************************************/
 
 
    gom_attribute(category, "paint")
    gom_attribute(icon, "paint_rect")
    gom_attribute(help, "paint attributes in rectangle")
    gom_attribute(message, "btn1: paint; btn2: probe; btn3: erase")
 
    gom_class MESH_GFX_API MeshGrobPaintRect : public MeshGrobPaintTool {
    public:
        MeshGrobPaintRect(ToolsManager* parent);
 
        void grab(const RayPick& p_ndc) override;
 
        void drag(const RayPick& p_ndc) override;
 
        void release(const RayPick& p_ndc) override;
 
    gom_properties:
 
    protected:
 
        void paint_rect(
            const RayPick& raypick,
            index_t x0, index_t y0, index_t x1, index_t y1,
            Image* mask = nullptr
        );
        vec2 p_;
    };
 
    /************************************************************************/
 
    gom_attribute(category, "paint")
    gom_attribute(icon, "paint")
    gom_attribute(help, "paint attributes")
    gom_attribute(message, "btn1: paint; btn2: probe; btn3: erase")
 
    gom_class MESH_GFX_API MeshGrobPaint : public MeshGrobPaintRect {
    public:
        MeshGrobPaint(ToolsManager* parent);
 
        void grab(const RayPick& p_ndc) override;
 
        void drag(const RayPick& p_ndc) override;
 
        void release(const RayPick& p_ndc) override;
 
    gom_properties:
 
        void set_width(index_t value) {
            width_ = value;
        }
 
        index_t get_width() const {
            return width_;
        }
 
        void set_stroke_mode(bool value) {
            stroke_mode_ = value;
        }
 
        bool get_stroke_mode() const {
            return stroke_mode_;
        }
 
    protected:
        void for_each_stroke_quad(
            std::function<void(vec2, vec2, vec2, vec2)> doit
        );
 
    protected:
        index_t width_;
        vec2 latest_ndc_;
        bool stroke_mode_;
        vector<vec2> stroke_;
    };
 
    /*************************************************************/
 
    gom_attribute(category, "paint")
    gom_attribute(icon, "paint_freeform")
    gom_attribute(help, "paint attributes with free-form selection")
    gom_attribute(message, "btn1: paint; btn2: probe; btn3: erase")
 
    gom_class MESH_GFX_API MeshGrobPaintFreeform : public MeshGrobPaintRect {
    public:
        MeshGrobPaintFreeform(ToolsManager* parent);
 
        void grab(const RayPick& p_ndc) override;
 
        void drag(const RayPick& p_ndc) override;
 
        void release(const RayPick& p_ndc) override;
 
    private:
        vec2 latest_ndc_;
        vector<vec2> selection_;
    };
 
    /*****************************************************************/
 
    gom_attribute(category, "paint")
    gom_attribute(icon, "paint_connected")
    gom_attribute(help, "paint attributes on connected components")
    gom_attribute(message, "btn1: paint; btn2: probe; btn3: erase")
 
    gom_class MESH_GFX_API MeshGrobPaintConnected : public MeshGrobPaintTool {
    public:
        MeshGrobPaintConnected(ToolsManager* parent);
 
        void grab(const RayPick& p_ndc) override;
 
    gom_properties:
 
        void set_fill_same_value(bool x) {
            fill_same_value_ = x;
        }
 
        bool get_fill_same_value() const {
            return fill_same_value_;
        }
 
        void set_tolerance(double value) {
            tolerance_ = value;
        }
 
        double get_tolerance() const {
            return tolerance_;
        }
 
 
    protected:
        bool test(double reference, double value) const {
            return !fill_same_value_ ||
                ::fabs(reference - value) <= tolerance_;
        }
 
    private:
        bool fill_same_value_;
        double tolerance_;
    };
 
    /**********************************************************************/
 
    gom_attribute(category, "paint")
    gom_attribute(icon, "pipette")
    gom_attribute(help, "probe attributes")
    gom_attribute(message, "btn1: probe attributes")
 
    gom_class MESH_GFX_API MeshGrobProbe : public MeshGrobTool {
    public:
        MeshGrobProbe(ToolsManager* parent);
 
        void grab(const RayPick& p_ndc) override;
 
        void drag(const RayPick& p_ndc) override;
 
        void release(const RayPick& p_ndc) override;
 
        void set_probed_as_paint(bool x) {
            set_probed_as_paint_ = x;
        }
 
 
        void set_display_probed_on_release(bool x) {
            display_probed_on_release_ = x;
        }
 
     protected:
        void probe(const RayPick& p_ndc);
 
    private:
        bool picked_;
        bool grabbed_;
        double value_;
        vec2 latest_ndc_;
        std::string message_;
        bool set_probed_as_paint_;
        bool display_probed_on_release_;
    };
 
    /********************************************************/
 
    gom_attribute(category, "paint")
    gom_attribute(icon, "ruler")
    gom_attribute(help, "measures distances on a mesh")
 
    gom_class MESH_GFX_API MeshGrobRuler : public MeshGrobTool {
    public:
        MeshGrobRuler(ToolsManager* parent);
 
        void grab(const RayPick& p_ndc) override;
 
        void drag(const RayPick& p_ndc) override;
 
        void release(const RayPick& p_ndc) override;
 
     protected:
        bool pick(const RayPick& p_ndc, vec3& p);
        void show_distance(const RayPick& p_ndc);
 
    private:
        bool p_picked_;
        vec3 p_;
        vec2 latest_ndc_;
    };
 
    /*******************************************************/
 
}
 
#endif