BrushPlugin.h

Go to the documentation of this file.

/*

             *
            ***
           *****
   *********************       Mercenaries Engineering SARL
     *****************              Copyright (C) 2019
       *************
         *********        http://www.mercenaries-engineering.com
        ***********
       ****     ****
      **           **

*/
#pragma once

#include "Export.h"
#include "Mesh.h"
#include "Scene.h"
#include "ToolPlugin.h"

namespace maquina
{

// Base class of the brush user data
class BrushUserData
{
public:
  virtual ~BrushUserData() {}
};

/* Base class to create brush plug-ins.
   By deriving this class, create tools such as vertex color brushes or sculpt brushes.
   The class has an API to compute and inspect the geometries which could be hit by the brush.
*/
class MAQUINA_EXPORT BrushPlugin : public ToolPlugin
{
public:

  enum class BrushType
  {
    surface = 0, 
    geodesic,    
    volume,      
    fill         
  };

  BrushPlugin(Node* node);
  BrushPlugin operator=(const BrushPlugin& ) = delete;

  void activate() override;
  void deactivate() override;
  void on_mouse_press( const CameraContext& camera, const InteractionContext& interaction ) override;
  void on_mouse_move( const CameraContext& camera, const InteractionContext& interaction ) override;
  void on_mouse_release( const CameraContext& camera, const InteractionContext& interaction ) override;
  bool override_selection() override;
  bool track_mouse() override;
  bool manipulates() override;


  virtual void stroke_begin(int modifiers);


  virtual void stroke_update(
    bool first, 
    bool finished 
  );


  virtual void update_weights(
    bool first, 
    const Imath::M44f& previous_brush_matrix  
  );


  virtual bool do_update_weights() { return true; }


  virtual float weight(float /* distance */) { return 1.f; }


  virtual void update_brush_matrix(const CameraContext& camera, const InteractionContext& interaction, bool& visible, Imath::M44f& brush_matrix, bool on_press);


  virtual float radius();

  void set_radius(float radius);


  virtual float flow();


  virtual bool multi_objects();


  virtual float geodesic_dt();


  virtual SceneConst scene();


  virtual BrushType brush_type();

  /* The brush object creates and hold one GeometryData object per "paintable" geometry.
   * It also hold the current vertex weight and the accumulation buffer of the brush on the geometry.
   */
  class MAQUINA_EXPORT GeometryData
  {
  public:
    GeometryData(const std::string& path,
                 const Mesh& displayed_mesh, const Imath::M44d& displayed_matrix,
                 const Mesh& input_mesh, const Imath::M44d& input_matrix,
                 bool side);

    bool dirty;

    const std::string path;

    Mesh displayed_mesh;

    const Imath::M44d displayed_matrix;           
    const Imath::M44d displayed_inversed_matrix;  
    const Imath::M44d displayed_inversed_transposed_matrix; 

    BufferV3f displayed_normals;  

    const Mesh input_mesh;

    const Imath::M44d input_matrix;           
    const Imath::M44d input_inversed_matrix;  
    const Imath::M44d input_inversed_transposed_matrix; 

    struct Vertex
    {
      Vertex(int index, float weight, float vertex_selection) : index(index), weight(weight), vertex_selection(vertex_selection) {}
      int index;
      float weight;
      float vertex_selection;
    };


    std::vector<Vertex> weights;

    std::vector<float> accum_weights;

    std::shared_ptr<BrushUserData> user_data;

    bool side;
  };


  gsl::span<GeometryData> geometry_data();

  Imath::V3f hit_pos_world() const;

  const Imath::V3f& hit_normal_world() const;

  Imath::V3f hit_pos_world_orig() const;

  const Imath::V3f& hit_normal_world_orig() const;

  const Imath::M44f& brush_matrix() const;

  const Imath::M44f& brush_matrix_orig() const;

  bool is_brush_visible() const;

  bool is_pressed() const;

private:
  std::vector<GeometryData> _geometry_data;

  // Once the mouse is pressed, initialize all the geometries which MAY by painted
  void _init_geometries(const CameraContext& camera, const InteractionContext& interaction);

  void _update_displayed_geometry(const CameraContext& camera);

  bool _pressed;
  Imath::M44f _brush_matrix;
  Imath::M44f _brush_matrix_orig;
  Imath::V3f _hit_normal;
  Imath::V3f _hit_normal_orig;
  bool _brush_visible;

  const GeometryData* _first_geometry = nullptr;  // The first object hit by the stroke
  bool _first_geometry_front_face = false;        // Was the first hit front face ?
};

inline gsl::span<BrushPlugin::GeometryData> BrushPlugin::geometry_data()
{
  return _geometry_data;
}

inline Imath::V3f BrushPlugin::hit_pos_world() const
{
  return _brush_matrix.translation();
}

inline const Imath::V3f& BrushPlugin::hit_normal_world() const
{
  return _hit_normal;
}

inline Imath::V3f BrushPlugin::hit_pos_world_orig() const
{
  return _brush_matrix_orig.translation();
}

inline const Imath::V3f& BrushPlugin::hit_normal_world_orig() const
{
  return _hit_normal_orig;
}

inline const Imath::M44f& BrushPlugin::brush_matrix() const
{
  return _brush_matrix;
}

inline const Imath::M44f& BrushPlugin::brush_matrix_orig() const
{
  return _brush_matrix_orig;
}

inline bool BrushPlugin::is_brush_visible() const
{
  return _brush_visible;
}

inline bool BrushPlugin::is_pressed() const
{
  return _pressed;
}

}