source: flair-src/trunk/lib/FlairSimulator/src/GenericObject.cpp@ 52

// %flair:license{
// This file is part of the Flair framework distributed under the
// CECILL-C License, Version 1.0.
// %flair:license}
//  created:    2013/03/25
//  filename:   GenericObject.cpp
//
//  author:     Cesar Richard
//              Copyright Heudiasyc UMR UTC/CNRS 7253
//
//  version:    $Id: $
//
//  purpose:    classe definissant un modele a simuler
//
/*********************************************************************/

#ifdef GL
#include "GenericObject.h"
#include "Simulator_impl.h"

#include "ConditionVariable.h"
#include "Quaternion.h"
#include "Gui.h"
#include "Gui_impl.h"
#include <IMesh.h>
#include <ISceneManager.h>
#include <IMetaTriangleSelector.h>
#include <IVideoDriver.h>
#include "AnimPoursuite.h"
using namespace irr;
using namespace video;
using namespace scene;
using namespace core;
using namespace io;

using namespace flair::core;
using namespace flair::simulator;

namespace flair {
namespace simulator {

GenericObject::GenericObject(Simulator *parent, std::string name,
                             ISceneManager *sceneManager)
    : IMeshSceneNode(sceneManager->getRootSceneNode(), sceneManager,
                     -1) //, IODevice(parent,name)
{
  setMaterialFlag(EMF_LIGHTING, false);
  Material = getMaterial(0);
  // setMaterialTexture(0,sceneManager->getVideoDriver()->getTexture("/home/cesar/igep/uav_dev_svn/trunk/media/nskinbl.jpg"));
  Material.NormalizeNormals = true;
  Material.Wireframe = false;
  Material.Lighting = false;

  parent->pimpl_->objects.push_back(this);
}

GenericObject::~GenericObject() {}

void GenericObject::setScale(float value) {
  ISceneNode::setScale(vector3df(value, value, value));
}

void GenericObject::setScale(vector3df scale) { ISceneNode::setScale(scale); }

ITriangleSelector *GenericObject::TriangleSelector(void) { return selector; }

void GenericObject::OnRegisterSceneNode(void) {
  if (IsVisible)
    SceneManager->registerNodeForRendering(this);

  ISceneNode::OnRegisterSceneNode();
}

void GenericObject::render(void) {
  IVideoDriver *driver = SceneManager->getVideoDriver();

  driver->setMaterial(Material);

  driver->setTransform(ETS_WORLD, AbsoluteTransformation);
  driver->drawMeshBuffer(mesh->getMeshBuffer(0));
}

void GenericObject::setMesh(IMesh *mesh) {
  this->mesh = mesh;
  box = mesh->getBoundingBox();

  selector = getSceneManager()->createTriangleSelector(mesh, this);
  setTriangleSelector(selector);
}

IMesh *GenericObject::getMesh(void) { return mesh; }

void GenericObject::setPosition(irr::core::vector3df pos) {
  ISceneNode::setPosition(ToIrrlichtCoordinates(pos));
}

void GenericObject::setRotation(irr::core::vector3df rotation) {
  Euler eulerA(rotation.X, rotation.Y, rotation.Z);
  Euler eulerB;
  Quaternion quatA, quatB;
  eulerA.ToQuaternion(quatA);
  quatB = ToIrrlichtOrientation(quatA);
  quatB.ToEuler(eulerB);

  ISceneNode::setRotation(Euler::ToDegree(1) *
                          vector3df(eulerB.roll, eulerB.pitch, eulerB.yaw));
}

} // end namespace simulator
} // end namespace flair
#endif