这里记载了UE中常用的知识和编码笔记。

C++ 编码

Exposing C++ inherited vars & funcs to Blueprint

Exposing Variable to Blueprint using UPROPERTY(), 这样可以在编辑器中更快地在蓝图中修改调试。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class SWORDSLASH_API AItem : public AActor
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	AItem();
	virtual void Tick(float DeltaTime) override;

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;
private:
	float Amplitude;
    UPROPERTY(VisibleDefaultsOnly) // This makes "RunningTime" visible in blueprint default, but blocks editting ("VisibleInstanceOnly", "VisibleAnywhere")
	float RunningTime;
    UPROPERTY(EditAnywhere) // This allows "TimeConstant" editable anywhere ("EditDefaultsOnly", "EditInstanceOnly")
	float TimeConstant;
};

Exposing varaibles to Blueprint in event graph. 这样可以在蓝图的Graph中右键使用Variable了

1
2
3
UPROPERTY(EditAnywhere, BluprintReadOnly) // BlueprintReadOnly cannot be used to private variables ("BlueprintReadWrite")
UPROPERTY(EditAnywhere, BluprintReadOnly, meta = (AllowPrivateAccess = "true")) // Unless you do this, this meta allows private variable to be accessed by Blueprint
UPROPERTY(BlueprintReadWrite) // Allows both getter and setter for this attribute in blueprint graph

Set category for inherited C++ variables for better variable organizations

1
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Sine Parameters")

Exposing function to Blueprint

1
2
3
4
5
6
class SWORDSLASH_API AItem : public AActor {
	UFUNCTION(BlueprintCallable) // Expose this function to Blueprint; "BlueprintPure" presents that the function won't actually change anything, but only do input and output.
	float TransformedSin(float Value) {
		return Amplitude * FMath::Sin(Value * TimeConstant);
	}
}

Template Function

1
2
template<typename T>
T Avg(T First, T Second); // You need to specify type T everytime you call Avg: Avg<int32>(1, 3);

Components in C++

To add a component to a class (like Item):

  1. You need to first create a Default Subobject
    1. Define object type
    2. Determine Internal Name
      1
      2
      3
      4
      5
      6
      7
      8
      CreateDefaultSubobject<Type>(Name) // It returns a Type* pointer

      // Header file
      UStaticMeshComponent* ItemMesh;

      // cpp file
      ItemMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ItemMeshComponent"));
      RootComponent = ItemMesh; // Sets the item mesh same as root component (setting the defaultSceneRoot same as WeaponMesh)

Pawn class in C++

Pawn class is an actor and receives input from a controller.

For example, if we wanna build a bird pawn class:

  1. Create a default pawn class
  2. Create a UCapsuleComponent for the pawn object
    UObject -> USceneComponent -> UCapsuleComponent (otherwise it would be very expensive to calculate the collision with the mesh itself)
    • Used for simple collision
    • Rendered as red lines in the editor
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      // header file
      #include "Components/CapsuleComponent.h"

      UPROPERTY(VisibleAnywhere)
      UCapsuleComponent* Capsule;

      // cpp file, constructor
      Capsule = CreateDefaultSubobject<UCapsuleComponent>(TEXT("Capsule"));
      Capsule->SetCapsuleHalfHeight(20.f);
      Capsule->SetCapsuleRadius(15.f);
      SetRootComponent(Capsule); // RootComponent variable is protected; But this function is a public function.
      Create mesh and attach mesh component to the object:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      // Header file
      class USkeletalMeshComponent; // Using forward declaration

      UPROPERTY(VisibleAnywhere)
      USkeletalMeshComponent* BirdMesh;

      // cpp file
      #include "Components/SkeletalMeshComponent.h"

      BirdMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("BirdMesh")); // Initialize BirdMesh
      BirdMesh->SetupAttachment(GetRootComponent()); // Since mesh component can be attached to root component, this ensures the sync movement of bird mesh and the root.

Controlling Pawns

Pawns have the ability of been “possessed”

  • Takes the input from the user to manipulate the pawn.
  • Has controller: AController
  • To control the pawn, we need to set the auto possess player on the pawn
  • Auto possess player = Player 0, the second player = Player 1 (in multi-player game)

