inputdevice.h

Go to the documentation of this file.

/* This file is part of COVISE.
 
   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.
 
 * License: LGPL 2+ */
 
/*
 * inputdevice.h
 *
 *  Created on: Dec 9, 2014
 *      Author: svnvlad
 */
 
#ifndef INPUT_DEVICE_H
#define INPUT_DEVICE_H
 
#include <OpenThreads/Thread>
#include <OpenThreads/Mutex>
#include <osg/Matrix>
#include <osg/Vec3>
#include <vector>
#include <cover/coVRDynLib.h>
 
namespace opencover
{
 
class COVEREXPORT InputDevice : public OpenThreads::Thread
{
    friend class Input;
    friend class ButtonDevice;
    friend class Valuator;
    friend class TrackingBody;
 
public:
    InputDevice(const std::string &configPath);
    virtual ~InputDevice();
 
    std::string configPath(const std::string &ent = "") const; //< path to config values for this device
    virtual bool poll(); //< called regularly to retrieve new values from hardware - reimplement
    virtual void run(); //< regularly calls poll() on another thread - reimplement if this is not appropriate
 
    virtual bool needsThread() const; //< whether a thread should be spawned - reimplement if not necessary
    void stopLoop(); //< request run()/other thread to terminate
 
    bool isValid() const;
    bool isVarying() const;
    bool is6Dof() const;
    const std::string &getName() const;
    const osg::Matrix &getOffsetMat() const;
    void setOffsetMat(const osg::Matrix &m);
 
    std::string &getCalibrationPointName(int i);
    osg::Vec3 &getCalibrationPoint(int i);
 
protected:
    static osg::Matrix s_identity; //< identity matrix, for returning a valid reference
    bool loop_is_running; 
    OpenThreads::Mutex m_mutex; //< protect state data structures
 
    const std::string m_config; //< path to config values for this device
    std::string m_name;
    osg::Matrix m_offsetMatrix; //< system matrix
    bool m_isVarying; //< whether returned values can change
    bool m_is6Dof; //< whether matrices represent position and orientation
    
    // state data, update during poll(), create them with the correct size
    bool m_valid;
    std::vector<bool> m_buttonStates;
    std::vector<double> m_valuatorValues;
    std::vector<std::pair<double, double> > m_valuatorRanges;
    std::vector<bool> m_bodyMatricesValid;
    std::vector<bool> m_bodyMatricesRelative;
    std::vector<osg::Matrix> m_bodyMatrices;
    osg::Vec3 m_calibrationPoints[3];
    std::string m_calibrationPointNames[3];
 
    // these are called by Input
    size_t numButtons() const
    {
        return m_buttonStates.size();
    }
    bool getButtonState(size_t idx) const;
 
    size_t numValuators() const
    {
        return m_valuatorValues.size();
    }
    double getValuatorValue(size_t idx) const;
    std::pair<double, double> getValuatorRange(size_t idx) const;
 
    size_t numBodies() const
    {
        return m_bodyMatrices.size();
    }
    bool isBodyMatrixValid(size_t idx) const;
    bool isBodyMatrixRelative(size_t idx) const;
    const osg::Matrix &getBodyMatrix(size_t idx) const;
 
    virtual void update(); //< called by Input::update()
 
private:
    // per-frame state
    bool m_validFrame;
    std::vector<bool> m_buttonStatesFrame;
    std::vector<double> m_valuatorValuesFrame;
    std::vector<std::pair<double, double> > m_valuatorRangesFrame;
    std::vector<bool> m_bodyMatricesValidFrame;
    std::vector<bool> m_bodyMatricesRelativeFrame;
    std::vector<osg::Matrix> m_bodyMatricesFrame;
};
 
class COVEREXPORT DriverFactoryBase
{
 
    friend class Input;
 
public:
    DriverFactoryBase(const std::string &name);
    virtual ~DriverFactoryBase();
 
    virtual InputDevice *newInstance(const std::string &name) = 0;
    const std::string &name() const;
    CO_SHLIB_HANDLE getLibHandle() const;
 
private:
    void setLibHandle(CO_SHLIB_HANDLE handle);
 
    std::string m_name;
    CO_SHLIB_HANDLE m_handle;
};
 
template <class Driver>
class DriverFactory : public DriverFactoryBase
{
 
public:
    DriverFactory(const std::string &name)
        : DriverFactoryBase(name)
    {
    }
 
    Driver *newInstance(const std::string &instanceName)
    {
 
        return new Driver(instanceName);
    }
};
}
 
#define INPUT_PLUGIN(Driver)                                                     \
    extern "C" PLUGINEXPORT opencover::DriverFactory<Driver> *newDriverFactory() \
    {                                                                            \
        return new opencover::DriverFactory<Driver>(#Driver);                    \
    }
 
#endif /* INPUTHDW_H_ */