ComponentLogic.h

Go to the documentation of this file.

// Copyright 2024 Lost in Game Studio. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "InputAction.h"
#include "InputActionValue.h"
#include "InputTriggers.h"
#include "UObject/Object.h"
#include "Layout/Geometry.h"
#include "Input/Events.h"
#include "Engine/LocalPlayer.h"
#include "Framework/Application/SlateApplication.h"
#include "ComponentLogic.generated.h"
 
class ULCInputModifier;
class ULayoutComponent;
class STouchInterfaceRuntime;
class UInputModifier;
class SLayoutComponent;
class UTouchInputComponent;
class UEnhancedInputLocalPlayerSubsystem;
class UInputAction;
class ULayoutComponentDecorator;
class ULocalPlayer;
class UForceFeedbackEffect;
 
USTRUCT(BlueprintType)
struct FAxisInputInjection
{
    GENERATED_BODY()
 
    UPROPERTY(Category="Axis Input Injection", BlueprintReadWrite)
    FKey InputKey;
 
    UPROPERTY(Category="Axis Input Injection", BlueprintReadWrite)
    float AxisValue;
 
    UPROPERTY(Category="Axis Input Injection", BlueprintReadWrite)
    FPlatformUserId UserId;
 
    UPROPERTY(Category="Axis Input Injection", BlueprintReadWrite)
    FInputDeviceId InputDeviceId;
 
    FAxisInputInjection()
    : AxisValue(ForceInitToZero)
    {
        UserId = IPlatformInputDeviceMapper::Get().GetPrimaryPlatformUser();
        InputDeviceId = IPlatformInputDeviceMapper::Get().GetPrimaryInputDeviceForUser(FSlateApplicationBase::SlateAppPrimaryPlatformUser);
    }
 
    FAxisInputInjection(const FKey& Key, const float Value, const FPlatformUserId PlatformUserId, const FInputDeviceId DeviceId)
    : InputKey(Key)
    , AxisValue(Value)
    , UserId(PlatformUserId)
    , InputDeviceId(DeviceId)
    {
        
    }
 
    FAxisInputInjection(const FKey& Key, const float Value, const ULocalPlayer* LocalPlayer)
    : InputKey(Key)
    , AxisValue(Value)
    {
        UserId = IPlatformInputDeviceMapper::Get().GetPlatformUserForUserIndex(LocalPlayer->GetControllerId());
        InputDeviceId = IPlatformInputDeviceMapper::Get().GetPrimaryInputDeviceForUser(UserId);
    }
};
 
UENUM(BlueprintType)
enum class EHitLocationSpace : uint8
{
    LocalSpace,
    LayoutSpace,
    ViewportSpace
};

UCLASS(Abstract, Blueprintable, BlueprintType, EditInlineNew, /*DefaultToInstanced*/ HideCategories=("Default", "Internal", "InternalUse"))
class TOUCHINTERFACE_API UComponentLogic : public UObject
{
    GENERATED_BODY()
 
public:
    UComponentLogic();
 
    virtual void BeginDestroy() override;
 
    //TODO: Make pure c++ function that call blueprint function because we need to do safe internal initialization
    
    //Called when component is initialized 
    UFUNCTION(Category="Layout Component Logic", BlueprintNativeEvent)
    void Initialize();
 
    UFUNCTION(Category="Layout Component Logic", BlueprintNativeEvent)
    void Deinitialize();
    
    void SetOuter(ULayoutComponent* Outer) { Owner = Outer; }
    void AssignLocalPlayer(ULocalPlayer* Player, TSharedRef<SLayoutComponent> Widget);
 
    virtual UWorld* GetWorld() const override;
 
    bool ShouldTick() const { return bShouldTick; }
 
    //TODO: Add layout geometry as input?
    virtual void ProcessPressEvent(const FGeometry& ComponentGeometry, const FGeometry& LayoutGeometry, const FPointerEvent& PointerEvent);
    virtual void ProcessMoveEvent(const FGeometry& ComponentGeometry, const FGeometry& LayoutGeometry, const FPointerEvent& PointerEvent);
    virtual void ProcessReleaseEvent(const FGeometry& ComponentGeometry, const FGeometry& LayoutGeometry, const FPointerEvent& PointerEvent);
    virtual void ProcessTickEvent(const FGeometry& ComponentGeometry, const double InCurrentTime, const float InDeltaTime);
 
#if WITH_EDITOR
    virtual void PreviewDecorator();
#endif
 
