#include <src/libigl/igl/opengl2/MouseController.h>

Collaboration diagram for igl::opengl2::MouseController:

Public Types
enum	WidgetMode { WIDGET_MODE_ROTATE = 0 , WIDGET_MODE_TRANSLATE = 1 , NUM_WIDGET_MODES = 2 }

typedef Eigen::VectorXi	VectorXb

Public Member Functions
	MouseController ()

const VectorXb &	selection () const

const bool &	is_selecting () const

bool	is_widget_down () const

bool	is_trans_widget_down () const

const RotationList &	rotations () const

const TranslationList &	translations () const

bool &	root_enabled ()

void	reshape (const int w, const int h)

bool	down (const int x, const int y)

bool	drag (const int x, const int y)

bool	up (const int x, const int y)

void	draw () const

void	set_selection_from_last_drag (const Eigen::MatrixXd &C, const Eigen::MatrixXi &BE, const Eigen::VectorXi &P, const Eigen::VectorXi &RP)

void	set_selection (const Eigen::VectorXi &S, const Eigen::MatrixXd &C, const Eigen::MatrixXi &BE, const Eigen::VectorXi &P, const Eigen::VectorXi &RP)

void	set_size (const int n)

void	reset ()

void	reset_selected ()

void	reset_rotations ()

void	reset_selected_rotations ()

void	reset_translations ()

void	reset_selected_translations ()

bool	set_rotations (const RotationList &vQ)

bool	set_translations (const TranslationList &vT)

void	clear_selection ()

bool	any_selection () const

void	set_widget_mode (const WidgetMode &mode)

Static Public Member Functions
static void	propogate_to_descendants_if (const VectorXb &S, const Eigen::VectorXi &P, VectorXb &T)

static void	color_if (const VectorXb &S, const Eigen::Vector4f &selected_color, const Eigen::Vector4f &unselected_color, Eigen::MatrixXf &C)

Private Types
typedef std::vector< Eigen::Quaterniond, Eigen::aligned_allocator< Eigen::Quaterniond > >	RotationList

typedef std::vector< Eigen::Vector3d >	TranslationList

Detailed Description

Member Typedef Documentation

◆ RotationList

typedef std::vector< Eigen::Quaterniond, Eigen::aligned_allocator<Eigen::Quaterniond> > igl::opengl2::MouseController::RotationList

private

◆ TranslationList

typedef std::vector< Eigen::Vector3d > igl::opengl2::MouseController::TranslationList

private

◆ VectorXb

typedef Eigen::VectorXi igl::opengl2::MouseController::VectorXb

Member Enumeration Documentation

◆ WidgetMode

enum igl::opengl2::MouseController::WidgetMode

Enumerator
WIDGET_MODE_ROTATE
WIDGET_MODE_TRANSLATE
NUM_WIDGET_MODES

        {
          WIDGET_MODE_ROTATE = 0,
          WIDGET_MODE_TRANSLATE = 1,
          NUM_WIDGET_MODES = 2,
        };

Constructor & Destructor Documentation

◆ MouseController()

igl::opengl2::MouseController::MouseController ( )

inline

                                                 :
  m_is_selecting(false),
  m_selection(),
  m_down_x(-1),m_down_y(-1),m_drag_x(-1),m_drag_y(-1),
  m_width(-1),m_height(-1),
  m_widget(),
  m_widget_rot_at_selection(),
  //m_trans_widget_trans_at_selection(),
  m_trans_widget(),
  m_rotations(),
  m_translations(),
  m_rotations_at_selection(),
  m_root_enabled(true),
  m_widget_mode(WIDGET_MODE_ROTATE)
{
}

Member Function Documentation

◆ any_selection()

bool igl::opengl2::MouseController::any_selection ( ) const

inline

{
  return m_selection.array().any();
}

◆ clear_selection()

void igl::opengl2::MouseController::clear_selection ( )

inline

{
  m_selection.setConstant(false);
}

◆ color_if()

void igl::opengl2::MouseController::color_if	(	const VectorXb &	S,
		const Eigen::Vector4f &	selected_color,
		const Eigen::Vector4f &	unselected_color,
		Eigen::MatrixXf &	C
	)

inlinestatic

{
  C.resize(S.rows(),4);
  for(int e=0;e<S.rows();e++)
  {
    C.row(e) = S(e)?selected_color:unselected_color;
  }
}

