File ManusSDK.cpp

File List > api > cppSDK > SDKBase > ManusSDK.cpp

Go to the documentation of this file

//If ALWAYS_USE_CORE_LITE is defined we will ALWAYS use core lite, even if Remote is available
//#define ALWAYS_USE_CORE_LITE

#include "ManusSDKTypes.h"
#include "ManusSDKExtendedTypes.h"

#include "ManusSDK.h"
#include "ManusSDKExtended.h"
#include "ManusSDKIntegrationPartner.h"

#include <cstdio>
#include <memory>
#include <thread>

#include "CoreConnection.hpp"

#ifdef _MANUS_CORE_LITE
#include "CoreLite/CoreLiteConnection.hpp"
#endif

#ifdef _MANUS_CORE_REMOTE
#include "CoreRemote/CoreRemoteConnection.hpp"
#endif

std::unique_ptr<ManusSDK::CoreConnection> s_CoreConnection;

#include "Logging.hpp"

// Note that the following warnings are disabled in the project settings, due to issues with the ManusSDK library:
// "warning LNK4099: PDB '[...].pdb' was not found with '[...].lib([...].obj)' or at '[...].pdb'; linking object as if no debug info"
// "warning LNK4217: symbol '[...]' defined in '[...].lib([...].obj)' is imported by '[...].lib([...].obj)' in function '[...]'"
// These settings can be found under Project->Properties->Linker->Command Line.

SDKReturnCode CoreSdk_InitializeCore()
{
    if (!s_CoreConnection)
    {
#ifdef _MANUS_CORE_REMOTE
        s_CoreConnection = std::make_unique<CoreRemote::CoreRemoteConnection>();
#else
        return SDKReturnCode::SDKReturnCode_InvalidArgument;
#endif
        return SDKReturnCode::SDKReturnCode_Success;
    }
    return SDKReturnCode::SDKReturnCode_FunctionCalledAtWrongTime;
}

SDKReturnCode CoreSdk_InitializeIntegrated()
{
    if (!s_CoreConnection)
    {
#ifdef _MANUS_CORE_LITE
        s_CoreConnection = std::make_unique<CoreLite::CoreLiteConnection>();
        s_CoreConnection->SetSessionType(SessionType_CoreSDK);
#else
        return SDKReturnCode::SDKReturnCode_InvalidArgument;
#endif
        return SDKReturnCode::SDKReturnCode_Success;
    }
    return SDKReturnCode::SDKReturnCode_FunctionCalledAtWrongTime;
}

SDKReturnCode CoreSdk_ShutDown()
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    s_CoreConnection.reset();
    return SDKReturnCode::SDKReturnCode_Success;
}

SDKReturnCode CoreSdk_SetSessionType(SessionType p_SessionType)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetSessionType(p_SessionType);
}

SDKReturnCode CoreSdk_SetSettingsLocation(const char* p_SettingsLocation)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetSettingsLocation(p_SettingsLocation);
}

SDKReturnCode CoreSdk_SetSessionTypeID(uint32_t p_SessionTypeID, const char* p_Secret)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetSessionTypeID(p_SessionTypeID, p_Secret);
}

SDKReturnCode CoreSdk_WasDllBuiltInDebugConfiguration(bool* p_WasBuiltInDebugConfiguration)
{
#if defined(_DEBUG) || defined(DEBUG)
    *p_WasBuiltInDebugConfiguration = true;
#else
    * p_WasBuiltInDebugConfiguration = false;
#endif 

    return SDKReturnCode::SDKReturnCode_Success;
}

SDKReturnCode CoreSdk_GetTimestampInfo(ManusTimestamp p_Timestamp, ManusTimestampInfo* p_Info)
{
    //Bits... Max numbers:
    // 1(1) 3(2) 7(3) 15(4) 31(5) 63(6) 127(7) 255(8) 511(9) 1023(10)
    // 2047(11) 4095(12) 8191(13) 16383(14) 32767(15) 65535(16) 131071(17) 262143(18) 524287(19) 1048575(20)
    p_Info->fraction = (uint64_t)p_Timestamp.time & 1023; //10 bits

    p_Info->second = ((uint64_t)p_Timestamp.time >> 10) & 63; //6 bits

    p_Info->minute = ((uint64_t)p_Timestamp.time >> 16) & 63; //6 bits

    p_Info->hour = ((uint64_t)p_Timestamp.time >> 22) & 31; //5 bits

    p_Info->day = ((uint64_t)p_Timestamp.time >> 27) & 31; //5 bits

    p_Info->month = ((uint64_t)p_Timestamp.time >> 32) & 15; //4 bits

    p_Info->year = ((uint64_t)p_Timestamp.time >> 36) & 1048575; //20 bits

    p_Info->timecode = (((uint64_t)p_Timestamp.time >> 56) & 1) == 1;

    return SDKReturnCode::SDKReturnCode_Success;
}

SDKReturnCode CoreSdk_SetTimestampInfo(ManusTimestamp* p_Timestamp, ManusTimestampInfo p_Info)
{
    //Bits... Max numbers:
    // 1(1) 3(2) 7(3) 15(4) 31(5) 63(6) 127(7) 255(8) 511(9) 1023(10)
    // 2047(11) 4095(12) 8191(13) 16383(14) 32767(15) 65535(16) 131071(17) 262143(18) 524287(19) 1048575(20)
    SDKReturnCode t_Res = SDKReturnCode::SDKReturnCode_Success;
    if (p_Info.fraction > 999)
    {
        t_Res = SDKReturnCode::SDKReturnCode_InvalidArgument;
        p_Info.fraction = 1023; //cap it.
    }
    uint64_t t_Time = (uint64_t)p_Info.fraction; //10 bits

    if (p_Info.second > 59)
    {
        t_Res = SDKReturnCode::SDKReturnCode_InvalidArgument;
        p_Info.second = 63; //cap it.
    }
    t_Time += (uint64_t)p_Info.second << 10; //6 bits

    if (p_Info.minute > 59)
    {
        t_Res = SDKReturnCode::SDKReturnCode_InvalidArgument;
        p_Info.minute = 63; //cap it.
    }
    t_Time += (uint64_t)p_Info.minute << 16; //6 bits

    if (p_Info.hour > 23)
    {
        t_Res = SDKReturnCode::SDKReturnCode_InvalidArgument;
        p_Info.hour = 31; //cap it.
    }
    t_Time += (uint64_t)p_Info.hour << 22; //5 bits

    if (p_Info.day > 31)
    {
        t_Res = SDKReturnCode::SDKReturnCode_InvalidArgument;
        p_Info.day = 31; //cap it.
    }
    t_Time += (uint64_t)p_Info.day << 27; //5 bits

    if (p_Info.month > 12)
    {
        t_Res = SDKReturnCode::SDKReturnCode_InvalidArgument;
        p_Info.month = 15; //cap it.
    }
    t_Time += (uint64_t)p_Info.month << 32; //4 bits

    if (p_Info.year > 1000000)
    {
        t_Res = SDKReturnCode::SDKReturnCode_InvalidArgument;
        p_Info.year = 1048575; //cap it. Seriously, we won't get there.
    }
    t_Time += (uint64_t)p_Info.year << 36; //20 bits

    if (p_Info.timecode)
    {
        t_Time += 1ull << 56;
    }

    p_Timestamp->time = t_Time;

    return t_Res;
}

