Plugin/Source/SenseGloveCoreKismet/Private/SGCoreKismet/SGHapticGloveKismetLibrary.cpp

/**
 * @file
 *
 * @author  Mamadou Babaei <mamadou@senseglove.com>
 *
 * @section LICENSE
 *
 * (The MIT License)
 *
 * Copyright (c) 2020 - 2022 SenseGlove
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * @section DESCRIPTION
 *
 *
 */


#include "SGCoreKismet/SGHapticGloveKismetLibrary.h"

#include "SGCore/SGBasicHandModel.h"
#include "SGCore/SGBuzzCommand.h"
#include "SGCore/SGForceFeedbackCommand.h"
#include "SGCore/SGHandPose.h"
#include "SGCore/SGHandProfile.h"
#include "SGCore/SGHapticGlove.h"
#include "SGCore/SGThumperCommand.h"

TArray<USGHapticGlove*> USGHapticGloveKismetLibrary::GetHapticGloves(UObject* WorldContextObject)
{
    return USGHapticGlove::GetHapticGloves(WorldContextObject);
}

bool USGHapticGloveKismetLibrary::GetGlove_OutG(UObject* WorldContextObject, USGHapticGlove*& OutGlove)
{
    return USGHapticGlove::GetGlove(WorldContextObject, OutGlove);
}

bool USGHapticGloveKismetLibrary::GetGlove_bRH_OutG(UObject* WorldContextObject,
                                                    const bool bRightHanded, USGHapticGlove*& OutGlove)
{
    return USGHapticGlove::GetGlove(WorldContextObject, bRightHanded, OutGlove);
}

ESGDeviceType USGHapticGloveKismetLibrary::GetDeviceType(const USGHapticGlove* HapticGlove)
{
    return HapticGlove->GetDeviceType();
}

FString USGHapticGloveKismetLibrary::GetDeviceId(const USGHapticGlove* HapticGlove)
{
    return HapticGlove->GetDeviceId();
}

FString USGHapticGloveKismetLibrary::GetHardwareVersion(const USGHapticGlove* HapticGlove)
{
    return HapticGlove->GetHardwareVersion();
}

int32 USGHapticGloveKismetLibrary::GetFirmwareVersion(const USGHapticGlove* HapticGlove)
{
    return HapticGlove->GetFirmwareVersion();
}

int32 USGHapticGloveKismetLibrary::GetSubFirmwareVersion(const USGHapticGlove* HapticGlove)
{
    return HapticGlove->GetSubFirmwareVersion();
}

bool USGHapticGloveKismetLibrary::IsRight(const USGHapticGlove* HapticGlove)
{
    return HapticGlove->IsRight();
}

bool USGHapticGloveKismetLibrary::GetImuRotation_FQuat_OutI(USGHapticGlove* HapticGlove, FQuat& OutImu)
{
    return HapticGlove->GetImuRotation(OutImu);
}

bool USGHapticGloveKismetLibrary::GetImuRotation_FRotator_OutI(USGHapticGlove* HapticGlove, FRotator& OutImu)
{
    return HapticGlove->GetImuRotation(OutImu);
}

