Converting Blueprint to C++

• I am working through Converting Blueprint to C++
  • These are notes that I typed up as I went through.
• He has a section on comparing Blueprint to C++
  • Blueprint is better at
    • Very quick to compile. C++ takes a while.
    • So it is good for rapid development.
    • Easy to understand?
    • Easy to discover the API
      • Strong context sensitive search.
    • Friendly for non programmers.
  • C++
    • FAST
    • Not limited
      • Apparently there are portions of unreal you can not get to from blueprints.
    • Very concise
    • More maintainable at scale
• Converting a Blueprint class to a C++ class (or mixture)
  • He has a blueprint class called BP_Grabber
  • This interacts with a BP_QuestManager
  • There are restrictions on how things can interact.
    • A C++ base class can lead to blueprint derived classes.
    • But you can't derive a c++ class from a blueprint class.
    • 
  • You want the same base class as the existing blueprint.
    • In the blueprint there is a Class Component button
    • 
    • So you create a c++ class of this type.
    • 
  • After a while, we get a class like before
    • The header file.

    • #pragma once
      
      #include "CoreMinimal.h"
      #include "Components/SceneComponent.h"
      #include "Grabber.generated.h"
      
      
      UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
      class BLUEPRINTSTOCPP_API UGrabber : public USceneComponent
      {
      	GENERATED_BODY()
      
      public:	
      	// Sets default values for this component's properties
      	UGrabber();
      
      protected:
      	// Called when the game starts
      	virtual void BeginPlay() override;
      
      public:	
      	// Called every frame
      	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
      
      		
      }; 

    • The implementation file

      #include "Grabber.h"
      
      // Sets default values for this component's properties
      UGrabber::UGrabber()
      {
      	// Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
      	// off to improve performance if you don't need them.
      	PrimaryComponentTick.bCanEverTick = true;
      
      	// ...
      }
      
      
      // Called when the game starts
      void UGrabber::BeginPlay()
      {
      	Super::BeginPlay();
      
      	// ...
      
      }
      
      
      // Called every frame
      void UGrabber::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
      {
      	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
      
      	// ...
      } 

    • Note, by default this is called UGrabber
  • The first change is to the class properties of this class.
    • It needs to be Blueprintable so blueprints can inherit from it.
    • So add this

    • // in Grabber.h
      UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent), Blueprintable ) 

    • Now the Grabber blueprint can be based on this class.
    • 
    • Ok, so what you don't see at this point is an engine restart. Apparently this is "required in some versions of the engine"
  • He does the same for his QuestManaer
    • This time it is based on the actor class.
    • Which is by default blueprintable.
    • So as soon as this is finished compiling you can re-parent the class right away.
• A little code
  • He introduces UE_LOG
    • This is a macro
    • A c/c++ preprocessor thing.
    • Lets you define code that gets directly inserted into your code by the c++ preprocessor
    • These are tricky and should be left to pros.
  • It takes a
    • Log destination
    • Log Level
    • Message.

  • void UGrabber::BeginPlay()
    {
    	Super::BeginPlay();
    
    	UE_LOG(LogTemp, Warning, TEXT("Grabber Begin Play"));
    } 

  • After a recompile, it is now loggin
  • 
  • 
  • He notes
    • The constructor is called in the editor
      • 
      • This makes sense as we are changing properties
    • It is also called when the game runs.
    • And this is the difference between the constructor and begin play.
• He goes on to describe the difference between an actor and a component.
  • In general Actors are big things, made up of many different components.
  • Actors are stand alone
  • Actors tend to be the last item in an object chain.
    • If it needs to be shared, don't make it an actor.
• His next step is to migrate a variable from the blueprint to the c++ class
  • This is MaxGrabDistance.
  • He adds the following code

  • protected:
    	UPROPERTY(EditAnywhere, BlueprintReadOnly)
    	float MaxGrabDistance{100};
              

  • He explains that the UPROPRTY is
    • Another macro
    • It tells UE4 to expose this to the engine in the blueprint.
  • Once you compile this now shows up in the Blueprint
    • There was a name conflict so it renamed the blueprint variable MaxGrabDistance_0
    • But this is easily deleted and everything is back to working.
• Next he replaces a function
  • The function GetMaxGrabLocation returns a vector.
  • 
  • First the function prototype

  • protected:
         UFUNCTION(BlueprintCallable, BlueprintPure)
         FVector GetMaxGrabLocation() const; 

  • He discusses different types
    • Builtins are limited, but float = Float
    • Mostly the data classes are F* (FVector, FString, ...)
    • Actors are AActor, Objects are UObject, ...
      • Remember, these are polymorphic so probably pointers.
  • He sort of force feeds the implementation.
    • It uses the Kismet mathclass

    • #include "Grabber.h"
      #include "Kismet/KismetMathLibrary.h" 

    • And the implementation

    • FVector UGrabber::GetMaxGrabLocation() const {
      	
      	auto answer = GetComponentLocation() 
      		          + UKismetMathLibrary::GetForwardVector(GetComponentRotation())
      		          * MaxGrabDistance;
      
      	return answer;
      } 

    • After a compile, this works just fine.
  • A side note, Pure functions in Blueprint.
    • 
    • Look here
    • Pure functions are essentially const functions in c++
    • The promise not to modify the class data members.
    • Thus it does not matter when they are called during a call to a event containing one of them.
    • Generally used for getters.
    • They don't get execution wires.
• He does a section on how to find the C++ equivalent to the Blueprint functions.
  • If you hover over a node, it will tell you the type.
    • 
    • Note it says target self, thus the base class must have this implemented.
  • Same in the visual studio editor
  • 
  • Since our Grabber is derived from USceneComponent

    • class BLUEPRINTSTOCPP_API UGrabber : public USceneComponent
                   

    • We can hover over USceneComponent and press alt-f12 and it will bring up the user interface.
    • 
    • You use alt-f12 quite a bit to search down for the real name.
• He next steps how to implement an event in c++
  • NOTE:
    • UE4 appears to have a problem if you do this with the same name as the function he is replacing.
    • He has problems doing this.
    • You would be better to create the event called NotifyQuestActor1 or something like that.
    • Do the tutorial
    • Delete NotifyQuestActor
    • And rename the c++ function.
  • Essentially you declare a virtual function (without the =0)
  • Of type BlueprntImplementableEvent

  • UFUNCTION(BlueprintImplementableEvent, BlueprintCallable)
    void NotifyQuestActor(AActor* Actor); 

  • reference
  • In the end, what this does is makes it so you can define an event in Blueprint and have it called from C++