Bind mappings and function

  • Create and define Axis Mappings in project setting -> input, scale is to times the float Value to adjust the movement.
  • Create function: ABird::MoveForward(float Value), then the MoveForward key is bound to MoveForward function, which moves the pawn with float Value every frame. (Using the following function)
  • Bind Axis Mapping under this function using callback function:ABird::SetupPlayerInputComponent(UInputComponent* InputComponent)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    // hpp file
    void MoveForward(float Value); // normally put it under protected field

    // cpp file
    void ABird::MoveForward(float Value)
    {
    	
    }
    // Called to bind functionality to input
    void ABird::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
    {
    	Super::SetupPlayerInputComponent(PlayerInputComponent);

    	PlayerInputComponent->BindAxis(FName("MoveForward"), this, &ABird::MoveForward); // Actual bind function
    }

Unreal Engine Blueprint

To show the variables inherited from C++ in Blueprint:

  • Go to blueprint
  • Click on left bottom “Gear” icon
  • Check “Show Inherited Variables”

Clamp function:

  • Sets min and max value for a value

Target Effects

Damped Effect

In event tick:

  • set an amplitude
  • amplitude -= deltaTime * 0.05 (the larger the number, the quicker the motion stops)
  • set clamp function for amplitude, so that it will finally stops at 0.
  • set the updated value to amplitude for event tick

Circular Movements

Combine cos and sin functions together in two axes

UE Basic Knowledge

HEADS UP!

#include "~.generated.h" needs to be the last included file, otherwise it shows error. This is because the preprocessor will paste in codes auto-generated for this class to work and integrate with the reflection system.

Components

Scene Component

An actor must have at least one component: Default Scene Component, which contains:

  • Transform
    • Location
    • Rotation
    • Scale
  • Can be attached to other components

So the GetActorLocation() function actually returns the “RootComponent’s Location”, which is stored in the Transform variable.

Static Mesh Component
UStaticMeshComponent, derived from SceneComponent class:

  • Has Transform
  • Attachable
  • Has a Mesh (UStaticMesh)

For a Weapon:

  • DefaultSceneRoot
  • WeaponMesh

So it has two transforms by default, which means the transformation of the DefaultSceneRoot and the WeaponMesh can be different (导致Mesh和Object错位)。

To solve this:

  • Method 1: In BP_Item, drag Static Mesh onto the DefaultSceneRoot, at the top left corner

Skeletal Mesh Component
UObject ->(derive) USceneComponent -> USkeletalMeshComponent:

  • It has its own USkeletalMesh
  • USkeletalMesh has Skeleton, which can be animated (Normal Static Mesh cannot be animated)

To show bones in UE:

  • Open Skeletal Mesh
  • On top center: click “Character” -> Bones -> All

Unreal Property System (Reflection System)

Reflection system is as the property system, 反射系统让开发者和引擎在运行时获取并操作类，对象，属性和方法的信息。

而Unreal Header Tool（UHT）就是指UE提供的宏，它能够将C++ object加入反射系统中，例如:
UENUM(), UCLASS(), USTRUCT(), UFUNCTION(), UPROPERTY()

CDO (Class Default Object):

  • is a master copy of object for specific class contained in reflection system.
  • It contains object defaults and make them accessible easily
  • It’s created when engine is initialized. During initialization, engine generates UClass objects for each class, then it executes constructor setting default variables.
  • Thus, objects or gameplay codes should not be placed in constructor. Because at that time during the initialization, other objects may not exist, and the level is mosly likely not even loaded. So you should put code in BeginPlay().

Enhanced Input

It provides advanced input system in UE.

To see the enhanced input: showdebug enhancedinput, type in cmd while starting the game.

UE Basic Operations

To Detach from the default player:

  • Hit Play
  • Shift + F1
  • Select “Detach from the control player” on top center

Set the auto possess player to pawn:

  • Select BP_Pawn
  • In detail panel -> select auto possess player -> select the player you want to set.
  • Or use C++: AutoPossessPlayer = EAutoReceiveInput::Player0; under your pawn class.

Add Input Binding

  • Edit -> Project Settings
  • Select “Input” -> Select “Axis Mapping” -> Click “Add” -> Select your binding

UE Self-study resources 自学资料

UE的所有Class类资料都可以在官方文档中查询，且资料齐全详细：官方文档