AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

massSpringEngineGUI.cpp

Go to the documentation of this file.

#include <qcombobox.h>
#include <qspinbox.h>
#include <qgroupbox.h>
#include <qcheckbox.h>

#include <animal/X3DTK/Qt/engineGUI/engineGUI.h>
#include <animal/X3DTK/Qt/objectGUI/WFloatLineEdit.h>
#include "massSpringEngineGUI.h"


namespace X3DTK{
namespace Qt{

MassSpringEngineQt::MassSpringEngineQt( AMassSpringEngine * massSpringEngine)
  : MassSpringEngineDesigner(0,"main q object")
  , _massSpringEngine(massSpringEngine)
{
  method_comboBox->insertItem( QString("euler") );
  method_comboBox->insertItem( QString("rk2") );
  method_comboBox->insertItem( QString("rk4") );
  method_comboBox->insertItem( QString("midpoint") );
  method_comboBox->insertItem( QString("velocity verlet") );
  method_comboBox->insertItem( QString("implicit euler") );
  connect(method_comboBox,SIGNAL(activated(int)),
          this, SLOT(setIntegrationMethod(int)));
  setIntegrationMethod( _massSpringEngine->getMethod() );
  method_comboBox->setCurrentItem( _massSpringEngine->getMethod() );

  // max nb of iterations
  cg_maxiter_spinBox->setValue(_massSpringEngine->maxCGiterations() );
  connect(cg_maxiter_spinBox,SIGNAL(valueChanged(int)),
          this, SLOT(setMaxCGiterations(int)));

  // damping ratio
  cg_damping_wFloatLineEdit->setFloatValue( _massSpringEngine->dampingRatio());
  cg_damping_wFloatLineEdit->setMinFloatValue( 0.0 );
  cg_damping_wFloatLineEdit->setMaxFloatValue( 1000.0 );
  connect(cg_damping_wFloatLineEdit,SIGNAL(floatValueChanged(float)),
          this, SLOT(setImplicitEulerDampingRatio(float)));

  // divider threshold
  cg_divider_wFloatLineEdit->setFloatValue( _massSpringEngine->smallDenominatorThreshold());
  cg_divider_wFloatLineEdit->setMinFloatValue( 0.0 );
  cg_divider_wFloatLineEdit->setMaxFloatValue( 1000.0 );
  connect(cg_divider_wFloatLineEdit,SIGNAL(floatValueChanged(float)),
          this, SLOT(setImplicitEulerDividerThreshold(float)));


  // isotropy
  isotropy_spinBox->setValue( static_cast<int>(_massSpringEngine->getIsotropy()*100+0.5) );
  connect(isotropy_spinBox,SIGNAL(valueChanged(int)),
          this, SLOT(setIsotropy(int)));


  // modified midpoint substeps
  mmid_spinBox->setValue( _massSpringEngine->MMIDsteps() );
  connect(mmid_spinBox,SIGNAL(valueChanged(int)),
          this, SLOT(setMmidSubsteps(int)));


  // exponential damping
  connect(exponentialDamping_wFloatLineEdit,SIGNAL(floatValueChanged(float)),
          this, SLOT(setExponentialDamping(float)));
  //cerr<<"MassSpringEngineQt::MassSpringEngineQt exponentialDamping "<<_massSpringEngine->get_exponentialDamping() << endl;
  exponentialDamping_wFloatLineEdit->setMinFloatValue( 0.0 );
  exponentialDamping_wFloatLineEdit->setMaxFloatValue( 1000.0 );
  exponentialDamping_wFloatLineEdit->setFloatValue( _massSpringEngine->get_exponentialDamping() );

  connect(exponentialDamping_checkBox,SIGNAL(toggled(bool)),
          this, SLOT(toggleExponentialDamping(bool)));
  exponentialDamping_checkBox->setChecked( _massSpringEngine->get_useExponentialDamping() );

 // gravity
 gravity_checkBox->setChecked( _massSpringEngine->get_useGravity() );
 connect(gravity_checkBox,SIGNAL(toggled(bool)),
          this, SLOT(toggleGravity(bool)));
 connect(gravity_x_wFloatLineEdit,SIGNAL(floatValueChanged(float)),
          this, SLOT(setXgravity(float)));
 connect(gravity_y_wFloatLineEdit,SIGNAL(floatValueChanged(float)),
          this, SLOT(setYgravity(float)));
 connect(gravity_z_wFloatLineEdit,SIGNAL(floatValueChanged(float)),
          this, SLOT(setZgravity(float)));

 gravity_x_wFloatLineEdit->setMinFloatValue( -1.0e+6 );
 gravity_x_wFloatLineEdit->setMaxFloatValue( +1.0e+6 );
 gravity_y_wFloatLineEdit->setMinFloatValue( -1.0e+6 );
 gravity_y_wFloatLineEdit->setMaxFloatValue( +1.0e+6 );
 gravity_z_wFloatLineEdit->setMinFloatValue( -1.0e+6 );
 gravity_z_wFloatLineEdit->setMaxFloatValue( +1.0e+6 );
 
 AMassSpringEngine::Vec g = _massSpringEngine->get_gravity();
 gravity_x_wFloatLineEdit->setFloatValue( g.x );
 gravity_y_wFloatLineEdit->setFloatValue( g.y );
 gravity_z_wFloatLineEdit->setFloatValue( g.z );

 // mass
 mass_groupBox->setEnabled( false );
 
 // threshold distance
 connect(threshold_distancewFloatLineEdit,SIGNAL(floatValueChanged(float)),
          this, SLOT(setThresholdDistance(float)));
  threshold_distancewFloatLineEdit->setMinFloatValue( 1.0e-20 );
  threshold_distancewFloatLineEdit->setMaxFloatValue( 1 );
  threshold_distancewFloatLineEdit->setFloatValue(_massSpringEngine->get_thresholdDistance() );
  
  // display mass_spring
  displayMScheckBox->setChecked( _massSpringEngine->get_displayMassSpring() );
  MS_colourgroupBox->setEnabled( _massSpringEngine->get_displayMassSpring() );
  connect(displayMScheckBox,SIGNAL(toggled(bool)),
    this, SLOT(setDisplayMassSpring(bool)));
  
  // mass_spring colour
  MS_colour_compressedcheck_Box->setChecked( _massSpringEngine->get_compressed_ok() );
  connect(MS_colour_compressedcheck_Box,SIGNAL(toggled(bool)),
     this, SLOT(setCompressed_ok(bool)));
  
  MS_colour_elongated_check_Box->setChecked( _massSpringEngine->get_elongated_ok() );
  connect(MS_colour_elongated_check_Box,SIGNAL(toggled (bool)),
     this, SLOT(setElongated_ok(bool)));


  // point size
  width_points_spinBox->setValue( _massSpringEngine->get_pointSize() );
  connect( width_points_spinBox,SIGNAL(valueChanged(int)), this, SLOT(setPointWidth(int)));
  
  // line width
  width_edges_spinBox->setValue( _massSpringEngine->get_lineWidth() );
  connect( width_edges_spinBox,SIGNAL(valueChanged(int)), this, SLOT(setLineWidth(int)));
  
     
  // debug info
  connect(debug_infocheckBox, SIGNAL(toggled(bool)),
    this, SLOT(toggleDebugInfo(bool)));
  debug_infocheckBox->setChecked(_massSpringEngine->get_debugInfo() );

//  // Set the interpolation method
//  if (massSpringEngine->getInterpolationID())
//    linearRadioButton->setChecked(false);
//  else
//    linearRadioButton->setChecked(true);
//
}

MassSpringEngineQt::~MassSpringEngineQt()
{
}

void MassSpringEngineQt::setIntegrationMethod( int methodID )
{
  _massSpringEngine->setMethod( methodID );
  //cerr<<"MassSpringEngineQt::setIntegrationMethod "<< methodID << endl;

  if( _massSpringEngine->getMethod()==AMassSpringEngine::IMPLICIT_EULER ){
    cg_groupBox->setEnabled(true);
  }
  else{
    cg_groupBox->setEnabled(false);
  }

  if( _massSpringEngine->getMethod()==AMassSpringEngine::MODMID ){
    mmid_groupBox->setEnabled(true);
  }
  else{
    mmid_groupBox->setEnabled(false);
  }
  emit changed();
}

void MassSpringEngineQt::setMaxCGiterations( int maxvalue )
{
  //cerr<<"MassSpringEngineQt::setMaxCGiterations "<< maxvalue << endl;
   _massSpringEngine->setMaxCGiterations( maxvalue );
  emit changed();
}

void MassSpringEngineQt::setIsotropy( int isotropy )
{
  //cerr<<"MassSpringEngineQt::setIsotropy "<< isotropy << endl;
   _massSpringEngine->setIsotropy( isotropy/100.0 );
  emit changed();
}

void MassSpringEngineQt::setMmidSubsteps( int nb )
{
  //cerr<<"MassSpringEngineQt::setMmidSubsteps "<< nb << endl;
   _massSpringEngine->setMMIDsteps(nb);
  emit changed();
}

void MassSpringEngineQt::setImplicitEulerDampingRatio( float r )
{
  //cerr<<"MassSpringEngineQt::setImplicitEulerDampingRatio "<< r << endl;
   _massSpringEngine->setDampingRatio(r);
  emit changed();
}

void MassSpringEngineQt::setImplicitEulerDividerThreshold( float d )
{
  //cerr<<"MassSpringEngineQt::setImplicitEulerDividerThreshold "<< d << endl;
   _massSpringEngine->setSmallDenominatorThreshold(d);
  emit changed();
}

void MassSpringEngineQt::setExponentialDamping( float value )
{
  //cerr<<"MassSpringEngineQt::setExponentialDamping "<< value << endl;
   _massSpringEngine->set_exponentialDamping(value);
  emit changed();
}

void MassSpringEngineQt::toggleExponentialDamping( bool value )
{
  //cerr<<"MassSpringEngineQt::toggleExponentialDamping "<< value << endl;
   _massSpringEngine->set_useExponentialDamping(value);
  emit changed();
}

void MassSpringEngineQt::toggleGravity( bool value )
{
  //cerr<<"MassSpringEngineQt::toggleGravity "<< value << endl;
   _massSpringEngine->set_useGravity(value);
  emit changed();
}
void MassSpringEngineQt::setXgravity( float value )
{
  //cerr<<"MassSpringEngineQt::setXgravity "<< value << endl;
  AMassSpringEngine::Vec g = _massSpringEngine->get_gravity();
  g.x=value;
  _massSpringEngine->set_gravity(g);
  emit changed();
}
void MassSpringEngineQt::setYgravity( float value )
{
  //cerr<<"MassSpringEngineQt::setYgravity "<< value << endl;
  AMassSpringEngine::Vec g = _massSpringEngine->get_gravity();
  g.y=value;
  _massSpringEngine->set_gravity(g);
  emit changed();
}
void MassSpringEngineQt::setZgravity( float value )
{
  //cerr<<"MassSpringEngineQt::setZgravity "<< value << endl;
  AMassSpringEngine::Vec g = _massSpringEngine->get_gravity();
  g.z=value;
  _massSpringEngine->set_gravity(g);
  emit changed();
}
void MassSpringEngineQt::setThresholdDistance(float value)
{
  //cerr << "MassSpringEngineQt::setThresholdDistance " << value << endl;
  _massSpringEngine->set_thresholdDistance(value);
  emit changed();
}
void MassSpringEngineQt::setCompressed_ok(bool b)
{
  //cerr << "MassSpringEngineQt::setCompressed_ok " << b << endl;
  _massSpringEngine->set_compressed_ok(b);
  emit changed();
}
void MassSpringEngineQt::setElongated_ok(bool b)
{  
  //cerr << "MassSpringEngineQt::setElongated_ok " << b << endl;
  _massSpringEngine->set_elongated_ok(b);
  emit changed();
}
void MassSpringEngineQt::setDisplayMassSpring(bool b)
{
  //cerr << "MassSpringEngineQt::setDisplayMassSpring " << b << endl;
  _massSpringEngine->set_displayMassSpring(b);
  MS_colourgroupBox->setEnabled(b);
  setElongated_ok(b); MS_colour_elongated_check_Box->setChecked(b);
  setCompressed_ok(b); MS_colour_compressedcheck_Box->setChecked(b);
  emit changed();
}

void MassSpringEngineQt::setPointWidth(int w)
{  
    _massSpringEngine->set_pointSize(w);
  emit changed();
}

void MassSpringEngineQt::setLineWidth(int w)
{  
    _massSpringEngine->set_lineWidth(w);
  emit changed();
}

