sVrpn.h

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef S_VRPN_H
#define S_VRPN_H
 
#include <scolPlugin.h>
#include <string>
#include <vector>
#include <set>
 
#include <boost/thread/thread.hpp>
 
#ifdef SCOL_STATIC
#include <boost/thread/recursive_mutex.hpp>
#endif
 
#include <boost/bind/bind.hpp>
 
#include <vrpn_Tracker.h>
#include <vrpn_Button.h>
#include <vrpn_Analog.h>
#include <vrpn_Dial.h>
#include <vrpn_Text.h>
#include <vrpn_Shared.h>
#include "vrpn_BaseClass.h"
#include "vrpn_Configure.h"
#include "vrpn_Types.h"  
 
static ScolWindowHandle HScol;
 
class SCbData
{
public:
  std::string textData;
  std::vector<float> analogData;
  std::vector<float> vectorData;
  std::vector<float> quatData;
  std::vector<int> btnData;
  int valueId;
  int btnState;
protected:
private:
 
public:
        SCbData()
        {
    textData = "";
        };
  
 
  ~SCbData()
  {
  };
protected:
private:
};
 
 
class SVrpn
{
public:
protected:
  bool mEnableAnalogData;
  bool mEnableButtonData;
  bool mEnableButtonStateData;
  bool mEnableTrackerData;
  bool mEnableTrackerVelData;
  bool mEnableTrackerAccelData;
  bool mEnableDialData;
  bool mEnableTextData;
 
private:
#ifdef SCOL_STATIC
  boost::recursive_mutex m_mutex;
#else
  boost::mutex m_mutex;
#endif
  vrpn_Analog_Remote* m_analog;
  vrpn_Button_Remote* m_button;
  vrpn_Tracker_Remote* m_traker;
  vrpn_Dial_Remote* m_dial;
  vrpn_Text_Receiver* m_textMessage;
  std::string m_host;
  std::string m_name;
 
public:
        SVrpn(const std::string& host, const std::string& name);
        
        ~SVrpn();
 
  std::string GetName();
  
  void EnableAnalogData(bool state);
  void EnableButtonData(bool state);
  void EnableButtonStateData(bool state);
  void EnableTrackerData(bool state);
  void EnableTrackerVelData(bool state);
  void EnableTrackerAccelData(bool state);
  void EnableDialData(bool state);
  void EnableTextData(bool state);
 
  bool GetEnableAnalogData();
  bool GetEnableButtonData();
  bool GetEnableButtonStateData();
  bool GetEnableTrackerData();
  bool GetEnableTrackerVelData();
  bool GetEnableTrackerAccelData();
  bool GetEnableDialData();
  bool GetEnableTextData();
 
  void Update();
 
protected:
private:
  static void VRPN_CALLBACK handle_analog(void* userData, const vrpn_ANALOGCB analog);
  static void VRPN_CALLBACK handle_button_state(void* userData, const vrpn_BUTTONCB button);
  static void VRPN_CALLBACK handle_button_states(void* userData, const vrpn_BUTTONSTATESCB button);
  static void VRPN_CALLBACK handle_tracker(void* userData, const vrpn_TRACKERCB tracker);
  static void VRPN_CALLBACK handle_tracker_vel(void* userData, const vrpn_TRACKERVELCB tracker);
  static void VRPN_CALLBACK handle_tracker_acc(void* userData, const vrpn_TRACKERACCCB tracker);
  static void VRPN_CALLBACK handle_dial(void* userData, const vrpn_DIALCB dial);
  static void VRPN_CALLBACK handle_text(void* userData, const vrpn_TEXTCB text);
};
 
 
class sVrpnThread
{
  public:
          typedef std::set<SVrpn*> DeviceList;
 
        public:
    DeviceList deviceList;
 
        protected:
 
        private:
    static sVrpnThread* _singleton;
    boost::thread m_thread;
#ifdef SCOL_STATIC
  boost::recursive_mutex m_mutex;
#else
  boost::mutex m_mutex;
#endif
    bool m_terminate;
                    
        public:
                static sVrpnThread* GetInstance();
                static void Kill();
                SVrpn* AddDevice(const std::string& host, const std::string& name);
                void RemoveDevice(SVrpn* device);
 
        protected:
                ~sVrpnThread();
 
        private:
                sVrpnThread();
    void UpdateThread();
};
 
#endif