PlaneObject.cc

//=============================================================================
//
//  MyTypes
//
//=============================================================================

#define PLANEOBJECT_C

//== INCLUDES =================================================================

#include <OpenFlipper/common/Types.hh>
#include "Plane.hh"

//== DEFINES ==================================================================

//== TYPEDEFS =================================================================

//== CLASS DEFINITION =========================================================

PlaneObject::PlaneObject( SeparatorNode* _rootNode ) :
  BaseObjectData(_rootNode ),
  planeNode_(NULL)
{
  setDataType(DATA_PLANE);
  init();
}

//=============================================================================


PlaneObject::PlaneObject(const PlaneObject & _object) :
  BaseObjectData(_object)
{

    init(_object.planeNode_);

    setName( name() );
}

PlaneObject::~PlaneObject()
{
  // Delete the data attached to this object ( this will remove all perObject data)
  // Not the best way to do it but it will work.
  // This is only necessary if people use references to the plane below and
  // they do something with the plane in the destructor of their
  // perObjectData.
  deleteData();

  // No need to delete the scenegraph Nodes as this will be managed by baseplugin
  planeNode_    = NULL;
}

void PlaneObject::cleanup() {

  BaseObjectData::cleanup();

  planeNode_   = NULL;

  setDataType(DATA_PLANE);

  init();

}

BaseObject* PlaneObject::copy() {
    PlaneObject* object = new PlaneObject(*this);
    return dynamic_cast< BaseObject* >(object);
}

void PlaneObject::init(PlaneNode* _plane) {

  if ( materialNode() == NULL)
    std::cerr << "Error when creating Plane Object! materialNode is NULL!" << std::endl;

  planeNode_ = new PlaneNode( materialNode() , "NEW PlaneNode");

  if (_plane){
    planeNode_->setPosition( _plane->position(), _plane->normal() );
    planeNode_->setSize( _plane->xDirection().norm(), _plane->yDirection().norm() );
  } else {
    planeNode_->setPosition( ACG::Vec3f(0.0, 0.0, 0.0), ACG::Vec3f(0.0, 1.0, 0.0) );
    planeNode_->setSize( 5.0, 5.0 );
  }
}

// ===============================================================================
// Name/Path Handling
// ===============================================================================

void PlaneObject::setName( QString _name ) {
  BaseObjectData::setName(_name);

  std::string nodename = std::string("PlaneNode for Plane "     + _name.toUtf8() );
  planeNode_->name( nodename );
}

// ===============================================================================
// Visualization
// ===============================================================================

PlaneNode* PlaneObject::planeNode() {
  return planeNode_;
}

// ===============================================================================
// Object information
// ===============================================================================

QString PlaneObject::getObjectinfo() {
  QString output;

  output += "========================================================================\n";
  output += BaseObjectData::getObjectinfo();

  if ( dataType( DATA_PLANE ) )
    output += "Object Contains Plane : ";

  ACG::Vec3f pos = planeNode_->position();
  ACG::Vec3f nor = planeNode_->normal();

  output += " Position ( " + QString::number(pos[0]) + ", " + QString::number(pos[1]) + ", " + QString::number(pos[2]) + ")";
  output += " Normal ( " + QString::number(nor[0]) + ", " + QString::number(nor[1]) + ", " + QString::number(nor[2]) + ")";

  output += "========================================================================\n";
  return output;
}

// ===============================================================================
// Picking
// ===============================================================================

bool PlaneObject::picked( uint _node_idx ) {
  return ( _node_idx == planeNode_->id() );
}

void PlaneObject::enablePicking( bool _enable ) {
  planeNode_->enablePicking( _enable );
}

bool PlaneObject::pickingEnabled() {
  return planeNode_->pickingEnabled();
}

//=============================================================================