SDKReturnCode CoreSdk_LookForHosts(uint32_t p_WaitSeconds, bool p_LoopbackOnly)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }

    if (s_CoreConnection->IsLookingForHosts())
    {
        return SDKReturnCode::SDKReturnCode_FunctionCalledAtWrongTime;
    }
    return s_CoreConnection->LookForHosts(p_WaitSeconds, p_LoopbackOnly);
}

SDKReturnCode CoreSdk_GetNumberOfAvailableHostsFound(uint32_t* p_NumberOfAvailableHostsFound)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }

    return s_CoreConnection->GetNumberOfAvailableHostsFound(*p_NumberOfAvailableHostsFound);
}

SDKReturnCode CoreSdk_GetAvailableHostsFound(ManusHost* p_AvailableHostsFound, const uint32_t p_NumberOfHostsThatFitInArray)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }

    return s_CoreConnection->GetAvailableHostsFound(p_AvailableHostsFound, p_NumberOfHostsThatFitInArray);
}

SDKReturnCode CoreSdk_GetIsConnectedToCore(bool* p_ConnectedToCore)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetIsConnectedToCore(*p_ConnectedToCore);
}

SDKReturnCode CoreSdk_ConnectGRPC()
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; } // how do we even get here if this happens. some real funky race conditions during shutdown.
    return s_CoreConnection->ConnectToPresetGRPC();
}

SDKReturnCode CoreSdk_Disconnect()
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; } // how do we even get here if this happens. some real funky race conditions during shutdown.
    return s_CoreConnection->Disconnect();
}

SDKReturnCode CoreSdk_ConnectToHost(ManusHost p_Host)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ConnectToHost(p_Host);
}

SDKReturnCode CoreSdk_InitializeCoordinateSystemWithVUH(CoordinateSystemVUH p_CoordinateSystem, bool p_UseWorldCoordinates)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetCoordinateSystem(p_CoordinateSystem, p_UseWorldCoordinates);
}

SDKReturnCode CoreSdk_InitializeCoordinateSystemWithDirection(CoordinateSystemDirection p_CoordinateSystem, bool p_UseWorldCoordinates)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetCoordinateSystem(p_CoordinateSystem, p_UseWorldCoordinates);
}

SDKReturnCode CoreSdk_GetVersionsAndCheckCompatibility(ManusVersion* p_SdkVersion, ManusVersion* p_CoreVersion, bool* p_AreVersionsCompatible)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetVersionsAndCheckCompatibility(*p_SdkVersion, *p_CoreVersion, *p_AreVersionsCompatible);
}

SDKReturnCode CoreSdk_GetSessionId(uint32_t* p_SessionId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSessionId(*p_SessionId);
}

