Plugin/Source/SenseGloveKismet/Private/SGKismet/SGPawnKismetLibrary.cpp

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

#include "Camera/CameraComponent.h"
#include "Components/SphereComponent.h"

#include "SenseGlove/Components/SGVirtualHandComponent.h"
#include "SenseGlove/Components/SGWristTrackerComponent.h"
#include "SenseGlove/GameFramework/SGPawn.h"

UCameraComponent* UPawnKismetLibrary::GetCamera(const ASGPawn* Pawn)
{
    return Pawn->GetCamera();
}

USGWristTrackerComponent* UPawnKismetLibrary::GetWristTrackerLeft(const ASGPawn* Pawn)
{
    return Pawn->GetWristTrackerLeft();
}

USGVirtualHandComponent* UPawnKismetLibrary::GetHandLeft(const ASGPawn* Pawn)
{
    return Pawn->GetHandLeft();
}

USphereComponent* UPawnKismetLibrary::GetLeftThumbFingertipGrabCollider(const ASGPawn* Pawn)
{
    return Pawn->GetLeftThumbFingertipGrabCollider();
}

USphereComponent* UPawnKismetLibrary::GetLeftIndexFingertipGrabCollider(const ASGPawn* Pawn)
{
    return Pawn->GetLeftIndexFingertipGrabCollider();
}

USphereComponent* UPawnKismetLibrary::GetLeftMiddleFingertipGrabCollider(const ASGPawn* Pawn)
{
    return Pawn->GetLeftMiddleFingertipGrabCollider();
}

USphereComponent* UPawnKismetLibrary::GetLeftThumbFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetLeftThumbFingertipTouchCollider();
}

USphereComponent* UPawnKismetLibrary::GetLeftIndexFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetLeftIndexFingertipTouchCollider();
}

USphereComponent* UPawnKismetLibrary::GetLeftMiddleFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetLeftMiddleFingertipTouchCollider();
}

USphereComponent* UPawnKismetLibrary::GetLeftRingFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetLeftRingFingertipTouchCollider();
}

USphereComponent* UPawnKismetLibrary::GetLeftPinkyFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetLeftPinkyFingertipTouchCollider();
}

USGWristTrackerComponent* UPawnKismetLibrary::GetWristTrackerRight(const ASGPawn* Pawn)
{
    return Pawn->GetWristTrackerRight();
}

USGVirtualHandComponent* UPawnKismetLibrary::GetHandRight(const ASGPawn* Pawn)
{
    return Pawn->GetHandRight();
}

USphereComponent* UPawnKismetLibrary::GetRightThumbFingertipGrabCollider(const ASGPawn* Pawn)
{
    return Pawn->GetRightThumbFingertipGrabCollider();
}

USphereComponent* UPawnKismetLibrary::GetRightIndexFingertipGrabCollider(const ASGPawn* Pawn)
{
    return Pawn->GetRightIndexFingertipGrabCollider();
}

USphereComponent* UPawnKismetLibrary::GetRightMiddleFingertipGrabCollider(const ASGPawn* Pawn)
{
    return Pawn->GetRightMiddleFingertipGrabCollider();
}

USphereComponent* UPawnKismetLibrary::GetRightThumbFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetRightThumbFingertipTouchCollider();
}

USphereComponent* UPawnKismetLibrary::GetRightIndexFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetRightIndexFingertipTouchCollider();
}

USphereComponent* UPawnKismetLibrary::GetRightMiddleFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetRightMiddleFingertipTouchCollider();
}

USphereComponent* UPawnKismetLibrary::GetRightRingFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetRightRingFingertipTouchCollider();
}

USphereComponent* UPawnKismetLibrary::GetRightPinkyFingertipTouchCollider(const ASGPawn* Pawn)
{
    return Pawn->GetRightPinkyFingertipTouchCollider();
}

bool UPawnKismetLibrary::CanLeftHandGrab(const ASGPawn* Pawn, const AActor* Actor)
{
    return Pawn->CanLeftHandGrab(Actor);
}

bool UPawnKismetLibrary::IsLeftHandGrabbing_Actor(const ASGPawn* Pawn, const AActor* Actor)
{
    return Pawn->IsLeftHandGrabbing(Actor);
}

bool UPawnKismetLibrary::IsLeftHandGrabbing_OutActor(const ASGPawn* Pawn, AActor*& OutActor)
{
    return Pawn->IsLeftHandGrabbing(OutActor);
}

bool UPawnKismetLibrary::IsLeftHandGrabbing(const ASGPawn* Pawn)
{
    return Pawn->IsLeftHandGrabbing();
}

bool UPawnKismetLibrary::CanRightHandGrab(const ASGPawn* Pawn, const AActor* Actor)
{
    return Pawn->CanRightHandGrab(Actor);
}

bool UPawnKismetLibrary::IsRightHandGrabbing_Actor(const ASGPawn* Pawn, const AActor* Actor)
{
    return Pawn->IsRightHandGrabbing(Actor);
}

bool UPawnKismetLibrary::IsRightHandGrabbing_OutActor(const ASGPawn* Pawn)
{
    return Pawn->IsRightHandGrabbing();
}

bool UPawnKismetLibrary::IsRightHandGrabbing(const ASGPawn* Pawn, AActor*& OutActor)
{
    return Pawn->IsRightHandGrabbing();
}

bool UPawnKismetLibrary::CanGrab(const ASGPawn* Pawn, const USGVirtualHandComponent* Hand, const AActor* Actor)
{
    return Pawn->CanGrab(Hand, Actor);
}

bool UPawnKismetLibrary::IsGrabbing_Actor(const ASGPawn* Pawn, const USGVirtualHandComponent* Hand, const AActor* Actor)
{
    return Pawn->IsGrabbing(Hand, Actor);
}

bool UPawnKismetLibrary::IsGrabbing_OutActor(const ASGPawn* Pawn, const USGVirtualHandComponent* Hand,
                                             AActor*& OutActor)
{
    return Pawn->IsGrabbing(Hand, OutActor);
}

bool UPawnKismetLibrary::IsGrabbing(const ASGPawn* Pawn, const USGVirtualHandComponent* Hand)
{
    return Pawn->IsGrabbing(Hand);
}

void UPawnKismetLibrary::GrabLeft(ASGPawn* Pawn, AActor* Actor, UPrimitiveComponent* Component)
{
    Pawn->GrabLeft(Actor, Component);
}

void UPawnKismetLibrary::GrabRight(ASGPawn* Pawn, AActor* Actor, UPrimitiveComponent* Component)
{
    Pawn->GrabRight(Actor, Component);
}

void UPawnKismetLibrary::Grab(
    ASGPawn* Pawn, USGVirtualHandComponent* Hand, AActor* Actor, UPrimitiveComponent* Component)
{
    Pawn->Grab(Hand, Actor, Component);
}

void UPawnKismetLibrary::ReleaseLeft(ASGPawn* Pawn)
{
    Pawn->ReleaseLeft();
}

void UPawnKismetLibrary::ReleaseRight(ASGPawn* Pawn)
{
    Pawn->ReleaseRight();
}

void UPawnKismetLibrary::Release(ASGPawn* Pawn, const USGVirtualHandComponent* Hand)
{
    Pawn->Release(Hand);
}