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_OutGlove(UObject* WorldContextObject, USGHapticGlove*& OutGlove)
{
    return USGHapticGlove::GetGlove(WorldContextObject, OutGlove);
}

bool USGHapticGloveKismetLibrary::GetGlove_bRightHanded_OutGlove(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_FQuatOutImu(USGHapticGlove* HapticGlove, FQuat& OutImu)
{
    return HapticGlove->GetImuRotation(OutImu);
}

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

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

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

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

bool USGHapticGloveKismetLibrary::GetHandPose_OutHandPose(
    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_ForceFeedbackCommand(
    USGHapticGlove* HapticGlove, const USGForceFeedbackCommand* ForceFeedbackCommand)
{
    return HapticGlove->SendHaptics(ForceFeedbackCommand);
}

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

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

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

void USGHapticGloveKismetLibrary::SendHaptics_ForceFeedbackCommand_BuzzCommand_ThumperCommand(
    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_CalibrationValues(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_ReferencePosition_ReferenceRotation_TrackingHardware_OutWristPosition_OutWristLocation(
    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_ReferencePosition_FRotatorReferenceRotation_TrackingHardware_OutWristPosition_FRotatorOutWristLocation(
    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_ReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_OutGloveRotation(
    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_FRotatorReferencePosition_ReferenceRotation_TrackingHardware_OutGlovePosition_FRotatorOutGloveRotation(
    const USGHapticGlove* HapticGlove,
    const FVector& ReferencePosition, const FRotator& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutGlovePosition, FRotator& OutGloveRotation)
{
    HapticGlove->GetGloveLocation(ReferencePosition, ReferenceRotation,
                                  TrackingHardware,
                                  OutGlovePosition, OutGloveRotation);
}