SDKReturnCode CoreSdk_RegisterCallbackForOnConnect(ConnectedToCoreCallback_t p_ConnectedCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForOnConnect(p_ConnectedCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForLandscapeStream(LandscapeStreamCallback_t p_LandscapeCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForLandscapeStream(p_LandscapeCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForDebuggingStream(DebuggingStreamCallback_t p_DebuggingCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForDebuggingStream(p_DebuggingCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForExtraDataStream(ExtraDataStreamCallback_t p_ExtraDataCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForExtraDataStream(p_ExtraDataCallback);
}

SDKReturnCode CoreSdk_UpdateCore(bool p_CheckOnly, UpdateCoreResponse* p_UpdateResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UpdateCore(p_CheckOnly, *p_UpdateResponse);
}

//-----------------------------------------------------------------------------------------
// Playback Recording
//-----------------------------------------------------------------------------------------
SDKReturnCode CoreSdk_StartRecording(bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StartRecording(*p_Success);
}

SDKReturnCode CoreSdk_StopRecording(bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StopRecording(*p_Success);
}

SDKReturnCode CoreSdk_UnloadRecording(bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UnloadRecording(*p_Success);
}

SDKReturnCode CoreSdk_StartPlayback(bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StartPlayback(*p_Success);
}

SDKReturnCode CoreSdk_EnablePlayback(bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->EnablePlayback(*p_Success);
}

SDKReturnCode CoreSdk_StopPlayback(bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StopPlayback(*p_Success);
}

SDKReturnCode CoreSdk_SeekFrame(SeekFrameInfo p_SeekFrameInfo, ManusTimestamp* p_Timestamp)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SeekFrame(p_SeekFrameInfo, *p_Timestamp);
}

SDKReturnCode CoreSdk_SaveRecordingToFile(char* p_PathName, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SaveRecordingToFile(p_PathName, *p_Success);
}

SDKReturnCode CoreSdk_LoadRecordingFromFile(char* p_PathName, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->LoadRecordingFromFile(p_PathName, *p_Success);
}

SDKReturnCode CoreSdk_StartPlaybackFromSpecificTime(uint32_t p_PlaybackStartingTime, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StartPlaybackFromSpecificTime(p_PlaybackStartingTime, *p_Success);
}

SDKReturnCode CoreSdk_GetCurrentRecordingProperties(PlaybackRecordingProperties* p_RecordingProperties)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetCurrentRecordingProperties(*p_RecordingProperties);
}

SDKReturnCode CoreSdk_ZipRecordingDataAndGetSize(uint32_t* p_RecordingLengthInBytes)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ZipRecordingDataAndGetSize(*p_RecordingLengthInBytes);
}

SDKReturnCode CoreSdk_GetRecordingData(unsigned char* p_RecordingData, uint32_t p_RecordingLengthInBytes)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRecordingData(p_RecordingData, p_RecordingLengthInBytes);
}

SDKReturnCode CoreSdk_LoadRecordingFromClientFile(unsigned char* p_RecordingData, uint32_t p_RecordingLengthInBytes, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->LoadRecordingFromClientFile(p_RecordingData, p_RecordingLengthInBytes, *p_Success);
}

//-----------------------------------------------------------------------------------------

SDKReturnCode CoreSdk_RegisterCallbackForSkeletonStream(SkeletonStreamCallback_t p_SkeletonStreamCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForSkeletonStream(p_SkeletonStreamCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForTrackerStream(TrackerStreamCallback_t p_TrackerStreamCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForTrackerStream(p_TrackerStreamCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForSystemStream(SystemStreamCallback_t p_SystemCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForSystemStream(p_SystemCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForErgonomicsStream(ErgonomicsStreamCallback_t p_ErgonomicsCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForErgonomicsStream(p_ErgonomicsCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForStatisticsStream(StatisticsStreamCallback_t p_StatisticsCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForStatisticsStream(p_StatisticsCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForOnDisconnect(DisconnectedFromCoreCallback_t p_DisconnectedCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForOnDisconnect(p_DisconnectedCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForOnLog(LoggingCallback_t p_LoggingCallback)
{
    ManusSDK::Log::RegisterCallback((void*)p_LoggingCallback);
    return SDKReturnCode::SDKReturnCode_Success;
}

SDKReturnCode CoreSdk_RegisterCallbackForRawSkeletonStream(RawSkeletonStreamCallback_t p_RawSkeletonStreamCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForRawSkeletonStream(p_RawSkeletonStreamCallback);
}

SDKReturnCode CoreSdk_RegisterCallbackForRawDeviceDataStream(RawDeviceDataStreamCallback_t p_RawDeviceDataStreamCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForRawDeviceDataStream(p_RawDeviceDataStreamCallback);
}

SDKReturnCode CoreSdk_VibrateFingers(uint32_t p_DongleId, Side p_HandType, const float* p_Powers)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->VibrateFingers(p_DongleId, p_HandType, p_Powers);
}

SDKReturnCode CoreSdk_VibrateFingersForGlove(uint32_t p_GloveId, const float* p_Powers)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->VibrateFingersForGlove(p_GloveId, p_Powers);
}

SDKReturnCode CoreSdk_VibrateFingersForSkeleton(uint32_t p_SkeletonId, Side p_HandType, const float* p_Powers)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->VibrateFingersForSkeleton(p_SkeletonId, p_HandType, p_Powers);
}

SDKReturnCode CoreSdk_GetGloveIdOfUser_UsingUserId(uint32_t p_UserId, Side p_HandType, uint32_t* p_GloveId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetGloveIdOfUserId(p_UserId, p_HandType, *p_GloveId);
}

SDKReturnCode CoreSdk_GetNumberOfAvailableGloves(uint32_t* p_NumberOfAvailableGloves)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNumberOfAvailableGloves(*p_NumberOfAvailableGloves);
}

SDKReturnCode CoreSdk_GetIdsOfAvailableGloves(uint32_t* p_IdsOfAvailableGloves, uint32_t p_NumberOfIdsThatFitInArray)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetIdsOfAvailableGloves(p_IdsOfAvailableGloves, p_NumberOfIdsThatFitInArray);
}

SDKReturnCode CoreSdk_GetGlovesForDongle(uint32_t p_DongleId, uint32_t* p_LeftGloveId, uint32_t* p_RightGloveId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetGlovesForDongle(p_DongleId, *p_LeftGloveId, *p_RightGloveId);
}

SDKReturnCode CoreSdk_GetDataForGlove_UsingGloveId(uint32_t p_GloveId, GloveLandscapeData* p_GloveData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetDataForGlove(p_GloveId, *p_GloveData);
}

SDKReturnCode CoreSdk_GetDataForDongle(uint32_t p_DongleId, DongleLandscapeData* p_DongleData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetDataForDongle(p_DongleId, *p_DongleData);
}

SDKReturnCode CoreSdk_GetNumberOfHapticsDongles(uint32_t* p_NumberOfHapticsDongles)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNumberOfHapticsDongles(*p_NumberOfHapticsDongles);
}

SDKReturnCode CoreSdk_GetHapticsDongleIds(uint32_t* p_HapticsDongleIds, uint32_t p_NumberOfIdsThatFitInArray)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetHapticsDongleIds(p_HapticsDongleIds, p_NumberOfIdsThatFitInArray);
}

SDKReturnCode CoreSdk_GetNumberOfDongles(uint32_t* p_NumberOfDongles)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNumberOfDongles(*p_NumberOfDongles);
}

SDKReturnCode CoreSdk_GetDongleIds(uint32_t* p_DongleIds, uint32_t p_NumberOfIdsThatFitInArray)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetDongleIds(p_DongleIds, p_NumberOfIdsThatFitInArray);
}

SDKReturnCode CoreSdk_SetRawSkeletonPinchCompensation(bool p_Enable)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetRawSkeletonPinchCompensation(p_Enable);
}

SDKReturnCode CoreSdk_GetRawSkeletonPinchCompensation(bool* p_Enabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawSkeletonPinchCompensation(*p_Enabled);
}

SDKReturnCode CoreSdk_SetRawSkeletonCasingCompensation(float p_FilterStength)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetRawSkeletonCasingCompensation(p_FilterStength);
}

SDKReturnCode CoreSdk_GetRawSkeletonCasingCompensation(float* p_FilterStength)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawSkeletonCasingCompensation(*p_FilterStength);
}

SDKReturnCode CoreSdk_GetNumberOfAvailableUsers(uint32_t* p_NumberOfAvailableUsers)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNumberOfAvailableUsers(*p_NumberOfAvailableUsers);
}

SDKReturnCode CoreSdk_GetIdsOfAvailableUsers(uint32_t* p_IdsOfAvailableUsers, uint32_t p_NumberOfIdsThatFitInArray)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetIdsOfAvailableUsers(p_IdsOfAvailableUsers, p_NumberOfIdsThatFitInArray);
}

SDKReturnCode CoreSdk_GetSkeletonInfo(uint32_t p_SkeletonIndex, SkeletonInfo* p_Info)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonInfo(p_SkeletonIndex, *p_Info);
}

SDKReturnCode CoreSdk_GetSkeletonData(uint32_t p_SkeletonIndex, SkeletonNode* p_Nodes, uint32_t p_NodeCount)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonData(p_SkeletonIndex, p_Nodes, p_NodeCount);
}

SDKReturnCode CoreSdk_SetRawSkeletonHandMotion(HandMotion p_HandMotion)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetRawSkeletonHandMotion(p_HandMotion);
}

SDKReturnCode CoreSdk_GetRawSkeletonHandMotion(HandMotion* p_HandMotion)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawSkeletonHandMotion(*p_HandMotion);
}