    //TODO: Function that called one to register decorator needed for logic like handle and bar in slider?
 
protected:
    virtual void Initialize_Implementation() {}
    virtual void Deinitialize_Implementation() {}
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    APawn* GetPawn();
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    APlayerController* GetPlayerController();
 
    //TODO: Add hitbox id and position (for multi hitbox)
    UFUNCTION(Category="Layout Component Logic", BlueprintNativeEvent)
    void OnPress(const FGeometry& ComponentGeometry, const FPointerEvent& PointerEvent);
    
    UFUNCTION(Category="Layout Component Logic", BlueprintNativeEvent)
    void OnMove(const FGeometry& ComponentGeometry, const FPointerEvent& PointerEvent);
    
    UFUNCTION(Category="Layout Component Logic", BlueprintNativeEvent)
    void OnRelease(const FGeometry& ComponentGeometry, const FPointerEvent& PointerEvent);
    
    UFUNCTION(Category="Layout Component Logic", BlueprintNativeEvent)
    void OnTick(const FGeometry& ComponentGeometry, const FPointerEvent& PointerEvent, double InCurrentTime, float InDeltaTime);
    
    virtual void OnPress_Implementation(const FGeometry& ComponentGeometry, const FPointerEvent& PointerEvent) {}
    virtual void OnMove_Implementation(const FGeometry& ComponentGeometry, const FPointerEvent& PointerEvent) {}
    virtual void OnRelease_Implementation(const FGeometry& ComponentGeometry, const FPointerEvent& PointerEvent) {}
    virtual void OnTick_Implementation(const FGeometry& ComponentGeometry, const FPointerEvent& PointerEvent, const double InCurrentTime, const float InDeltaTime) {}
    
public:
    TSharedPtr<SLayoutComponent> GetSlotWidget();
 
    TSharedPtr<STouchInterfaceRuntime> GetLayoutWidget();
 
    bool IsPressed() const { return bIsPressed; }
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    ULocalPlayer* GetLocalPlayer();
 
    //Get object that drive slate widget
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    ULayoutComponent* GetTouchInputObject() const;
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    const FGeometry& GetLastComponentGeometry() const { return LastComponentGeometry; }
 
    //ENHANCED INPUT
    
    //Start injecting input (inject input each frame until stop)
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void InjectInput(const UInputAction* Action, FInputActionValue RawValue, bool bInjectImmediately = false);
 
    //Inject input in one frame
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void InjectInputInFrame(const UInputAction* Action, FInputActionValue RawValue);
 
    //Stop injecting input
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void StopInjectingInput(const UInputAction* Action);
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    bool IsInputInjected(const UInputAction* Action) const;
 
    //LEGACY INPUT

    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void InjectActionInput(const FKey& InputKey);
 
    // Release Action Input
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void StopInjectingActionInput(const FKey& InputKey);

    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void InjectAxisInput(const FAxisInputInjection AxisInput, const bool bInjectImmediately = false);
 
    // Inject input in one frame
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void InjectAxisInputInFrame(const FAxisInputInjection AxisInput);
    
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void StopInjectingAxisInput(FKey AxisInput);
    
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void StopInjectingAxisInputByName(const FName InputName);
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    FAxisInputInjection CreateAxisInputInjectionForPlayer(FKey Key, const float Value);
    
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintNativeEvent)
    void SetInputAction(UInputAction* NewInputAction);
 
    //Enable input. This logic will now process inputs.
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    virtual void EnableInput() { bBlockInput = false; }
 
    //Disable input. This logic will not process inputs.
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    virtual void DisableInput() { bBlockInput = true; }
 
    //Return true if this logic process inputs
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    virtual bool IsInputEnabled() { return !bBlockInput; }
 
    
    //TODO: Process Gesture (UObject Gesture)?
 
 
    //TICK
    
    //Enable tick on this logic
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void EnableTick();

    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void DisableTick();
 
    
    // EFFECTS
    
    //TODO: Force feedback effect on move and end?
 
    //TODO: Little force when joystick thumb move?
 
    //Simple function to play UI sound
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void PlaySound(USoundBase* Sound);
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void PlaySimpleHaptic(const float Duration = 0.05f, const float Intensity = 0.3f, const bool bAffectLarge = true, const bool bAffectSmall = true);
 
    //Simple function to trigger a vibration
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void PlayHaptic(UForceFeedbackEffect* ForceFeedbackEffect, bool bLooping, bool bIgnoreTimeDilation, bool bPlayWhilePaused);
 
    //Stop vibration
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    void StopHaptic(UForceFeedbackEffect* ForceFeedbackEffect);
 
    //Return true if a vibration is being processed
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    bool IsHapticPlayed(UForceFeedbackEffect* ForceFeedbackEffect);
 
    bool ContainPointerIndex(int32 PointerIndex) const;
 
