imstkDeviceClient.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkMath.h"
#include "imstkEventObject.h"
#include "imstkSpinLock.h"

#include <unordered_map>

namespace imstk
{
using DeviceType = int;
#define UNKNOWN_DEVICE 0
#define OPENHAPTICS_DEVICE 1
#define OPENVR_LEFT_CONTROLLER 3
#define OPENVR_RIGHT_CONTROLLER 4
#define OPENVR_HMD 5

using ButtonStateType = int;
#define BUTTON_RELEASED 0
#define BUTTON_TOUCHED 1
#define BUTTON_UNTOUCHED 2
#define BUTTON_PRESSED 3

class ButtonEvent : public Event
{
public:
    ButtonEvent(std::string type, const int button, const ButtonStateType keyPressType) : Event(type),
        m_buttonState(keyPressType),
        m_button(button)
    {
    }

    virtual ~ButtonEvent() override = default;

    ButtonStateType m_buttonState;
    const int       m_button = -1;
};

class DeviceClient : public EventObject
{
public:
    virtual ~DeviceClient() = default;

    // *INDENT-OFF*
    SIGNAL(DeviceClient,buttonStateChanged);
    // *INDENT-ON*

    const std::string& getIp() { return m_ip; }
    void setIp(const std::string& ip) { m_ip = ip; }

    const std::string& getDeviceName() { return m_deviceName; }
    void setDeviceName(const std::string& deviceName) { m_deviceName = deviceName; }

    bool getTrackingEnabled() const { return m_trackingEnabled; }
    void setTrackingEnabled(const bool status) { m_trackingEnabled = status; }
    bool getAnalogicEnabled() const { return m_analogicEnabled; }
    void setAnalogicEnabled(const bool status) { m_analogicEnabled = status; }
    bool getButtonsEnabled() const { return m_buttonsEnabled; }
    void setButtonsEnabled(const bool status) { m_buttonsEnabled = status; }
    bool getForceEnabled() const { return m_forceEnabled; }
    void setForceEnabled(const bool status) { m_forceEnabled = status; }

    Vec3d getPosition();

    Vec3d getVelocity();

    Vec3d getAngularVelocity();

    Quatd getOrientation();

    const Vec3d& getOffset() const { return m_endEffectorOffset; }

    Vec3d getForce();
    void setForce(Vec3d force);

    const std::unordered_map<int, int>& getButtons() const;

    int getButton(const int buttonId);

    std::vector<double> getAnalog() const;

    double getAnalog(int i) const;

    virtual void update() {}

protected:
    DeviceClient(const std::string& name, const std::string& ip);

    std::string m_deviceName;                         
    std::string m_ip;                                 

    bool m_trackingEnabled = true;                    
    bool m_analogicEnabled = true;                    
    bool m_buttonsEnabled  = true;                    
    bool m_forceEnabled    = false;                   

    Vec3d m_position;                                 
    Vec3d m_velocity;                                 
    Vec3d m_angularVelocity;                          
    Quatd m_orientation;                              
    Vec3d m_force;                                    
    Vec3d m_endEffectorOffset = Vec3d(0.0, 0.0, 0.0); 

    std::unordered_map<int, int> m_buttons;
    std::vector<double> m_analogChannels;

    ParallelUtils::SpinLock m_transformLock;    
    ParallelUtils::SpinLock m_forceLock;        
    mutable ParallelUtils::SpinLock m_dataLock; 
};
} // namespace imstk