File CoreConnection.hpp
File List > api > cppSDK > SDKBase > CoreConnection.hpp
Go to the documentation of this file
#ifndef __CORE_CONNECTION_HPP__
#define __CORE_CONNECTION_HPP__
#include <map>
#include <mutex>
#include <string>
#include <unordered_set>
#include <vector>
#include "ManusSDKTypes.h"
#include "ManusSDKExtendedTypes.h"
namespace ManusSDK
{
class CoreConnection
{
public:
CoreConnection();
virtual ~CoreConnection();
virtual SDKReturnCode ConnectToHost(const ManusHost& p_Host);
virtual SDKReturnCode ConnectToPresetGRPC();
virtual SDKReturnCode Disconnect();
virtual SDKReturnCode GetIsConnectedToCore(bool& p_IsConnected);
virtual SDKReturnCode GetVersionsAndCheckCompatibility(ManusVersion& p_SdkVersion, ManusVersion& p_CoreVersion, bool& p_AreVersionsCompatible);
virtual SDKReturnCode GetSessionId(uint32_t& p_SessionId);
//@brief Underlying function will sleep for p_WaitSeconds to allow servers to reply
virtual SDKReturnCode LookForHosts(uint32_t p_WaitSeconds = SECONDS_TO_FIND_HOSTS, bool p_LoopbackOnly = false);
virtual SDKReturnCode GetNumberOfAvailableHostsFound(uint32_t& p_NumberOfAvailableHostsFound) const;
virtual SDKReturnCode GetAvailableHostsFound(ManusHost* p_AvailableHostsFound, const uint32_t p_NumberOfHostsThatFitInArray) const;
virtual bool IsLookingForHosts();
SDKReturnCode SetSessionType(SessionType p_SessionType);
SDKReturnCode SetSessionTypeID(uint32_t p_SessionTypeID, const char* p_Secret);
virtual SDKReturnCode SetSettingsLocation(const char* p_SettingsLocation);
SDKReturnCode SetCoordinateSystem(CoordinateSystemVUH& p_CoordinateSystem, bool p_UseWorldCoordinates);
SDKReturnCode SetCoordinateSystem(CoordinateSystemDirection& p_CoordinateSystem, bool p_UseWorldCoordinates);
// Callbacks
virtual SDKReturnCode RegisterCallbackForOnConnect(ConnectedToCoreCallback_t p_OnConnectionCallback);
virtual SDKReturnCode RegisterCallbackForOnDisconnect(DisconnectedFromCoreCallback_t p_OnDisconnectionCallback);
virtual SDKReturnCode RegisterCallbackForLandscapeStream(const LandscapeStreamCallback_t p_LandscapeStreamCallback);
virtual SDKReturnCode RegisterCallbackForSkeletonStream(const SkeletonStreamCallback_t p_SkeletonStreamCallback);
virtual SDKReturnCode RegisterCallbackForTrackerStream(const TrackerStreamCallback_t p_TrackerStreamCallback);
virtual SDKReturnCode RegisterCallbackForSystemStream(const SystemStreamCallback_t p_SystemStreamCallback);
virtual SDKReturnCode RegisterCallbackForDebuggingStream(const DebuggingStreamCallback_t p_DebuggingStreamCallback);
virtual SDKReturnCode RegisterCallbackForErgonomicsStream(const ErgonomicsStreamCallback_t p_ErgonomicsStreamCallback);
virtual SDKReturnCode RegisterCallbackForExtraDataStream(const ExtraDataStreamCallback_t p_ExtraDataStreamCallback);
virtual SDKReturnCode RegisterCallbackForStatisticsStream(const StatisticsStreamCallback_t p_StatisticsStreamCallback);
virtual SDKReturnCode RegisterCallbackForGestureStream(const GestureStreamCallback_t p_GestureStreamCallback);
virtual SDKReturnCode RegisterCallbackForRawSkeletonStream(const RawSkeletonStreamCallback_t p_RawSkeletonStreamCallback);
virtual SDKReturnCode RegisterCallbackForRawDeviceDataStream(const RawDeviceDataStreamCallback_t p_RawDeviceDataStreamCallback);
// -----------------------------------------------------------------------------------------
// Wrapper methods
// -----------------------------------------------------------------------------------------
// Haptics - the exception to the rest of manus core architecture and a legacy hold over from the olden days.
virtual SDKReturnCode VibrateFingers(uint32_t p_DongleId, Side p_HandType, const float* p_Powers);
virtual SDKReturnCode VibrateFingersForGlove(uint32_t p_GloveId, const float* p_Powers);
virtual SDKReturnCode VibrateFingersForSkeleton(uint32_t p_SkeletonId, Side p_HandType, const float* p_Powers);
virtual SDKReturnCode UpdateCore(bool p_CheckOnly, UpdateCoreResponse& p_Response);
virtual SDKReturnCode UpdateTrackers(const TrackerData* p_TrackerData, uint32_t p_NumberOfTrackers);
virtual SDKReturnCode SetTrackerOffset(uint32_t p_UserId, const TrackerOffset* p_TrackerOffset);
virtual SDKReturnCode RefreshTrackingSystems();
// Skeletons
virtual SDKReturnCode CreateSkeletonSetup(const SkeletonSetupInfo& p_Skeleton, uint32_t& p_SkeletonSetupIndex);
virtual SDKReturnCode AddNodeToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const NodeSetup& p_Node);
virtual SDKReturnCode OverwriteSkeletonSetup(uint32_t p_SkeletonSetupIndex, const SkeletonSetupInfo& p_Skeleton);
virtual SDKReturnCode OverwriteChainToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const ChainSetup& p_Chain);
virtual SDKReturnCode OverwriteNodeToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const NodeSetup& p_Node);
virtual SDKReturnCode AddChainToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const ChainSetup& p_Chain);
virtual SDKReturnCode AddColliderToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const ColliderSetup& p_Collider);
virtual SDKReturnCode AddMeshSetupToSkeletonSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_NodeId, uint32_t& p_MeshSetupIndex);
virtual SDKReturnCode AddVertexToMeshSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, const Vertex& p_Vertex);
virtual SDKReturnCode AddTriangleToMeshSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, const Triangle& p_Triangle);
virtual SDKReturnCode GetMeshSetupInfo(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, MeshSetupInfo& p_MeshSetupInfo);
virtual SDKReturnCode GetVertexData(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, uint32_t p_VertexIndex, Vertex& p_Vertex);
virtual SDKReturnCode GetTriangleData(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, uint32_t p_TriangleIndex, Triangle& p_Triangle);
virtual SDKReturnCode LoadSkeleton(uint32_t p_SkeletonSetupIndex, uint32_t& p_SkeletonId);
virtual SDKReturnCode UnloadSkeleton(uint32_t p_SkeletonId);
virtual SDKReturnCode SaveTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, bool p_IsSkeletonModified);
virtual SDKReturnCode CompressTemporarySkeletonAndGetSize(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, uint32_t* p_TemporarySkeletonLengthInBytes);
virtual SDKReturnCode GetCompressedTemporarySkeletonData(unsigned char* p_TemporarySkeletonData, uint32_t p_TemporarySkeletonLengthInBytes);
virtual SDKReturnCode GetTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId);
virtual SDKReturnCode GetTemporarySkeletonFromCompressedData(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, unsigned char* p_RecordingData, uint32_t p_RecordingLengthInBytes);
virtual SDKReturnCode ClearTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId);
virtual SDKReturnCode ClearAllTemporarySkeletons();
virtual SDKReturnCode GetTemporarySkeletonCountForAllSessions(TemporarySkeletonCountForAllSessions& p_TemporarySkeletonCountForAllSessions);
virtual SDKReturnCode GetTemporarySkeletonsInfoForSession(uint32_t p_SessionId, TemporarySkeletonsInfoForSession& p_TemporarySkeletonsInfoForSession);
virtual SDKReturnCode AllocateChains(uint32_t p_SkeletonSetupIndex);
virtual SDKReturnCode PrepareSkeleton(uint32_t p_SkeletonSetupIndex);
virtual SDKReturnCode GetSkeletonSetupInfo(uint32_t p_SkeletonSetupIndex, SkeletonSetupInfo* p_SDK);
virtual SDKReturnCode GetSkeletonSetupArraySizes(uint32_t p_SkeletonSetupIndex, SkeletonSetupArraySizes& p_SkeletonInfo);
virtual SDKReturnCode GetSkeletonChains(uint32_t p_SkeletonSetupIndex, ChainSetup* p_SDK);
virtual SDKReturnCode GetSkeletonChains(uint32_t p_SkeletonSetupIndex, ChainSetup* p_ChainSetupArray, uint32_t p_ArraySize);
virtual SDKReturnCode GetSkeletonNodes(uint32_t p_SkeletonSetupIndex, NodeSetup* p_SDK);
virtual SDKReturnCode GetSkeletonNodes(uint32_t p_SkeletonSetupIndex, NodeSetup* p_NodeSetupArray, uint32_t p_ArraySize);
virtual SDKReturnCode GetSkeletonColliders(uint32_t p_SkeletonSetupIndex, ColliderSetup* p_SDK);
virtual SDKReturnCode CalibrateHapticsModule(uint32_t p_DongleId, Side p_HandType);
virtual SDKReturnCode SetDonglePolygon(const DonglePolygonArgs& p_Args, SetPolygonDongleResponse& p_SetPolygonDongleResponse);// (license)
virtual SDKReturnCode Pair(const PairingArgs& p_Args);
virtual SDKReturnCode Unpair(const PairingArgs& p_Args);
virtual SDKReturnCode CalibrationSetMin(const CalibrationArgs& p_Args, bool& p_CommandResponse);
virtual SDKReturnCode CalibrationSetMax(const CalibrationArgs& p_Args, bool& p_CommandResponse);
virtual SDKReturnCode CalibrationStore(const CalibrationArgs& p_Args, bool& p_CommandResponse);
virtual SDKReturnCode CalibrationBegin(const CalibrationArgs& p_Args, bool& p_CommandResponse);
virtual SDKReturnCode CalibrationEnd(const CalibrationArgs& p_Args, bool& p_CommandResponse);
virtual SDKReturnCode CalibrationDataGet(const CalibrationArgs& p_Args, CalibrationData& p_CalibrationData);
virtual SDKReturnCode CalibrationDataSet(const CalibrationArgs& p_Args, bool& p_CommandResponse);
virtual SDKReturnCode UpdateDongleFirmware(const DongleUpdateArgs& p_Args, DongleUpdateResponse& p_DongleUpdateResponse);
virtual SDKReturnCode StartQuantumCalibration(const StartQuantumCalibrationArgs& p_Args, bool& p_CommandResponse);
virtual SDKReturnCode StartQuantumCalibrationStep(const StartQuantumCalibrationStepArgs& p_Args, bool& p_CommandResponse);
virtual SDKReturnCode StopQuantumCalibration(uint32_t p_GloveID, bool& p_CommandResponse);
virtual SDKReturnCode GetGloveCalibrationSize(uint32_t p_GloveId, uint32_t* p_Size);
virtual SDKReturnCode GetGloveCalibrationSizeForUser(uint32_t p_UserId, Side p_Side, GloveProfileType p_ProfileType, uint32_t* p_Size);
virtual SDKReturnCode GetGloveCalibration(unsigned char* p_CalibrationBytes, uint32_t p_BytesLength);
virtual SDKReturnCode SetGloveCalibration(uint32_t p_GloveId, unsigned char* p_CalibrationBytes, uint32_t p_BytesLength, SetGloveCalibrationReturnCode& p_Response);
virtual SDKReturnCode SetGloveCalibrationForUser(uint32_t p_UserId, unsigned char* p_CalibrationBytes, uint32_t p_BytesLength, SetGloveCalibrationReturnCode& p_Response);
virtual SDKReturnCode GetBandScan(BandScanArgs& p_BandScanArgs, int32_t& p_BandScanType, unsigned char* p_BandScanData);
virtual SDKReturnCode SetChannel(uint32_t p_Channel, uint32_t p_DongleId, bool& p_Success);
virtual SDKReturnCode SetPersistentDongleChannels(bool p_SetPersistent);
virtual SDKReturnCode AreDongleChannelsPersistent(bool& p_IsPersistent);
virtual SDKReturnCode SetEnableVirtualDongles(bool p_Enable);
virtual SDKReturnCode AreVirtualDonglesEnabled(bool& p_IsEnabled);
virtual SDKReturnCode SetSettingIgnoreThumbIMU(bool p_IgnoreThumbIMU);
virtual SDKReturnCode GetSettingIgnoreThumbIMU(bool& p_IgnoreThumbIMU);
virtual SDKReturnCode SetSettingIgnoreNonThumbFingerIMU(bool p_IgnoreNonThumbFingerIMU);
virtual SDKReturnCode GetSettingIgnoreNonThumbFingerIMU(bool& p_IgnoreNonThumbFingerIMU);
virtual SDKReturnCode SetSettingPinchCompensation(bool p_PinchCompensation);
virtual SDKReturnCode GetSettingPinchCompensation(bool& p_PinchCompensation);
virtual SDKReturnCode AssignProfileToUser(UserProfileArgs p_UserProfileArgs, CompleteType& p_Message);
virtual SDKReturnCode GetCalibrationProfile(uint32_t p_UserId, CalibrationProfile& p_CalibrationProfile);
virtual SDKReturnCode IsUserUsingHMD(bool& p_IsUsingHMD, uint32_t p_UserId);
virtual SDKReturnCode AutoGroupTrackers();
virtual SDKReturnCode AutoAssignTrackers(uint32_t p_UserId);
virtual SDKReturnCode ResetTrackerAssignment(uint32_t p_UserId);
virtual SDKReturnCode AssignTrackerToUser(TrackerId p_TrackerId, uint32_t p_UserId);
virtual SDKReturnCode AssignRoleToTracker(TrackerId p_TrackerId, TrackerType p_TrackerType);
virtual SDKReturnCode ChangeUserForRole(TrackerType p_Role, uint32_t p_CurrentUser, uint32_t p_TargetUser);
virtual SDKReturnCode GetTrackingSystems(TrackingSystemInfo& p_Current, TrackingSystemInfo* p_Systems);
virtual SDKReturnCode KeepLastPosition(bool p_UseLastPosition);
virtual SDKReturnCode UseTimeout(bool p_UseTimeOut);
virtual SDKReturnCode SetTimeout(float p_TimeOut);
virtual SDKReturnCode GetTrackerServiceSettings(bool& p_UseTimeout, float& p_Timeout, bool& p_KeepLastPosition);
virtual SDKReturnCode GetTrackerSystemsSettings(TrackerSystem* p_TrackerSystems, uint32_t& p_TrackerSystemCount);
virtual SDKReturnCode SetTrackerSystemsSettings(TrackerSystem* p_TrackerSystems);
// polygon calibration
virtual SDKReturnCode StartSequence(StartSequenceArg p_Args, SequenceData& p_SequenceData);
virtual SDKReturnCode StopSequence(uint32_t p_Id, CompleteType& p_Message);
virtual SDKReturnCode StartNextStep(uint32_t p_Id, CompleteType& p_Message);
virtual SDKReturnCode UndoStep(uint32_t p_Id, CompleteType& p_Message);
virtual SDKReturnCode GetSequenceState(uint32_t p_Id, SequenceStateValue& p_SequenceStateValue);
virtual SDKReturnCode GetStepData(uint32_t p_Id, StepData& p_StepData);
virtual SDKReturnCode ApplyProfile(uint32_t p_Id, CompleteType& p_Message);
// Extended telemetry
virtual SDKReturnCode ReportFeatureUsage(FeatureUsed p_Feature, bool& p_CommandResponse);
virtual SDKReturnCode ReportExportFeatureUsage(ExportFeatureReport p_Report, bool& p_CommandResponse);
virtual SDKReturnCode ReportExportCSVFeatureUsage(ExportCSVFeatureReport p_Report, bool& p_CommandResponse);
virtual SDKReturnCode ReportOpenXRFeatureUsage(OpenXRFeatureReport p_Report, bool& p_CommandResponse);
//Playback Recording
virtual SDKReturnCode StartRecording(bool& p_Success);
virtual SDKReturnCode StopRecording(bool& p_Success);
virtual SDKReturnCode UnloadRecording(bool& p_Success);
virtual SDKReturnCode StartPlayback(bool& p_Success);
virtual SDKReturnCode EnablePlayback(bool& p_Success);
virtual SDKReturnCode StopPlayback(bool& p_Success);
virtual SDKReturnCode SeekFrame(SeekFrameInfo p_SeekFrameInfo, ManusTimestamp& p_Timestamp);
virtual SDKReturnCode StartPlaybackFromSpecificTime(uint32_t p_PlaybackStartingTime, bool& p_Success);
virtual SDKReturnCode GetCurrentRecordingProperties(PlaybackRecordingProperties& p_RecordingProperties);
virtual SDKReturnCode SaveRecordingToFile(char* p_PathName, bool& p_Success);
virtual SDKReturnCode LoadRecordingFromFile(char* p_PathName, bool& p_Success);
virtual SDKReturnCode ZipRecordingDataAndGetSize(uint32_t& p_RecordingLengthInBytes);
virtual SDKReturnCode GetRecordingData(unsigned char* p_RecordingData, uint32_t p_RecordingSize);
virtual SDKReturnCode LoadRecordingFromClientFile(unsigned char* p_RecordingData, uint32_t p_RecordingLengthInBytes, bool& p_Success);
//Timecode
virtual SDKReturnCode UseTimecodeTimestamps(bool p_Use);
virtual SDKReturnCode IsUsingTimecodeTimestamps(bool& p_IsUsing);
virtual SDKReturnCode StartTimecode(StartTimecodeArgs p_Args, bool& p_Success);
virtual SDKReturnCode StopTimecode(bool& p_Success);
virtual SDKReturnCode RefreshTimecodeInterfaces(bool p_Reconnect, bool& p_Success);
virtual SDKReturnCode IsTimecodeRunning(bool& p_Running);
virtual SDKReturnCode SetTimecodeAutoStart(bool p_Enabled, bool& p_Success);
virtual SDKReturnCode GetTimecodeAutoStart(bool& p_Enabled);
virtual SDKReturnCode SetTimecodeDeviceKeepAlive(bool p_Enabled, bool& p_Success);
virtual SDKReturnCode GetTimecodeDeviceKeepAlive(bool& p_Enabled);
virtual SDKReturnCode SetTimecodeGenlock(bool p_Enabled, bool& p_Success);
virtual SDKReturnCode GetTimecodeGenlock(bool& p_Enabled);
virtual SDKReturnCode SetTimecodeNonRealTime(bool p_Enabled, bool& p_Success);
virtual SDKReturnCode GetTimecodeNonRealTime(bool& p_Enabled);
virtual SDKReturnCode SetLtcChannel(int32_t p_Channel, bool& p_Success);
virtual SDKReturnCode GetLtcChannel(int32_t& p_Channel);
virtual SDKReturnCode SetTimecodePreferredInterfaceAPI(char* p_Name, bool& p_Success);
virtual SDKReturnCode GetTimecodePreferredInterfaceAPI(char* p_Name);
virtual SDKReturnCode SetTimecodePreferredInterfaceName(char* p_Name, bool& p_Success);
virtual SDKReturnCode GetTimecodePreferredInterfaceName(char* p_Name);
virtual SDKReturnCode GetNumberOfAvailableGloves(uint32_t& p_NumberOfAvailableGloves);
virtual SDKReturnCode GetIdsOfAvailableGloves(uint32_t* p_IdsOfAvailableGloves, uint32_t p_NumberOfIdsThatFitInArray);
virtual SDKReturnCode GetGlovesForDongle(uint32_t p_DongleId, uint32_t& p_LeftGloveId, uint32_t& p_RightGloveId);
// Glove data
virtual SDKReturnCode GetDataForGlove(uint32_t p_GloveId, GloveLandscapeData& p_GloveData);
virtual SDKReturnCode GetDataForDongle(uint32_t p_DongleId, DongleLandscapeData& p_DongleData);
virtual SDKReturnCode SetRawSkeletonPinchCompensation(bool p_Enable);
virtual SDKReturnCode GetRawSkeletonPinchCompensation(bool& p_Enabled);
virtual SDKReturnCode SetRawSkeletonCasingCompensation(float p_FilterStrength);
virtual SDKReturnCode GetRawSkeletonCasingCompensation(float& p_FilterStrength);
// Dongles
virtual SDKReturnCode GetDongleIds(uint32_t* p_DongleIds, uint32_t p_NumberOfIdsThatFitInArray);
virtual SDKReturnCode GetHapticsDongleIds(uint32_t* p_HapticsDongleIds, uint32_t p_NumberOfIdsThatFitInArray);
virtual SDKReturnCode GetNumberOfDongles(uint32_t& p_NumberOfDongles);
virtual SDKReturnCode GetNumberOfHapticsDongles(uint32_t& p_NumberOfHapticsDongles);
// Users
virtual SDKReturnCode GetNumberOfAvailableUsers(uint32_t& p_NumberOfAvailableUsers);
virtual SDKReturnCode GetIdsOfAvailableUsers(uint32_t* p_IdsOfAvailableUsers, uint32_t p_NumberOfIdsThatFitInArray);
virtual SDKReturnCode GetGloveIdOfUserId(uint32_t p_UserId, Side p_HandType, uint32_t& p_GloveId);
virtual SDKReturnCode AddUser(char* p_Name, uint32_t& p_UserID);
virtual SDKReturnCode RemoveUser(uint32_t p_Id);
virtual SDKReturnCode SetUserName(uint32_t p_Id, char* p_Name);
virtual SDKReturnCode SetAutoUserAssignment(bool p_Enabled);
virtual SDKReturnCode AssignDongleToUser(uint32_t p_Id, uint32_t p_DongleId);
virtual SDKReturnCode AssignGloveToUser(uint32_t p_UserId, uint32_t p_GloveId, Side p_Side);
virtual SDKReturnCode MoveUserUp(uint32_t p_Id);
virtual SDKReturnCode MoveUserDown(uint32_t p_Id);
// Trackers
virtual SDKReturnCode GetNumberOfAvailableTrackers(uint32_t& p_NumberOfAvailableTrackers);
virtual SDKReturnCode GetIdsOfAvailableTrackers(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_NumberOfIdsThatFitInArray);
virtual SDKReturnCode GetNumberOfAvailableTrackersForUserId(uint32_t& p_NumberOfAvailableTrackers, uint32_t p_UserId);
virtual SDKReturnCode GetIdsOfAvailableTrackersForUserId(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_UserId, uint32_t p_NumberOfIdsThatFitInArray);
virtual SDKReturnCode GetNumberOfAvailableTrackersForUserIndex(uint32_t& p_NumberOfAvailableTrackers, uint32_t p_UserIndex);
virtual SDKReturnCode GetIdsOfAvailableTrackersForUserIndex(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_UserIndex, uint32_t p_NumberOfIdsThatFitInArray);
virtual SDKReturnCode GetDataForTracker(TrackerId p_TrackerId, TrackerData& p_TrackerData);
virtual SDKReturnCode GetDataForTracker(uint32_t p_UserId, uint32_t p_TrackerType, TrackerData& p_TrackerData);
virtual SDKReturnCode GetTrackerData(uint32_t p_TrackerIndex, TrackerData& p_TrackerData);
// Pairing
virtual SDKReturnCode PairGlove(uint32_t p_GloveID, bool& p_Result);
virtual SDKReturnCode PairGloveToDongle(uint32_t p_GloveID, uint32_t p_DongleID, bool& p_Result);
virtual SDKReturnCode UnpairGlove(uint32_t p_GloveID, bool& p_Result);
// Glove Calibration
virtual SDKReturnCode GloveCalibrationStart(GloveCalibrationArgs p_CalibrationArgs, bool& p_Result);
virtual SDKReturnCode GloveCalibrationStop(GloveCalibrationArgs p_CalibrationArgs, bool& p_Result);
virtual SDKReturnCode GloveCalibrationFinish(GloveCalibrationArgs p_CalibrationArgs, bool& p_Result);
virtual SDKReturnCode GloveCalibrationGetNumberOfSteps(GloveCalibrationArgs p_CalibrationArgs, uint32_t& p_NumberOfSteps);
virtual SDKReturnCode GloveCalibrationGetStepData(GloveCalibrationStepArgs p_CalibrationStepArgs, GloveCalibrationStepData& p_Data);
virtual SDKReturnCode GloveCalibrationStartStep(GloveCalibrationStepArgs p_CalibrationStepArgs, bool& p_Result);
// Gestures
virtual SDKReturnCode GetGestureLandscapeData(GestureLandscapeData* p_LandscapeDataArray, uint32_t p_ArraySize);
// Skeletons
virtual SDKReturnCode DoesSkeletonGloveSupportHaptics(uint32_t p_SkeletonId, Side p_HandType, bool& p_IsHaptics);
virtual SDKReturnCode GetSkeletonInfo(uint32_t p_SkeletonIndex, SkeletonInfo& p_Info);
virtual SDKReturnCode GetSkeletonData(uint32_t p_SkeletonIndex, SkeletonNode* p_Nodes, uint32_t p_NodeCount);
virtual SDKReturnCode SetRawSkeletonHandMotion(HandMotion p_HandMotion);
virtual SDKReturnCode GetRawSkeletonHandMotion(HandMotion& p_HandMotion);
virtual SDKReturnCode GetRawSkeletonInfo(uint32_t p_SkeletonIndex, RawSkeletonInfo& p_Info);
virtual SDKReturnCode GetRawSkeletonData(uint32_t p_SkeletonIndex, SkeletonNode* p_Nodes, uint32_t p_NodeCount);
virtual SDKReturnCode GetRawSkeletonNodeCount(uint32_t p_GloveId, uint32_t& p_NodeCount);
virtual SDKReturnCode GetRawSkeletonNodeInfo(uint32_t p_GloveId, NodeInfo* p_NodeInfo);
virtual SDKReturnCode GetRawSkeletonNodeInfo(uint32_t p_GloveId, NodeInfo* p_NodeInfo, uint32_t p_NodeCount);
virtual SDKReturnCode GetRawDeviceData(uint32_t p_RawDeviceDataIndex, RawDeviceData& p_RawDeviceData);
virtual SDKReturnCode GetExtraDeviceData(uint32_t p_ExtraDeviceDataIndex, ExtraDeviceData& p_Data);
virtual SDKReturnCode GetStatistics(StatisticsStream* p_Statistics);
virtual SDKReturnCode GetDebuggingData(uint32_t p_StartIndex, DebuggingData& p_DebuggingData);
virtual SDKReturnCode GetGestureStreamData(uint32_t p_GestureStreamDataIndex, uint32_t p_StartDataIndex, GestureProbabilities& p_GestureProbabilitiesCollection);
virtual SDKReturnCode SetSettingsRawSkeletonStream(bool p_StreamActive);
virtual SDKReturnCode GetSettingsRawSkeletonStream(bool& p_StreamActive);
// Multicore netdevices
virtual SDKReturnCode NetDeviceGetNumberOfAvailableHosts(uint32_t& p_NumberOfAvailableHosts);
virtual SDKReturnCode NetDeviceGetAvailableHosts(ManusHost* p_Hosts, const uint32_t p_NumberOfAvailableHosts);
virtual SDKReturnCode NetDeviceConnect(ManusHost p_Host);
virtual SDKReturnCode NetDeviceDisconnect(ManusHost p_Host);
virtual SDKReturnCode SetNetDeviceMode(bool p_Client);
virtual SDKReturnCode GetNetDeviceMode(bool& p_Client);
virtual SDKReturnCode SetNetDeviceAutoconnectPolicy(bool p_Autoconnect);
virtual SDKReturnCode GetNetDeviceAutoconnectPolicy(bool& p_Autoconnect);
protected:
CoreConnection(const CoreConnection& p_ToCopy) = delete; // Preventing Copy.
CoreConnection& operator=(const CoreConnection& p_ToCopy) = delete; // Preventing Copy.
CoreConnection(CoreConnection&& p_ToMoveFrom) = delete; // Preventing move.
CoreConnection& operator=(CoreConnection&& p_ToMoveFrom) = delete; // Preventing move.
std::string FormRandomizedClientName();
std::string GetClientInfo();
SessionType m_SessionType = SessionType::SessionType_Unknown;
uint32_t m_SessionTypeId;
std::string m_Secret;
bool m_IsCoordinateSystemSet = false;
bool m_IsUsingVUH = true;
bool m_UseWorldCoordinates = true;
CoordinateSystemVUH m_CoordinateSystemVUH;
CoordinateSystemDirection m_CoordinateSystemDirection;
};
} // namespace ManusSDK
#endif // #ifndef HPP_CORECONNECTION