SDKReturnCode CoreSdk_GetRawSkeletonInfo(uint32_t p_SkeletonIndex, RawSkeletonInfo* p_Info)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawSkeletonInfo(p_SkeletonIndex, *p_Info);
}

SDKReturnCode CoreSdk_GetRawSkeletonData(uint32_t p_SkeletonIndex, SkeletonNode* p_Nodes, uint32_t p_NodeCount)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawSkeletonData(p_SkeletonIndex, p_Nodes, p_NodeCount);
}

SDKReturnCode CoreSdk_GetRawDeviceData(uint32_t p_RawDeviceDataIndex, RawDeviceData* p_RawDeviceData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawDeviceData(p_RawDeviceDataIndex, *p_RawDeviceData);
}

SDKReturnCode CoreSdk_GetTrackerData(uint32_t p_TrackerIndex, TrackerData* p_TrackerData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTrackerData(p_TrackerIndex, *p_TrackerData);
}

SDKReturnCode CoreSdk_GetNumberOfAvailableTrackers(uint32_t* p_NumberOfAvailableTrackers)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNumberOfAvailableTrackers(*p_NumberOfAvailableTrackers);
}

SDKReturnCode CoreSdk_GetIdsOfAvailableTrackers(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_NumberOfIdsThatFitInArray)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetIdsOfAvailableTrackers(p_IdsOfAvailableTrackers, p_NumberOfIdsThatFitInArray);
}

SDKReturnCode CoreSdk_GetNumberOfAvailableTrackersForUserId(uint32_t* p_NumberOfAvailableTrackers, uint32_t p_UserId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNumberOfAvailableTrackersForUserId(*p_NumberOfAvailableTrackers, p_UserId);
}

SDKReturnCode CoreSdk_GetIdsOfAvailableTrackersForUserId(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_UserId, uint32_t p_NumberOfIdsThatFitInArray)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetIdsOfAvailableTrackersForUserId(p_IdsOfAvailableTrackers, p_UserId, p_NumberOfIdsThatFitInArray);
}

SDKReturnCode CoreSdk_GetNumberOfAvailableTrackersForUserIndex(uint32_t* p_NumberOfAvailableTrackers, uint32_t p_UserIndex)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNumberOfAvailableTrackersForUserIndex(*p_NumberOfAvailableTrackers, p_UserIndex);
}

SDKReturnCode CoreSdk_GetIdsOfAvailableTrackersForUserIndex(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_UserIndex, uint32_t p_NumberOfIdsThatFitInArray)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetIdsOfAvailableTrackersForUserIndex(p_IdsOfAvailableTrackers, p_UserIndex, p_NumberOfIdsThatFitInArray);
}


SDKReturnCode CoreSdk_GetDataForTracker_UsingTrackerId(TrackerId p_TrackerId, TrackerData* p_TrackerData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetDataForTracker(p_TrackerId, *p_TrackerData);
}

SDKReturnCode CoreSdk_GetDataForTracker_UsingIdAndType(uint32_t p_UserId, uint32_t p_TrackerType, TrackerData* p_TrackerData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetDataForTracker(p_UserId, p_TrackerType, *p_TrackerData);
}

SDKReturnCode CoreSdk_DoesSkeletonGloveSupportHaptics(uint32_t p_SkeletonId, Side p_HandType, bool* p_IsHaptics)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->DoesSkeletonGloveSupportHaptics(p_SkeletonId, p_HandType, *p_IsHaptics);
}

SDKReturnCode CoreSdk_SendDataForTrackers(const TrackerData* p_TrackerData, uint32_t p_NumberOfTrackers)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UpdateTrackers(p_TrackerData, p_NumberOfTrackers);
}

SDKReturnCode CoreSdk_SetTrackerOffset(uint32_t p_UserId, const TrackerOffset* p_TrackerOffset)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetTrackerOffset(p_UserId, p_TrackerOffset);
}

SDKReturnCode CoreSdk_GetGestureLandscapeData(GestureLandscapeData* p_LandscapeDataArray, uint32_t p_ArraySize)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetGestureLandscapeData(p_LandscapeDataArray, p_ArraySize);
}


SDKReturnCode CoreSdk_CreateSkeletonSetup(SkeletonSetupInfo p_Skeleton, uint32_t* p_SkeletonSetupIndex)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CreateSkeletonSetup(p_Skeleton, *p_SkeletonSetupIndex);
}

SDKReturnCode CoreSdk_AddNodeToSkeletonSetup(uint32_t p_SkeletonSetupIndex, NodeSetup p_Node)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AddNodeToSkeletonSetup(p_SkeletonSetupIndex, p_Node);
}

SDKReturnCode CoreSdk_AddChainToSkeletonSetup(uint32_t p_SkeletonSetupIndex, ChainSetup p_Chain)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AddChainToSkeletonSetup(p_SkeletonSetupIndex, p_Chain);
}

SDKReturnCode CoreSdk_AddColliderToSkeletonSetup(uint32_t p_SkeletonSetupIndex, ColliderSetup p_Collider)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AddColliderToSkeletonSetup(p_SkeletonSetupIndex, p_Collider);
}

//Mesh
SDKReturnCode CoreSdk_AddMeshSetupToSkeletonSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_NodeId, uint32_t* p_MeshSetupIndex)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AddMeshSetupToSkeletonSetup(p_SkeletonSetupIndex, p_NodeId, *p_MeshSetupIndex);
}

SDKReturnCode CoreSdk_AddVertexToMeshSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, Vertex p_Vertex)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AddVertexToMeshSetup(p_SkeletonSetupIndex, p_MeshSetupIndex, p_Vertex);
}

SDKReturnCode CoreSdk_AddTriangleToMeshSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, Triangle p_Triangle)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AddTriangleToMeshSetup(p_SkeletonSetupIndex, p_MeshSetupIndex, p_Triangle);
}

SDKReturnCode CoreSdk_GetMeshSetupInfo(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, MeshSetupInfo* p_MeshSetupInfo)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetMeshSetupInfo(p_SkeletonSetupIndex, p_MeshSetupIndex, *p_MeshSetupInfo);
}

SDKReturnCode CoreSdk_GetVertexData(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, uint32_t p_VertexIndex, Vertex* p_Vertex)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetVertexData(p_SkeletonSetupIndex, p_MeshSetupIndex, p_VertexIndex, *p_Vertex);
}

SDKReturnCode CoreSdk_GetTriangleData(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, uint32_t p_TriangleIndex, Triangle* p_Triangle)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTriangleData(p_SkeletonSetupIndex, p_MeshSetupIndex, p_TriangleIndex, *p_Triangle);
}

