InputProcessor.h

#ifndef INPUT_PROCESSOR_H
#define INPUT_PROCESSOR_H

#include "Modeling/World.h"
#include "Planning/PlannerObjective.h"
#include <KrisLibrary/utils/AsyncIO.h>
#include <KrisLibrary/Timer.h>

class InputProcessorBase
{
 public:
  InputProcessorBase();
  virtual ~InputProcessorBase() {}
  virtual string Instructions() const { return ""; }
  virtual void Activate(bool enabled) {}
  virtual bool HasUpdate() { return true; }
  virtual void Hover(int mx,int my) {}
  virtual void Drag(float dx,float dy) {}
  virtual void Spaceball(const RigidTransform& T) {}
  virtual void SetGlobalTime(Real time) { currentTime = time; }
  virtual void SetPredictionTime(Real splitTime) {}
  virtual PlannerObjectiveBase* MakeObjective(Robot* robot) { return NULL; }
  virtual void DrawGL() {}

  //helpers
  Robot* GetRobot() const;
  void GetClickRay(int mx, int my, Ray3D& ray) const;

  RobotWorld* world;
  Camera::Viewport* viewport;
  Real currentTime;
};

class StandardInputProcessor : public InputProcessorBase
{
 public:
  StandardInputProcessor();
  virtual ~StandardInputProcessor() {}
  virtual string Instructions() const { return "Click and drag to pose points on the robot"; }
  virtual void Activate(bool enabled);
  virtual bool HasUpdate() { return changed; }
  virtual void Hover(int mx,int my);
  virtual void Drag(float dx,float dy);
  virtual void Spaceball(const RigidTransform& T);
  virtual PlannerObjectiveBase* MakeObjective(Robot* robot);
  virtual void DrawGL();

  bool move, changed;
  int currentLink;
  Vector3 currentPoint;
  Vector3 currentDestination;
  bool useSpaceball;
  RigidTransform currentDesiredTransform;
  IKGoal goal;
  Real pathCost;
};

class PredictiveExtrapolationInputProcessor : public StandardInputProcessor
{
 public:
  PredictiveExtrapolationInputProcessor();
  virtual void Activate(bool enabled);
  virtual bool HasUpdate() { return true; }
  virtual void Hover(int mx,int my);
  virtual void Drag(float mx,float my);
  virtual void SetPredictionTime(Real splitTime);
  virtual PlannerObjectiveBase* MakeObjective(Robot* robot);
  virtual void DrawGL();

  Real currentInputTime;
  int numInputs;
  Vector3 sumVelocity;
  Real alpha;  //decay term for velocity estimator
  Real weightDecay,speedDecay;
  Real predictionOffset;
  bool tracking;
  PlannerObjectiveBase* lastObjective;
};



class SerializedObjectiveProcessor : public InputProcessorBase
{
 public:
  SerializedObjectiveProcessor(AsyncReaderThread* reader=NULL);
  virtual ~SerializedObjectiveProcessor() {}
  virtual void Activate(bool enabled);
  virtual bool HasUpdate();
  virtual PlannerObjectiveBase* MakeObjective(Robot* robot);

  AsyncReaderThread* reader;
};

class SocketObjectiveProcessor : public SerializedObjectiveProcessor
{
 public:
  SocketObjectiveProcessor(const char* addr) 
    :SerializedObjectiveProcessor(&socketReader),socketReader(addr)
    {}
  virtual ~SocketObjectiveProcessor() {}
  virtual string Instructions() { return "Reading objectives over socket..."; }
  SocketReadWorker socketReader;
};

#endif