◆ down()

bool igl::opengl2::MouseController::down	(	const int	x,
		const int	y
	)

inline

{
  using namespace std;
  m_down_x = m_drag_x =x;
  m_down_y = m_drag_y =y;
  const bool widget_down = any_selection() && 
    (
     (m_widget_mode == WIDGET_MODE_ROTATE && m_widget.down(x,m_height-y)) ||
     (m_widget_mode == WIDGET_MODE_TRANSLATE && 
        m_trans_widget.down(x,m_height-y))
    );
  if(!widget_down)
  {
    m_is_selecting = true;
  }
  return m_is_selecting || widget_down;
}

◆ drag()

bool igl::opengl2::MouseController::drag	(	const int	x,
		const int	y
	)

inline

{
  using namespace std;
  using namespace Eigen;
  m_drag_x = x;
  m_drag_y = y;
  if(m_is_selecting)
  {
    return m_is_selecting;
  }else
  {
    switch(m_widget_mode)
    {
      default: // fall through
      case WIDGET_MODE_ROTATE:
      {
        if(!m_widget.drag(x,m_height-y))
        {
          return false;
        }
        assert(any_selection());
        assert(m_selection.size() == (int)m_rotations.size());
        assert(m_selection.size() == (int)m_translations.size());
        for(int e = 0;e<m_selection.size();e++)
        {
          if(m_selection(e))
          {
            // Let:
            //     w.θr = w.θ ⋅ w.θ₀*  
            // w.θr takes (absolute) frame of w.θ₀ to w.θ:
            //     w.θ = w.θr ⋅ w.θ₀ 
            // Define:
            //     w.θ₀ = θfk ⋅ θx,
            // the absolute rotation of the x axis to the deformed bone at
            // selection. Likewise,
            //     w.θ = θfk' ⋅ θx,
            // the current absolute rotation of the x axis to the deformed bone.
            // Define recursively:
            //     θfk = θfk(p) ⋅ Θr,
            // then because we're only changeing this relative rotation
            //     θfk' = θfk(p) ⋅ Θr ⋅ θr* ⋅ θr'
            //     θfk' = θfk ⋅ θr* ⋅ θr'
            //     w.θ ⋅ θx* = θfk ⋅ θr* ⋅ θr'
            //     θr ⋅ θfk* ⋅ w.θ ⋅ θx* = θr'
            //     θr ⋅ θfk* ⋅ w.θr ⋅ w.θ₀ ⋅ θx* = θr'
            //     θr ⋅ θfk* ⋅ w.θr ⋅ θfk ⋅θx ⋅ θx* = θr'
            //     θr ⋅ θfk* ⋅ w.θr ⋅ θfk = θr'
            // which I guess is the right multiply change after being changed to
            // the bases of θfk, the rotation of the bone relative to its rest
            // frame.
            //
            const Quaterniond & frame = m_fk_rotations_at_selection[e];
            m_rotations[e] = 
              m_rotations_at_selection[e] *
              frame.conjugate() * 
              (m_widget.rot*m_widget_rot_at_selection.conjugate()) *
              frame;
          }
        }
      }
      case WIDGET_MODE_TRANSLATE:
      {
        if(!m_trans_widget.drag(x,m_height-y))
        {
          return false;
        }
        assert(any_selection());
        assert(m_selection.size() == (int)m_rotations.size());
        assert(m_selection.size() == (int)m_translations.size());
        for(int e = 0;e<m_selection.size();e++)
        {
          if(m_selection(e))
          {
            m_translations[e] = 
              m_translations_at_selection[e] + 
              m_parent_rotations_at_selection[e].conjugate()*
                m_trans_widget.m_trans;
          }
        }
      }
    }
    return true;
  }
}

References Eigen::QuaternionBase< Derived >::conjugate().

Here is the call graph for this function:

◆ draw()

void igl::opengl2::MouseController::draw ( ) const

inline