SDKReturnCode CoreSdk_OverwriteSkeletonSetup(uint32_t p_SkeletonSetupIndex, SkeletonSetupInfo p_Skeleton)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->OverwriteSkeletonSetup(p_SkeletonSetupIndex, p_Skeleton);
}

SDKReturnCode CoreSdk_OverwriteChainToSkeletonSetup(uint32_t p_SkeletonSetupIndex, ChainSetup p_Chain)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->OverwriteChainToSkeletonSetup(p_SkeletonSetupIndex, p_Chain);
}

SDKReturnCode CoreSdk_OverwriteNodeToSkeletonSetup(uint32_t p_SkeletonSetupIndex, NodeSetup p_Node)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->OverwriteNodeToSkeletonSetup(p_SkeletonSetupIndex, p_Node);
}

SDKReturnCode CoreSdk_LoadSkeleton(uint32_t p_SkeletonSetupIndex, uint32_t* p_SkeletonId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->LoadSkeleton(p_SkeletonSetupIndex, *p_SkeletonId);
}

SDKReturnCode CoreSdk_SaveTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, bool p_IsSkeletonModified)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SaveTemporarySkeleton(p_SkeletonSetupIndex, p_SessionId, p_IsSkeletonModified);
}

SDKReturnCode CoreSdk_CompressTemporarySkeletonAndGetSize(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, uint32_t* p_TemporarySkeletonLengthInBytes)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CompressTemporarySkeletonAndGetSize(p_SkeletonSetupIndex, p_SessionId, p_TemporarySkeletonLengthInBytes);
}

SDKReturnCode CoreSdk_GetCompressedTemporarySkeletonData(unsigned char* p_TemporarySkeletonData, uint32_t p_TemporarySkeletonLengthInBytes)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetCompressedTemporarySkeletonData(p_TemporarySkeletonData, p_TemporarySkeletonLengthInBytes);
}

SDKReturnCode CoreSdk_GetTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTemporarySkeleton(p_SkeletonSetupIndex, p_SessionId);
}

SDKReturnCode CoreSdk_GetTemporarySkeletonFromCompressedData(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, unsigned char* p_TemporarySkeletonData, uint32_t p_TemporarySkeletonLengthInBytes)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTemporarySkeletonFromCompressedData(p_SkeletonSetupIndex, p_SessionId, p_TemporarySkeletonData, p_TemporarySkeletonLengthInBytes);
}

SDKReturnCode CoreSdk_ClearTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ClearTemporarySkeleton(p_SkeletonSetupIndex, p_SessionId);
}

SDKReturnCode CoreSdk_ClearAllTemporarySkeletons()
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ClearAllTemporarySkeletons();
}

SDKReturnCode CoreSdk_GetTemporarySkeletonCountForAllSessions(TemporarySkeletonCountForAllSessions* p_TemporarySkeletonCountForAllSessions)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTemporarySkeletonCountForAllSessions(*p_TemporarySkeletonCountForAllSessions);
}

SDKReturnCode CoreSdk_GetTemporarySkeletonsInfoForSession(uint32_t p_SessionId, TemporarySkeletonsInfoForSession* p_TemporarySkeletonsInfoForSession)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTemporarySkeletonsInfoForSession(p_SessionId, *p_TemporarySkeletonsInfoForSession);
}

SDKReturnCode CoreSdk_UnloadSkeleton(uint32_t p_SkeletonId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UnloadSkeleton(p_SkeletonId);
}

SDKReturnCode CoreSdk_GetSkeletonSetupArraySizes(uint32_t p_SkeletonSetupIndex, SkeletonSetupArraySizes* p_SkeletonInfo)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonSetupArraySizes(p_SkeletonSetupIndex, *p_SkeletonInfo);
}

SDKReturnCode CoreSdk_AllocateChainsForSkeletonSetup(uint32_t p_SkeletonSetupIndex)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AllocateChains(p_SkeletonSetupIndex);
}

SDKReturnCode CoreSdk_PrepareSkeletonSetup(uint32_t p_SkeletonSetupIndex)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->PrepareSkeleton(p_SkeletonSetupIndex);
}

SDKReturnCode CoreSdk_GetSkeletonSetupInfo(uint32_t p_SkeletonSetupIndex, SkeletonSetupInfo* p_SDK)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonSetupInfo(p_SkeletonSetupIndex, p_SDK);
}

SDKReturnCode CoreSdk_GetSkeletonSetupChains(uint32_t p_SkeletonSetupIndex, ChainSetup* p_SDK)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonChains(p_SkeletonSetupIndex, p_SDK);
}

SDKReturnCode CoreSdk_GetSkeletonSetupChainsArray(uint32_t p_SkeletonSetupIndex, ChainSetup* p_ChainSetupArray, uint32_t p_ArraySize)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonChains(p_SkeletonSetupIndex, p_ChainSetupArray, p_ArraySize);
}

SDKReturnCode CoreSdk_GetSkeletonSetupNodes(uint32_t p_SkeletonSetupIndex, NodeSetup* p_SDK)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonNodes(p_SkeletonSetupIndex, p_SDK);
}

SDKReturnCode CoreSdk_GetSkeletonSetupNodesArray(uint32_t p_SkeletonSetupIndex, NodeSetup* p_NodeSetupArray, uint32_t p_ArraySize)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonNodes(p_SkeletonSetupIndex, p_NodeSetupArray, p_ArraySize);
}

SDKReturnCode CoreSdk_GetSkeletonSetupColliders(uint32_t p_SkeletonSetupIndex, ColliderSetup* p_SDK)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSkeletonColliders(p_SkeletonSetupIndex, p_SDK);
}

SDKReturnCode CoreSdk_GetRawSkeletonNodeCount(uint32_t p_GloveId, uint32_t& p_NodeCount)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawSkeletonNodeCount(p_GloveId, p_NodeCount);
}

SDKReturnCode CoreSdk_GetRawSkeletonNodeInfo(uint32_t p_GloveId, NodeInfo* p_NodeInfo)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawSkeletonNodeInfo(p_GloveId, p_NodeInfo);
}

SDKReturnCode CoreSdk_GetRawSkeletonNodeInfoArray(uint32_t p_GloveId, NodeInfo* p_NodeInfoArray, uint32_t p_ArraySize)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetRawSkeletonNodeInfo(p_GloveId, p_NodeInfoArray, p_ArraySize);

}

// ******************************************************************************
//                                   Haptics module. 
// ******************************************************************************
SDKReturnCode CoreSdk_CalibrateHapticsModule(uint32_t p_DongleId, Side p_HandType)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CalibrateHapticsModule(p_DongleId, p_HandType);
}