bool USGHapticGloveKismetLibrary::GetHandPose_HG_HP_OutHP(
    UObject* WorldContextObject, USGHapticGlove* HapticGlove,
    const USGBasicHandModel* HandGeometry, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
{
    return HapticGlove->GetHandPose(WorldContextObject, HandGeometry, HandProfile, OutHandPose);
}

bool USGHapticGloveKismetLibrary::GetHandPose_HP_OutHP(
    UObject* WorldContextObject,
    USGHapticGlove* HapticGlove, const USGHandProfile* HandProfile, USGHandPose*& OutHandPose)
{
    return HapticGlove->GetHandPose(WorldContextObject, HandProfile, OutHandPose);
}

bool USGHapticGloveKismetLibrary::GetHandPose_HG_OutHP(
    UObject* WorldContextObject,
    USGHapticGlove* HapticGlove, const USGBasicHandModel* HandGeometry, USGHandPose*& OutHandPose)
{
    return HapticGlove->GetHandPose(WorldContextObject, HandGeometry, OutHandPose);
}

bool USGHapticGloveKismetLibrary::GetHandPose_OutHP(
    UObject* WorldContextObject, USGHapticGlove* HapticGlove, USGHandPose*& OutHandPose)
{
    return HapticGlove->GetHandPose(WorldContextObject, OutHandPose);
}

void USGHapticGloveKismetLibrary::StopHaptics(USGHapticGlove* HapticGlove)
{
    return HapticGlove->StopHaptics();
}

void USGHapticGloveKismetLibrary::StopVibrations(USGHapticGlove* HapticGlove)
{
    return HapticGlove->StopVibrations();
}

void USGHapticGloveKismetLibrary::SendHaptics_FFC(
    USGHapticGlove* HapticGlove, const USGForceFeedbackCommand* ForceFeedbackCommand)
{
    return HapticGlove->SendHaptics(ForceFeedbackCommand);
}

void USGHapticGloveKismetLibrary::SendHaptics_BC(
    USGHapticGlove* HapticGlove, const USGBuzzCommand* BuzzCommand)
{
    return HapticGlove->SendHaptics(BuzzCommand);
}

void USGHapticGloveKismetLibrary::SendHaptics_TC(
    USGHapticGlove* HapticGlove, const USGThumperCommand* ThumperCommand)
{
    return HapticGlove->SendHaptics(ThumperCommand);
}

void USGHapticGloveKismetLibrary::SendHaptics_FFC_BC(
    USGHapticGlove* HapticGlove,
    const USGForceFeedbackCommand* ForceFeedbackCommand, const USGBuzzCommand* BuzzCommand)
{
    return HapticGlove->SendHaptics(ForceFeedbackCommand, BuzzCommand);
}

void USGHapticGloveKismetLibrary::SendHaptics_FFC_BC_TC(
    USGHapticGlove* HapticGlove,
    const USGForceFeedbackCommand* ForceFeedbackCommand,
    const USGBuzzCommand* BuzzCommand,
    const USGThumperCommand* ThumperCommand)
{
    return HapticGlove->SendHaptics(ForceFeedbackCommand, BuzzCommand, ThumperCommand);
}

bool USGHapticGloveKismetLibrary::GetCalibrationValues(USGHapticGlove* HapticGlove, TArray<FVector>& OutValues)
{
    return HapticGlove->GetCalibrationValues(OutValues);
}

void USGHapticGloveKismetLibrary::ResetCalibrationRange(USGHapticGlove* HapticGlove)
{
    HapticGlove->ResetCalibrationRange();
}

void USGHapticGloveKismetLibrary::UpdateCalibrationRange(USGHapticGlove* HapticGlove)
{
    HapticGlove->UpdateCalibrationRange();
}

void USGHapticGloveKismetLibrary::UpdateCalibrationRange_CV(USGHapticGlove* HapticGlove,
                                                                           const TArray<FVector>& CalibrationValues)
{
    HapticGlove->UpdateCalibrationRange(CalibrationValues);
}

void USGHapticGloveKismetLibrary::GetCalibrationRange(USGHapticGlove* HapticGlove,
                                                      TArray<FVector>& OutMinValues,
                                                      TArray<FVector>& OutMaxValues)
{
    HapticGlove->GetCalibrationRange(OutMinValues, OutMaxValues);
}

void USGHapticGloveKismetLibrary::UpdateCalibration(
    UObject* WorldContextObject, USGHapticGlove* HapticGlove, USGHandProfile*& OutProfile)
{
    HapticGlove->UpdateCalibration(WorldContextObject, OutProfile);
}

void USGHapticGloveKismetLibrary::ApplyCalibration(
    UObject* WorldContextObject, const USGHapticGlove* HapticGlove, USGHandProfile*& OutProfile)
{
    HapticGlove->ApplyCalibration(WorldContextObject, OutProfile);
}

void USGHapticGloveKismetLibrary::GetWristLocation_RP_FQuat_RR_TH_OutWP_OutWR(
    const USGHapticGlove* HapticGlove,
    const FVector& ReferencePosition, const FQuat& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutWristPosition, FQuat& OutWristRotation)
{
    HapticGlove->GetWristLocation(ReferencePosition, ReferenceRotation,
                                  TrackingHardware,
                                  OutWristPosition, OutWristRotation);
}

void USGHapticGloveKismetLibrary::GetWristLocation_RP_FRotator_RR_TH_OutWP_OutWR(
    const USGHapticGlove* HapticGlove,
    const FVector& ReferencePosition, const FRotator& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutWristPosition, FRotator& OutWristRotation)
{
    HapticGlove->GetWristLocation(ReferencePosition, ReferenceRotation,
                                  TrackingHardware,
                                  OutWristPosition, OutWristRotation);
}

void USGHapticGloveKismetLibrary::GetGloveLocation_RP_FQuat_RR_TH_OutGP_OutGR(
    const USGHapticGlove* HapticGlove,
    const FVector& ReferencePosition, const FQuat& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutGlovePosition, FQuat& OutGloveRotation)
{
    HapticGlove->GetGloveLocation(ReferencePosition, ReferenceRotation,
                                  TrackingHardware,
                                  OutGlovePosition, OutGloveRotation);
}

void USGHapticGloveKismetLibrary::GetGloveLocation_RP_FRotator_RR_TH_OutGP_OutGR(
    const USGHapticGlove* HapticGlove,
    const FVector& ReferencePosition, const FRotator& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutGlovePosition, FRotator& OutGloveRotation)
{
    HapticGlove->GetGloveLocation(ReferencePosition, ReferenceRotation,
                                  TrackingHardware,
                                  OutGlovePosition, OutGloveRotation);
}