  void MassSpringEngineQt::toggleDebugInfo(bool b){
    _massSpringEngine->set_debugInfo(b);
  emit changed();
}


//void MassSpringEngineQt::toggleLinearMethod(bool b)
//{
//  massSpringEngine->toggleLinearMethod(b);
//}
//
//void MassSpringEngineQt::toggleCatmullRomMethod(bool b)
//{
//  massSpringEngine->toggleCatmullRomMethod(b);
//}

QWidget * createMassSpringNodeQWidget(X3D::MassSpringNode * node, QWidget * parent)
{
  //std::cerr<< "createMassSpringNodeQWidget"<<std::endl;

  if (node)
  {
    MassSpringEngineQt * MSEQt = new MassSpringEngineQt(node);
    //MSEQt->reparent(parent, 0, QPoint(0,0));

    // Create the GUI of a animal::engine and insert the new features of a MassSpring
    EngineGUI * engineGUI = static_cast<EngineGUI *>(createEngineNodeQWidget(node, parent));
    engineGUI->insertTab(MSEQt, "MassSpring",0);
    engineGUI->setCurrentPage(0);
    QWidget::connect( MSEQt, SIGNAL( changed() ), engineGUI, SLOT(ok()));
    
    return engineGUI;
  }
  
  std::cerr<<"Warning createMassSpringNodeQWidget(): impossible to create a X3DTK::Qt::EngineGUI because the associated animal::Engine is NULL."<<std::endl;
  std::cerr<<"        or the MainController is NULL."<<std::endl;
  return NULL;
}

}// Qt
}// X3DTK

---