protected:
    //Get Enhanced input local player subsystem
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable)
    UEnhancedInputLocalPlayerSubsystem* GetEnhancedInputSubsystem();
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    FVector2D GetHitLocationFromCenter(const bool bNormalize, bool bConvertToWorldSpace = false);
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    FVector2D GetLocalHitLocation(const bool bNormalized);
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    FVector2D GetAbsoluteHitLocation();
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    FVector2D GetHitLocation(const EHitLocationSpace Space, const bool bNormalized);
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    ULayoutComponent* GetLayoutComponent() const { return Owner; }
 
    //Clamp offset to the ellipse of the component. Useful for thumbstick of joystick
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    FVector2D ClampOffsetToEllipse(const FVector2D Offset, const FVector2D ComponentSize);
 
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    FVector2D GetNormalizedOffset(const FVector2D LocalPosition, const FVector2D ComponentSize);
    
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    bool IsOrientedInDirection(const FVector2D Direction, const FVector2D Other, const float Threshold) const;
    
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    float GetAngleBetweenVector(const FVector2D VectorA, const FVector2D VectorB, const bool bSignedAngle = true, const bool bInvert = false);
    
    UFUNCTION(Category="Layout Component Logic", BlueprintCallable, BlueprintPure)
    float ConvertSignedAngleTo360(const float SignedAngle);
 
    //TODO: Lock Input at desired value
 
    //TODO: Lock decorator to desired position
 
    //TODO: Unlock input
 
    //TODO: IsLocked
    
    //TODO: Convert to world space
    
    // UTILITIES
 
    UFUNCTION(Category="LayoutComponentLogic|Utility", BlueprintCallable, BlueprintPure, meta=(CompactNodeTitle="CheckName"))
    bool CheckNameValidity(const FName Name) const;
    
    UFUNCTION()
    TArray<FName> GetAllDecoratorNames() const;
 
protected:
    UPROPERTY(Category="Layout Component", BlueprintReadOnly, EditDefaultsOnly, meta=(AllowPrivateAccess="true"))
    bool bShouldTick;
    
public: 
    UPROPERTY(Category="Layout Component", EditAnywhere, BlueprintReadWrite, Instanced)
    TArray<TObjectPtr<UInputTrigger>> InputTriggers;
 
    //TODO: Doesn't work with EditInstanceOnly
    //UPROPERTY(Category="Touch Logic", EditAnywhere, BlueprintReadWrite, Instanced)
    //TArray<TObjectPtr<UInputModifier>> InputModifiers;
    
    UPROPERTY(Category="Layout Component", EditAnywhere, BlueprintReadWrite, Instanced)
    TArray<TObjectPtr<ULCInputModifier>> InputModifiers;
 
    //TODO: Decorator to drive (Array or use group)
    
 
private:
    UPROPERTY()
    UWorld* WorldContext;
    
    UPROPERTY()
    ULocalPlayer* LocalPlayer;
 
    UPROPERTY()
    UEnhancedInputLocalPlayerSubsystem* InputSubsystem;
 
    UPROPERTY()
    TObjectPtr<ULayoutComponent> Owner;
    
    TSharedPtr<SLayoutComponent> OwnerWidget;
 
    FPointerEvent LastPointerEvent;
 
    FGeometry LastComponentGeometry;
 
    FGeometry LastLayoutGeometry;
 
    UPROPERTY()
    TMap<const UInputAction*, FInputActionValue> InjectedInputs;
 
    TArray<FAxisInputInjection> InjectedAxis;
 
    //Currently pressed by user
    uint8 bIsPressed:1;
 
    //Pressed event has been sent 
    uint8 bHasStarted:1;
 
    //Do not send touch event
    uint8 bBlockInput:1;
 
    TArray<int32> ActivePointerIndex;
 
    FVector2D LastLocalCoord;
};