First-Person Kamera, Mesh und Animation hinzufügen

Bevor du beginnst

Stellen Sie sicher, dass Sie folgende Ziele im vorherigen Abschnitt, Charakterbewegung konfigurieren, erreicht haben:

• Verstehen, wie Input-Actions und Input-Mapping-Kontexte funktionieren.

• Einrichten eines Charakters mit den Bewegungen vorwärts, rückwärts, links, rechts und springen.

Steuerelemente der First-Person-Kamera

Um die Ausrichtung zu ändern, ändern wir den Wert der Transformation-Eigenschaft der Kamera. Für die Drehung in einem 3D-Raum nutzen Objekte die Funktionen Nickachse, Rollachse und Gierachse, um zu steuern, in welche Richtung sie sich drehen und auf welcher Achse. 

• Nickachse: Steuert die Drehung entlang der horizontalen (X-)Achse. Wenn Sie diese Einstellung ändern, wird ein Objekt nach oben oder unten gedreht, ähnlich wie beim Kopfnicken.

• Gierachse: Steuert die Drehung entlang der vertikalen (Y-)Achse. Wenn Sie diese Einstellung ändern, wird ein Objekt nach links oder rechts gedreht, ähnlich wie beim Drehen nach rechts oder links.

• Rollachse: Steuert die Drehung entlang der Z-Achse. Wenn Sie diese Einstellung ändern, wird ein Objekt seitlich gerollt, ähnlich wie wenn man den Kopf nach rechts oder links neigt.

Kameras in First-Person-Spielen verwenden normalerweise Gierachse und Nickachse, um Bewegung zu steuern. Rollen kann relevant werden, wenn Sie ein Spiel programmieren, in dem ein Flugzeug oder Raumschiff rotieren muss, oder wenn Sie das Spähen um Ecken simulieren müssen.

Kamerabewegung in Blueprints erkunden

Öffnen Sie BP_FirstPersonCharacter, um die Logik des Standard-Charakters im Blueprint-Editor zu betrachten. Im EventGraph finden Sie oben links die beiden Knoten der Kamera-Input-Knotengruppe. 

Wie bei IA_Move weist die Input-Action IA_Look auf einen Axis2D-Typ auf, sodass sie die Bewegung in X- und Y-Werte aufteilt. Dieses Mal werden X und Y zu den Gierachsen- und Nickachsen-Inputs der benutzerdefinierten Zielen-Funktion.

Doppelklicken Sie auf den Zielen-Funktionsknoten, um die darin enthaltene Logik zu sehen. Die Funktionsknoten Controller Gierachse-Input hinzufügen und Nickachse-Input fügen die Werte zum Charakter hinzu. 

First-Person-Charakter-Komponenten erkunden 

Wechseln Sie in den Viewport -Tab von BP_FirstPersonCharacter, um eine 3D-Vorschau des Actors und seiner Komponenten anzuzeigen. 

Im Komponenten-Tab sehen Sie eine strukturierte Hierarchie angekoppelter Komponenten, die den Charakter in der Welt definieren. 

Charakter-Blueprints werden automatisch instanziert mit: 

• einer Kapsel-Komponente, die den Charakter mit Objekten in der Welt kollidieren lässt.

• einer Skelett-Mesh-Komponente, die Animationen ermöglicht und den Charakter visualisiert. Im Details-Panel sehen Sie, dass dieser Charakter SKM_Manny_Simple als Skelett-Mesh-Asset verwendet.

• Eine Charakter-Bewegungs-Komponente, die es dem Charakter ermöglicht, sich umher zu bewegen.

Dieser Charakter hat auch ein zweites Skelett-Mesh namens FirstPersonMesh (nutzt ebenfalls SKM_Manny_Simple), das ein Child der Haupt-Mesh-Komponente ist. In First-Person-Spielen haben Charaktere normalerweise separate Meshs für Third-Person- und First-Person-Kontexte. Das Mesh ist nur für andere Spieler sichtbar, oder wenn sich der Spieler in der Third-Person-Perspektive befindet. Das First-Person-Mesh ist für den Spieler sichtbar, wenn er sich in der First-Person-Perspektive befindet. 

