source: flair-src/trunk/lib/FlairSimulator/src/AnimPoursuite.cpp@ 15

// %flair:license{

// This file is part of the Flair framework distributed under the

// CECILL-C License, Version 1.0.

// %flair:license}

//  created:    2012/08/21

//  filename:   AnimPoursuite.cpp

//

//  author:     Guillaume Sanahuja

//              Copyright Heudiasyc UMR UTC/CNRS 7253

//

//  version:    $Id: $

//

//  purpose:    classe definissant une animation poursuite pour camera

//

/*********************************************************************/

#ifdef GL



#include "AnimPoursuite.h"

#include "Simulator.h"

#include "Model.h"

#include "Model_impl.h"

#include <ICursorControl.h>

#include <ICameraSceneNode.h>



using namespace irr;

using namespace gui;

using namespace core;

using namespace scene;



namespace flair {

namespace simulator {



AnimPoursuite::AnimPoursuite(const ISceneNode *parent, float rotateSpeed,

                             float zoomSpeed) {

  this->parent = parent;

  this->zoomSpeed = zoomSpeed;

  this->rotateSpeed = rotateSpeed;

  currentZoom = 100;

  RotY = 20;

  RotZ = 0;

  Rotating = false;

  LMouseKey = false;

}



AnimPoursuite::~AnimPoursuite() {}



void AnimPoursuite::setPositionOffset(vector3df newpos) { pos_offset = newpos; }



void AnimPoursuite::setTargetOffset(vector3df newpos) {

  target_offset = newpos;

}



float AnimPoursuite::sat(float value) {

  if (value > 89)

    value = 89;

  if (value < -89)

    value = -89;

  return value;

}



void AnimPoursuite::animateNode(ISceneNode *node, u32 timeMs) {

  ICameraSceneNode *camera = static_cast<ICameraSceneNode *>(node);

  vector3df pos;



  float nRotY = RotY;

  float nRotZ = RotZ;



  if (LMouseKey == true) {

    if (!Rotating) {

      RotateStart = MousePos;

      Rotating = true;

      nRotY = RotY;

      nRotZ = RotZ;

    } else {

      nRotY += (RotateStart.Y - MousePos.Y) * rotateSpeed;

      nRotZ += (RotateStart.X - MousePos.X) * rotateSpeed;

      nRotY = sat(nRotY);

    }

  } else if (Rotating) {

    RotY += (RotateStart.Y - MousePos.Y) * rotateSpeed;

    RotZ += (RotateStart.X - MousePos.X) * rotateSpeed;

    RotY = sat(RotY);

    nRotY = RotY;

    nRotZ = RotZ;

    Rotating = false;

  }



  pos.X = -currentZoom;

  pos.Y = 0;

  pos.Z = 0;



  pos.rotateXZBy(-nRotY);

  pos.rotateXYBy(getSimulator()->Yaw() + nRotZ + parent->getRotation().Z);



  camera->setPosition(parent->getPosition() + pos + pos_offset);

  camera->setTarget(parent->getPosition() + target_offset);

}



ISceneNodeAnimator *AnimPoursuite::createClone(ISceneNode *node,

                                               ISceneManager *newManager) {

  return NULL;

}



bool AnimPoursuite::MouseMoved(const SEvent &event,

                               irr::core::position2df MousePos) {

  if (event.EventType != EET_MOUSE_INPUT_EVENT)

    return false;



  switch (event.MouseInput.Event) {



  case EMIE_MOUSE_WHEEL:

    currentZoom -= event.MouseInput.Wheel * zoomSpeed;

    if (currentZoom <= 0)

      currentZoom = zoomSpeed;

    break;

  case EMIE_LMOUSE_PRESSED_DOWN:

    LMouseKey = true;

    break;

  case EMIE_LMOUSE_LEFT_UP:

    LMouseKey = false;

    break;

  case EMIE_MOUSE_MOVED:

    this->MousePos = MousePos;

    break;

  default:

    return false;

    break;

  }



  return true;

}



} // end namespace simulator

} // end namespace flair



#endif // GL