Casting Quick Start Guide

Overview

Casting Blueprint classes is a common communication type, in which you use a reference to an Actor class Blueprint and convert it to a different class. If this conversion is successful, then you can use Direct Blueprint communication to access its information and functionality.

This method requires a reference to the Actor class Blueprint in your Level so you can use the Cast node to try to convert it to a specific class. This communication type uses a one-to-one relationship between your working Actor class Blueprint to your target Actor class Blueprint.

Goals

In this Quick Start guide, you will learn how to create an Actor in C++, that has the Blueprint casting functionality used to access information from a target Blueprint.

Objectives

• Create a Blueprint that rotates based on the value of a variable.

• Modify the ThirdPersonCharacter Blueprint to cast to the rotating Blueprint on overlap.

• Create several child Blueprint clases from the rotating Blueprint to show how Blueprint casting works for many Blueprint classes that share the same parent.

1 - Required Setup

1. In the New Project Categories section of the menu, select Games and click Next .

2. Select the Third Person template and click Next .

3. Select the C++ and With Starter Content options and click Create Project .

Section Results

You have created a new Third Person project and are now ready to learn about casting with Actor class Blueprints.

2 - Creating a Rotating Actor

For this example, you will create an Actor class Blueprint that has the functionality to rotate its Static Mesh Component when the player is nearby.

1. From the C++ Class Wizard , create a new Actor class named RotatingActor .

2. In the class defaults of your RotatingActor.h implement the following code.

   public: 
   
       void SetbCanRotate(bool value);
   
   protected:
   
       // Called when the game starts or when spawned
       virtual void BeginPlay() override;
       void RotateActor();
       bool bCanRotate;
   
       UPROPERTY(EditAnywhere, BlueprintReadWrite)
       UStaticMeshComponent* MeshComp;

3. Navigate to your RotatingActor.cpp and declare the following code in the constructor ARotatingActor::ARotatingActor

   RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneComponent"));
   MeshComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StaticMesh"));
   MeshComp->SetupAttachment(RootComponent, FAttachmentTransformRules::KeepRelativeTransform);
   bCanRotate = false;

4. Implement the following code for your ARotatingActor::RotateActor method.

   AddActorLocalRotation(ActorRotation);

5. Navigate to the ARotatingActor::Tick method and implement the following code.

   void ARotatingActor::Tick(float DeltaTime)
   {
       Super::Tick(DeltaTime);
   
       if (bCanRotate)
       {
           RotateActor();
       }
   }

Finished Code

#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "RotatingActor.generated.h"

UCLASS()
class BPCOMMUNICATION_API ARotatingActor : public AActor
{
GENERATED_BODY()

public: 
    // Sets default values for this actor's properties
    ARotatingActor();
    void SetbCanRotate(bool value);

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;
    void RotateActor();
    bool bCanRotate;

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    UStaticMeshComponent* MeshComp;

    //Rotation Rate for our Actor.
    const FQuat ActorRotationRate =(FQuat(FRotator(0,2,0));

public: 
    // Called every frame
    virtual void Tick(float DeltaTime) override;
};

#include "RotatingActor.h"

// Sets default values
ARotatingActor::ARotatingActor()
{
    // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;
    RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneComponent"));
    MeshComp = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MeshComp"));
    MeshComp->SetupAttachment(RootComponent, FAttachmentTransformRules::KeepRelativeTransform);
    bCanRotate = false;
}

void ARotatingActor::SetbCanRotate(bool value)
{
    bCanRotate = value;
}

// Called when the game starts or when spawned
void ARotatingActor::BeginPlay()
{
    Super::BeginPlay();
}

void ARotatingActor::RotateActor()
{
    AddActorLocalRotation(ActorRotation);
}

// Called every frame
void ARotatingActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    if (bCanRotate)
    {
        RotateActor();
    }
}

1. Compile your code.

2. In the editor, navigate to your C++ Classes folder , right-click your RotatingActor and from the C++ class actions dropdown menu, select Create Blueprint class based on RotatingActor named BP_RotatingActor .

3. In the class defaults for your BP_RotatingActor Blueprint, navigate to the Components tab, select the MeshComp Static Mesh Component , then navigate to the Details panel and from the Static Mesh category , select the arrow next to the Static Mesh variable . Lastly, from the dropdown menu, select the Shape_Cube static mesh.

4. Compile and save your Blueprint.

5. From the Content Browser , drag an instance of your Bp_RotatingActor into the Level.

Section Results

In this section, you created a Rotating Actor class Blueprint that includes the functionality to rotate a Static Mesh on tick when the bCanRotate variable is set to True .

3 - Modifying the Third Person Character Class

In this section, you will modify the BPCommunicationCharacter class to cast to the Rotating Actor class and set the bCanRotate variable to True when your player is nearby.

1. Open your BPCommunicationCharacter.h and implement the following.

   protected:
       virtual void NotifyActorBeginOverlap(AActor* OtherActor);
       virtual void NotifyActorEndOverlap(AActor* OtherActor);
       class USphereComponent* SphereComp;

2. In your BPCommunicationCharacter.cpp include the following class libraries

   #include "RotatingActor.h"
   #include "Components/SphereComponent.h"

