How to handle input from PlayerController instead of Pawn?

Here is MyPawn code adjusted from Player Input and Pawns tutorial (Quick Start Guide to Player Input in Unreal Engine CPP | Unreal Engine 5.1 Documentation). How would I now move the input into a new player controller, so the pawn would be controlled using the PlayerController not the pawn.

MyPawn.ccp

AMyPawn::AMyPawn()
{
	// Set this pawn to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;
	// Set this pawn to be controlled by the lowest-numbered player
	AutoPossessPlayer = EAutoReceiveInput::Player0;
	// Create a dummy root component we can attach things to.
	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootComponent"));
	OurVisibleComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("OurVisibleComponent"));
	OurVisibleComponent->SetupAttachment(RootComponent);
	// Create a camera boom...
	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
	CameraBoom->SetupAttachment(RootComponent);
	CameraBoom->bAbsoluteRotation = true; // Don't want arm to rotate when character does
	CameraBoom->TargetArmLength = 800.f;
	CameraBoom->RelativeRotation = FRotator(-60.f, 0.f, 0.f);
	CameraBoom->bDoCollisionTest = false; // Don't want to pull camera in when it collides with level
	// Create a camera...
	TopDownCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("TopDownCamera"));
	TopDownCameraComponent->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);
	TopDownCameraComponent->bUsePawnControlRotation = false; // Camera does not rotate relative to arm
}
 // Called when the game starts or when spawned
void AMyPawn::BeginPlay()
{
	Super::BeginPlay();
}
// Called every frame
void AMyPawn::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
		// Handle movement based on our "MoveX" and "MoveY" axes
	{
		if (!CurrentVelocity.IsZero())
		{
			FVector NewLocation = GetActorLocation() + (CurrentVelocity * DeltaTime);
			SetActorLocation(NewLocation);
		}
	}
}
// Called to bind functionality to input
void AMyPawn::SetupPlayerInputComponent(class UInputComponent* InputComponent)
{
	Super::SetupPlayerInputComponent(InputComponent);
	// Respond every frame to the values of our two movement axes, "MoveX" and "MoveY".
	InputComponent->BindAxis("MoveX", this, &AMyPawn::Move_XAxis);
	InputComponent->BindAxis("MoveY", this, &AMyPawn::Move_YAxis);
}
void AMyPawn::Move_XAxis(float AxisValue)
{
	// Move at 1000 units per second forward or backward
	CurrentVelocity.X = FMath::Clamp(AxisValue, -1.0f, 1.0f) * 1000.0f;
}
void AMyPawn::Move_YAxis(float AxisValue)
{
	// Move at 1000 units per second right or left
	CurrentVelocity.Y = FMath::Clamp(AxisValue, -1.0f, 1.0f) * 1000.0f;
}

MyPawn.h

UCLASS()
class SPIKE4_5_6_API AMyPawn : public APawn
{
	GENERATED_BODY()
public:
	// Sets default values
	AMyPawn();
protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;
public:
	UPROPERTY(EditAnywhere)
		USceneComponent* OurVisibleComponent;
	virtual void Tick(float DeltaSeconds) override;
	// Input functions
	void Move_XAxis(float AxisValue);
	void Move_YAxis(float AxisValue);
	// Called to bind functionality to input
	virtual void SetupPlayerInputComponent(class UInputComponent* InputComponent) override;
	// Input variables
	FVector CurrentVelocity;
	/** Returns TopDownCameraComponent subobject **/
	FORCEINLINE class UCameraComponent* GetTopDownCameraComponent() const { return TopDownCameraComponent; }
	/** Returns CameraBoom subobject **/
	FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
private:
	/** Top down camera */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	class UCameraComponent* TopDownCameraComponent;
	/** Camera boom positioning the camera above the character */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	class USpringArmComponent* CameraBoom;
};

I have messed around and have got a working PlayerController now.

PlayerController.ccp

void AMyPlayerController::PlayerTick(float DeltaTime)
{
	Super::PlayerTick(DeltaTime);
	// Handle movement based on our "MoveX" and "MoveY" axes
	{
		if (AMyPawn* MyPawn = Cast<AMyPawn>(GetPawn()))
		{
			if (!CurrentVelocity.IsZero())
					{
						FVector NewLocation = MyPawn->GetActorLocation() + (CurrentVelocity * DeltaTime);
						MyPawn->SetActorLocation(NewLocation);
					}
		}
	}
}
void AMyPlayerController::SetupInputComponent() {
	Super::SetupInputComponent();
	this->InputComponent->BindAxis("MoveX", this, &AMyPlayerController::Move_XAxis);
	this->InputComponent->BindAxis("MoveY", this, &AMyPlayerController::Move_YAxis);
}
void AMyPlayerController::Move_XAxis(float AxisValue)
{
	APawn* Pawn = this->GetPawn();
	CurrentVelocity.X = FMath::Clamp(AxisValue, -1.0f, 1.0f) * 1000.0f;
}
void AMyPlayerController::Move_YAxis(float AxisValue)
{
	APawn* Pawn = this->GetPawn();
	CurrentVelocity.Y = FMath::Clamp(AxisValue, -1.0f, 1.0f) * 1000.0f;
}

PlayerController.h

UCLASS()
class SPIKE4_5_6_API AMyPlayerController : public APlayerController
{
	GENERATED_BODY()
public:
	//Properties
	UPROPERTY(VisibleAnywhere, Category = CustomProperties) class AMyPawn * MyPawn;
	//Overriding SetupInputComponent
	void SetupInputComponent() override;
	// Called every frame
	virtual void PlayerTick(float DeltaSeconds) override;
	// Input functions
	void Move_XAxis(float AxisValue);
	void Move_YAxis(float AxisValue);
	FVector CurrentVelocity;
};

You can override APlayerController::SetupInputComponent(), iirc