SDKReturnCode CoreSdk_SetDonglePolygon(DonglePolygonArgs p_Args, SetPolygonDongleResponse* p_SetPolygonDongleResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetDonglePolygon(p_Args, *p_SetPolygonDongleResponse);
}

SDKReturnCode CoreSdk_CalibrationSetMin(CalibrationArgs p_Args, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CalibrationSetMin(p_Args, *p_CommandResponse);
}

SDKReturnCode CoreSdk_CalibrationSetMax(CalibrationArgs p_Args, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CalibrationSetMax(p_Args, *p_CommandResponse);
}

SDKReturnCode CoreSdk_CalibrationStore(CalibrationArgs p_Args, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CalibrationStore(p_Args, *p_CommandResponse);
}

SDKReturnCode CoreSdk_CalibrationBegin(CalibrationArgs p_Args, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CalibrationBegin(p_Args, *p_CommandResponse);
}

SDKReturnCode CoreSdk_CalibrationEnd(CalibrationArgs p_Args, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CalibrationEnd(p_Args, *p_CommandResponse);
}

SDKReturnCode CoreSdk_CalibrationDataGet(CalibrationArgs p_Args, CalibrationData* p_CalibrationData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CalibrationDataGet(p_Args, *p_CalibrationData);
}

SDKReturnCode CoreSdk_CalibrationDataSet(CalibrationArgs p_Args, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->CalibrationDataSet(p_Args, *p_CommandResponse);
}

SDKReturnCode CoreSdk_UpdateDongleFirmware(DongleUpdateArgs p_Args, DongleUpdateResponse* p_DongleUpdateResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UpdateDongleFirmware(p_Args, *p_DongleUpdateResponse);
}

SDKReturnCode CoreSdk_StartQuantumCalibration(StartQuantumCalibrationArgs p_Args, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StartQuantumCalibration(p_Args, *p_CommandResponse);
}

SDKReturnCode CoreSdk_StartQuantumCalibrationStep(StartQuantumCalibrationStepArgs p_Args, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StartQuantumCalibrationStep(p_Args, *p_CommandResponse);
}

SDKReturnCode CoreSdk_StopQuantumCalibration(uint32_t p_GloveID, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StopQuantumCalibration(p_GloveID, *p_CommandResponse);
}


SDKReturnCode CoreSdk_GetBandScan(BandScanArgs p_BandScanArgs, int32_t* p_BandScanType, unsigned char* p_BandScanData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetBandScan(p_BandScanArgs, *p_BandScanType, p_BandScanData);
}

SDKReturnCode CoreSdk_SetChannel(uint32_t p_Channel, uint32_t p_DongleId, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetChannel(p_Channel, p_DongleId, *p_Success);
}

SDKReturnCode CoreSdk_SetPersistentDongleChannels(bool p_SetPersistent)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetPersistentDongleChannels(p_SetPersistent);
}

SDKReturnCode CoreSdk_AreDongleChannelsPersistent(bool* p_IsPersistent)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AreDongleChannelsPersistent(*p_IsPersistent);
}

//Virtual Dongles
SDKReturnCode CoreSdk_SetEnableVirtualDongles(bool p_Enable)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetEnableVirtualDongles(p_Enable);
}

SDKReturnCode CoreSdk_AreVirtualDonglesEnabled(bool* p_IsEnabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AreVirtualDonglesEnabled(*p_IsEnabled);
}

//Extended Settings IMU
SDKReturnCode CoreSdk_SetSettingIgnoreThumbIMU(bool p_IgnoreThumbIMU)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetSettingIgnoreThumbIMU(p_IgnoreThumbIMU);
}

SDKReturnCode CoreSdk_GetSettingIgnoreThumbIMU(bool* p_IgnoreThumbIMU)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSettingIgnoreThumbIMU(*p_IgnoreThumbIMU);
}

SDKReturnCode CoreSdk_SetSettingIgnoreNonThumbFingerIMU(bool p_IgnoreNonThumbFingerIMU)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetSettingIgnoreNonThumbFingerIMU(p_IgnoreNonThumbFingerIMU);
}

SDKReturnCode CoreSdk_GetSettingIgnoreNonThumbFingerIMU(bool* p_IgnoreNonThumbFingerIMU)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSettingIgnoreNonThumbFingerIMU(*p_IgnoreNonThumbFingerIMU);
}

// extended Users
SDKReturnCode CoreSdk_AddUser(char* p_Name, uint32_t* p_UserID)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AddUser(p_Name, *p_UserID);
}

SDKReturnCode CoreSdk_RemoveUser(uint32_t p_Id)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RemoveUser(p_Id);
}

SDKReturnCode CoreSdk_SetUserName(uint32_t p_Id, char* p_Name)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetUserName(p_Id, p_Name);
}

SDKReturnCode CoreSdk_SetAutoUserAssignment(bool p_Enabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetAutoUserAssignment(p_Enabled);
}

SDKReturnCode CoreSdk_AssignDongleToUser(uint32_t p_Id, uint32_t p_DongleId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AssignDongleToUser(p_Id, p_DongleId);
}

SDKReturnCode CoreSdk_AssignGloveToUser(uint32_t p_UserId, uint32_t p_GloveId, Side p_Side)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AssignGloveToUser(p_UserId, p_GloveId, p_Side);
}

SDKReturnCode CoreSdk_AssignProfileToUser(UserProfileArgs p_UserProfileArgs, CompleteType* p_Message)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AssignProfileToUser(p_UserProfileArgs, *p_Message);
}

SDKReturnCode CoreSdk_MoveUserUp(uint32_t p_Id)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->MoveUserUp(p_Id);
}

SDKReturnCode CoreSdk_MoveUserDown(uint32_t p_Id)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->MoveUserDown(p_Id);
}

SDKReturnCode CoreSdk_GetCalibrationProfile(uint32_t p_UserId, CalibrationProfile* p_CalibrationProfile)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetCalibrationProfile(p_UserId, *p_CalibrationProfile);
}

// extended trackers


SDKReturnCode CoreSdk_IsUserUsingHMD(bool* p_IsUsingHMD, uint32_t p_UserId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->IsUserUsingHMD(*p_IsUsingHMD, p_UserId);
}

SDKReturnCode CoreSdk_RefreshTrackingSystems()
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RefreshTrackingSystems();
}

SDKReturnCode CoreSdk_AutoGroupTrackers()
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AutoGroupTrackers();
}

SDKReturnCode CoreSdk_AutoAssignTrackers(uint32_t p_UserId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AutoAssignTrackers(p_UserId);
}