Das FirstPersonMesh hat eine Child-Kamera-Komponente namens FirstPersonCamera. Die Kamera bestimmt die First-Person-Perspektive des Spielers und rotiert mit dem Charakter, während er sich umschaut. In diesem Teil des Tutorials verwenden Sie C++, um zur Laufzeit eine Kamera auf Ihrem Charakter zu instanzieren und sie so zu positionieren, dass sie der Position dieser Kamera entspricht. 

Mehr Informationen zu Charakter-Komponenten finden Sie in der Characters Gameplay Framework documentation.

Blick-Input in Code implementieren

Um diese Funktionalität im Code zu implementieren, müssen Sie ebenso wie die im vorherigen Schritt implementierte Bewegung die Input-Action IA_Look an eine Funktion binden und diese Funktion dann an Ihren Charakter binden. 

Look()-Funktion und -Variablen deklarieren

Öffnen Sie in Visual Studio die .h- Datei Ihres Charakters. 

Wenn Ihr Charakter zur Laufzeit erstellt wird, weisen Sie die UE an, ihm eine Kamera-Komponente hinzuzufügen und die Kamera dynamisch zu positionieren. Um diese Funktionalität zu aktivieren, fügen Sie ein neues #include für ”Camera/CameraComponent.h” hinzu:  

#include "CoreMinimal.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"
#include "AdventureCharacter.generated.h"

Deklarieren Sie im protected-Abschnitt des Headers einen neuen UInputAction-Zeiger namens LookAction. Geben Sie diesem Zeiger das gleiche UPROPERTY()-Makro wie MoveAction und JumpAction. Dieses verweist auf die Input-Action IA_Look.

// Look Input Actions
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input)
UInputAction* LookAction;

Deklarieren Sie im public-Abschnitt eine neue Funktion namens Look(), die eine konstante FInputActionValue-Referenz namens Value entgegennimmt. Stellen Sie sicher, dass Sie der Funktion ein UFUNCTION()-Makro hinzufügen. 

// Handles Look Input
UFUNCTION()
void Look(const FInputActionValue& Value);

Deklarieren Sie nach der Look()-Funktion einen neuen UCameraComponent-Zeiger namens FirstPersonCameraComponent. Um diese Eigenschaft im Unreal Editor anzuzeigen, fügen Sie ein UPROPERTY()-Makro mit den Argumenten VisibleAnywhere und Category = Camera hinzu, damit es im Abschnitt Kamera des Details-Panels angezeigt wird. 

// First Person camera
UPROPERTY(VisibleAnywhere, Category = Camera)
UCameraComponent* FirstPersonCameraComponent;

Deklarieren Sie einen FVector mit dem Namen FirstPersonCameraOffset. Sie werden diesen Versatz verwenden, um die Kamera beim Einrichten Ihres Charakters richtig zu positionieren. Initialisieren Sie es als FVector mit den folgenden Werten und Makros EditAnywhere und Category = Camera, damit Sie es bei Bedarf im Unreal Editor anpassen können.

// Offset for the first-person camera
UPROPERTY(EditAnywhere, Category = Camera)
FVector FirstPersonCameraOffset = FVector(2.8f, 5.9f, 0.0f);

Sie benötigen noch einige weitere Eigenschaften, um einzustellen, wie nahe Objekte (wie beispielsweise der Körper des Charakters) in der Kameraansicht erscheinen. Deklarieren Sie die folgenden zwei float Variablen:  

• FirstPersonFieldOfView: Das horizontale Sichtfeld (in Grad), das diese Kamera beim Rendering mit FirstPerson getaggten Grundkörper-Komponenten verwenden soll. Legen Sie es auf 70.0f fest.  

• FirstPersonScale: Der Maßstab, den diese Kamera auf mit FirstPerson getaggte Grundkörper-Komponenten anwenden soll. Legen Sie es auf 0.6f fest.   

