File ManusSDKTypes.h

File List > api > cppSDK > SDKClient > ManusSDKTypes.h

Go to the documentation of this file

#ifndef __MANUS_SDK_TYPES_H__
#define __MANUS_SDK_TYPES_H__

#ifdef __cplusplus
extern "C"
{
#endif

#include <stdint.h>

/******************************************************************************
 * Preprocessor defines.
 *****************************************************************************/

#define NUM_FINGERS_ON_HAND 5

#define NUM_FLEX_SEGMENTS_PER_FINGER 2

#define MAX_NUM_IMUS_ON_GLOVE (NUM_FINGERS_ON_HAND + 1)

#define MAX_USERS 8 // we should never reach that

#define MAX_NUM_CHARS_IN_USERNAME 64

#define MAX_NUM_CHARS_IN_MEASUREMENT 64

#define MAX_NUM_CHARS_IN_HOST_NAME 256

#define MAX_NUM_CHARS_IN_IP_ADDRESS 40

#define MAX_NUM_CHARS_IN_TRACKER_ID 32

#define MAX_NUM_CHARS_IN_TRACKER_MANUFACTURER 32

#define MAX_NUM_CHARS_IN_TRACKER_PRODUCTNAME 32

#define MAX_NUM_CHARS_IN_TARGET_ID 32

#define MAX_NUM_CHARS_IN_VERSION 16

#define UNINITIALIZED_ID 0

#define MAX_NUMBER_OF_HOSTS 100

#define MAX_NUMBER_OF_DONGLES 16 // we only have 35 radio channels available. if we got 16 dongles, expect wireless issues! and no 16 usb ports is also not likely.

#define MAX_NUM_CHARS_IN_LICENSE_TYPE 64

#define MAX_NUMBER_OF_GLOVES  (MAX_NUMBER_OF_DONGLES* 2)
#define MAX_NUMBER_OF_HAPTICS_DONGLES  MAX_NUMBER_OF_DONGLES

#define MAX_NUMBER_OF_SKELETONS  32

#define MAX_NUMBER_OF_USERS  MAX_NUMBER_OF_DONGLES

#define NUMBER_OF_TRACKERS_PER_POLYGON_SKELETON 8

#define MAX_NUMBER_OF_TRACKERS (MAX_NUMBER_OF_USERS * NUMBER_OF_TRACKERS_PER_POLYGON_SKELETON)

#define MAX_NUM_CHARS_IN_NODE_NAME 256 // this is for a UTF8 string , NOT an ASCII CHAR array (same base type though)


#define MAX_CHAIN_LENGTH 32

#define MAX_NUM_FINGER_IDS 10

#define MAX_NUM_TOE_IDS 10

#define MAX_NUM_CHARS_IN_SYSTEM_ERROR_MESSAGE 256

#define MAX_NUM_CHAR_DEBUGGING_ID 64

#define MAX_NUMBER_OF_ERGONOMICS_DATA MAX_NUMBER_OF_GLOVES

#define MAX_NUMBER_OF_SESSIONS 8 // this is not the real limit for Core but just for the SDKClient to handle

#define MAX_NUMBER_OF_SKELETONS_PER_SESSION 32  

#define MAX_NUM_CHARS_IN_SKELETON_NAME 256 // we already encountered 34 char names in unreal, but its utf8 so enbiggen even more!

#define MAX_NUM_CHARS_IN_TIMECODE_INTERFACE_STRINGS 64

#define MAX_NUMBER_OF_AUDIO_INTERFACES 32

#define MAX_BONE_WEIGHTS_PER_VERTEX 4

#define MAX_NUMBER_OF_NODES_PER_ESTIMATION_SKELETON 40

#define MAX_GESTURE_DATA_CHUNK_SIZE 64

#define MAX_NUM_CHARS_IN_OPENXR_FEATURE_STRING 64

#define MAX_NUMBER_OF_NETDEVICES  MAX_NUMBER_OF_DONGLES

#define BROADCAST_ADDRESS "255.255.255.255"
#define BROADCAST_PORT "62687"
#define SECONDS_TO_FIND_HOSTS 2
#define SECONDS_TO_FIND_LOCAL_HOSTS 2
#define DEFAULT_BUFFER_SIZE 512

/******************************************************************************
 * Enums.
 *****************************************************************************/

typedef enum SDKReturnCode
{
    SDKReturnCode_Success,

    SDKReturnCode_Error,

    SDKReturnCode_InvalidArgument,

    SDKReturnCode_ArgumentSizeMismatch,

    SDKReturnCode_UnsupportedStringSizeEncountered,

    SDKReturnCode_SdkNotAvailable,

    SDKReturnCode_HostFinderNotAvailable,

    SDKReturnCode_DataNotAvailable,

    SDKReturnCode_MemoryError,

    SDKReturnCode_InternalError,

    SDKReturnCode_FunctionCalledAtWrongTime,

    SDKReturnCode_NotConnected,

    SDKReturnCode_ConnectionTimeout,

    SDKReturnCode_InvalidID,

    SDKReturnCode_NullPointer,

    SDKReturnCode_InvalidSequence,

    SDKReturnCode_NoCoordinateSystemSet,

    SDKReturnCode_SdkIsTerminating,

    SDKReturnCode_StubNullPointer,

    SDKReturnCode_SkeletonNotLoaded,

    SDKReturnCode_FunctionNotAvailable,

    SDKReturnCode_MAX_SIZE
} SDKReturnCode;

typedef enum SessionType
{
    SessionType_Unknown,
    SessionType_UnityPlugin,
    SessionType_UnrealPlugin,
    SessionType_CoreSDK,
    SessionType_Xsens,
    SessionType_Optitrack,
    SessionType_MotionBuilder,
    SessionType_VRED,
    SessionType_OpenXR,
    SessionType_Qualisys
} SessionType;

typedef enum TrackerType
{
    TrackerType_Unknown,
    TrackerType_Head,
    TrackerType_Waist,
    TrackerType_LeftHand,
    TrackerType_RightHand,
    TrackerType_LeftFoot,
    TrackerType_RightFoot,
    TrackerType_LeftUpperArm,
    TrackerType_RightUpperArm,
    TrackerType_LeftUpperLeg,
    TrackerType_RightUpperLeg,
    TrackerType_Controller,
    TrackerType_Camera,

    TrackerType_MAX_SIZE
} TrackerType;

typedef enum TrackingQuality
{
    TrackingQuality_Untrackable,
    TrackingQuality_BadTracking,
    TrackingQuality_Trackable,
} TrackerQuality;

typedef enum TrackerSystemType
{
    TrackerSystemType_Unknown,
    TrackerSystemType_Antilatency,
    TrackerSystemType_ART,
    TrackerSystemType_OpenVR,
    TrackerSystemType_Optitrack,
    TrackerSystemType_Vicon,
    TrackerSystemType_OpenXR,
} TrackerSystemType;

typedef enum DevicePairedState
{
    DevicePairedState_Unknown,
    DevicePairedState_Paired,
    DevicePairedState_Unpaired,
    DevicePairedState_Pairing,
} DevicePairedState;

typedef enum DeviceClassType
{
    DeviceClassType_Unknown,
    DeviceClassType_Dongle,
    DeviceClassType_Glove,
    DeviceClassType_Glongle
} DeviceClassType;

typedef enum DeviceFamilyType
{
    DeviceFamilyType_Unknown,
    DeviceFamilyType_Prime1,
    DeviceFamilyType_Prime2,
    DeviceFamilyType_PrimeX, // TODO obsolete?
    DeviceFamilyType_Quantum,
    DeviceFamilyType_Prime3,
    DeviceFamilyType_Virtual
} DeviceFamilyType;

typedef enum ProfileType
{
    ProfileType_Hands,
    ProfileType_FullBody,

    ProfileType_MAX_SIZE
} ProfileType;

typedef enum MeasurementType
{
    MeasurementType_Unknown,
    MeasurementType_PlayerHeight,
    MeasurementType_SpineLength,
    MeasurementType_NeckLength,
    MeasurementType_UpperArmLength,
    MeasurementType_LowerArmLength,
    MeasurementType_ArmLength,
    MeasurementType_ArmSpan,
    MeasurementType_UpperLegLength,
    MeasurementType_LowerLegLength,
    MeasurementType_LegLength,
    MeasurementType_HandLength,
    MeasurementType_FootLength,
    MeasurementType_HipWidth,
    MeasurementType_ShoulderWidth,
    MeasurementType_ShoulderHeight,
    MeasurementType_HeadLength,
    MeasurementType_Thickness,
    MeasurementType_ArmRatio,
    MeasurementType_LegRatio,

    MeasurementType_MAX_SIZE // Warning, this value is used to define the UserProfile.Measurement[SIZE]
} MeasurementType;

typedef enum TrackerOffsetType
{
    TrackerOffsetType_Unknown,
    TrackerOffsetType_HeadTrackerToHead,
    TrackerOffsetType_HeadTrackerToTopOfHead,

    TrackerOffsetType_LeftHandTrackerToWrist,
    TrackerOffsetType_RightHandTrackerToWrist,
    TrackerOffsetType_LeftFootTrackerToAnkle,
    TrackerOffsetType_RightFootTrackerToAnkle,

    TrackerOffsetType_HipTrackerToHip,
    TrackerOffsetType_HipTrackerToLeftLeg,
    TrackerOffsetType_HipTrackerToRightLeg,

    TrackerOffsetType_LeftUpperArmTrackerToElbow,
    TrackerOffsetType_RightUpperArmTrackerToElbow,
    TrackerOffsetType_LeftUpperArmTrackerToShoulder,
    TrackerOffsetType_RightUpperArmTrackerToShoulder,

    TrackerOffsetType_MAX_SIZE // Warning, this value is used to define the UserProfile.TrackerOffset[SIZE]
} TrackerOffsetType;

typedef enum ExtraTrackerOffsetType
{
    ExtraTrackerOffsetType_Unknown,
    ExtraTrackerOffsetType_HeadForward,
    ExtraTrackerOffsetType_HipForward,
    ExtraTrackerOffsetType_HipHeight,
    ExtraTrackerOffsetType_MAX_SIZE // Warning, this value is used to define the UserProfile.TrackerOffset[SIZE]
} ExtraTrackerOffsetType;

typedef enum MeasurementUnit
{
    MeasurementUnit_Meters,
    MeasurementUnit_Percentage,
} MeasurementUnit;

typedef enum MeasurementCategory
{
    MeasurementCategory_Misc,
    MeasurementCategory_Generic,
    MeasurementCategory_Arms,
    MeasurementCategory_Legs,
    MeasurementCategory_Body,
} MeasurementCategory;

typedef enum UpdateStatusEnum
{
    UpdateStatusEnum_Unknown,
    UpdateStatusEnum_NoUpdateAvailable,
    UpdateStatusEnum_UpdateAvailable,
    UpdateStatusEnum_MandatoryUpdateAvailable,
    UpdateStatusEnum_Updating,
} UpdateStatusEnum;

typedef enum SkeletonType
{
    SkeletonType_Invalid,
    SkeletonType_Hand,
    SkeletonType_Body,
    SkeletonType_Both
} SkeletonType;

typedef enum SkeletonTargetType
{
    SkeletonTargetType_Invalid,
    SkeletonTargetType_UserData,
    SkeletonTargetType_UserIndexData,
    SkeletonTargetType_AnimationData,
    SkeletonTargetType_GloveData
} SkeletonTargetType;

typedef enum NodeType
{
    NodeType_Invalid,
    NodeType_Joint,
    NodeType_Mesh,
    NodeType_Leaf,
    NodeType_Collider
} NodeType;

typedef enum NodeSettingsFlag
{
    NodeSettingsFlag_None = 0,
    NodeSettingsFlag_IK = 1 << 0,
    NodeSettingsFlag_Foot = 1 << 1,
    NodeSettingsFlag_RotationOffset = 1 << 2,
    NodeSettingsFlag_Leaf = 1 << 3,
} NodeSettingsFlag;

typedef enum ChainType
{
    ChainType_Invalid,
    ChainType_Arm,
    ChainType_Leg,
    ChainType_Neck,
    ChainType_Spine,
    ChainType_FingerThumb,
    ChainType_FingerIndex,
    ChainType_FingerMiddle,
    ChainType_FingerRing,
    ChainType_FingerPinky,
    ChainType_Pelvis,
    ChainType_Head,
    ChainType_Shoulder,
    ChainType_Hand,
    ChainType_Foot,
    ChainType_Toe
} ChainType;

typedef enum CollisionType
{
    CollisionType_None,
    CollisionType_Discrete,
    CollisionType_Continuous,
} CollisionType;

typedef enum ColliderType
{
    ColliderType_Invalid,
    ColliderType_Sphere,
    ColliderType_Capsule,
    ColliderType_Box,
} ColliderType;

typedef enum Side
{
    Side_Invalid,
    Side_Left,
    Side_Right,
    Side_Center
} Side;

typedef enum HandMotion
{
    HandMotion_None,
    HandMotion_IMU,
    HandMotion_Tracker,
    HandMotion_Tracker_RotationOnly,
    HandMotion_Auto
} HandMotion;

typedef enum AxisDirection
{
    AxisDirection_Invalid,
    AxisDirection_Backward,
    AxisDirection_Left,
    AxisDirection_Down,
    AxisDirection_Up,
    AxisDirection_Right,
    AxisDirection_Forward
} AxisDirection;

typedef enum AxisView
{
    AxisView_Invalid,

    AxisView_ZFromViewer,
    AxisView_YFromViewer,
    AxisView_XFromViewer,

    AxisView_XToViewer,
    AxisView_YToViewer,
    AxisView_ZToViewer
} AxisView;

typedef enum AxisPolarity
{
    AxisPolarity_Invalid,

    AxisPolarity_NegativeZ,
    AxisPolarity_NegativeY,
    AxisPolarity_NegativeX,

    AxisPolarity_PositiveX,
    AxisPolarity_PositiveY,
    AxisPolarity_PositiveZ
} AxisPolarity;

typedef enum SystemMessageType
{
    SystemMessageType_Unknown,
    SystemMessageType_LibDebugReplugDongle,
    SystemMessageType_LibDebugRxStall,
    SystemMessageType_LibDebugTxStall,

    SystemMessageType_TrackerError,
    SystemMessageType_TrackerOk,
    SystemMessageType_TrackerSystemOutOfDate,

    SystemMessageType_GloveSanityErrorPSOCInit,
    SystemMessageType_GloveSanityErrorQCBatV,
    SystemMessageType_GloveSanityErrorQCLRACalib,
    SystemMessageType_GloveSanityErrorQCFlexInit,
    SystemMessageType_GloveSanityErrorQCIMUInit,
    SystemMessageType_GloveSanityErrorQCIMUCalib,
    SystemMessageType_GloveSanityErrorQCID,
    SystemMessageType_GloveSanityErrorQCInterCPU,

    SystemMessageType_SessionConnectionVersionMismatch,

    SystemMessageType_TemporarySkeletonModified,

    SystemMessageType_SessionRefusedDueToLicenseIssue,

    SystemMessageType_LaunchDevTools
} SystemMessageType;

typedef enum ErgonomicsDataType
{
//  ErgonomicsDataType_Invalid,

    ErgonomicsDataType_LeftFingerThumbMCPSpread,
    ErgonomicsDataType_LeftFingerThumbMCPStretch,
    ErgonomicsDataType_LeftFingerThumbPIPStretch,
    ErgonomicsDataType_LeftFingerThumbDIPStretch,

    ErgonomicsDataType_LeftFingerIndexMCPSpread,
    ErgonomicsDataType_LeftFingerIndexMCPStretch,
    ErgonomicsDataType_LeftFingerIndexPIPStretch,
    ErgonomicsDataType_LeftFingerIndexDIPStretch,

    ErgonomicsDataType_LeftFingerMiddleMCPSpread,
    ErgonomicsDataType_LeftFingerMiddleMCPStretch,
    ErgonomicsDataType_LeftFingerMiddlePIPStretch,
    ErgonomicsDataType_LeftFingerMiddleDIPStretch,

    ErgonomicsDataType_LeftFingerRingMCPSpread,
    ErgonomicsDataType_LeftFingerRingMCPStretch,
    ErgonomicsDataType_LeftFingerRingPIPStretch,
    ErgonomicsDataType_LeftFingerRingDIPStretch,

    ErgonomicsDataType_LeftFingerPinkyMCPSpread,
    ErgonomicsDataType_LeftFingerPinkyMCPStretch,
    ErgonomicsDataType_LeftFingerPinkyPIPStretch,
    ErgonomicsDataType_LeftFingerPinkyDIPStretch,


    ErgonomicsDataType_RightFingerThumbMCPSpread,
    ErgonomicsDataType_RightFingerThumbMCPStretch,
    ErgonomicsDataType_RightFingerThumbPIPStretch,
    ErgonomicsDataType_RightFingerThumbDIPStretch,

    ErgonomicsDataType_RightFingerIndexMCPSpread,
    ErgonomicsDataType_RightFingerIndexMCPStretch,
    ErgonomicsDataType_RightFingerIndexPIPStretch,
    ErgonomicsDataType_RightFingerIndexDIPStretch,

    ErgonomicsDataType_RightFingerMiddleMCPSpread,
    ErgonomicsDataType_RightFingerMiddleMCPStretch,
    ErgonomicsDataType_RightFingerMiddlePIPStretch,
    ErgonomicsDataType_RightFingerMiddleDIPStretch,

    ErgonomicsDataType_RightFingerRingMCPSpread,
    ErgonomicsDataType_RightFingerRingMCPStretch,
    ErgonomicsDataType_RightFingerRingPIPStretch,
    ErgonomicsDataType_RightFingerRingDIPStretch,

    ErgonomicsDataType_RightFingerPinkyMCPSpread,
    ErgonomicsDataType_RightFingerPinkyMCPStretch,
    ErgonomicsDataType_RightFingerPinkyPIPStretch,
    ErgonomicsDataType_RightFingerPinkyDIPStretch,

    ErgonomicsDataType_MAX_SIZE
} ErgonomicsDataType;

typedef enum LicenseType
{
    LicenseType_Undefined,
    LicenseType_Polygon,
    LicenseType_CoreXO,
    LicenseType_CorePro,
    LicenseType_CoreXOPro,

    LicenseType_CoreX,
    LicenseType_CoreO,
    LicenseType_CoreQ,
    LicenseType_CoreXPro,
    LicenseType_CoreOPro,
    LicenseType_CoreQPro,
    LicenseType_CoreXOQPro,
    LicenseType_CoreXR,
    LicenseType_CorePrimeThree,
} LicenseType;

typedef enum TimecodeFPS
{
    TimecodeFPS_Undefined,
    TimecodeFPS_23_976,
    TimecodeFPS_24,
    TimecodeFPS_25,
    TimecodeFPS_29_97,
    TimecodeFPS_30,
    TimecodeFPS_48,
    TimecodeFPS_50,
    TimecodeFPS_59_94,
    TimecodeFPS_60,
    TimecodeFPS_29_97DF,
    TimecodeFPS_59_94DF,
} TimecodeFPS;

typedef enum FingerJointType
{
    FingerJointType_Invalid,
    FingerJointType_Metacarpal,
    FingerJointType_Proximal,
    FingerJointType_Intermediate,
    FingerJointType_Distal, //thumb doesn't have it 
    FingerJointType_Tip
}FingerJointType;
/******************************************************************************
 * Structs.
 *****************************************************************************/

typedef struct ManusVec3
{
    float x; //default = 0.0f;
    float y; //default = 0.0f;
    float z; //default = 0.0f;
} ManusVec3;

typedef struct ManusVec2
{
    float x; //default = 0.0f;
    float y; //default = 0.0f;
} ManusVec2;

typedef struct ManusQuaternion
{
    float w; //default = 1.0f;
    float x; //default = 0.0f;
    float y; //default = 0.0f;
    float z; //default = 0.0f;
} ManusQuaternion;

typedef struct ManusTransform
{
    ManusVec3 position;
    ManusQuaternion rotation;
    ManusVec3 scale;
} ManusTransform;

typedef struct Color
{
    float r; //default = 0.0f;
    float g; //default = 0.0f;
    float b; //default = 0.0f;
    float a; //default = 0.0f;
}Color;

typedef struct ManusTimestampInfo
{
    uint16_t fraction; //is either frame in timecode or miliseconds in non timecode
    uint8_t second;
    uint8_t minute;
    uint8_t hour;
    uint8_t day; //is 0 in timecode
    uint8_t month; //is 0 in timecode
    uint32_t year; //is 0 in timecode
    bool timecode;
} ManusTimestampInfo;

typedef struct ManusTimestamp
{
    uint64_t time;
} ManusTimestamp;

typedef struct IMUCalibrationInfo
{
    uint32_t mag;                   // Magnometer calibration level 0-3
    uint32_t acc;                   // Accelerometer caibraton level 0-3
    uint32_t gyr;                   // Gyroscope calibration level 0-3
    uint32_t sys;                   // System accuracy
} IMUCalibrationInfo;

typedef struct Version
{
    uint32_t major;
    uint32_t minor;
    uint32_t patch;
    char label[MAX_NUM_CHARS_IN_VERSION];
    char sha[MAX_NUM_CHARS_IN_VERSION];
    char tag[MAX_NUM_CHARS_IN_VERSION];
} Version;

typedef struct FirmwareVersion
{
    int32_t version;
    ManusTimestamp timestamp;
} FirmwareVersion;

typedef struct ManusVersion 
{
    char versionInfo[MAX_NUM_CHARS_IN_VERSION];
} ManusVersion;

typedef struct ManusHost
{
    char hostName[MAX_NUM_CHARS_IN_HOST_NAME]; // TODO utf8 compliant?
    char ipAddress[MAX_NUM_CHARS_IN_IP_ADDRESS];
    Version manusCoreVersion;
} ManusHost;

/******************************************************************************
 * Tracking
 *****************************************************************************/



typedef struct TrackerId
{
    char id[MAX_NUM_CHARS_IN_TRACKER_ID]; // todo. make this UTF8 compliant ?
} TrackerId;

typedef struct TrackerData
{
    ManusTimestamp lastUpdateTime; //default = 0;

    TrackerId trackerId;

    uint32_t userId; //default = 0; 

    bool isHmd; //default = false;
    TrackerType trackerType; //default = TrackerType::TrackerType_Unknown;

    ManusQuaternion rotation;
    ManusVec3 position;

    TrackingQuality quality; //default = TrackingQuality::TrackingQuality_Untrackable;
} TrackerData;


typedef struct TrackerStreamInfo
{
    ManusTimestamp publishTime; //default = 0;  //  DateTime.UtcNow.
    uint32_t trackerCount; //default = 0;
} TrackerStreamInfo;

// ------------------------------------------------------------------------------------------------------------------------------
// end of Tracking
// ------------------------------------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------------------------------------
// Gesture Stream
// ------------------------------------------------------------------------------------------------------------------------------

typedef struct GestureProbability
{
    uint32_t id;
    float percent;
} GestureProbability;

typedef struct GestureProbabilities
{
    uint32_t id; //default = 0;
    bool isUserID; //default = false;
    uint32_t totalGestureCount; //default = 0;
    GestureProbability gestureData[MAX_GESTURE_DATA_CHUNK_SIZE]; //default = { 0 };
    uint32_t gestureCount; //default = 0;
} GestureProbabilities;

typedef struct GestureStreamInfo
{
    ManusTimestamp publishTime; //default = 0;  //  DateTime.UtcNow.
    uint32_t gestureProbabilitiesCount; //default = 0;
} GestureStreamInfo;


// ------------------------------------------------------------------------------------------------------------------------------
// end of Gesture Stream
// ------------------------------------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------------------------------------
// Skeleton Stream
// ------------------------------------------------------------------------------------------------------------------------------

typedef struct SkeletonNode
{
    uint32_t id;
    ManusTransform transform;
} SkeletonNode;

typedef struct SkeletonInfo
{
    uint32_t id; //default = 0;
    uint32_t nodesCount; //default = 0;
    ManusTimestamp publishTime; //default = 0;  //  DateTime.UtcNow.
} SkeletonInfo;

typedef struct RawSkeletonInfo
{
    uint32_t gloveId; //default = 0;
    uint32_t nodesCount; //default = 0;
    ManusTimestamp publishTime; //default = 0;  //  DateTime.UtcNow.
} RawSkeletonInfo;

typedef struct SkeletonStreamInfo
{
    ManusTimestamp publishTime; //default = 0;  //  DateTime.UtcNow.
    uint32_t skeletonsCount; //default = 0;
} SkeletonStreamInfo;


// ------------------------------------------------------------------------------------------------------------------------------
// end of Skeleton Stream
// ------------------------------------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------------------------------------
// Ergonomics
// ------------------------------------------------------------------------------------------------------------------------------

typedef struct ErgonomicsData
{
    uint32_t id; //default = 0;
    bool isUserID; //default = false;
    float data[ErgonomicsDataType_MAX_SIZE]; //default = { 0 };
} ErgonomicsData;

typedef struct ErgonomicsStream
{
    ManusTimestamp publishTime; //default = 0;
    ErgonomicsData data[MAX_NUMBER_OF_ERGONOMICS_DATA];
    uint32_t dataCount; //default = 0;
} ErgonomicsStream;

// ------------------------------------------------------------------------------------------------------------------------------
// end of Ergonomics
// ------------------------------------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------------------------------------
// Landscape
// ------------------------------------------------------------------------------------------------------------------------------

typedef struct DongleLandscapeData
{
    uint32_t id;
    DeviceClassType classType;
    DeviceFamilyType familyType;
    bool isHaptics;

    Version hardwareVersion;
    Version firmwareVersion;
    ManusTimestamp firmwareTimestamp;

    uint32_t chargingState;

    int32_t channel;

    UpdateStatusEnum updateStatus;

    char licenseType[MAX_NUM_CHARS_IN_LICENSE_TYPE];

    ManusTimestamp lastSeen; // this may be used in playback/recording TBD

    uint32_t leftGloveID;
    uint32_t rightGloveID;

    LicenseType licenseLevel; //default = LicenseType::LicenseType_Undefined;

    uint32_t netDeviceID;
} DongleLandscapeData;

typedef struct GloveLandscapeData
{
    uint32_t id;
    DeviceClassType classType;
    DeviceFamilyType familyType;
    Side side;
    bool isHaptics;

    DevicePairedState pairedState;
    uint32_t dongleID;

    Version hardwareVersion;
    Version firmwareVersion;
    ManusTimestamp firmwareTimestamp;

    UpdateStatusEnum updateStatus;

    uint32_t batteryPercentage;
    int32_t transmissionStrength;

    IMUCalibrationInfo iMUCalibrationInfo[MAX_NUM_IMUS_ON_GLOVE];

    ManusTimestamp lastSeen; // this may be used in playback/recording TBD
    bool excluded;

    uint32_t netDeviceID;
} GloveLandscapeData;

typedef struct Measurement
{
    MeasurementType entryType; //default = MeasurementType::MeasurementType_Unknown;
    float value; //default = 0.0f;

    MeasurementUnit unit; //default = MeasurementUnit_Meters;
    MeasurementCategory category; //default = MeasurementCategory_Misc;
    char displayName[MAX_NUM_CHARS_IN_MEASUREMENT];
} Measurement;

typedef struct TrackerOffset
{
    TrackerOffsetType entryType;
    ManusVec3 translation;
    ManusQuaternion rotation;
} TrackerOffset;

typedef struct ExtraTrackerOffset
{
    ExtraTrackerOffsetType entryType; //default = ExtraTrackerOffsetType::ExtraTrackerOffsetType_Unknown;
    float value; //default = 0.0f;
} ExtraTrackerOffset;

typedef struct TrackerLandscapeData
{
    char id[MAX_NUM_CHARS_IN_TRACKER_ID];
    TrackerType type; //default = TrackerType::TrackerType_Unknown;
    TrackerSystemType systemType; //default = TrackerSystemType::TrackerSystemType_Unknown;
    uint32_t user; //default = 0;
    bool isHMD; //default = false;
    char manufacturer[MAX_NUM_CHARS_IN_TRACKER_MANUFACTURER]; // default = "Unknown"
    char productName[MAX_NUM_CHARS_IN_TRACKER_PRODUCTNAME]; // default = "Unknown"
} TrackerLandscapeData;

typedef struct UserProfileLandscapeData
{
    ProfileType profileType; //default = ProfileType::ProfileType_Hands;
    Measurement measurements[MeasurementType_MAX_SIZE];
    TrackerOffset trackerOffsets[TrackerOffsetType_MAX_SIZE];
    ExtraTrackerOffset extraTrackerOffsets[ExtraTrackerOffsetType_MAX_SIZE];
} UserProfileLandscapeData;

typedef struct UserLandscapeData
{
    uint32_t id; //default = 0;
    char name[MAX_NUM_CHARS_IN_USERNAME];
    Color color;
    uint32_t dongleID; //default = 0;
    uint32_t leftGloveID; //default = 0;
    uint32_t rightGloveID; //default = 0;
    UserProfileLandscapeData profile;
    uint32_t userIndex; //default = 0;
} UserLandscapeData;

typedef struct SkeletonLandscapeData
{
    uint32_t id; //default = 0;
    char session[MAX_NUM_CHARS_IN_HOST_NAME];
    uint32_t userId; //default = 0;
    SkeletonType type; //default = SkeletonType::SkeletonType_Invalid;
    char rootBoneName[MAX_NUM_CHARS_IN_NODE_NAME];
    bool scaled; //default = false;
} SkeletonLandscapeData;

typedef struct DeviceLandscape
{
    DongleLandscapeData dongles[MAX_NUMBER_OF_DONGLES];
    uint32_t dongleCount; //default = 0;
    GloveLandscapeData gloves[MAX_NUMBER_OF_GLOVES];
    uint32_t gloveCount; //default = 0;
} DeviceLandscape;

typedef struct UserLandscape
{
    UserLandscapeData users[MAX_USERS];
    uint32_t userCount; //default = 0;
} UserLandscape;

typedef struct SkeletonLandscape
{
    SkeletonLandscapeData skeletons[MAX_NUMBER_OF_SKELETONS];
    uint32_t skeletonCount; //default = 0;
} SkeletonLandscape;

typedef struct TrackerLandscape
{
    TrackerLandscapeData trackers[MAX_NUMBER_OF_TRACKERS];
    uint32_t trackerCount; //default = 0;
} TrackerLandscape;

typedef struct LicenseInfo
{
    bool sdkData; //default = false;
    bool recordingAndPlayback; //default = false;
    bool timeCode; //default = false;
    bool unlimitedGloves; //default = false;
    bool ergonomicData; //default = false;

    bool xsensSession; //default = false;
    bool optitrackSession; //default = false;
    bool unitySession; //default = false;
    bool unrealSession; //default = false;
    bool mobuSession; //default = false;
    bool qualisysSession; //default = false;
    bool vredSession; //default = false;
} LicenseInfo;

typedef struct SettingsLandscape
{
    Version manusCoreVersion;
    LicenseInfo license;
    bool playbackMode; //default = false;
    bool ignoreSessionTimeOuts; //default = false;
    FirmwareVersion firmwareOne;
    FirmwareVersion firmwareTwo;
    bool recordingMode; //default = false;
    bool isNetDevice; // default = false;
    bool isConnectedAsNetDevice; // default = false;
}SettingsLandscape;

typedef struct TimecodeInterface
{
    char name[MAX_NUM_CHARS_IN_TIMECODE_INTERFACE_STRINGS];
    char api[MAX_NUM_CHARS_IN_TIMECODE_INTERFACE_STRINGS];
    int index; //default = -1;
} TimecodeInterface;

typedef struct TimeLandscape
{
    TimecodeInterface interfaces[MAX_NUMBER_OF_AUDIO_INTERFACES];
    uint32_t interfaceCount; //default = 0;
    TimecodeInterface currentInterface;
    TimecodeFPS fps; //default = Undefined;
    bool fakeTimecode; //default = false;
    bool useSyncPulse; //default = false;
    bool deviceKeepAlive; //default = false;
    bool syncStatus; //default = false;
    bool timecodeStatus; //default = false;
    int32_t ltcChannel; //default = -1;
} TimeLandscape;

typedef struct GestureLandscapeData
{
    uint32_t id; //default = 0;
    char name[MAX_NUM_CHARS_IN_USERNAME];
} GestureLandscapeData;

typedef struct NetDeviceLandscapeData
{
    uint32_t netDeviceID;
    char hostname[MAX_NUM_CHARS_IN_HOST_NAME];
    char ip[MAX_NUM_CHARS_IN_IP_ADDRESS];
} NetDeviceLandscapeData;

typedef struct NetDevicesLandscape
{
    uint32_t numberOfNetDevices; // default = 0;
    NetDeviceLandscapeData netDevices[MAX_NUMBER_OF_NETDEVICES];
} NetDeviceLandscape;

typedef struct Landscape
{
    DeviceLandscape gloveDevices;
    UserLandscape users;
    SkeletonLandscape skeletons;
    TrackerLandscape trackers;
    SettingsLandscape settings;
    NetDevicesLandscape netDevices;
    TimeLandscape time;
    uint32_t gestureCount; //default = 0;
} Landscape;

// ------------------------------------------------------------------------------------------------------------------------------
// end of Landscape
// ------------------------------------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------------------------------------
// Skeleton
// ------------------------------------------------------------------------------------------------------------------------------
typedef struct NodeSettingsIK
{
    float ikAim;
} NodeSettingsIK;

typedef struct NodeSettingsFoot
{
    float heightFromGround;
} NodeSettingsFoot;

typedef struct NodeSettingsRotationOffset
{
    ManusQuaternion value;
} NodeSettingsRotationOffset;

typedef struct NodeSettingsLeaf
{
    ManusVec3 direction;
    float length;
} NodeSettingsLeaf;

typedef struct NodeSettings
{
    NodeSettingsFlag usedSettings;
    NodeSettingsIK ik;
    NodeSettingsFoot foot;
    NodeSettingsRotationOffset rotationOffset;
    NodeSettingsLeaf leaf;
} NodeSettings;

typedef struct NodeSetup
{
    uint32_t id; //default = 0;
    char name[MAX_NUM_CHARS_IN_NODE_NAME]; // this is a UTF8 string , NOT an ASCII CHAR array (same base type though)
    NodeType type; //default = NodeType::NodeType_Invalid;
    ManusTransform transform;
    uint32_t parentID; //default = 0;
    NodeSettings settings;
} NodeSetup;

typedef struct ChainSettingsPelvis
{
    float hipHeight; //default = 0.0f;
    float hipBendOffset; //default = 0.0f;
    float thicknessMultiplier; //default = 1.0f;
} ChainSettingsPelvis;

typedef struct ChainSettingsLeg
{
    bool reverseKneeDirection; //default = false;
    float kneeRotationOffset; //default = 0.0f;
    float footForwardOffset; //default = 0.0f;
    float footSideOffset; //default = 0.0f;
} ChainSettingsLeg;

typedef struct ChainSettingsSpine
{
    float spineBendOffset; //default = 0.0f;
} ChainSettingsSpine;

typedef struct ChainSettingsNeck
{
    float neckBendOffset; //default = 0.0f;
} ChainSettingsNeck;

typedef struct ChainSettingsHead
{
    float headPitchOffset; //default = 0.0f;
    float headYawOffset; //default = 0.0f;
    float headTiltOffset; //default = 0.0f;
    bool useLeafAtEnd; //default = false;
} ChainSettingsHead;

typedef struct ChainSettingsArm
{
    float armLengthMultiplier; //default = 0.0f;
    float elbowRotationOffset; //default = 0.0f;

    ManusVec3 armRotationOffset;

    ManusVec3 positionMultiplier;
    ManusVec3 positionOffset;
} ChainSettingsArm;

typedef struct ChainSettingsShoulder
{
    float forwardOffset; //default = 0.0f;
    float shrugOffset; //default = 0.0f;

    float forwardMultiplier; //default = 0.0f;
    float shrugMultiplier; //default = 0.0f;
} ChainSettingsShoulder;

typedef struct ChainSettingsFinger
{
    bool useLeafAtEnd; //default = false;
    int32_t metacarpalBoneId; //default = 0;
    int32_t handChainId; //default = 0;
    float fingerWidth; //default = 0;
} ChainSettingsFinger;

typedef struct ChainSettingsHand
{
    int32_t fingerChainIds[MAX_NUM_FINGER_IDS];
    int32_t fingerChainIdsUsed; //default = 0;
    HandMotion handMotion; //default = HandMotion::HandMotion_None;
} ChainSettingsHand;

typedef struct ChainSettingsFoot
{
    int32_t toeChainIds[MAX_NUM_TOE_IDS];
    int32_t toeChainIdsUsed; //default = 0;
} ChainSettingsFoot;

typedef struct ChainSettingsToe
{
    int32_t footChainId; //default = 0;
    bool useLeafAtEnd; //default = false;
} ChainSettingsToe;

typedef struct ChainSettings
{
    ChainType usedSettings;
    ChainSettingsPelvis pelvis;
    ChainSettingsLeg leg;
    ChainSettingsSpine spine;
    ChainSettingsNeck neck;
    ChainSettingsHead head;
    ChainSettingsArm arm;
    ChainSettingsShoulder shoulder;
    ChainSettingsFinger finger;
    ChainSettingsHand hand;
    ChainSettingsFoot foot;
    ChainSettingsToe toe;
} ChainSettings;

typedef struct ChainSetup
{
    uint32_t id; //default = 0;
    ChainType type; //default = ChainType::ChainType_Invalid;
    ChainType dataType; //default = ChainType::ChainType_Invalid;
    uint32_t dataIndex; //default = 0;
    uint32_t nodeIdCount; //default = 0;
    uint32_t nodeIds[MAX_CHAIN_LENGTH];
    ChainSettings settings;
    Side side; //default = Side::Side_Invalid;
} ChainSetup;

typedef struct SphereColliderSetup
{
    float radius; //default = 0;
} SphereColliderSetup;

typedef struct CapsuleColliderSetup
{
    float radius; //default = 0;
    float length; //default = 0;
} CapsuleColliderSetup;

typedef struct BoxColliderSetup
{
    ManusVec3 size; //default = 0,0,0;
} BoxColliderSetup;

typedef struct ColliderSetup 
{
    uint32_t nodeID; //default = 0;
    ManusVec3 localPosition; // default 0,0,0
    ManusVec3 localRotation; // default 0,0,0

    ColliderType type;//default = ColliderType::ColliderType_Invalid
    SphereColliderSetup sphere;
    CapsuleColliderSetup capsule;
    BoxColliderSetup box;
} ColliderSetup;

typedef struct Weight
{
    uint32_t nodeID;
    float weightValue;
} Weight;

typedef struct Vertex
{
    ManusVec3 position; // default 0,0,0
    uint32_t weightsCount; //default = 0;
    Weight weights[MAX_BONE_WEIGHTS_PER_VERTEX];
} Vertex;

typedef struct Triangle
{
    int32_t vertexIndex1;
    int32_t vertexIndex2;
    int32_t vertexIndex3;
} Triangle;

typedef struct SkeletonTargetUserData
{
    uint32_t userID; //default = 0;
} SkeletonTargetUserData;

typedef struct SkeletonTargetUserIndexData
{
    uint32_t userIndex; //default = 0;
} SkeletonTargetUserIndexData;

typedef struct SkeletonTargetAnimationData
{
    char id[MAX_NUM_CHARS_IN_TARGET_ID];
} SkeletonTargetAnimationData;

typedef struct SkeletonTargetGloveData
{
    uint32_t gloveID; //default = 0;
} SkeletonTargetGloveData;

typedef struct SkeletonSettings
{
    bool scaleToTarget; //default = false;
    bool useEndPointApproximations; //default = false;
    CollisionType collisionType; //default = CollisionType::CollisionType_None

    SkeletonTargetType targetType;
    SkeletonTargetUserData skeletonTargetUserData;
    SkeletonTargetUserIndexData skeletonTargetUserIndexData;
    SkeletonTargetAnimationData skeletonTargetAnimationData;
    SkeletonTargetGloveData skeletonGloveData;
} SkeletonSettings;

typedef struct SkeletonSetupInfo
{
    uint32_t id; //default = 0;
    SkeletonType type; //default = SkeletonType::SkeletonType_Invalid;
    SkeletonSettings settings;
    char name[MAX_NUM_CHARS_IN_SKELETON_NAME]; // this is a UTF8 string , NOT an ASCII CHAR array (same base type though)
} SkeletonSetupInfo;


typedef struct SkeletonSetupArraySizes
{
    uint32_t nodesCount; //default = 0;
    uint32_t chainsCount; //default = 0;
    uint32_t collidersCount; //default = 0;
    uint32_t meshCount; //default = 0;
} SkeletonSetupArraySizes;

typedef struct TemporarySkeletonInfo
{
    char name[MAX_NUM_CHARS_IN_SKELETON_NAME]; // this is a UTF8 string , NOT an ASCII CHAR array (same base type though)
    uint32_t index; //default = UINT32_MAX;
} TemporarySkeletonInfo;

typedef struct TemporarySkeletonsInfoForSession
{
    uint32_t sessionId; //default = 0;
    char sessionName[MAX_NUM_CHARS_IN_HOST_NAME];
    uint32_t skeletonCount; //default = 0;
    TemporarySkeletonInfo skeletonInfo[MAX_NUMBER_OF_SKELETONS_PER_SESSION];
} TemporarySkeletonsInfoForSession;

typedef struct TemporarySkeletonCountForSession
{
    uint32_t sessionId; //default = 0;
    char sessionName[MAX_NUM_CHARS_IN_HOST_NAME];
    uint32_t skeletonCount; //default = 0;
} TemporarySkeletonCountForSession;

typedef struct TemporarySkeletonCountForAllSessions
{
    uint32_t sessionsCount; //default = 0;
    TemporarySkeletonCountForSession temporarySkeletonCountForSessions[MAX_NUMBER_OF_SESSIONS];
} TemporarySkeletonCountForAllSessions;

typedef struct TemporarySkeletonSessionsData
{
    uint32_t sessionsCount; //default = 0;
    TemporarySkeletonsInfoForSession temporarySkeletonsSessions[MAX_NUMBER_OF_SESSIONS];
} TemporarySkeletonSessionsData;

typedef struct SystemMessage
{
    SystemMessageType type;
    char infoString[MAX_NUM_CHARS_IN_SYSTEM_ERROR_MESSAGE];
    uint32_t infoUInt;
} SystemMessage;

typedef struct NodeInfo
{
    uint32_t nodeId; //default = 0;
    uint32_t parentId; //default = 0;
    ChainType chainType;
    Side side;
    FingerJointType fingerJointType;
}NodeInfo;

// ------------------------------------------------------------------------------------------------------------------------------
// end of Skeleton
// ------------------------------------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------------------------------------
// Coordinate system settings
// ------------------------------------------------------------------------------------------------------------------------------

typedef struct CoordinateSystemVUH
{
    AxisView view;
    AxisPolarity up;
    Side handedness;
    float unitScale; // in meters
} CoordinateSystemVUH;

typedef struct CoordinateSystemDirection
{
    AxisDirection x;
    AxisDirection y;
    AxisDirection z;
    float unitScale; // in meters
} CoordinateSystemDirection;

// ------------------------------------------------------------------------------------------------------------------------------
// end of Coordinate system settings
// ------------------------------------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------------------------------------
// Callbacks
// ------------------------------------------------------------------------------------------------------------------------------

typedef void(*ConnectedToCoreCallback_t)(const ManusHost* const p_Host);
typedef void(*DisconnectedFromCoreCallback_t)(const ManusHost* const p_Host);
typedef void(*SkeletonStreamCallback_t)(const SkeletonStreamInfo* const p_SkeletonInfo);
typedef void(*LandscapeStreamCallback_t)(const Landscape* const p_Landscape);
typedef void(*TrackerStreamCallback_t)(const TrackerStreamInfo* const p_TrackerStreamInfo);
typedef void(*ErgonomicsStreamCallback_t)(const ErgonomicsStream* const p_Ergonomics);
typedef void(*SystemStreamCallback_t)(const SystemMessage* const p_SystemMessage);
typedef void(*RawSkeletonStreamCallback_t)(const SkeletonStreamInfo* const p_SkeletonInfo);
typedef void(*GestureStreamCallback_t)(const GestureStreamInfo* const p_GestureStream);

// ------------------------------------------------------------------------------------------------------------------------------
// end of Callbacks
// ------------------------------------------------------------------------------------------------------------------------------
#ifdef __cplusplus
} // extern "C"
#endif

#endif // #ifndef H_CORESDKWRAPPERTYPES