{
  if(any_selection())
  {
    switch(m_widget_mode)
    {
      default:
      case WIDGET_MODE_ROTATE:
        m_widget.draw();
        break;
      case WIDGET_MODE_TRANSLATE:
        m_trans_widget.draw();
        break;
    }
  }
  if(m_is_selecting)
  {
    // Remember settings
    GLboolean dt;
    glGetBooleanv(GL_DEPTH_TEST,&dt);
    int old_vp[4];
    glGetIntegerv(GL_VIEWPORT,old_vp);
 
    // True screen space
    glViewport(0,0,m_width,m_height);
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    gluOrtho2D(0,m_width,0,m_height);
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
 
    glDisable(GL_DEPTH_TEST);
    draw_rectangular_marquee(
      m_down_x,
      m_height-m_down_y,
      m_drag_x,
      m_height-m_drag_y);
 
    // Restore settings
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    glViewport(old_vp[0],old_vp[1],old_vp[2],old_vp[3]);
    dt?glEnable(GL_DEPTH_TEST):glDisable(GL_DEPTH_TEST);
 
  }
}

References igl::opengl2::draw_rectangular_marquee().

Here is the call graph for this function:

◆ is_selecting()

const bool & igl::opengl2::MouseController::is_selecting ( ) const

inline

103{return m_is_selecting;}

References m_is_selecting.

◆ is_trans_widget_down()

bool igl::opengl2::MouseController::is_trans_widget_down ( ) const

inline

105{return m_trans_widget.is_down();}

igl::opengl2::TranslateWidget::is_down

bool is_down() const

Definition TranslateWidget.h:128

References igl::opengl2::TranslateWidget::is_down(), and m_trans_widget.

Here is the call graph for this function:

◆ is_widget_down()

bool igl::opengl2::MouseController::is_widget_down ( ) const

inline

104{return m_widget.is_down();}

igl::opengl2::RotateWidget::is_down

bool is_down() const

Definition RotateWidget.h:367

References igl::opengl2::RotateWidget::is_down(), and m_widget.

Here is the call graph for this function:

◆ propogate_to_descendants_if()

void igl::opengl2::MouseController::propogate_to_descendants_if	(	const VectorXb &	S,
		const Eigen::VectorXi &	P,
		VectorXb &	T
	)

inlinestatic

{
  using namespace std;
  const int n = S.rows();
  assert(P.rows() == n);
  // dynamic programming
  T = S;
  vector<bool> seen(n,false);
  // Recursively look up chain and see if ancestor is selected
  const function<bool(int)> look_up = [&](int e) -> bool
  {
    if(e==-1)
    {
      return false;
    }
    if(!seen[e])
    {
      seen[e] = true;
      T(e) |= look_up(P(e));
    }
    return T(e);
  };
  for(int e = 0;e<n;e++)
  {
    if(!seen[e])
    {
      T(e) = look_up(e);
    }
  }
}

◆ reset()

void igl::opengl2::MouseController::reset ( )

inline

{
  reset_rotations();
  reset_translations();
}

◆ reset_rotations()

void igl::opengl2::MouseController::reset_rotations ( )

inline

{
  using namespace Eigen;
  using namespace std;
  fill(m_rotations.begin(),m_rotations.end(),Quaterniond::Identity());
  // cop out. just clear selection
  clear_selection();
}

◆ reset_selected()

void igl::opengl2::MouseController::reset_selected ( )

inline

{
  reset_selected_rotations();
  reset_selected_translations();
}

◆ reset_selected_rotations()

void igl::opengl2::MouseController::reset_selected_rotations ( )

inline

{
  using namespace Eigen;
  for(int e = 0;e<m_selection.size();e++)
  {
    if(m_selection(e))
    {
      m_rotations[e] = Quaterniond::Identity();
    }
  }
}

◆ reset_selected_translations()

void igl::opengl2::MouseController::reset_selected_translations ( )

inline

{
  using namespace Eigen;
  for(int e = 0;e<m_selection.size();e++)
  {
    if(m_selection(e))
    {
      m_translations[e] = Vector3d(0,0,0);
    }
  }
}

◆ reset_translations()

void igl::opengl2::MouseController::reset_translations ( )

inline

{
  using namespace Eigen;
  using namespace std;
  fill(m_translations.begin(),m_translations.end(),Vector3d(0,0,0));
  // cop out. just clear selection
  clear_selection();
}

◆ reshape()

void igl::opengl2::MouseController::reshape	(	const int	w,
		const int	h
	)

inline

{
  m_width = w;
  m_height = h;
}

◆ root_enabled()

bool & igl::opengl2::MouseController::root_enabled ( )

inline

110{ return m_root_enabled;}

References m_root_enabled.

◆ rotations()

const RotationList & igl::opengl2::MouseController::rotations ( ) const