3. From the constructor ABPCommunicaionCharacter::BPCommunicationCharacter declare the following code.

   SphereComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComp"));
   SphereComp->AttachToComponent(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform);
   SphereComp->SetSphereRadius(200);

4. Next, implement the ABPCommunicationCharacter::NotifyActorBeginOverlap , and ABPCommunicationCharacter::NotifyActorEndOverlap .

   void ABPCommunicationCharacter::NotifyActorBeginOverlap(AActor* OtherActor)
   {
       if (ARotatingActor* RotatingActorCheck =Cast<ARotatingActor>(OtherActor))
       {
           ActorCheck->SetbCanRotate(true);
       }
   }
   
   void ABPCommunicationCharacter::NotifyActorEndOverlap(AActor* OtherActor)
   {
       if (ARotatingActor* RotatingActorCheck = Cast<ARotatingActor>(OtherActor))
       {
           ActorCheck->SetbCanRotate(false);
       }
   }

5. Compile your code.

Finished Code

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "BPCommunicationCharacter.generated.h"

UCLASS(config=Game)
class ABPCommunicationCharacter : public ACharacter
{
    GENERATED_BODY()

    /** Camera boom positioning the camera behind the character */
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
    class USpringArmComponent* CameraBoom;

    /** Follow camera */
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
    class UCameraComponent* FollowCamera;

    public:
        ABPCommunicationCharacter();

        /** Base turn rate, in deg/sec. Other scaling may affect final turn rate. */
        UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
        float BaseTurnRate;

        /** Base look up/down rate, in deg/sec. Other scaling may affect final rate. */
        UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
        float BaseLookUpRate;

    protected:
        virtual void NotifyActorBeginOverlap(AActor* OtherActor);
        virtual void NotifyActorEndOverlap(AActor* OtherActor);

    UPROPERTY(EditAnywhere, BlueprintReadWrite)

        class USphereComponent* SphereComp;

        /** Resets HMD orientation in VR. */
        void OnResetVR();

        /** Called for forwards/backward input */
        void MoveForward(float Value);

        /** Called for side to side input */
        void MoveRight(float Value);

        /** 
         * Called via input to turn at a given rate. 
         * @param Rate  This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
         */
        void TurnAtRate(float Rate);

        /**
         * Called via input to turn look up/down at a given rate. 
         * @param Rate  This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
         */
        void LookUpAtRate(float Rate);

        /** Handler for when a touch input begins. */
        void TouchStarted(ETouchIndex::Type FingerIndex, FVector Location);

        /** Handler for when a touch input stops. */
        void TouchStopped(ETouchIndex::Type FingerIndex, FVector Location);

    protected:
        // APawn interface
        virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
        // End of APawn interface

    public:
        /** Returns CameraBoom subobject **/
        FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }

        /** Returns FollowCamera subobject **/
        FORCEINLINE class UCameraComponent* GetFollowCamera() const { return FollowCamera; }
};

// Copyright Epic Games, Inc. All Rights Reserved.
#include "BPCommunicationCharacter.h"
#include "HeadMountedDisplayFunctionLibrary.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "Components/InputComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/Controller.h"
#include "GameFramework/SpringArmComponent.h"
#include "CeilingLight.h"
#include "RotatingActor.h"
#include "Components/SphereComponent.h"

//////////////////////////////////////////////////////////////////////////
// ABPCommunicationCharacter

ABPCommunicationCharacter::ABPCommunicationCharacter()
{
    // Set size for collision capsule
    GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);

    // set our turn rates for input
    BaseTurnRate = 45.f;
    BaseLookUpRate = 45.f;

    // Don't rotate when the controller rotates. Let that just affect the camera.
    bUseControllerRotationPitch = false;
    bUseControllerRotationYaw = false;
    bUseControllerRotationRoll = false;

    // Configure character movement
    GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...   
    GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate
    GetCharacterMovement()->JumpZVelocity = 600.f;
    GetCharacterMovement()->AirControl = 0.2f;

    // Create a camera boom (pulls in towards the player if there is a collision)
    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
    CameraBoom->SetupAttachment(RootComponent);
    CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character   
    CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller

    // Create a follow camera
    FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
    FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
    FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm

    SphereComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComp"));
    SphereComp->SetupAttachment(GetMesh(), FAttachmentTransformRules::KeepRelativeTransform);
    SphereComp->SetSphereRadius(200);

    // Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 
    // are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++) 
}

//////////////////////////////////////////////////////////////////////////
// Input

void ABPCommunicationCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
{
    // Set up gameplay key bindings
    check(PlayerInputComponent);
    PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
    PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);
    PlayerInputComponent->BindAction("Use", IE_Pressed, this, &ABPCommunicationCharacter::ToggleCeilingLight);
    PlayerInputComponent->BindAxis("MoveForward", this, &ABPCommunicationCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &ABPCommunicationCharacter::MoveRight);

    // We have 2 versions of the rotation bindings to handle different kinds of devices differently
    // "turn" handles devices that provide an absolute delta, such as a mouse.
    // "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
    PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
    PlayerInputComponent->BindAxis("TurnRate", this, &ABPCommunicationCharacter::TurnAtRate);
    PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
    PlayerInputComponent->BindAxis("LookUpRate", this, &ABPCommunicationCharacter::LookUpAtRate);

    // handle touch devices
    PlayerInputComponent->BindTouch(IE_Pressed, this, &ABPCommunicationCharacter::TouchStarted);
    PlayerInputComponent->BindTouch(IE_Released, this, &ABPCommunicationCharacter::TouchStopped);

    // VR headset functionality
    PlayerInputComponent->BindAction("ResetVR", IE_Pressed, this, &ABPCommunicationCharacter::OnResetVR);
}

void ABPCommunicationCharacter::NotifyActorBeginOverlap(AActor* OtherActor)
{
    if (ARotatingActor* RotatingActorCheck =Cast<ARotatingActor>(OtherActor))
    {
        ActorCheck->SetbCanRotate(true);
    }
}

void ABPCommunicationCharacter::NotifyActorEndOverlap(AActor* OtherActor)
{
    if (ARotatingActor* RotatingActorCheck = Cast<ARotatingActor>(OtherActor))
    {
        ActorCheck->SetbCanRotate(false);
    }
}

void ABPCommunicationCharacter::OnResetVR()
{
    // If BPCommunication is added to a project via 'Add Feature' in the Unreal Editor the dependency on HeadMountedDisplay in BPCommunication.Build.cs is not automatically propagated
    // and a linker error will result.

    // You will need to either:
    //      Add "HeadMountedDisplay" to [YourProject].Build.cs PublicDependencyModuleNames in order to build successfully (appropriate if supporting VR).
    // or:
    //      Comment or delete the call to ResetOrientationAndPosition below (appropriate if not supporting VR)

    UHeadMountedDisplayFunctionLibrary::ResetOrientationAndPosition();
}

void ABPCommunicationCharacter::TouchStarted(ETouchIndex::Type FingerIndex, FVector Location)
{
        Jump();
}

void ABPCommunicationCharacter::TouchStopped(ETouchIndex::Type FingerIndex, FVector Location)
{
        StopJumping();
}

void ABPCommunicationCharacter::TurnAtRate(float Rate)
{
    // calculate delta for this frame from the rate information
    AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}

void ABPCommunicationCharacter::LookUpAtRate(float Rate)
{
    // calculate delta for this frame from the rate information
    AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}

void ABPCommunicationCharacter::MoveForward(float Value)
{
    if ((Controller != nullptr) && (Value != 0.0f))
    {
        // find out which way is forward
        const FRotator Rotation = Controller->GetControlRotation();
        const FRotator YawRotation(0, Rotation.Yaw, 0);

        // get forward vector
        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
        AddMovementInput(Direction, Value);
    }
}

void ABPCommunicationCharacter::MoveRight(float Value)
{
    if ( (Controller != nullptr) && (Value != 0.0f) )
    {
        // find out which way is right
        const FRotator Rotation = Controller->GetControlRotation();
        const FRotator YawRotation(0, Rotation.Yaw, 0);

        // get right vector 
        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

        // add movement in that direction
        AddMovementInput(Direction, Value);
    }
}

1. Press Play and approach the BP_RotateObject Actor to see it rotate only when the player is nearby.

Section Results

In this section you added a Sphere Component to the BPCommunicationCharacter class.

You also created the overlap logic necessary to cast into the RotatingActor class, and call its SetbCanRotate function, which sets the bCanRotate variable to True when the player Character's Sphere Component overlaps it.

4 - Adding Different Rotating Shapes

You can now create several child Blueprint classes from the BP_RotatingActor Blueprint to add different shapes that react to the player Character. This will demonstrate how you can use child Blueprint classes to modify or add additional functionality, while still retaining the ability to cast to the common parent class.

1. From the Content Browser, right-click BP_Rotating Actor and select Create Child Blueprint Class . Name the Blueprint BP_RotateObject_Cone .

2. Repeat step 1 two more times to create BP_RotateObject_Pyramid and BP_RotateObject_Torus Blueprint classes.

3. Open BP_RotateObject_Cone in the Blueprint editor and select the Static Mesh component from the Components tab. From the Details panel, click the Static Mesh dropdown then search for and select Shape_Cone .

4. Set the Y Rotation to 90 degrees.

5. Compile and save the Blueprint.

6. Repeat steps 3 - 5 for BP_RotatingActor_Pyramid and select Shape_Quad_Pyramid as the Static Mesh.

7. Repeat steps 3 - 5 for BP_RotatingActor_Torus and select Shape_Torus as the Static Mesh. Rotate the mesh by 90 degrees in Y.

8. Drag each shape into your Level and click Play to verify they all rotate when the player is nearby.

Section Results

In this section, you created several child Blueprint classes from the BP_RotateObject Blueprint and assigned a different Static Mesh to each.

You also learned that you can cast to a Blueprint Actor's parent class to access common functionality. In this case, you overlapped each separate child Blueprint and casted to its parent class to trigger the rotation.

Next Steps

Now that you know how to use Blueprint casting, take a look at the other communication types referenced in the Actor Communication documentation page.