File CoreConnection.cpp

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

Go to the documentation of this file

#include "CoreConnection.hpp"

#include <array>
#include <functional>

#include "ManusSDKTypeInitializers.h"
#include "ManusSDKExtendedTypeInitializers.h"
#include "Logging.hpp"


template <> struct fmt::formatter<SessionType> : formatter<string_view> {
    // parse is inherited from formatter<string_view>.

    auto format(SessionType c, fmt::format_context& ctx) const {
        std::string_view name = "";
        switch (c) {
            case SessionType::SessionType_Unknown: name = "Unknown"; break;
            case SessionType::SessionType_UnityPlugin: name = "Unity Plugin"; break;
            case SessionType::SessionType_UnrealPlugin:  name = "Unreal Plugin"; break;
            case SessionType::SessionType_CoreSDK:  name = "CoreSDK"; break;
            default:
                name = "Invalid";
                break;
        }
        return formatter<string_view>::format(name, ctx);
    }
};

namespace ManusSDK
{
    static const std::string s_ClientInfo = "The Manus Core SDK wrapper DLL.";
    static const std::string s_InvalidClientType = "InvalidClient";
    static const std::string s_UnrealClientType = "Unreal";
    static const std::string s_UnityClientType = "Unity";
    static const std::string s_CoreSDKClientType = "CoreSDK";
    static const std::string s_UnrecognizedClientType = "UnrecognizedClient";

#define RPC_OK_OR_RETURN \
        if (!m_CoreNetwork || !m_CoreNetwork->IsRunning() || m_CoreCallbacks->isShuttingdown ) \
        { \
            Log::Warn(__FUNCTION__, "Caretaker not connected to manus core yet, or shutting down."); \
            return SDKReturnCode::SDKReturnCode_NotConnected; \
        }

    CoreConnection::CoreConnection()
    {
    }

    CoreConnection::~CoreConnection()
    {
    }

    // Form a client name for the connection to Core, with a randomized part in it to hopefully make it unique.
    std::string CoreConnection::FormRandomizedClientName()
    {
        srand(static_cast<unsigned int>(time(nullptr)));
        const int t_Random = rand() % 100000;

        // This is used for licensing, so it is important to keep it up to date.
        std::string t_ClientTypeString("Uninitialized");
        switch ((int)m_SessionType)
        {
            case (int)SessionType::SessionType_UnrealPlugin:
                {
                    t_ClientTypeString = s_UnrealClientType;
                } break;
            case (int)SessionType::SessionType_UnityPlugin:
                {
                    t_ClientTypeString = s_UnityClientType;
                } break;
            case (int)SessionType::SessionType_CoreSDK:
                {
                    t_ClientTypeString = s_CoreSDKClientType;
                } break;
            case (int)SessionType::SessionType_Unknown:
                {
                    t_ClientTypeString = s_UnrecognizedClientType;
                    Log::Error(__FUNCTION__,
                        "Tried to form a client name with the unknown client type set. Please set your session to the correct type please.");
                } break;
            default:
                {
                    Log::Error(__FUNCTION__,"Tried to form a client name with an unrecognized client type set. The client type was {}.",m_SessionType);
                    t_ClientTypeString = s_UnrecognizedClientType;
                } break;
        }

        return std::string("CoreSdkWrapper_") + t_ClientTypeString + std::string("_") + std::to_string(t_Random);
    }

    std::string CoreConnection::GetClientInfo()
    {
        // This is used for licensing, so it is important to keep it up to date.
        std::string t_ClientTypeString;
        switch ((int)m_SessionType)
        {
            case (int)SessionType::SessionType_UnrealPlugin:
                {
                    t_ClientTypeString = s_UnrealClientType;
                } break;
            case (int)SessionType::SessionType_UnityPlugin:
                {
                    t_ClientTypeString = s_UnityClientType;
                } break;
            case (int)SessionType::SessionType_CoreSDK:
                {
                    t_ClientTypeString = s_CoreSDKClientType;
                } break;
            default:
                {
                    t_ClientTypeString = s_UnrecognizedClientType;
                } break;
        }

        return std::string("CoreSdkWrapper_") + t_ClientTypeString;
    }

