Plugin/Source/SenseGlove/Private/SenseGlove/Components/SGGrabComponent.cpp

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

#include "Components/PrimitiveComponent.h"
#include "GameFramework/Actor.h"

#include "SGSettings/SGSettings.h"

struct USGGrabComponent::FImpl
{
    /************************
     * Static methods
     ************************/

    FORCEINLINE static const FName& GetDefaultGrabAttachPointSocketName()
    {
        const USGSettings* Settings{USGSettings::GetInstance()};
        const FName& SocketName{Settings->GetVirtualHandSettings().GrabSettings.GrabAttachPointSocketName};
        return SocketName;
    }

    /************************
     * Owner object
     ************************/

    USGGrabComponent* Owner;

    /************************
     * Constructor / Destructor
     ************************/

    explicit FImpl(USGGrabComponent* InOwner);
    ~FImpl();

    /************************
     * Default copy constructor & copy assignment operator
     ************************/

    FImpl(const FImpl& Rhs) = default;
    FImpl& operator=(const FImpl& Rhs) = default;

    /************************
     * Methods
     ************************/
};

USGGrabComponent* USGGrabComponent::GetGrabComponent(const AActor* Actor)
{
    if (!ensureAlwaysMsgf(IsValid(Actor), TEXT("%s"), TEXT("ERROR: invalid actor!")))
    {
        return nullptr;
    }

    USGGrabComponent* GrabComponent = Cast<USGGrabComponent>(
        Actor->GetComponentByClass(USGGrabComponent::StaticClass()));
    return GrabComponent;
}

bool USGGrabComponent::IsGrabbable(const AActor* Actor)
{
    if (!ensureAlwaysMsgf(IsValid(Actor), TEXT("%s"), TEXT("ERROR: invalid actor!")))
    {
        return false;
    }

    const USGGrabComponent* GrabComponent = Cast<USGGrabComponent>(
        Actor->GetComponentByClass(USGGrabComponent::StaticClass()));
    if (!IsValid(GrabComponent))
    {
        return false;
    }

    return true;
}

USGGrabComponent::USGGrabComponent(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer),
      Pimpl(TUniquePtr<FImpl, FImplDeleter>(new FImpl{this}, PimplDeleter))
{
    AttachmentLocationRule = EAttachmentRule::SnapToTarget;
    AttachmentRotationRule = EAttachmentRule::KeepRelative;
    AttachmentScaleRule = EAttachmentRule::KeepWorld;
    bAttachmentWeldSimulatedBodies = true;

    AttachmentSocketName = FImpl::GetDefaultGrabAttachPointSocketName();

    DetachmentLocationRule = EDetachmentRule::KeepWorld;
    DetachmentRotationRule = EDetachmentRule::KeepWorld;
    DetachmentScaleRule = EDetachmentRule::KeepWorld;
    bDetachmentCallModify = false;

    bAffectPhysicsState = true;
}

USGGrabComponent::FImpl::FImpl(USGGrabComponent* InOwner)
    : Owner(InOwner)
{
}

USGGrabComponent::FImpl::~FImpl() = default;

void USGGrabComponent::FImplDeleter::operator()(const FImpl* P) const
{
    delete P;
}

void USGGrabComponent::SimulatePhysics(const bool bSimulatePhysics) const
{
    const AActor* OwnerActor{GetOwner()};
    if (!ensureAlwaysMsgf(IsValid(OwnerActor), TEXT("Invalid OwnerActor!")))
    {
        return;
    }

    UPrimitiveComponent* ActorRootComponent{Cast<UPrimitiveComponent>(OwnerActor->GetRootComponent())};
    if (!ensureAlwaysMsgf(IsValid(ActorRootComponent),
                          TEXT("RootComponent is not a valid UPrimativeComponent!")))
    {
        return;
    }

    ActorRootComponent->SetEnableGravity(bSimulatePhysics);
    ActorRootComponent->SetSimulatePhysics(bSimulatePhysics);

    if (bSimulatePhysics)
    {
        ActorRootComponent->WakeRigidBody();
    }
    else
    {
        ActorRootComponent->PutRigidBodyToSleep();
    }
}

void USGGrabComponent::BeginPlay()
{
    Super::BeginPlay();

    if (bAffectPhysicsState)
    {
        SimulatePhysics(true);
    }
}