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

/**
 * @file
 *
 * @author  Mamadou Babaei <mamadou@senseglove.com>
 *
 * @section LICENSE
 *
 * (The MIT License)
 *
 * Copyright (c) 2020 - 2024 NovaGlove
 *
 * 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/SGNovaGloveKismetLibrary.h"

#include "SGCore/SGHandPose.h"
#include "SGCore/SGNovaGlove.h"
#include "SGCore/SGNovaGloveSensorData.h"
#include "SGUtils/SGArrayUtils.h"

USGDevice* USGNovaGloveKismetLibrary::Parse(UObject* WorldContextObject, const FString& ConstantsString)
{
    return USGNovaGlove::Parse(WorldContextObject, ConstantsString);
}

TArray<USGNovaGlove*> USGNovaGloveKismetLibrary::GetNovaGloves(UObject* WorldContextObject)
{
    return USGNovaGlove::GetNovaGloves(WorldContextObject);
}

bool USGNovaGloveKismetLibrary::GetNovaGlove_OutG(UObject* WorldContextObject, USGNovaGlove*& OutGlove)
{
    return USGNovaGlove::GetNovaGlove(WorldContextObject, OutGlove);
}

bool USGNovaGloveKismetLibrary::GetNovaGlove_bRH_OutG(UObject* WorldContextObject,
                                                      const bool bRightHanded, USGNovaGlove*& OutGlove)
{
    return USGNovaGlove::GetNovaGlove(WorldContextObject, bRightHanded, OutGlove);
}

void USGNovaGloveKismetLibrary::CalculateGloveLocation_RP_FQuat_RR_TH_bRH_OutGP_OutGR(
    const FVector& ReferencePosition, const FQuat& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
    FVector& OutGlovePosition, FQuat& OutGloveRotation)
{
    USGNovaGlove::CalculateGloveLocation(ReferencePosition, ReferenceRotation,
                                         TrackingHardware, bRightHanded,
                                         OutGlovePosition, OutGloveRotation);
}

void USGNovaGloveKismetLibrary::CalculateGloveLocation_RP_FRotator_RR_TH_bRH_OutGP_OutGR(
    const FVector& ReferencePosition, const FRotator& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
    FVector& OutGlovePosition, FRotator& OutGloveRotation)
{
    USGNovaGlove::CalculateGloveLocation(ReferencePosition, ReferenceRotation,
                                         TrackingHardware, bRightHanded,
                                         OutGlovePosition, OutGloveRotation);
}

void USGNovaGloveKismetLibrary::CalculateWristLocation_RP_FQuat_RR_TH_bRH_OutWP_OutWR(
    const FVector& ReferencePosition, const FQuat& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
    FVector& OutWristPosition, FQuat& OutWristRotation)
{
    USGNovaGlove::CalculateWristLocation(ReferencePosition, ReferenceRotation,
                                         TrackingHardware, bRightHanded,
                                         OutWristPosition, OutWristRotation);
}

void USGNovaGloveKismetLibrary::CalculateWristLocation_RP_FRotator_RR_TH_bRH_OutWP_OutWR(
    const FVector& ReferencePosition, const FRotator& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware, const bool bRightHanded,
    FVector& OutWristPosition, FRotator& OutWristRotation)
{
    USGNovaGlove::CalculateWristLocation(ReferencePosition, ReferenceRotation,
                                         TrackingHardware, bRightHanded,
                                         OutWristPosition, OutWristRotation);
}

FString USGNovaGloveKismetLibrary::GetHapticsByte()
{
    return FString::Printf(TEXT("%c"), USGNovaGlove::GetHapticsByte());
}

FString USGNovaGloveKismetLibrary::GetThresholdsByte()
{
    return FString::Printf(TEXT("%c"), USGNovaGlove::GetThresholdsByte());
}

FString USGNovaGloveKismetLibrary::GetIgnoreThresholdsByte()
{
    return FString::Printf(TEXT("%c"), USGNovaGlove::GetIgnoreThresholdsByte());
}

TArray<float> USGNovaGloveKismetLibrary::GetNovaSensorRanges()
{
    return USGNovaGlove::GetNovaSensorRanges();
}

TArray<float> USGNovaGloveKismetLibrary::ToNormalizedValues_SD(const USGNovaGloveSensorData* SensorData)
{
    return USGNovaGlove::ToNormalizedValues(SensorData);
}

TArray<float> USGNovaGloveKismetLibrary::ToNormalizedValues_SD_OutSN(
    UObject* WorldContextObject,
    const USGNovaGloveSensorData* SensorData, USGSensorNormalization*& OutSensorNormalizer)
{
    return USGNovaGlove::ToNormalizedValues(WorldContextObject, SensorData, OutSensorNormalizer);
}

TArray<FSGVectorArray> USGNovaGloveKismetLibrary::CalculateHandAngles(
    const TArray<float>& NormalizedValues, const USGHandInterpolator* Interpolator)
{
    const TArray<FSGVectorArray> HandAngles{
        FSGArrayUtils::ToNestedBPArray<FVector, FSGVectorArray>(
            USGNovaGlove::CalculateHandAngles(NormalizedValues, Interpolator))
    };
    return HandAngles;
}

FString USGNovaGloveKismetLibrary::ToNovaCommandAsFlexion(const USGThresholdCommand* Thresholds)
{
    return USGNovaGlove::ToNovaCommandAsFlexion(Thresholds);
}

FString USGNovaGloveKismetLibrary::ToNovaCommandAsRaw(
    const USGThresholdCommand* Thresholds, const USGSensorNormalization* Interpolator)
{
    return USGNovaGlove::ToNovaCommandAsRaw(Thresholds, Interpolator);
}

ESGDeviceType USGNovaGloveKismetLibrary::GetDeviceType(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->GetDeviceType();
}

FString USGNovaGloveKismetLibrary::GetDeviceId(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->GetDeviceId();
}

FString USGNovaGloveKismetLibrary::GetHardwareVersion(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->GetHardwareVersion();
}

int32 USGNovaGloveKismetLibrary::GetFirmwareVersion(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->GetFirmwareVersion();
}

int32 USGNovaGloveKismetLibrary::GetSubFirmwareVersion(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->GetSubFirmwareVersion();
}

void USGNovaGloveKismetLibrary::SetDeviceIndex(USGNovaGlove* NovaGlove, const int32 NewIndex)
{
    NovaGlove->SetDeviceIndex(NewIndex);
}

bool USGNovaGloveKismetLibrary::HasBattery(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->HasBattery();
}

bool USGNovaGloveKismetLibrary::IsCharging(USGNovaGlove* NovaGlove)
{
    return NovaGlove->IsCharging();
}

bool USGNovaGloveKismetLibrary::GetBatteryLevel(USGNovaGlove* NovaGlove, float& OutBatteryLevel)
{
    return NovaGlove->GetBatteryLevel(OutBatteryLevel);
}

bool USGNovaGloveKismetLibrary::IsRight(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->IsRight();
}

bool USGNovaGloveKismetLibrary::GetImuRotation_FQuat_OutI(USGNovaGlove* NovaGlove, FQuat& OutImu)
{
    return NovaGlove->GetImuRotation(OutImu);
}

bool USGNovaGloveKismetLibrary::GetImuRotation_FRotator_OutI(USGNovaGlove* NovaGlove, FRotator& OutImu)
{
    return NovaGlove->GetImuRotation(OutImu);
}

bool USGNovaGloveKismetLibrary::GetHandPose(
    UObject* WorldContextObject,
    USGNovaGlove* NovaGlove, const USGBasicHandModel* HandModel, USGHandPose*& OutHandPose)
{
    return NovaGlove->GetHandPose(WorldContextObject, HandModel, OutHandPose);
}

bool USGNovaGloveKismetLibrary::GetHandAngles(const USGNovaGlove* NovaGlove, TArray<FSGVectorArray>& OutHandAngles)
{
    TArray<TArray<FVector>> HandAnglesNestedArray;
    const bool bResult = NovaGlove->GetHandAngles(HandAnglesNestedArray);
    OutHandAngles = FSGArrayUtils::ToNestedBPArray<FVector, FSGVectorArray>(MoveTemp(HandAnglesNestedArray));
    return bResult;
}

ESGHapticGloveCalibrationState USGNovaGloveKismetLibrary::GetCalibrationState(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->GetCalibrationState();
}

void USGNovaGloveKismetLibrary::EndCalibration(USGNovaGlove* NovaGlove)
{
    NovaGlove->EndCalibration();
}

void USGNovaGloveKismetLibrary::ResetCalibration(USGNovaGlove* NovaGlove)
{
    NovaGlove->ResetCalibration();
}

void USGNovaGloveKismetLibrary::StopHaptics(USGNovaGlove* NovaGlove)
{
    NovaGlove->StopHaptics();
}

void USGNovaGloveKismetLibrary::StopVibrations(USGNovaGlove* NovaGlove)
{
    NovaGlove->StopVibrations();
}

bool USGNovaGloveKismetLibrary::SendHaptics(USGNovaGlove* NovaGlove)
{
    return NovaGlove->SendHaptics();
}

bool USGNovaGloveKismetLibrary::SupportsCustomWaveform(const USGNovaGlove* NovaGlove,
                                                       const ESGHapticLocation AtLocation)
{
    return NovaGlove->SupportsCustomWaveform(AtLocation);
}

bool USGNovaGloveKismetLibrary::SendCustomWaveform(USGNovaGlove* NovaGlove,
                                                   USGCustomWaveform* OutWaveform, const ESGHapticLocation Location)
{
    return NovaGlove->SendCustomWaveform(OutWaveform, Location);
}

bool USGNovaGloveKismetLibrary::QueueForceFeedbackLevels(USGNovaGlove* NovaGlove, const TArray<float>& Levels01)
{
    return NovaGlove->QueueForceFeedbackLevels(Levels01);
}

bool USGNovaGloveKismetLibrary::QueueForceFeedbackLevel(
    USGNovaGlove* NovaGlove, const int32 Finger, const float Level01)
{
    return NovaGlove->QueueForceFeedbackLevel(Finger, Level01);
}

bool USGNovaGloveKismetLibrary::QueueVibroLevels(USGNovaGlove* NovaGlove, const TArray<float>& Amplitudes)
{
    return NovaGlove->QueueVibroLevels(Amplitudes);
}

bool USGNovaGloveKismetLibrary::QueueVibroLevel_L_L(USGNovaGlove* NovaGlove,
                                                    const ESGHapticLocation Location, const float Level01)
{
    return NovaGlove->QueueVibroLevel(Location, Level01);
}

void USGNovaGloveKismetLibrary::GetGloveLocation_RP_FQuat_RR_TH_OutGP_FQuat_OutGR(
    const USGNovaGlove* NovaGlove,
    const FVector& ReferencePosition, const FQuat& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutGlovePosition, FQuat& OutGloveRotation)
{
    NovaGlove->GetGloveLocation(ReferencePosition, ReferenceRotation,
                                TrackingHardware,
                                OutGlovePosition, OutGloveRotation);
}

void USGNovaGloveKismetLibrary::GetGloveLocation_RP_FRotator_RR_TH_OutGP_FRotator_OutGR(
    const USGNovaGlove* NovaGlove,
    const FVector& ReferencePosition, const FRotator& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutGlovePosition, FRotator& OutGloveRotation)
{
    NovaGlove->GetGloveLocation(ReferencePosition, ReferenceRotation,
                                TrackingHardware,
                                OutGlovePosition, OutGloveRotation);
}

void USGNovaGloveKismetLibrary::GetWristLocation_RP_FQuat_RR_TH_OutWP_FQuat_OutWR(
    const USGNovaGlove* NovaGlove,
    const FVector& ReferencePosition, const FQuat& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutWristPosition, FQuat& OutWristRotation)
{
    NovaGlove->GetWristLocation(ReferencePosition, ReferenceRotation,
                                TrackingHardware,
                                OutWristPosition, OutWristRotation);
}

void USGNovaGloveKismetLibrary::GetWristLocation_RP_FRotator_RR_TH_OutWP_FRotator_OutWR(
    const USGNovaGlove* NovaGlove,
    const FVector& ReferencePosition, const FRotator& ReferenceRotation,
    const ESGPositionalTrackingHardware TrackingHardware,
    FVector& OutWristPosition, FRotator& OutWristRotation)
{
    NovaGlove->GetWristLocation(ReferencePosition, ReferenceRotation,
                                TrackingHardware,
                                OutWristPosition, OutWristRotation);
}

USGNovaGloveInfo* USGNovaGloveKismetLibrary::GetGloveInfo(UObject* WorldContextObject, const USGNovaGlove* NovaGlove)
{
    return NovaGlove->GetGloveInfo(WorldContextObject);
}

bool USGNovaGloveKismetLibrary::SupportsThresholds(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->SupportsThresholds();
}

bool USGNovaGloveKismetLibrary::SupportsCustomWaveforms(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->SupportsCustomWaveforms();
}

bool USGNovaGloveKismetLibrary::SupportsOnBoardNormalization(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->SupportsOnBoardNormalization();
}

bool USGNovaGloveKismetLibrary::GetSensorData(
    UObject* WorldContextObject, USGNovaGlove* NovaGlove, USGNovaGloveSensorData*& OutSensorData)
{
    return NovaGlove->GetSensorData(WorldContextObject, OutSensorData);
}

FString USGNovaGloveKismetLibrary::ToNovaCommand(
    const USGNovaGlove* NovaGlove,
    const TArray<float>& ForceFeedbackLevels, const TArray<float>& BuzzLevels, const float WristLevel)
{
    return NovaGlove->ToNovaCommand(ForceFeedbackLevels, BuzzLevels, WristLevel);
}

bool USGNovaGloveKismetLibrary::QueueVibroLevel_F_A(USGNovaGlove* NovaGlove, const int32 Finger, const float Amplitude)
{
    return NovaGlove->QueueVibroLevel(Finger, Amplitude);
}

bool USGNovaGloveKismetLibrary::QueueWristLevel(USGNovaGlove* NovaGlove, const float Amplitude)
{
    return NovaGlove->QueueWristLevel(Amplitude);
}

ESGNovaVibroMotor USGNovaGloveKismetLibrary::ToNovaMotor(const USGNovaGlove* NovaGlove,
                                                         const ESGHapticLocation Location)
{
    return NovaGlove->ToNovaMotor(Location);
}

int32 USGNovaGloveKismetLibrary::ChannelIndex(const USGNovaGlove* NovaGlove, const ESGNovaVibroMotor Motor)
{
    return NovaGlove->ChannelIndex(Motor);
}

void USGNovaGloveKismetLibrary::ValidateWaveform(const USGNovaGlove* NovaGlove,
                                                 USGCustomWaveform* OutWaveform, const ESGNovaVibroMotor Motor)
{
    NovaGlove->ValidateWaveform(OutWaveform, Motor);
}

bool USGNovaGloveKismetLibrary::SendCustomWaveform_Nova(
    USGNovaGlove* NovaGlove,
    USGCustomWaveform* OutWaveform, const ESGNovaVibroMotor Motor, const bool bValidateWaveform)
{
    return NovaGlove->SendCustomWaveform_Nova(OutWaveform, Motor, bValidateWaveform);
}

bool USGNovaGloveKismetLibrary::QueueThresholdCommand_Flexion(USGNovaGlove* NovaGlove,
                                                              const int32 Finger, const float FlexionThreshold)
{
    return NovaGlove->QueueThresholdCommand_Flexion(Finger, FlexionThreshold);
}

bool USGNovaGloveKismetLibrary::QueueClearThreshold(USGNovaGlove* NovaGlove, const int32 Finger)
{
    return NovaGlove->QueueClearThreshold(Finger);
}

FString USGNovaGloveKismetLibrary::ToString(const USGNovaGlove* NovaGlove)
{
    return NovaGlove->ToString();
}