GmiInterface.h

Go to the documentation of this file.

#pragma once
#include "misc/gen/TListener.h"
 
#include <gmi/iface/AxesCoord.h>
#include <gmi/iface/GmiTypes.h>
#include <gmi/iface/global.h>
#include <misc/gen/TVector.h>
#include <misc/gen/Value.h>
 
namespace sf::gmi
{
 
class _GMI_CLASS Controller;
 
class _GMI_CLASS ParamState
{
  public:
    ParamState(const ParamState& ps);
 
    ParamState(const std::string& name, const Value& value);
 
    bool operator==(const ParamState& ps) const;
 
    std::string _name;
    Value _value;
 
    typedef TVector<ParamState> Vector;
};
 
enum EParamFlag
{
  pfREADONLY = 1 << 0,
  pfEFFECTPARAM = 1 << 1,
  pfEFFECTRESULT = 1 << 2,
  pfAXIS = 1 << 3,
  pfMOVE = 1 << 4,
  pfMOVEPOS = 1 << 5,
  pfMOVEVEL = 1 << 6,
  pfEXPORT = 1 << 7,
  pfSYSTEM = 1 << 8,
  pfWRITEABLE = 1 << 9,
  pfALIAS = 1 << 10,
  //
  // Parameters like these must not be used to restore.
  //
  pfARCHIVE = 1 << 11,
  pfMOVECON = 1 << 12,
};
 
enum EResultFlag
{
  rfINDEX = 1 << 0,
  rfASYNC = 1 << 1,
  rfASYNCINDEX = 1 << 2,
  rfHUGE = 1 << 3,
};
 
struct _GMI_CLASS ParamInfo
{
    ParamInfo() = default;
 
    ParamInfo(const ParamInfo& pi)
    {
      copyFrom(pi);
    }
 
    ParamInfo& operator=(const ParamInfo& pi);
 
    void init();
 
    ParamInfo& copyFrom(const ParamInfo& pi);
 
    IdType Id{0};
    int Controller{0};
    unsigned Axis{0};
    unsigned Index{0};
    std::string Name;
    std::string Unit;
    std::string Description;
    Value Round{Value::vitUndefined};
    Value Default{Value::vitUndefined};
    Value Minimum{Value::vitUndefined};
    Value Maximum{Value::vitUndefined};
    ParamState::Vector States;
    int Flags{0};
};
 
struct _GMI_CLASS ResultInfo
{
    ResultInfo() = default;
 
    ResultInfo(const ResultInfo& pi)
    {
      copy(pi);
    }
 
    ResultInfo& operator=(const ResultInfo& pi)
    {
      return copy(pi);
    }
 
    void init();
 
    ResultInfo& copy(const ResultInfo& pi);
 
    IdType Id{0};
    int Flags{0};
    unsigned Axis{0};
    unsigned Index{0};
    std::string Name;
    std::string Description;
    unsigned Bits{0};
    unsigned WordSize{0};
    unsigned ArraySize{0};
    unsigned Offset{0};
};
 
struct BufferInfo
{
    BufferInfo() = default;
 
    void Clear();
 
    IdType Id{0};
    void* Buffer{nullptr};
    unsigned Size{0};
    unsigned Remain{0};
    unsigned Counter{0};
};
 
inline void BufferInfo::Clear()
{
  Id = 0;
  Buffer = nullptr;
  Size = 0;
  Remain = 0;
  Counter = 0;
}
 
typedef void (*NotifyProc)(void* data, IdType id);
 
enum EParam
{
  mpNONE = 0x0000,
  mpVERSION = 0x0001,
  mpAXISCOUNT = 0x0002,
  mpMOVEPOS = 0x0003,
  mpMOVEVEL = 0x0004,
  mpJOYSTICK = 0x0005,
  mpTRIGGER_AXIS = 0x0006,
  mpTRIGGER_DENSITY = 0x0007,
  mpTRIGGER_MODE = 0x0008,
 
  mpJOYSTICK_AXIS = 0x0009,
  mpPOP_AXIS = 0x000A,
  mpTRIGGER_ENABLE = 0x000B,
  mpMOVECON = 0x000C,
  mpCHUCKJAW = 0x000D,
  mpERROR = 0x000E,
  mpERROR_MESSAGE = 0x000F,
  mpTRIGGER_FREQ = 0x0010,
  mpTIMEUNIT = 0x0011,
  mpLAST = 0x0200,
  mpAXIS_MASK = 0x8000,
  mpAXIS_NAME = 0x8001,
  mpAXIS_IDX_POS = 0x8002,
  mpAXIS_MODE = 0x8003,
  mpAXIS_ACCURACY = 0x8004,
  mpAXIS_RESOLUTION = 0x8005,
  //
  // Axis minimum and maximum positions.
  //
  mpAXIS_MIN_POS = 0x8010,
  mpAXIS_MAX_POS = 0x8011,
  mpAXIS_MAX_VEL = 0x8012,
  mpAXIS_MAX_ACC = 0x8013,
  mpAXIS_OFS_POS = 0x8014,
  //
  // Volatile data. It changes when moving.
  //
  mpAXIS_CUR_POS = 0x8020,
  mpAXIS_CUR_VEL = 0x8021,
  //
  // Targeting data before move.
  //
  mpAXIS_TRG_POS = 0x8030,
  mpAXIS_TRG_VEL = 0x8031,
  mpAXIS_TRG_ACC = 0x8032,
  //
  // Effects all position fields.
  //
  mpAXIS_HOME_OFS = 0x8033,
  mpAXIS_MOVEMENT = 0x8034,
  mpAXIS_LAST = 0x8200,
};
 
enum EResult
{
  mrLAST = 0x0200,
  //
  // Axis results from here.
  //
  mrAXIS_INDEX_POS = 0x8000,
  // measurement trigger. Position is relative from
  mrAXIS_LAST = 0x8200,
};
 
enum EMovePosCmd
{
  mpcCOMPLETE = 0,
  mpcABORT = 1,
  mpcSTOP = 2,
  mpcPOSITION = 3,
  mpcCURVE = 4,
};
 
enum EMoveVelCmd
{
  mvcCOMPLETE = 0,
  mvcABORT = 1,
  mvcSTOP = 2,
  mvcON = 3,
};
 
enum EMoveConCmd : int
{
  mccCOMPLETE = 0,
  mccABORT = 1,
  mccSTOP = 2,
  mccON = 3,
};
 
enum EJoystickCmd : int
{
  jscINHIBIT = -1,
  jscOFF = 0,
 
  jscSTOP = 1,
  jscON = 2,
};
 
enum EAxisMode
{
  amDISABLED = 0,
  amPOSITION = 1,
 
  amVELOCITY = 2,
  amHOME = 3,
  amCONTINUE = 4
};
 
enum EAxisMinMax : unsigned int
{
  ammMIN_POS = 0,
  ammMAX_POS = 1,
  ammMAX_VEL = 2,
  ammMAX_ACC = 3
};
 
enum EChuckJaw
{
  cjOFF = 0,
  cjOPEN = 1,
  cjCLOSE = 2,
};
 
enum EControllerEvent : int
{
  ceSTATUS = 0x0000,
  ceHOOKED = 0x1001,
  ceUNHOOKED = 0x1002,
  ceCOMPLETE = 0x2001,
  cePOPEVENT = 0x3001,
};
 
typedef TListener<Controller*, EControllerEvent> ControllerListener;
}// namespace sf::gmi