Weisen Sie diesen Eigenschaften ein UPROPERTY Makro mit den Bezeichner EditAnywhere and Category = Camera zu.    

// First-person primitives field of view
UPROPERTY(EditAnywhere, Category = Camera)
float FirstPersonFieldOfView = 70.0f;

// First-person primitives view scale
UPROPERTY(EditAnywhere, Category = Camera)
float FirstPersonScale = 0.6f;

Zuletzt deklarieren Sie einen neuen Pointer USkeletalMeshComponent mit dem Namen FirstPersonMeshComponent. Geben Sie ihm ein UPROPERTY()-Makro mit den Argumenten VisibleAnywhere und Category = Mesh. 

// First-person mesh, visible only to the owning player
UPROPERTY(VisibleAnywhere, Category = Mesh)
USkeletalMeshComponent* FirstPersonMeshComponent;

Sie haben nun Deklarationen für Folgendes eingerichtet: 

• First-Person-Mesh (das mit dem Child FirstPersonMesh korreliert, das Sie im Blueprint gesehen haben)

• Kamera

• Look()-Funktion

• IA_Look-Input-Action

Die .h- Datei Ihres Charakters sollte nun so aussehen:

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"

Blick-Input mit Look() hinzufügen

Öffnen Sie die .cpp- Datei Ihres Charakters, um die Kamera-Logik des Charakter-Blueprints mit der Funktion Look() zu implementieren.

Wie bei IA_Move gibt IA_Look bei der Auslösung einen FVector2D Wert zurück. Fügen Sie eine neue Funktionsdefinition für Look() hinzu. Rufen Sie innerhalb der Funktion den Wert von FInputActionValue in einem neuen FVector2D mit dem Namen LookAxisValue ab.

void AAdventureCharacter::Look(const FInputActionValue& Value)
{
	const FVector2D LookAxisValue = Value.Get<FVector2D>();
}

Prüfen als Nächstes in einer if-Anweisung, ob der Controller gültig ist. 

Wenn dies so ist, rufen Sie AddControllerYawInput() und AddControllerPitchInput() auf und übergeben Sie LookAxisValue.X bzw. LookAxisValue.Y. Ihre fertige Look()-Funktion sollte so aussehen:

void AAdventureCharacter::Look(const FInputActionValue& Value)
{
	const FVector2D LookAxisValue = Value.Get<FVector2D>();

	if (Controller)
	{
		AddControllerYawInput(LookAxisValue.X);
		AddControllerPitchInput(LookAxisValue.Y);
	}
}

Blick-Funktionalität mit SetupPlayerInputComponent an Input binden

In SetupPlayerInputComponent() binden Sie ähnlich wie bei den Bewegungs-Actions die Look()-Funktion an die LookAction-Input-Action. 

EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &AAdventureCharacter::Look);

Ihre SetupPlayerInputComponent()-Funktion sollte nun so aussehen:

// Called to bind functionality to input
void AAdventureCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	// Check the UInputComponent passed to this function and cast it to an UEnhancedInputComponent
	if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
	{
		// Bind Movement Actions
		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AAdventurenCharacter::Move);

		// Bind Look Actions

Speichern Sie Ihren Code und kompilieren Sie ihn, indem Sie in Visual Studio auf Build klicken. 

Zuweisen einer Blick-Input-Aktion im Blueprint

Weisen Sie abschließend der neuen Eigenschaft Blickaktion des Charakter-Blueprint eine Input-Aktion zu.

Gehen Sie wie folgt vor, um Ihrem Charakter Blick-Steuerelement zuzuweisen:

1. Öffnen Sie Ihren Charakter-Blueprint in Unreal Editor.

2. Stellen Sie sicher, dass im Komponenten-Panel die BP_[CharacterName]-Stammkomponente ausgewählt ist.

3. Setzen Sie im Details-Panel im Abschnitt Input die Option Blickaktion auf IA_Look.

   

4. Kompilieren und speichern Sie den Blueprint nun.

Blick-Bewegungen testen

Wenn Sie auf Spielen klicken, um Ihr Spiel zu testen, können Sie sich umschauen und Ihren Charakter in jede gewünschte Richtung bewegen! 