SDKReturnCode CoreSdk_ResetTrackerAssignment(uint32_t p_UserId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ResetTrackerAssignment(p_UserId);
}

SDKReturnCode CoreSdk_AssignTrackerToUser(TrackerId p_TrackerId, uint32_t p_UserId)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AssignTrackerToUser(p_TrackerId, p_UserId);
}

SDKReturnCode CoreSdk_AssignRoleToTracker(TrackerId p_TrackerId, TrackerType p_TrackerType)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->AssignRoleToTracker(p_TrackerId, p_TrackerType);
}

SDKReturnCode CoreSdk_ChangeUserForRole(TrackerType p_Role, uint32_t p_CurrentUser, uint32_t p_TargetUser)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ChangeUserForRole(p_Role, p_CurrentUser, p_TargetUser);
}

SDKReturnCode CoreSdk_GetTrackingSystems(TrackingSystemInfo* p_Current, TrackingSystemInfo* p_Systems)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTrackingSystems(*p_Current, p_Systems);
}

SDKReturnCode CoreSdk_KeepLastPosition(bool p_UseLastPosition)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->KeepLastPosition(p_UseLastPosition);
}

SDKReturnCode CoreSdk_UseTimeout(bool p_UseTimeOut)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UseTimeout(p_UseTimeOut);
}

SDKReturnCode CoreSdk_SetTimeout(float p_TimeOut)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetTimeout(p_TimeOut);
}

SDKReturnCode CoreSdk_GetTrackerServiceSettings(bool* p_UseTimeout, float* p_Timeout, bool* p_KeepLastPosition)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTrackerServiceSettings(*p_UseTimeout, *p_Timeout, *p_KeepLastPosition);
}

SDKReturnCode CoreSdk_GetTrackerSystemsSettings(TrackerSystem* p_TrackerSystems, uint32_t* p_TrackerSystemCount)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTrackerSystemsSettings(p_TrackerSystems, *p_TrackerSystemCount);
}

SDKReturnCode CoreSdk_SetTrackerSystemsSettings(TrackerSystem* p_TrackerSystems)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetTrackerSystemsSettings(p_TrackerSystems);
}

//Polygon Calibration
SDKReturnCode CoreSdk_StartSequence(StartSequenceArg p_Args, SequenceData* p_SequenceData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StartSequence(p_Args, *p_SequenceData);
}

SDKReturnCode CoreSdk_StopSequence(uint32_t p_Id, CompleteType* p_Message)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StopSequence(p_Id, *p_Message);
}

SDKReturnCode CoreSdk_StartNextStep(uint32_t p_Id, CompleteType* p_Message)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StartNextStep(p_Id, *p_Message);
}

SDKReturnCode CoreSdk_UndoStep(uint32_t p_Id, CompleteType* p_Message)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UndoStep(p_Id, *p_Message);
}

SDKReturnCode CoreSdk_GetSequenceState(uint32_t p_Id, SequenceStateValue* p_SequenceStateValue)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetSequenceState(p_Id, *p_SequenceStateValue);
}

SDKReturnCode CoreSdk_GetStepData(uint32_t p_Id, StepData* p_StepData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetStepData(p_Id, *p_StepData);
}

SDKReturnCode CoreSdk_ApplyProfile(uint32_t p_Id, CompleteType* p_Message)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ApplyProfile(p_Id, *p_Message);
}

// extended telemetry

SDKReturnCode CoreSdk_ReportFeatureUsage(FeatureUsed p_Feature, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ReportFeatureUsage(p_Feature, *p_CommandResponse);
}

SDKReturnCode CoreSdk_ReportExportFeatureUsage(ExportFeatureReport p_Report, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ReportExportFeatureUsage(p_Report, *p_CommandResponse);
}

SDKReturnCode CoreSdk_ReportExportCSVFeatureUsage(ExportCSVFeatureReport p_Report, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ReportExportCSVFeatureUsage(p_Report, *p_CommandResponse);
}

SDKReturnCode CoreSdk_ReportOpenXRFeatureUsage(OpenXRFeatureReport p_Report, bool* p_CommandResponse)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->ReportOpenXRFeatureUsage(p_Report, *p_CommandResponse);
}

// Other
SDKReturnCode CoreSdk_GetDebuggingData(uint32_t p_StartIndex, DebuggingData* p_DebuggingData)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetDebuggingData(p_StartIndex, *p_DebuggingData);
}

SDKReturnCode CoreSdk_GetExtraDeviceData(uint32_t p_ExtraDeviceDataIndex, ExtraDeviceData* p_Data)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetExtraDeviceData(p_ExtraDeviceDataIndex, *p_Data);
}

SDKReturnCode CoreSdk_GetStatistics(StatisticsStream* p_Data)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetStatistics(p_Data);
}

//Timecode
SDKReturnCode CoreSdk_UseTimecodeTimestamps(bool p_Enabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UseTimecodeTimestamps(p_Enabled);
}

SDKReturnCode CoreSdk_IsUsingTimecodeTimestamps(bool* p_Enabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->IsUsingTimecodeTimestamps(*p_Enabled);
}

SDKReturnCode CoreSdk_StartTimecode(StartTimecodeArgs p_Args, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StartTimecode(p_Args, *p_Success);
}

SDKReturnCode CoreSdk_StopTimecode(bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->StopTimecode(*p_Success);
}

SDKReturnCode CoreSdk_RefreshTimecodeInterfaces(bool p_Reconnect, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RefreshTimecodeInterfaces(p_Reconnect, *p_Success);
}

SDKReturnCode CoreSdk_IsTimecodeRunning(bool* p_Running)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->IsTimecodeRunning(*p_Running);
}

SDKReturnCode CoreSdk_SetTimecodeAutoStart(bool p_Enabled, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetTimecodeAutoStart(p_Enabled, *p_Success);
}

SDKReturnCode CoreSdk_GetTimecodeAutoStart(bool* p_Enabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTimecodeAutoStart(*p_Enabled);
}

SDKReturnCode CoreSdk_SetTimecodeDeviceKeepAlive(bool p_Enabled, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetTimecodeDeviceKeepAlive(p_Enabled, *p_Success);
}

SDKReturnCode CoreSdk_GetTimecodeDeviceKeepAlive(bool* p_Enabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTimecodeDeviceKeepAlive(*p_Enabled);
}

SDKReturnCode CoreSdk_SetTimecodeGenlock(bool p_Enabled, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetTimecodeGenlock(p_Enabled, *p_Success);
}