    SDKReturnCode CoreConnection::SetCoordinateSystem(CoordinateSystemVUH& p_CoordinateSystem, bool p_UseWorldCoordinates)
    {
        m_IsCoordinateSystemSet = true;
        m_IsUsingVUH = true;
        m_UseWorldCoordinates = p_UseWorldCoordinates;
        m_CoordinateSystemVUH.handedness = p_CoordinateSystem.handedness;
        m_CoordinateSystemVUH.up = p_CoordinateSystem.up;
        m_CoordinateSystemVUH.view = p_CoordinateSystem.view;
        m_CoordinateSystemVUH.unitScale = p_CoordinateSystem.unitScale;
        return SDKReturnCode::SDKReturnCode_Success;
        // caretaker may not yet exist at this point, so we cannot yet pass it on
    }

    SDKReturnCode CoreConnection::SetCoordinateSystem(CoordinateSystemDirection& p_CoordinateSystem, bool p_UseWorldCoordinates)
    {
        m_IsCoordinateSystemSet = true;
        m_IsUsingVUH = false;
        m_UseWorldCoordinates = p_UseWorldCoordinates;
        m_CoordinateSystemDirection.x = p_CoordinateSystem.x;
        m_CoordinateSystemDirection.y = p_CoordinateSystem.y;
        m_CoordinateSystemDirection.z = p_CoordinateSystem.z;
        m_CoordinateSystemDirection.unitScale = p_CoordinateSystem.unitScale;
        return SDKReturnCode::SDKReturnCode_Success;
        // caretaker may not yet exist at this point, so we cannot yet pass it on
    }

    SDKReturnCode CoreConnection::SetSessionType(SessionType p_SessionType)
    {
        m_SessionType = p_SessionType;
        m_SessionTypeId = 0;
        m_Secret = "";
        return SDKReturnCode::SDKReturnCode_Success;
    }

    SDKReturnCode CoreConnection::SetSessionTypeID(uint32_t p_SessionTypeID, const char* p_Secret)
    {
        m_SessionType = SessionType::SessionType_Unknown;
        m_SessionTypeId = p_SessionTypeID;
        m_Secret = std::string(p_Secret);
        return SDKReturnCode::SDKReturnCode_Success;
    }

    SDKReturnCode CoreConnection::SetSettingsLocation(const char* p_SettingsLocation)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    // -----------------------------------------------------------------------------------------
    // Network finder functions
    // -----------------------------------------------------------------------------------------