Beachten Sie, dass Ihre In-game-Perspektive zwar von einer First-Person-Kamera zu kommen scheint, aber Sie haben in Ihrem Charakter noch keine Kamera-Komponente. Stattdessen simuliert die Unreal Engine eine Ansicht von der Mitte der Kapsel-Komponente Ihres Charakters. Im nächsten Schritt lernen Sie, dies zu ändern, indem Sie Ihrer Charakterklasse eine Kamera hinzufügen.

Komponenten zur Laufzeit erstellen

Als Nächstes schließen Sie die Erstellung des First-Person-Mesh und der Kamera Ihres Charakters ab, indem Sie die Zeiger FirstPersonCameraComponent und FirstPersonMeshComponent instanzieren, die Sie in der Header-Datei deklariert haben.

Öffnen Sie zunächst die .cpp- Datei Ihres Charakters. 

Am Anfang der Datei sehen Sie den Klassen-Constructor (AAdventureCharacter() in diesem Tutorial). Diese Klasse wird ausgeführt, wenn das Objekt im Speicher zugewiesen wird, und legt die Standardwerte für Ihren Charakter fest. Hier fügen Sie zusätzliche Komponenten hinzu. 

Erstellen Sie eine Kamera-Komponente

Um Komponenten zum Charakter hinzuzufügen, verwenden Sie die Vorlagenfunktion CreateDefaultSubobject(). Sie gibt einen Pointer auf die neue Komponente zurück und nimmt die folgenden Argumente entgegen:

CreateDefaultSubobject<Typ>(TEXT(“Name”));

Dabei ist Typ der Typ des Unterobjekts, das Sie erstellen, und Name ist der interne Name der Unreal Engine, mit dem das Unterobjekt identifiziert und im Editor angezeigt wird.

Legen Sie im Klassen-Constructor den Pointer FirstPersonCameraComponent auf das Ergebnis des Aufrufs von CreateDefaultSubobject() vom Typ UCameraComponent fest. Im Argument TEXT benennen Sie das Objekt „FirstPersonCamera“. 

FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));

Dadurch wird ein Standard-Kameraobjekt als Child der Klasse Character erstellt.  Um sicherzustellen, dass die Kamera ordnungsgemäß instanziiert wurde, prüfen Sie als Nächstes, ob FirstPersonCameraComponent nicht null ist. 

// Create a first person camera component.
FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
check(FirstPersonCameraComponent != nullptr);

Erstellen Sie eine Mesh-Komponente

Legen Sie FirstPersonMeshComponent auf einen anderen Aufruf der Funktion CreateDefaultSubobject fest. Verwenden Sie diesmal USkeletalMeshComponent als Typ und „FirstPersonMesh” als Namen. Denken Sie daran, anschließend einen check hinzuzufügen.

// Create a first person mesh component for the owning player.
FirstPersonMeshComponent = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
	check(FirstPersonMeshComponent != nullptr);

Mesh anhängen und konfigurieren 

Nachdem Sie Ihr Mesh erstellt haben, fügen Sie es dem Charakter hinzu und aktivieren Sie das First-Person-Rendering dafür. 

Die Funktion SetupAttachment() fügt eine Szenenkomponente an eine andere an und stellt damit eine Parent-Child-Beziehung in der Komponentenhierarchie her.   

Rufen Sie die Funktion SetupAttachment() für das Objekt auf, auf das FirstPersonMeshComponent, zeigt und übergeben Sie ihr die Parent-Komponente. In diesem Fall sollte die Parent Komponente das Standard-Skelett-Mesh des Charakters sein, das Sie mit GetMesh() abrufen können. 

// Attach the FirstPerson mesh to the Skeletal Mesh
FirstPersonMeshComponent->SetupAttachment(GetMesh());

In der Header-Datei des Charakters haben Sie ein Kamera-Sichtfeld und einen Maßstab für Komponenten in der Nähe der Kamera deklariert. Um diese Kameraeigenschaften auf das First-Person-Mesh anzuwenden, setzen Sie die Eigenschaft FirstPersonPrimitiveType auf FirstPerson. 