inline

107{return m_rotations;}

References m_rotations.

◆ selection()

const VectorXb & igl::opengl2::MouseController::selection ( ) const

inline

101{return m_selection;};

References m_selection.

◆ set_rotations()

bool igl::opengl2::MouseController::set_rotations ( const RotationList & vQ )

inline

{
  if(vQ.size() != m_rotations.size())
  {
    return false;
  }
  assert(!any_selection());
  m_rotations = vQ;
  return true;
}

◆ set_selection()

void igl::opengl2::MouseController::set_selection	(	const Eigen::VectorXi &	S,
		const Eigen::MatrixXd &	C,
		const Eigen::MatrixXi &	BE,
		const Eigen::VectorXi &	P,
		const Eigen::VectorXi &	RP
	)

inline

{
  using namespace Eigen;
  using namespace std;
  vector<Quaterniond,aligned_allocator<Quaterniond> > & vQ = 
    m_fk_rotations_at_selection;
  vector<Vector3d> & vT = m_fk_translations_at_selection;
  forward_kinematics(C,BE,P,m_rotations,m_translations,vQ,vT);
  m_parent_rotations_at_selection.resize(
    m_rotations.size(),Quaterniond::Identity());
  for(size_t r = 0;r<vQ.size();r++)
  {
    if(P(r)>=0)
    {
      m_parent_rotations_at_selection[r] = vQ[P(r)];
    }
  }
 
 
  if(&m_selection != &S)
  {
    m_selection = S;
  }
  assert(m_selection.rows() == BE.rows());
  assert(BE.rows() == P.rows());
  assert(BE.rows() == RP.rows());
  // Zero-out S up a path of ones from e
  auto propagate = [&](const int e, const VectorXb & S, VectorXb & N)
  {
    if(S(e))
    {
      int f = e;
      while(true)
      {
        int p = P(f);
        if(p==-1||!S(p))
        {
          break;
        }
        N(f) = false;
        f = p;
      }
    }
  };
  VectorXb prev_selection = m_selection;
  // Combine upward, group rigid parts, repeat
  while(true)
  {
    // Spread selection across rigid pieces
    VectorXb SRP(VectorXb::Zero(RP.maxCoeff()+1));
    for(int e = 0;e<BE.rows();e++)
    {
      SRP(RP(e)) |= m_selection(e);
    }
    for(int e = 0;e<BE.rows();e++)
    {
      m_selection(e) = SRP(RP(e));
    }
    // Clear selections below m_selection ancestors
    VectorXb new_selection = m_selection;
    for(int e = 0;e<P.rows();e++)
    {
      propagate(e,m_selection,new_selection);
    }
    m_selection = new_selection;
    if(m_selection==prev_selection)
    {
      break;
    }
    prev_selection = m_selection;
  }
 
  // Now selection should contain just bone roots of m_selection subtrees
  if(m_selection.array().any())
  {
    // Taking average 
    Vector3d avg_pos(0,0,0);
    //m_trans_widget_trans_at_selection.setConstant(0);
    m_widget_rot_at_selection.coeffs().setConstant(0);
    m_widget.rot.coeffs().array().setConstant(0);
    Quaterniond cur_rot(0,0,0,0);
    int num_selection = 0;
    // Compute average widget for selection
    for(int e = 0;e<BE.rows();e++)
    {
      if(m_selection(e))
      {
        Vector3d s = C.row(BE(e,0));
        Vector3d d = C.row(BE(e,1));
        auto b = (d-s).transpose().eval();
        {
          Affine3d a = Affine3d::Identity();
          a.translate(vT[e]);
          a.rotate(vQ[e]);
          avg_pos += a*s;
        }
        // Rotation of x axis to this bone
        Quaterniond rot_at_bind;
        rot_at_bind.setFromTwoVectors(Vector3d(1,0,0),b);
        const Quaterniond abs_rot = vQ[e] * rot_at_bind;
        m_widget_rot_at_selection.coeffs() += abs_rot.coeffs();
        //m_trans_widget_trans_at_selection += vT[e];
        num_selection++;
      }
    }
    // Take average
    avg_pos.array() /= (double)num_selection;
    //m_trans_widget_trans_at_selection.array() /= (double)num_selection;
    m_widget_rot_at_selection.coeffs().array() /= (double)num_selection;
    m_widget_rot_at_selection.normalize();
    m_widget.rot = m_widget_rot_at_selection;
    m_widget.pos      = avg_pos;
    m_trans_widget.m_pos = avg_pos;
    //m_trans_widget.m_trans = m_trans_widget_trans_at_selection;
    m_trans_widget.m_trans.setConstant(0);
  }
  m_widget.m_is_enabled = true;
  m_trans_widget.m_is_enabled = true;
  for(int s = 0;s<m_selection.rows();s++)
  {
    // a root is selected then disable.
    if(!m_root_enabled && m_selection(s) && P(s) == -1)
    {
      m_widget.m_is_enabled = false;
      m_trans_widget.m_is_enabled = false;
      break;
    }
  }
}