SDKReturnCode CoreSdk_GetTimecodeGenlock(bool* p_Enabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTimecodeGenlock(*p_Enabled);
}

SDKReturnCode CoreSdk_SetTimecodeNonRealTime(bool p_Enabled, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetTimecodeNonRealTime(p_Enabled, *p_Success);
}

SDKReturnCode CoreSdk_GetTimecodeNonRealTime(bool* p_Enabled)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetTimecodeNonRealTime(*p_Enabled);
}

SDKReturnCode CoreSdk_SetLtcChannel(int32_t p_Channel, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetLtcChannel(p_Channel, *p_Success);
}

SDKReturnCode CoreSdk_GetLtcChannel(int32_t* p_Channel)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetLtcChannel(*p_Channel);
}

SDKReturnCode CoreSdk_RegisterCallbackForGestureStream(GestureStreamCallback_t p_GestureStreamCallback)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->RegisterCallbackForGestureStream(p_GestureStreamCallback);
}

SDKReturnCode CoreSdk_PairGlove(uint32_t p_GloveID, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->PairGlove(p_GloveID, *p_Success);
}

SDKReturnCode CoreSdk_PairGloveToDongle(uint32_t p_GloveID, uint32_t p_DongleID, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->PairGloveToDongle(p_GloveID, p_DongleID, *p_Success);
}

SDKReturnCode CoreSdk_UnpairGlove(uint32_t p_GloveID, bool* p_Success)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->UnpairGlove(p_GloveID, *p_Success);
}

SDKReturnCode CoreSdk_GetGestureStreamData(uint32_t p_GestureStreamDataIndex, uint32_t p_StartDataIndex, GestureProbabilities* p_GestureProbabilitiesCollection)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetGestureStreamData(p_GestureStreamDataIndex, p_StartDataIndex, *p_GestureProbabilitiesCollection);
}

SDKReturnCode CoreSdk_GloveCalibrationStart(GloveCalibrationArgs p_CalibrationArgs, bool* p_Result)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GloveCalibrationStart(p_CalibrationArgs, *p_Result);
}

SDKReturnCode CoreSdk_GloveCalibrationStop(GloveCalibrationArgs p_CalibrationArgs, bool* p_Result)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GloveCalibrationStop(p_CalibrationArgs, *p_Result);
}

SDKReturnCode CoreSdk_GloveCalibrationFinish(GloveCalibrationArgs p_CalibrationArgs, bool* p_Result)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GloveCalibrationFinish(p_CalibrationArgs, *p_Result);
}

SDKReturnCode CoreSdk_GloveCalibrationGetNumberOfSteps(GloveCalibrationArgs p_CalibrationArgs, uint32_t* p_NumberOfSteps)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GloveCalibrationGetNumberOfSteps(p_CalibrationArgs, *p_NumberOfSteps);
}

SDKReturnCode CoreSdk_GloveCalibrationGetStepData(GloveCalibrationStepArgs p_CalibrationStepArgs, GloveCalibrationStepData* p_Data)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GloveCalibrationGetStepData(p_CalibrationStepArgs, *p_Data);
}

SDKReturnCode CoreSdk_GloveCalibrationStartStep(GloveCalibrationStepArgs p_CalibrationStepArgs, bool* p_Result)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GloveCalibrationStartStep(p_CalibrationStepArgs, *p_Result);
}

SDKReturnCode CoreSdk_GetGloveCalibrationSize(uint32_t p_GloveId, uint32_t* p_Size)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetGloveCalibrationSize(p_GloveId, p_Size);
}

SDKReturnCode CoreSdk_GetGloveCalibrationSizeForUser(uint32_t p_UserId, Side p_Side, GloveProfileType p_ProfileType, uint32_t* p_Size)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetGloveCalibrationSizeForUser(p_UserId, p_Side, p_ProfileType, p_Size);
}

SDKReturnCode CoreSdk_GetGloveCalibration(unsigned char* p_CalibrationBytes, uint32_t p_Size)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetGloveCalibration(p_CalibrationBytes, p_Size);
}

SDKReturnCode CoreSdk_SetGloveCalibration(uint32_t p_GloveId, unsigned char* p_CalibrationBytes, uint32_t p_BytesLength, SetGloveCalibrationReturnCode* p_Result)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetGloveCalibration(p_GloveId, p_CalibrationBytes, p_BytesLength, *p_Result);
}

SDKReturnCode CoreSdk_SetGloveCalibrationForUser(uint32_t p_UserId, unsigned char* p_CalibrationBytes, uint32_t p_BytesLength, SetGloveCalibrationReturnCode* p_Result)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetGloveCalibrationForUser(p_UserId, p_CalibrationBytes, p_BytesLength, *p_Result);
}


SDKReturnCode CoreSdk_SetSettingsRawSkeletonStream(bool p_StreamActive)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return SDKReturnCode::SDKReturnCode_Success;
}

SDKReturnCode CoreSdk_GetSettingsRawSkeletonStream(bool& p_StreamActive)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    p_StreamActive = true;
    return SDKReturnCode::SDKReturnCode_Success;
}

SDKReturnCode CoreSdk_NetDeviceGetNumberOfAvailableHosts(uint32_t& p_NumberOfAvailableHosts)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->NetDeviceGetNumberOfAvailableHosts(p_NumberOfAvailableHosts);
}

SDKReturnCode CoreSdk_NetDeviceGetAvailableHosts(ManusHost* p_Hosts, const uint32_t p_NumberOfAvailableHosts)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->NetDeviceGetAvailableHosts(p_Hosts, p_NumberOfAvailableHosts);
}

SDKReturnCode CoreSdk_NetDeviceConnect(ManusHost p_Host)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->NetDeviceConnect(p_Host);
}

SDKReturnCode CoreSdk_NetDeviceDisconnect(ManusHost p_Host)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->NetDeviceDisconnect(p_Host);
}

SDKReturnCode CoreSdk_SetNetDeviceMode(bool p_Client)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetNetDeviceMode(p_Client);
}

SDKReturnCode CoreSdk_GetNetDeviceMode(bool& p_Client)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNetDeviceMode(p_Client);
}

SDKReturnCode CoreSdk_SetNetDeviceAutoconnectPolicy(bool p_Autoconnect)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->SetNetDeviceAutoconnectPolicy(p_Autoconnect);
}

SDKReturnCode CoreSdk_GetNetDeviceAutoconnectPolicy(bool& p_Autoconnect)
{
    if (!s_CoreConnection) { return SDKReturnCode::SDKReturnCode_SdkNotAvailable; }
    return s_CoreConnection->GetNetDeviceAutoconnectPolicy(p_Autoconnect);
}