FirstPersonMeshComponent->FirstPersonPrimitiveType = EFirstPersonPrimitiveType::FirstPerson;

Sichtbarkeit des Mesh

Bisher verfügt Ihr Charakter über ein Skelett-Mesh in der ersten und dritten Person, die sich während des Gameplay überlappen. Allerdings sollte das First-Person Mesh für andere Spieler unsichtbar sein und das Third-Person Mesh für Sie, den Spieler, unsichtbar sein.

Um die Sichtbarkeit von Meshs und Schatten in der First-Person- und Third-Person-Perspektive zu konfigurieren, gehen Sie wie folgt vor: 

1. Im Klassen-Constructor des Charakters legen Sie nach dem Festlegen des Grundköpertyps des First-Person-Meshs die Komponente FirstPersonPrimitiveType des Third-Person-Meshs auf WorldSpaceRepresentation fest.  

   C++

   GetMesh()->FirstPersonPrimitiveType = EFirstPersonPrimitiveType::WorldSpaceRepresentation;
   

   Copy full snippet(1 line long)

   Dieser Grundkörper-Typ ist für Komponenten vorgesehen, die andere Spieler sehen können. Es setzt automatisch die Eigenschaft OwnerNoSee dieser Komponente auf False, wodurch sie für den Spieler unsichtbar wird. Das Mesh wirft jedoch weiterhin einen Schatten. 

2. Rufen Sie in BeginPlay() nach der globalen Engine-Pointerprüfung SetOnlyOwnerSee() für FirstPersonMeshComponent, auf True damit das First-Person-Mesh nur für den besitzenden Spieler sichtbar ist.   

   C++

   // Only the owning player sees the first-person mesh
   FirstPersonMeshComponent->SetOnlyOwnerSee(true);

   Copy full snippet(2 lines long)

Befestigen Sie die Kamerakomponente.

Verwenden Sie im Constructor des Charakters einen weiteren Aufruf von SetupAttachment(), um die Kamerakomponente an das First-Person-Mesh anzuhängen. Diesmal fügen Sie eine optionale Überlast hinzu, um eine genaue Stelle (einen Socket) auf dem Mesh anzugeben, an der die Komponente angebracht werden soll.

Das in diesem Tutorial verwendete Mesh SKM_Manny_Simple hat eine Sammlung von Voreinstellung Sockets (oder Bones), die für die Animation verwendet werden. Sie können Sockets im Code mit einem FName-String referenzieren. Es ist am besten, die Kamera in der Nähe des Kopfes des Charakters zu positionieren, also übergeben Sie den Socket-Namen Head an SetupAttachment, um die Kamera mit diesem Socket zu verbinden. Sie werden die Kamera später näher an die Augen der Figur heranbringen.

// Attach the camera component to the first-person Skeletal Mesh.
FirstPersonCameraComponent->SetupAttachment(FirstPersonMeshComponent, FName("head"));

Für weitere Informationen darüber, was Sockets sind und wie sie erstellt werden, finden Sie auf Skeletal Mesh Sockets.

Konfigurieren Sie die Kamera

Wenn Sie Ihre Kamerakomponente initialisiert haben, haben Sie sie mit dem Kopf Socket des Charakters verbunden. Allerdings sieht die Kamera genauer aus, wenn sie auf die Augen des Charakters gerichtet ist. Die Kamera ist standardmäßig nach unten gerichtet, daher müssen Sie sie hinter dem Kopf dem Charakter drehen.

Um die Kamera in Position zu bringen und zu drehen, rufen Sie SetRelativeLocationAndRotation(), auf und übergeben Sie dabei den FirstPersonCameraOffset und einen neuen FRotator, der auf (0.0f, 90.0f, -90.0f) festgelgt ist. 

// Position the camera slightly above the eyes and rotate it to behind the player's head
FirstPersonCameraComponent->SetRelativeLocationAndRotation(FirstPersonCameraOffset, FRotator(0.0f, 90.0f, -90.0f));