References Eigen::Quaternion< _Scalar, _Options >::coeffs(), igl::forward_kinematics(), and Eigen::QuaternionBase< Derived >::setFromTwoVectors().

Here is the call graph for this function:

◆ set_selection_from_last_drag()

void igl::opengl2::MouseController::set_selection_from_last_drag	(	const Eigen::MatrixXd &	C,
		const Eigen::MatrixXi &	BE,
		const Eigen::VectorXi &	P,
		const Eigen::VectorXi &	RP
	)

inline

{
  using namespace Eigen;
  using namespace std;
  m_rotations_at_selection = m_rotations;
  m_translations_at_selection = m_translations;
  assert(BE.rows() == P.rows());
  m_selection = VectorXb::Zero(BE.rows());
  // m_rotation[e]  is the relative rotation stored at bone e (as seen by the
  //   joint traveling with its parent)
  // vQ[e]  is the absolute rotation of a bone at rest to its current position:
  //   vQ[e] = vQ[p(e)] * m_rotation[e]
  vector<Quaterniond,aligned_allocator<Quaterniond> > vQ;
  vector<Vector3d> vT;
  forward_kinematics(C,BE,P,m_rotations,m_translations,vQ,vT);
  // Loop over deformed bones
  for(int e = 0;e<BE.rows();e++)
  {
    Affine3d a = Affine3d::Identity();
    a.translate(vT[e]);
    a.rotate(vQ[e]);
    Vector3d s = a * (Vector3d)C.row(BE(e,0));
    Vector3d d = a * (Vector3d)C.row(BE(e,1));
    Vector3d projs = project(s);
    Vector3d projd = project(d);
    m_selection(e) = line_segment_in_rectangle(
      projs.head(2),projd.head(2),
      Vector2d(m_down_x,m_height-m_down_y),
      Vector2d(m_drag_x,m_height-m_drag_y));
  }
  return set_selection(m_selection,C,BE,P,RP);
}

References igl::forward_kinematics(), igl::line_segment_in_rectangle(), and igl::opengl2::project().

Here is the call graph for this function:

◆ set_size()

void igl::opengl2::MouseController::set_size ( const int n )

inline

{
  using namespace Eigen;
  clear_selection();
  m_rotations.clear();
  m_rotations.resize(n,Quaterniond::Identity());
  m_translations.clear();
  m_translations.resize(n,Vector3d(0,0,0));
  m_selection = VectorXb::Zero(n);
}

◆ set_translations()

bool igl::opengl2::MouseController::set_translations ( const TranslationList & vT )

inline

{
  if(vT.size() != m_translations.size())
  {
    return false;
  }
  assert(!any_selection());
  m_translations = vT;
  return true;
}

◆ set_widget_mode()

void igl::opengl2::MouseController::set_widget_mode ( const WidgetMode & mode )

inline

{
  switch(m_widget_mode)
  {
    default:
    case WIDGET_MODE_TRANSLATE:
      m_widget.pos = m_trans_widget.m_pos+m_trans_widget.m_trans;
      break;
    case WIDGET_MODE_ROTATE:
      break;
  }
  m_widget_mode = mode;
}

References igl::mode().

Here is the call graph for this function:

◆ translations()

const TranslationList & igl::opengl2::MouseController::translations ( ) const

inline

108{return m_translations;}

References m_translations.

◆ up()

bool igl::opengl2::MouseController::up	(	const int	x,
		const int	y
	)

inline

{
  m_is_selecting = false;
  m_widget.up(x,m_height-y);
  m_trans_widget.up(x,m_height-y);
  return false;
}

Member Data Documentation

◆ m_down_x

int igl::opengl2::MouseController::m_down_x