    SDKReturnCode CoreConnection::GetIsConnectedToCore(bool& p_IsConnected)
    {
        p_IsConnected = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::LookForHosts(uint32_t p_WaitSeconds, bool p_LoopbackOnly)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNumberOfAvailableHostsFound(uint32_t& p_NumberOfAvailableHostsFound) const
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetAvailableHostsFound(ManusHost* p_AvailableHostsFound, const uint32_t p_NumberOfHostsThatFitInArray) const
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    bool CoreConnection::IsLookingForHosts()
    {
        return false;
    }

    // -----------------------------------------------------------------------------------------
    // Connect functions
    // -----------------------------------------------------------------------------------------

    SDKReturnCode CoreConnection::ConnectToHost(const ManusHost& p_Host)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ConnectToPresetGRPC()
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::Disconnect()
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForOnConnect(ConnectedToCoreCallback_t p_OnConnectionCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForOnDisconnect(DisconnectedFromCoreCallback_t p_OnDisconnectionCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }


    SDKReturnCode CoreConnection::RegisterCallbackForLandscapeStream(const LandscapeStreamCallback_t p_LandscapeStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForSkeletonStream(const SkeletonStreamCallback_t p_SkeletonStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForTrackerStream(const TrackerStreamCallback_t p_TrackerStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForSystemStream(const SystemStreamCallback_t p_SystemStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForDebuggingStream(const DebuggingStreamCallback_t p_DebuggingStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForErgonomicsStream(const ErgonomicsStreamCallback_t p_ErgonomicsStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForExtraDataStream(const ExtraDataStreamCallback_t p_ExtraDataStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForStatisticsStream(const StatisticsStreamCallback_t p_StatisticsStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForGestureStream(const GestureStreamCallback_t p_GestureStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForRawSkeletonStream(const RawSkeletonStreamCallback_t p_RawSkeletonStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RegisterCallbackForRawDeviceDataStream(const RawDeviceDataStreamCallback_t p_RawDeviceDataStreamCallback)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    // -----------------------------------------------------------------------------------------
    // Wrapper functions
    // -----------------------------------------------------------------------------------------
    SDKReturnCode CoreConnection::GetSessionId(uint32_t& p_SessionId)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetVersionsAndCheckCompatibility(ManusVersion& p_SdkVersion, ManusVersion& p_CoreVersion, bool& p_AreVersionsCompatible)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    // Haptics
    // todo can we get this out of the reconnection too nicely? not until prime one disintegrates. argh. 
    // check back on this in 2023 at the earliest. our telemetry hopefully confirms prime one death by then.
    SDKReturnCode CoreConnection::VibrateFingers(uint32_t p_DongleId, Side p_HandType, const float* p_Powers)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::VibrateFingersForGlove(uint32_t p_GloveId, const float* p_Powers)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::VibrateFingersForSkeleton(uint32_t p_SkeletonId, Side p_HandType, const float* p_Powers)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::UpdateCore(bool p_CheckOnly, UpdateCoreResponse& p_Response)
    {
        UpdateCoreResponse_Init(&p_Response);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::UpdateTrackers(const TrackerData* p_TrackerData, uint32_t p_NumberOfTrackers)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTrackerOffset(uint32_t p_UserId, const TrackerOffset* p_TrackerOffset)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RefreshTrackingSystems()
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    // Skeletons
    SDKReturnCode CoreConnection::CreateSkeletonSetup(const SkeletonSetupInfo& p_Skeleton, uint32_t& p_SkeletonSetupIndex)
    {
        p_SkeletonSetupIndex = UINT32_MAX;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AddNodeToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const NodeSetup& p_Node)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::OverwriteSkeletonSetup(uint32_t p_SkeletonSetupIndex, const SkeletonSetupInfo& p_Skeleton)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::OverwriteChainToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const ChainSetup& p_Chain)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::OverwriteNodeToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const NodeSetup& p_Node)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AddChainToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const ChainSetup& p_Chain)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AddColliderToSkeletonSetup(uint32_t p_SkeletonSetupIndex, const ColliderSetup& p_Collider)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AddMeshSetupToSkeletonSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_NodeId, uint32_t& p_MeshSetupIndex)
    {
        p_MeshSetupIndex = UINT32_MAX;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AddVertexToMeshSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, const Vertex& p_Vertex)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AddTriangleToMeshSetup(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, const Triangle& p_Triangle)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetMeshSetupInfo(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, MeshSetupInfo& p_MeshSetupInfo)
    {
        MeshSetupInfo_Init(&p_MeshSetupInfo);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetVertexData(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, uint32_t p_VertexIndex, Vertex& p_Vertex)
    {
        Vertex_Init(&p_Vertex);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTriangleData(uint32_t p_SkeletonSetupIndex, uint32_t p_MeshSetupIndex, uint32_t p_TriangleIndex, Triangle& p_Triangle)
    {
        Triangle_Init(&p_Triangle);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }
    SDKReturnCode CoreConnection::LoadSkeleton(uint32_t p_SkeletonSetupIndex, uint32_t& p_SkeletonId)
    {
        p_SkeletonId = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::UnloadSkeleton(uint32_t p_SkeletonId)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SaveTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, bool p_IsSkeletonModified)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CompressTemporarySkeletonAndGetSize(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, uint32_t* p_TemporarySkeletonLengthInBytes)
    {
        *p_TemporarySkeletonLengthInBytes = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetCompressedTemporarySkeletonData(unsigned char* p_TemporarySkeletonData, uint32_t p_TemporarySkeletonLengthInBytes)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTemporarySkeletonFromCompressedData(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId, unsigned char* p_RecordingData, uint32_t p_RecordingLengthInBytes)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ClearTemporarySkeleton(uint32_t p_SkeletonSetupIndex, uint32_t p_SessionId)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ClearAllTemporarySkeletons()
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTemporarySkeletonCountForAllSessions(TemporarySkeletonCountForAllSessions& p_TemporarySkeletonCountForSessions)
    {
        TemporarySkeletonCountForAllSessions_Init(&p_TemporarySkeletonCountForSessions);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTemporarySkeletonsInfoForSession(uint32_t p_SessionId, TemporarySkeletonsInfoForSession& p_TemporarySkeletonsInfoForSession)
    {
        TemporarySkeletonsInfoForSession_Init(&p_TemporarySkeletonsInfoForSession);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AllocateChains(uint32_t p_SkeletonSetupIndex)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::PrepareSkeleton(uint32_t p_SkeletonSetupIndex)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSkeletonSetupInfo(uint32_t p_SkeletonSetupIndex, SkeletonSetupInfo* p_SDK)
    {
        SkeletonSetupInfo_Init(p_SDK);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSkeletonSetupArraySizes(uint32_t p_SkeletonSetupIndex, SkeletonSetupArraySizes& p_SkeletonInfo)
    {
        SkeletonSetupArraySizes_Init(&p_SkeletonInfo);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSkeletonChains(uint32_t p_SkeletonSetupIndex, ChainSetup* p_SDK)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSkeletonChains(uint32_t p_SkeletonSetupIndex, ChainSetup* p_ChainSetupArray, uint32_t p_ArraySize)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }


    SDKReturnCode CoreConnection::GetSkeletonNodes(uint32_t p_SkeletonSetupIndex, NodeSetup* p_SDK)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSkeletonNodes(uint32_t p_SkeletonSetupIndex, NodeSetup* p_NodeSetupArray, uint32_t p_ArraySize)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSkeletonColliders(uint32_t p_SkeletonSetupIndex, ColliderSetup* p_SDK)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CalibrateHapticsModule(uint32_t p_DongleId, Side p_HandType)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetDonglePolygon(const DonglePolygonArgs& p_Args, SetPolygonDongleResponse& p_SetPolygonDongleResponse)
    {
        SetPolygonDongleResponse_Init(&p_SetPolygonDongleResponse);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::Pair(const PairingArgs& p_Args)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::Unpair(const PairingArgs& p_Args)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CalibrationSetMin(const CalibrationArgs& p_Args, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CalibrationSetMax(const CalibrationArgs& p_Args, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CalibrationStore(const CalibrationArgs& p_Args, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CalibrationBegin(const CalibrationArgs& p_Args, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CalibrationEnd(const CalibrationArgs& p_Args, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CalibrationDataGet(const CalibrationArgs& p_Args, CalibrationData& p_CalibrationData)
    {
        CalibrationData_Init(&p_CalibrationData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::CalibrationDataSet(const CalibrationArgs& p_Args, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::UpdateDongleFirmware(const DongleUpdateArgs& p_Args, DongleUpdateResponse& p_DongleUpdateResponse)
    {
        DongleUpdateResponse_Init(&p_DongleUpdateResponse);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }


    SDKReturnCode CoreConnection::StartQuantumCalibration(const StartQuantumCalibrationArgs& p_Args, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StartQuantumCalibrationStep(const StartQuantumCalibrationStepArgs& p_Args, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StopQuantumCalibration(uint32_t p_GloveID, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetGloveCalibrationSize(uint32_t p_GloveId, uint32_t* p_Size)
    {
        p_Size = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetGloveCalibrationSizeForUser(uint32_t p_UserId, Side p_Side, GloveProfileType p_ProfileType, uint32_t* p_Size)
    {
        p_Size = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetGloveCalibration(unsigned char* p_CalibrationBytes, uint32_t p_BytesLength)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetGloveCalibration(uint32_t p_GloveId, unsigned char* p_CalibrationBytes, uint32_t p_BytesLength, SetGloveCalibrationReturnCode& p_Response)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetGloveCalibrationForUser(uint32_t p_UserId, unsigned char* p_CalibrationBytes, uint32_t p_BytesLength, SetGloveCalibrationReturnCode& p_Response)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetBandScan(BandScanArgs& p_BandScanArgs, int32_t& p_BandScanType, unsigned char* p_BandScanData)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetChannel(uint32_t p_Channel, uint32_t p_DongleId, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetPersistentDongleChannels(bool p_SetPersistent)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AreDongleChannelsPersistent(bool& p_IsPersistent)
    {
        p_IsPersistent = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetEnableVirtualDongles(bool p_Enable)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AreVirtualDonglesEnabled(bool& p_IsEnabled)
    {
        p_IsEnabled = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }


    SDKReturnCode CoreConnection::SetSettingIgnoreThumbIMU(bool p_IgnoreThumbIMU)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSettingIgnoreThumbIMU(bool& p_IgnoreThumbIMU)
    {
        p_IgnoreThumbIMU = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetSettingIgnoreNonThumbFingerIMU(bool p_IgnoreNonThumbFingerIMU)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSettingIgnoreNonThumbFingerIMU(bool& p_IgnoreNonThumbFingerIMU)
    {
        p_IgnoreNonThumbFingerIMU = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }


    SDKReturnCode CoreConnection::SetSettingPinchCompensation(bool p_PinchCompensation)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSettingPinchCompensation(bool& p_PinchCompensation)
    {
        p_PinchCompensation = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AddUser(char* p_Name, uint32_t& p_UserID)
    {
        p_UserID = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RemoveUser(uint32_t p_Id)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetUserName(uint32_t p_Id, char* p_Name)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetAutoUserAssignment(bool p_Enabled)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AssignDongleToUser(uint32_t p_Id, uint32_t p_DongleId)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AssignGloveToUser(uint32_t p_UserId, uint32_t p_GloveId, Side p_Side)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AssignProfileToUser(UserProfileArgs p_UserProfileArgs, CompleteType& p_Message)
    {
        p_Message = CompleteType_Error;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::MoveUserUp(uint32_t p_Id)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::MoveUserDown(uint32_t p_Id)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetCalibrationProfile(uint32_t p_UserId, CalibrationProfile& p_CalibrationProfile)
    {
        CalibrationProfile_Init(&p_CalibrationProfile);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }



    SDKReturnCode CoreConnection::IsUserUsingHMD(bool& p_IsUsingHMD, uint32_t p_UserId)
    {
        p_IsUsingHMD = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AutoGroupTrackers()
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AutoAssignTrackers(uint32_t p_UserId)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ResetTrackerAssignment(uint32_t p_UserId)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AssignTrackerToUser(TrackerId p_TrackerId, uint32_t p_UserId)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::AssignRoleToTracker(TrackerId p_TrackerId, TrackerType p_TrackerType)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ChangeUserForRole(TrackerType p_Role, uint32_t p_CurrentUser, uint32_t p_TargetUser)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTrackingSystems(TrackingSystemInfo& p_Current, TrackingSystemInfo* p_Systems)
    {
        TrackingSystemInfo_Init(&p_Current);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::KeepLastPosition(bool p_UseLastPosition)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::UseTimeout(bool p_UseTimeOut)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTimeout(float p_TimeOut)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTrackerServiceSettings(bool& p_UseTimeout, float& p_Timeout, bool& p_KeepLastPosition)
    {
        p_UseTimeout = false;
        p_Timeout = false;
        p_KeepLastPosition = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }


    SDKReturnCode CoreConnection::GetTrackerSystemsSettings(TrackerSystem* p_TrackerSystems, uint32_t& p_TrackerSystemCount)
    {
        p_TrackerSystemCount = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTrackerSystemsSettings(TrackerSystem* p_TrackerSystems)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    // polygon calibration 
    SDKReturnCode CoreConnection::StartSequence(StartSequenceArg p_Args, SequenceData& p_SequenceData)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StopSequence(uint32_t p_Id, CompleteType& p_Message)
    {
        p_Message = CompleteType_Error;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StartNextStep(uint32_t p_Id, CompleteType& p_Message)
    {
        p_Message = CompleteType_Error;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::UndoStep(uint32_t p_Id, CompleteType& p_Message)
    {
        p_Message = CompleteType_Error;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSequenceState(uint32_t p_Id, SequenceStateValue& p_SequenceStateValue)
    {
        SequenceStateValue_Init(&p_SequenceStateValue);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetStepData(uint32_t p_Id, StepData& p_StepData)
    {
        StepData_Init(&p_StepData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ApplyProfile(uint32_t p_Id, CompleteType& p_Message)
    {
        p_Message = CompleteType_Error;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    // Extended telemetry
    SDKReturnCode CoreConnection::ReportFeatureUsage(FeatureUsed p_Feature, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ReportExportFeatureUsage(ExportFeatureReport p_Report, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ReportExportCSVFeatureUsage(ExportCSVFeatureReport p_Report, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ReportOpenXRFeatureUsage(OpenXRFeatureReport p_Report, bool& p_CommandResponse)
    {
        p_CommandResponse = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    //Playback Recording
    SDKReturnCode CoreConnection::StartRecording(bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StopRecording(bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::UnloadRecording(bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StartPlayback(bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::EnablePlayback(bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StopPlayback(bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SeekFrame(SeekFrameInfo p_SeekFrameInfo, ManusTimestamp& p_Timestamp)
    {
        ManusTimestamp_Init(&p_Timestamp);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StartPlaybackFromSpecificTime(uint32_t p_PlaybackStartingTime, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetCurrentRecordingProperties(PlaybackRecordingProperties& p_RecordingProperties)
    {
        PlaybackRecordingProperties_Init(&p_RecordingProperties);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SaveRecordingToFile(char* p_PathName, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::LoadRecordingFromFile(char* p_PathName, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::ZipRecordingDataAndGetSize(uint32_t& p_RecordingLengthInBytes)
    {
        p_RecordingLengthInBytes = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRecordingData(unsigned char* p_RecordingData, uint32_t p_RecordingSize)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::LoadRecordingFromClientFile(unsigned char* p_RecordingData, uint32_t p_RecordingLengthInBytes, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    //Timecode
    SDKReturnCode CoreConnection::UseTimecodeTimestamps(bool p_Use)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::IsUsingTimecodeTimestamps(bool& p_IsUsing)
    {
        p_IsUsing = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StartTimecode(StartTimecodeArgs p_Args, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::StopTimecode(bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::RefreshTimecodeInterfaces(bool p_Reconnect, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::IsTimecodeRunning(bool& p_Running)
    {
        p_Running = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTimecodeAutoStart(bool p_Enabled, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTimecodeAutoStart(bool& p_Enabled)
    {
        p_Enabled = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTimecodeDeviceKeepAlive(bool p_Enabled, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTimecodeDeviceKeepAlive(bool& p_Enabled)
    {
        p_Enabled = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTimecodeGenlock(bool p_Enabled, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTimecodeGenlock(bool& p_Enabled)
    {
        p_Enabled = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTimecodeNonRealTime(bool p_Enabled, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTimecodeNonRealTime(bool& p_Enabled)
    {
        p_Enabled = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetLtcChannel(int32_t p_Channel, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetLtcChannel(int32_t& p_Channel)
    {
        p_Channel = -1;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTimecodePreferredInterfaceAPI(char* p_Name, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTimecodePreferredInterfaceAPI(char* p_Name)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetTimecodePreferredInterfaceName(char* p_Name, bool& p_Success)
    {
        p_Success = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTimecodePreferredInterfaceName(char* p_Name)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNumberOfAvailableGloves(uint32_t& p_NumberOfAvailableGloves)
    {
        p_NumberOfAvailableGloves = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetIdsOfAvailableGloves(uint32_t* p_IdsOfAvailableGloves, uint32_t p_NumberOfIdsThatFitInArray)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetGlovesForDongle(uint32_t p_DongleId, uint32_t& p_LeftGloveId, uint32_t& p_RightGloveId)
    {
        p_LeftGloveId = 0;
        p_RightGloveId = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetDataForGlove(uint32_t p_GloveId, GloveLandscapeData& p_GloveData)
    {
        GloveLandscapeData_Init(&p_GloveData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetDataForDongle(uint32_t p_DongleId, DongleLandscapeData& p_DongleData)
    {
        DongleLandscapeData_Init(&p_DongleData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetRawSkeletonPinchCompensation(bool p_Enable)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawSkeletonPinchCompensation(bool& p_Enabled)
    {
        p_Enabled = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetRawSkeletonCasingCompensation(float p_FilterStrength)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawSkeletonCasingCompensation(float& p_FilterStrength)
    {
        p_FilterStrength = 0.0f;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetDongleIds(uint32_t* p_DongleIds, uint32_t p_NumberOfIdsThatFitInArray)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetHapticsDongleIds(uint32_t* p_HapticsDongleIds, uint32_t p_NumberOfIdsThatFitInArray)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNumberOfDongles(uint32_t& p_NumberOfDongles)
    {
        p_NumberOfDongles = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNumberOfHapticsDongles(uint32_t& p_NumberOfHapticsDongles)
    {
        p_NumberOfHapticsDongles = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNumberOfAvailableUsers(uint32_t& p_NumberOfAvailableUsers)
    {
        p_NumberOfAvailableUsers = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetIdsOfAvailableUsers(uint32_t* p_IdsOfAvailableUsers, uint32_t p_NumberOfIdsThatFitInArray)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetGloveIdOfUserId(uint32_t p_UserId, Side p_HandType, uint32_t& p_GloveId)
    {
        p_GloveId = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNumberOfAvailableTrackers(uint32_t& p_NumberOfAvailableTrackers)
    {
        p_NumberOfAvailableTrackers = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetIdsOfAvailableTrackers(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_NumberOfIdsThatFitInArray)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNumberOfAvailableTrackersForUserId(uint32_t& p_NumberOfAvailableTrackers, uint32_t p_UserId)
    {
        p_NumberOfAvailableTrackers = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetIdsOfAvailableTrackersForUserId(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_UserId, uint32_t p_NumberOfIdsThatFitInArray)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNumberOfAvailableTrackersForUserIndex(uint32_t& p_NumberOfAvailableTrackers, uint32_t p_UserIndex)
    {
        p_NumberOfAvailableTrackers = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetIdsOfAvailableTrackersForUserIndex(TrackerId* p_IdsOfAvailableTrackers, uint32_t p_UserIndex, uint32_t p_NumberOfIdsThatFitInArray)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetDataForTracker(TrackerId p_TrackerId, TrackerData& p_TrackerData)
    {
        TrackerData_Init(&p_TrackerData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetDataForTracker(uint32_t p_UserId, uint32_t p_TrackerType, TrackerData& p_TrackerData)
    {
        TrackerData_Init(&p_TrackerData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetTrackerData(uint32_t p_TrackerIndex, TrackerData& p_TrackerData)
    {
        TrackerData_Init(&p_TrackerData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::PairGlove(uint32_t p_GloveID, bool& p_Result)
    {
        p_Result = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::PairGloveToDongle(uint32_t p_GloveID, uint32_t p_DongleID, bool& p_Result)
    {
        p_Result = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::UnpairGlove(uint32_t p_GloveID, bool& p_Result)
    {
        p_Result = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GloveCalibrationStart(GloveCalibrationArgs p_CalibrationArgs, bool& p_Result)
    {
        p_Result = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GloveCalibrationStop(GloveCalibrationArgs p_CalibrationArgs, bool& p_Result)
    {
        p_Result = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GloveCalibrationFinish(GloveCalibrationArgs p_CalibrationArgs, bool& p_Result)
    {
        p_Result = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GloveCalibrationGetNumberOfSteps(GloveCalibrationArgs p_CalibrationArgs, uint32_t& p_NumberOfSteps)
    {
        p_NumberOfSteps = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GloveCalibrationGetStepData(GloveCalibrationStepArgs p_CalibrationStepArgs, GloveCalibrationStepData& p_Data)
    {
        GloveCalibrationStepData_Init(&p_Data);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GloveCalibrationStartStep(GloveCalibrationStepArgs p_CalibrationStepArgs, bool& p_Result)
    {
        p_Result = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetGestureLandscapeData(GestureLandscapeData* p_LandscapeDataArray, uint32_t p_ArraySize)
    {
        for (size_t i = 0; i < p_ArraySize; i++)
        {
            GestureLandscapeData_Init(&p_LandscapeDataArray[i]);
        }
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::DoesSkeletonGloveSupportHaptics(uint32_t p_SkeletonId, Side p_HandType, bool& p_IsHaptics)
    {
        p_IsHaptics = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSkeletonInfo(uint32_t p_SkeletonIndex, SkeletonInfo& p_Info)
    {
        SkeletonInfo_Init(&p_Info);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSkeletonData(uint32_t p_SkeletonIndex, SkeletonNode* p_Nodes, uint32_t p_NodeCount)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetRawSkeletonHandMotion(HandMotion p_HandMotion)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawSkeletonHandMotion(HandMotion& p_HandMotion)
    {
        p_HandMotion = HandMotion::HandMotion_None;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawSkeletonInfo(uint32_t p_SkeletonIndex, RawSkeletonInfo& p_Info)
    {
        RawSkeletonInfo_Init(&p_Info);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawSkeletonData(uint32_t p_SkeletonIndex, SkeletonNode* p_Nodes, uint32_t p_NodeCount)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawSkeletonNodeCount(uint32_t p_GloveId, uint32_t& p_NodeCount)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawSkeletonNodeInfo(uint32_t p_GloveId, NodeInfo* p_NodeHierarchy)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawSkeletonNodeInfo(uint32_t p_GloveId, NodeInfo* p_NodeInfo, uint32_t p_NodeCount)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetRawDeviceData(uint32_t p_RawDeviceDataIndex, RawDeviceData& p_RawDeviceData)
    {
        RawDeviceData_Init(&p_RawDeviceData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetExtraDeviceData(uint32_t p_ExtraDeviceDataIndex, ExtraDeviceData& p_Data)
    {
        ExtraDeviceData_Init(&p_Data);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetStatistics(StatisticsStream* p_Statistics)
    {
        StatisticsStream_Init(p_Statistics);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetDebuggingData(uint32_t p_StartIndex, DebuggingData& p_DebuggingData)
    {
        DebuggingData_Init(&p_DebuggingData);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetGestureStreamData(uint32_t p_GestureStreamDataIndex, uint32_t p_StartDataIndex, GestureProbabilities& p_GestureProbabilitiesCollection)
    {
        GestureProbabilities_Init(&p_GestureProbabilitiesCollection);
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetSettingsRawSkeletonStream(bool p_StreamActive)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetSettingsRawSkeletonStream(bool& p_StreamActive)
    {
        p_StreamActive = false;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    //Multicore netdevices
    SDKReturnCode CoreConnection::NetDeviceGetNumberOfAvailableHosts(uint32_t& p_NumberOfAvailableHosts)
    {
        p_NumberOfAvailableHosts = 0;
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::NetDeviceGetAvailableHosts(ManusHost* p_Hosts, const uint32_t p_NumberOfAvailableHosts)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::NetDeviceConnect(ManusHost p_Host)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::NetDeviceDisconnect(ManusHost p_Host)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetNetDeviceMode(bool p_Client)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNetDeviceMode(bool& p_Client)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::SetNetDeviceAutoconnectPolicy(bool p_Autoconnect)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

    SDKReturnCode CoreConnection::GetNetDeviceAutoconnectPolicy(bool& p_Autoconnect)
    {
        return SDKReturnCode::SDKReturnCode_FunctionNotAvailable;
    }

} // namespace ManusSDK