Um die Kamera während des Gameplay mit dem Charakter zu drehen, setzen Sie die Eigenschaft von FirstPersonCameraComponent's bUsePawnControlRotation auf True. Dadurch übernimmt die Kamera die Drehung des Parent Pawns, so dass die Kamera der Drehung des Charakters folgt. 

// Enable the pawn to control camera rotation.
FirstPersonCameraComponent->bUsePawnControlRotation = true;

Zuletzt fügen Sie Ihrer Kamera das Rendering Blickfeld aus der First Person-Perspektive und First-Person-Maßstab hinzu. Setzen Sie die Eigenschaften  bEnableFirstPersonFieldOfView und bEnableFirstPersonScale der Komponente auf True. Weisen Sie dann die zuvor festgelegten Standardwerte für Blickfeld und Skalierung zu.  

// Enable first-person rendering and set default FOV and scale values
FirstPersonCameraComponent->bEnableFirstPersonFieldOfView = true;
FirstPersonCameraComponent->bEnableFirstPersonScale = true;
FirstPersonCameraComponent->FirstPersonFieldOfView = FirstPersonFieldOfView;
FirstPersonCameraComponent->FirstPersonScale = FirstPersonScale;

Der Constructor Ihres Charakters sollte wie folgt aussehen:

// Sets default values
AAdventureCharacter::AAdventureCharacter()
{
	// Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it
	PrimaryActorTick.bCanEverTick = true;

	// Create a first person camera component
	FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
	check(FirstPersonCameraComponent != nullptr);

Speichern Sie Ihren Code und kompilieren Sie ihn, indem Sie in Visual Studio auf Build klicken. 

Meshs im Unreal Editor zuweisen

Ihre Kamerasteuerungen sind eingerichtet, aber Sie haben noch einen Schritt vor sich - verwenden Sie den Editor, um die Skelett-Mesh-Assets zu den Variablen hinzuzufügen, die Sie im Code deklariert haben. 

Führen Sie die folgenden Schritte aus, um ein Skelett-Mesh zu einem Charakter Blueprint hinzuzufügen:

1. Öffnen Sie im Unreal Editor Ihren Charakter Blueprint, falls er noch nicht offen ist.

2. Stellen Sie sicher, dass im Komponenten-Panel der BP_[CharacterName]-Stamm ausgewählt ist.

3. Im Details-Panel sehen Sie im Abschnitt Mesh, dass Ihr Charakter zwei SkeletalMeshAsset-Slots anstatt einem hat, da Sie FirstPersonMeshComponent im Code erstellt haben. Klicken Sie in jeder Eigenschafts-Dropdown-Liste Menü auf den Pfeil und wählen Sie für beide Meshs SKM_Manny_Simple aus. 

   

   Wenn Sie die FirstPersonMeshComponent festlegen, sollte Ihre Kamera sich hinter dem Kopf der Figur in Position bewegen.

4. Speichern Sie Ihre Blueprints und klicken Sie auf Kompilieren.

Wenn Sie Ihr Spiel spielen und nach unten schauen, sollten Sie das First-Person Mesh Ihres Charakters sehen! Das Mesh rotiert, wenn Sie sich umsehen, und die Kamera passt sich dieser Bewegung an. Das Third-Person Mesh ist zur Laufzeit ausgeblendet und nur andere Spieler können es sehen. Allerdings befindet sich Ihr Charakter immer noch in einer statischen T-Pose. Verwenden Sie also einen Animations-Blueprint, um Ihrem Charakter Animationen hinzuzufügen und ihn zum Leben zu erwecken.  

Animationen zu Ihrem Charakter hinzufügen

Im Code können Sie über Instanzen der Klasse UAnimInstance auf die Logik der Animation zugreifen. Dabei handelt es sich um einen Controller, der auf der Grundlage des Zustands und anderer Variablen festlegt, welche Animationen überlagert und auf einem Skelett-Mesh abgespielt werden. Animations-Blueprints leiten sich ebenfalls von UAnimInstance ab, und Sie können in C++ mit dem Typ UAnimBlueprint auf sie verweisen. 

Die Erstellung einer Anim-Instanzklasse liegt außerhalb des Rahmens dieses Tutorials; stattdessen fügen Sie Ihrem Charakter den vorgefertigten Animation Blueprint der First Person-Vorlage hinzu. Dieser Blueprint enthält die Animationen und die Logik, die Ihr Charakter benötigt, um verschiedene Bewegungs- und Leerlaufanimationen auszuführen.

Animationen in der Unreal Engine werden pro Mesh einzeln festgelegt, so dass Sie separate Animationen für Ihre First- und Third-Person-Meshs benötigen. Da Ihr Third-Person Mesh verborgen ist, wenn das Spiel beginnt, müssen Sie nur Animationen auf dem First-Person Mesh festlegen. 

Befolgen Sie diese Schritte, um Ihrem Charakter eine Animation und einen Animationsblueprint hinzuzufügen:

1. Am Anfang der Datei .h Ihres Charakters wird die Klasse UAnimBlueprint vorwärts deklariert. Diese Klasse stellt die Animation Blueprints in Ihrem Projekt dar.

   C++

   class UAnimBlueprint;
   class UInputMappingContext;
   class UInputAction;
   class UInputComponent;

   Copy full snippet(4 lines long)

2. Deklarieren Sie dann im Abschnitt public einen neuen UAnimBlueprint Pointer mit dem Namen FirstPersonDefaultAnim. Geben Sie ihm das UCLASS()-Makro mit EditAnywhere und Category = Animation.

   C++

   // First Person animations
   UPROPERTY(EditAnywhere, Category = Animation)
   UAnimBlueprint* FirstPersonDefaultAnim;

   Copy full snippet(3 lines long)

3. Rufen Sie in der Datei .cpp Ihres Charakters in BeginPlay(), die Funktion FirstPersonMeshComponent->SetAnimInstanceClass() auf. Auch wenn Sie keine Anim-Instanzklasse im Code definiert haben, können Sie mit GeneratedClass eine Klasse aus dem Animationsblueprint erzeugen.

   C++

   // Only the owning player sees the first person mesh.
   FirstPersonMeshComponent->SetOnlyOwnerSee(true);
   
   // Set the animations on the first person mesh.
   FirstPersonMeshComponent->SetAnimInstanceClass(FirstPersonDefaultAnim->GeneratedClass);

   Copy full snippet(5 lines long)

4. Speichern Sie Ihren Code und kompilieren Sie ihn mit Visual Studio.

5. Öffnen Sie in Unreal Editor erneut den Charakter-Blueprint und wählen Sie die BP_[CharacterName]-Stammkomponente.

6. Legen Sie im Panel Details unter Animation die First Person Standard Anim auf ABP_Unarmed fest.

   

7. Speichern Sie Ihren Blueprint und kompilieren Sie ihn.

Testen Sie Ihren Charakter

Klicken Sie auf Spielen um Ihr Spiel zu testen. Wenn Sie nach unten blicken, sehen Sie, wie sich das First-Person Mesh animiert, während Sie sich bewegen! Bewegen Sie sich und springen Sie, um verschiedene Animationen zu sehen, die von diesem Blueprint gesteuert werden.   

Als Nächstes

Im nächsten Abschnitt erfahren Sie, wie Sie einen Gegenstand erstellen, den Ihr Charakter aufheben und benutzen kann!

Gegenstände und Daten verwalten

Lernen Sie, Gegenstand-Datenstrukturen, Daten-Assets und Datentabellen zu verwenden, um Gegenstände zu definieren und Gegenstandsdaten für Skalierbarkeit zu speichern und zu organisieren.

Vollständiger Code

Dies ist der vollständige Code, der in diesem Teil erstellt wurde:

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"

#include "AdventureCharacter.h"

// Sets default values
AAdventureCharacter::AAdventureCharacter()
{
	// Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it
	PrimaryActorTick.bCanEverTick = true;

	// Create a first-person camera component
	FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));