private

◆ m_down_y

int igl::opengl2::MouseController::m_down_y

private

◆ m_drag_x

int igl::opengl2::MouseController::m_drag_x

private

◆ m_drag_y

int igl::opengl2::MouseController::m_drag_y

private

◆ m_fk_rotations_at_selection

RotationList igl::opengl2::MouseController::m_fk_rotations_at_selection

private

◆ m_fk_translations_at_selection

TranslationList igl::opengl2::MouseController::m_fk_translations_at_selection

private

◆ m_height

int igl::opengl2::MouseController::m_height

private

◆ m_is_selecting

bool igl::opengl2::MouseController::m_is_selecting

private

Referenced by is_selecting().

◆ m_parent_rotations_at_selection

RotationList igl::opengl2::MouseController::m_parent_rotations_at_selection

private

◆ m_root_enabled

bool igl::opengl2::MouseController::m_root_enabled

private

Referenced by root_enabled().

◆ m_rotations

RotationList igl::opengl2::MouseController::m_rotations

private

Referenced by rotations().

◆ m_rotations_at_selection

RotationList igl::opengl2::MouseController::m_rotations_at_selection

private

◆ m_selection

VectorXb igl::opengl2::MouseController::m_selection

private

Referenced by selection().

◆ m_trans_widget

igl::opengl2::TranslateWidget igl::opengl2::MouseController::m_trans_widget

private

Referenced by is_trans_widget_down().

◆ m_translations

TranslationList igl::opengl2::MouseController::m_translations

private

Referenced by translations().

◆ m_translations_at_selection

TranslationList igl::opengl2::MouseController::m_translations_at_selection

private

◆ m_widget

igl::opengl2::RotateWidget igl::opengl2::MouseController::m_widget

private

Referenced by is_widget_down().

◆ m_widget_mode

WidgetMode igl::opengl2::MouseController::m_widget_mode

private

◆ m_widget_rot_at_selection

Eigen::Quaterniond igl::opengl2::MouseController::m_widget_rot_at_selection

private

◆ m_width

int igl::opengl2::MouseController::m_width

private

The documentation for this class was generated from the following file:

src/libigl/igl/opengl2/MouseController.h

Private Attributes
bool	m_is_selecting

VectorXb	m_selection

int	m_down_x

int	m_down_y

int	m_drag_x

int	m_drag_y

int	m_width

int	m_height

igl::opengl2::RotateWidget	m_widget

igl::opengl2::TranslateWidget	m_trans_widget

Eigen::Quaterniond	m_widget_rot_at_selection

RotationList	m_rotations

RotationList	m_rotations_at_selection

RotationList	m_fk_rotations_at_selection

RotationList	m_parent_rotations_at_selection

TranslationList	m_translations

TranslationList	m_translations_at_selection

TranslationList	m_fk_translations_at_selection

bool	m_root_enabled

WidgetMode	m_widget_mode

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ RotationList

◆ TranslationList

◆ VectorXb

Member Enumeration Documentation

◆ WidgetMode

Constructor & Destructor Documentation

◆ MouseController()

Member Function Documentation

◆ any_selection()

◆ clear_selection()

◆ color_if()

◆ down()

◆ drag()

◆ draw()

◆ is_selecting()

◆ is_trans_widget_down()

◆ is_widget_down()

◆ propogate_to_descendants_if()

◆ reset()

◆ reset_rotations()

◆ reset_selected()

◆ reset_selected_rotations()

◆ reset_selected_translations()

◆ reset_translations()

◆ reshape()

◆ root_enabled()

◆ rotations()

◆ selection()

◆ set_rotations()

◆ set_selection()

◆ set_selection_from_last_drag()

◆ set_size()

◆ set_translations()

◆ set_widget_mode()

◆ translations()

◆ up()

Member Data Documentation

◆ m_down_x

◆ m_down_y

◆ m_drag_x

◆ m_drag_y

◆ m_fk_rotations_at_selection

◆ m_fk_translations_at_selection

◆ m_height

◆ m_is_selecting

◆ m_parent_rotations_at_selection

◆ m_root_enabled

◆ m_rotations

◆ m_rotations_at_selection

◆ m_selection

◆ m_trans_widget

◆ m_translations

◆ m_translations_at_selection

◆ m_widget

◆ m_widget_mode

◆ m_widget_rot_at_selection

◆ m_width