Como adicionar câmera, malha e animação em primeira pessoa

Antes de começar

Certifique-se de ter concluído os seguintes objetivos da seção anterior, Como configurar o movimento do personagem:

• Entendeu como funcionam as ações de entrada e os contextos de mapeamento de entrada.

• Configurou um personagem com movimentos para a frente, trás, esquerda, direita e salto.

Controles de câmera em primeira pessoa

Para alterar a orientação da câmera, alteramos o valor de Rotação da propriedade Transformar da câmera. Para girar em um espaço 3D, os objetos usam Eixo Lateral, Eixo de Inclinação e Eixo Vertical para controlar a direção do giro e ao longo de qual eixo ele é realizado. 

• Eixo Lateral: controla a rotação ao longo do eixo horizontal (X). Ao alterá-lo, o objeto gira para cima ou para baixo, de forma semelhante a um movimento de "sim" com a cabeça.

• Eixo Vertical: controla de rotação ao longo do eixo vertical (Y). Ao alterá-lo, o objeto gira para a esquerda ou direita.

• Eixo de Inclinação: controla a rotação ao longo do eixo longitudinal (Z). Ao alterá-lo, o objeto gira de um lado para o outro, de forma semelhante a inclinar a cabeça para a direita ou para a esquerda.

Em jogos em primeira pessoa, as câmeras usam o Eixo Vertical e o Eixo Lateral para controlar o movimento. O Eixo de Inclinação pode ser relevante se você estiver programando um jogo em que precisa girar um avião ou uma nave espacial, ou se precisar simular espiar pelos cantos.

Explore o movimento da câmera em Blueprints

Abra BP_FirstPersonCharacter para visualizar a lógica de controle da câmera do personagem padrão no Editor de Blueprint. No EventGraph, observe dois nós no canto superior esquerdo do grupo de nós Entrada da câmera. 

Assim como com IA_Move, a ação de entrada IA_Look tem um Tipo de Valor Axis2D, então ela divide o movimento em valores X e Y. Desta vez, X e Y se tornam as entradas Eixo vertical e Arfagem da função Mira personalizada.

Clique duas vezes no nó da função Mira para ver a lógica interna. Os nós de função Adicionar entrada de eixo vertical do controle e Entrada de arfagem adicionam os valores ao personagem. 

Explore componentes de personagem em primeira pessoa 

Vá para a aba da janela de visualização de BP_FirstPersonCharacter para visualizar uma pré-visualização 3D do Ator e de seus componentes. 

Na aba Componentes, você verá uma hierarquia estruturada de componentes anexados que definem o personagem no mundo. 

Blueprints de Personagem são instanciados automaticamente com: 

• um Componente de Cápsula que faz o personagem colidir com objetos no mundo.

• um Componente de Malha Esquelética que ativa animações e visualiza o personagem. No painel Detalhes, você verá que o personagem usa SKM_Manny_Simple como Ativo de Malha Esquelética.

• Um Componente de Movimento do Personagem que permite que o personagem se mova.

Esse personagem também tem uma segunda Malha Esquelética chamada FirstPersonMesh (também usando SKM_Manny_Simple) que é filha do componente da malha principal. Em jogos em primeira pessoa, os personagens costumam ter malhas separadas para contextos de primeira e terceira pessoa. A malha de terceira pessoa só é visível para outros jogadores ou quando o jogador está em uma visualização em terceira pessoa. A malha de primeira pessoa é visível para o jogador quando ele está na visualização em primeira pessoa. 

A FirstPersonMesh tem um Componente de Câmera filho chamado FirstPersonCamera. Essa câmera determina a visão em primeira pessoa do jogador e gira com o personagem conforme ele olha ao redor. Nesta parte do tutorial, você usará C++ para instanciar uma câmera no personagem no tempo de execução e posicioná-lo de acordo com a posição dessa câmera. 

Para obter mais informações sobre os componentes de personagem, confira a documentação do framework de jogabilidade de personagens.

Implemente a entrada de visão em código

Para implementar essa funcionalidade de câmera em código, assim como o movimento implementado na etapa anterior, vincule a ação de entrada IA_Look a uma função e vincule essa função ao personagem. 

Declare a função Look() e as variáveis

No Visual Studio, abra o arquivo .h do personagem. 

Quando o personagem for criado em tempo de execução, você solicitará à UE que adicione um componente de câmera a ele e posicione a câmera dinamicamente. Para habilitar essa funcionalidade, adicione um novo #include para ”Camera/CameraComponent.h”:  

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

Na seção protected do cabeçalho, declare um novo ponteiro para UInputAction chamado LookAction. Dê a esse ponteiro o mesmo macro UPROPERTY() de MoveAction e JumpAction. Isso apontará para a ação de entrada IA_Look.

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

Na seção public, declare uma nova função chamada Look() que recebe uma referência FInputActionValue constante chamada Value. Certifique-se de adicionar um macro UFUNCTION() à função. 

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

Após a declaração da função Look(), declare um novo ponteiro para UCameraComponent chamado FirstPersonCameraComponent. Para expor essa propriedade ao Unreal Editor, adicione uma macro UPROPERTY() com argumentos VisibleAnywhere e Category = Camera para que ele apareça na seção Câmera do painel Detalhes. 

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

Declare um FVector chamado FirstPersonCameraOffset. Você usará esse deslocamento para posicionar adequadamente a câmera ao configurar seu personagem. Inicialize-o com um FVector usando os seguintes valores e as macros EditAnywhere e Category = Camera, para que possa ajustá-lo no Unreal Editor, se necessário.

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

Você precisa de mais algumas propriedades para ajustar a proximidade com que objetos em close-up (como o corpo do personagem) aparecem na visão da câmera. Declare as duas seguintes variáveis float:  

• FirstPersonFieldOfView: o campo de visão horizontal (em graus) que a câmera deve usar ao renderizar componentes primitivos marcados com a tag FirstPerson. Defina como 70.0f.  

• FirstPersonScale: a escala que a câmera deve aplicar a componentes primitivos marcados com a tag FirstPerson. Defina como 0.6f.   

Dê a essas propriedades uma macro UPROPERTY com os especificadores EditAnywhere e Category = Camera.    

// 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;

Por fim, declare um novo ponteiro USkeletalMeshComponent chamado FirstPersonMeshComponent. Dê a ele uma macro UPROPERTY() com os argumentos VisibleAnywhere e Category = Mesh. 

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

Até aqui, você configurou declarações para: 

• Malha em primeira pessoa (que se correlaciona a FirstPersonMesh filho que você viu nos Blueprints)

• Câmera

• FunçãoLook()

• Ação de entrada IA_Look

O arquivo .h do seu personagem deve ficar assim:

// 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"

Adicione a entrada de visão com Look()

Abra a classe .cpp do personagem para implementar a lógica de entrada de câmera do Blueprint de Personagem usando a função Look().

Assim como com IA_Move, IA_Look retorna um valor FVector2D quando acionado. Adicione uma nova definição de função para Look(). Dentro da função, obtenha o valor de FInputActionValue dentro de um novo FVector2D chamado LookAxisValue.

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

Em seguida, em uma instrução if, verifique se o Controle é válido. 

Se for, chame AddControllerYawInput() e AddControllerPitchInput(), passando os valores LookAxisValue.X e LookAxisValue.Y, respectivamente. A função Look() completa deve ficar assim:

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

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

Vincule a funcionalidade de visão à entrada com SetupPlayerInputComponent

Em SetupPlayerInputComponent(), como nas ações de movimento, você vinculará a função Look() à ação de entrada LookAction. 

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

Sua função SetupPlayerInputComponent() deve ficar semelhante a esta:

// 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

Salve o código e compile-o clicando em Compilar no Visual Studio. 

Atribuir uma ação de entrada de aparência no Blueprint

Por fim, atribua uma ação de entrada à nova propriedade Look Action do Blueprint de personagem.

Para atribuir controles de aparência ao seu personagem, siga estas etapas:

1. No Unreal Editor, abra o seu Blueprint de personagem.

2. No painel Componentes, certifique-se de que o componente-raiz BP_[CharacterName] esteja selecionado.

3. No painel Detalhes, na seção Entrada, defina Look Action como IA_Look.

   

4. Compile e salve o Blueprint.

Teste os movimentos de visão

Se você pressionar Jogar para testar o jogo, poderá olhar ao redor e mover o personagem na direção que desejar! 

Observe que, embora a visão no jogo pareça vir de uma câmera em primeira pessoa, você ainda não possui um componente de câmera no personagem. Em vez disso, a Unreal Engine simula uma visão do centro do componente de cápsula do personagem. Na próxima etapa, você aprenderá a mudar isso adicionando uma câmera à classe de personagem.

Crie componentes no tempo de execução

Em seguida, você terminará de criar a malha e a câmera de primeira pessoa do personagem ao instanciar os ponteiros para FirstPersonCameraComponent e FirstPersonMeshComponent declarados no arquivo de cabeçalho.

Para começar, abra o arquivo .cpp do personagem. 

No parte superior do arquivo, você verá o construtor de classe (AAdventureCharacter() neste tutorial). Essa classe é executada quando o objeto é alocado na memória e define os valores padrão para seu personagem. É aqui que você adiciona componentes. 

Crie um componente de câmera

Para adicionar componentes ao Personagem, use a função modelo CreateDefaultSubobject(). Ela retorna um ponteiro para o novo componente com os seguintes argumentos:

CreateDefaultSubobject<type>(TEXT("Name"));

Onde type é o tipo de subobjeto que você está criando e Name é o nome interno que a Unreal Engine usa para identificar o subobjeto e exibi-lo no editor.

No construtor de classe, defina o ponteiro FirstPersonCameraComponent para o resultado de chamar CreateDefaultSubobject() do tipo UCameraComponent. No argumento TEXT, nomeie o objeto como "FirstPersonCamera". 

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

Assim, criamos um objeto de câmera padrão como filho da classe Character.  dsd, para garantir que a câmera foi instanciada corretamente, verifique se FirstPersonCameraComponent não está nulo. 

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

Crie um componente de malha

Defina FirstPersonMeshComponent com outra chamada da função CreateDefaultSubobject. Desta vez, use USkeletalMeshComponent como o tipo e "FirstPersonMesh" como o nome. Lembre-se de adicionar uma verificação depois.

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

Anexe e configure a malha 

Depois de criar a malha, você precisa anexá-la ao personagem e habilitar nela a renderização de primeira pessoa. 

A função SetupAttachment() anexa um componente de cena a outro, estabelecendo uma relação pai-filho na hierarquia de componentes.   

Chame a função SetupAttachment() no objeto ao qual FirstPersonMeshComponent aponta e passe o componente pai como parâmetro. Nesse caso, o componente pai deve ser a malha do esqueleto padrão do personagem, que você pode obter usando GetMesh(). 

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

No arquivo de cabeçalho do personagem, você declarou um campo de visão da câmera e uma escala para usar em componentes próximos à câmera. Para que essas propriedades da câmera se apliquem à malha em primeira pessoa, defina a propriedade FirstPersonPrimitiveType da malha como FirstPerson. 

FirstPersonMeshComponent->FirstPersonPrimitiveType = EFirstPersonPrimitiveType::FirstPerson;

Defina a visibilidade da malha

Até agora, seu personagem tem malhas do esqueleto de primeira e terceira pessoa que se sobrepõem durante a jogabilidade. No entanto, a malha de primeira pessoa deve ser invisível para os outros jogadores e a malha de terceira pessoa deve ser invisível para você, o jogador.

Para configurar a visibilidade de sombra para as malhas de primeira e terceira pessoa, siga estas etapas: 

1. No construtor de classe do personagem, após definir o tipo primitivo da malha de primeira pessoa, defina a propriedade FirstPersonPrimitiveType do componente da malha de terceira pessoa para WorldSpaceRepresentation.  

   C++

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

   Copy full snippet(1 line long)

   Esse tipo de primitivo é usado para componentes que outros jogadores veem. Ele define automaticamente a propriedade OwnerNoSee do componente como false, tornando-o invisível para o jogador. No entanto, a malha ainda projeta uma sombra. 

2. Em BeginPlay(), após a verificação do ponteiro global da engine, chame SetOnlyOwnerSee() em FirstPersonMeshComponent, passando true para tornar a malha de primeira pessoa visível apenas ao jogador proprietário.   

   C++

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

   Copy full snippet(2 lines long)

Anexe o componente de câmera

No construtor do personagem, use outra chamada SetupAttachment() para anexar o componente de câmera à malha de primeira pessoa. Desta vez, você adicionará uma sobrecarga opcional para especificar uma posição exata (um soquete) na malha ao qual o componente deve ser anexado.

A malha SKM_Manny_Simple usada neste tutorial tem uma coleção de soquetes (ou ossos) predefinidos usados para animação. Você pode referenciar os soquetes no código usando uma string FName. Posicione a câmera perto da cabeça do personagem, assim você passará o nome do soquete Head para SetupAttachment para anexar a câmera ao soquete. Você moverá a câmera para mais perto dos olhos do personagem depois.

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

Consulte mais informações sobre o que são soquetes e como são criados em Soquetes da Malha esquelética.

Configure a câmera

Ao inicializar o componente de câmera, você o anexou ao soquete "Head" do personagem. No entanto, a câmera parece mais precisa quando está posicionada nos olhos do personagem. A câmera também está apontando para baixo por padrão, então você precisará girá-la para trás da cabeça do personagem.

Para mover e girar a câmera para a posição correta, chame SetRelativeLocationAndRotation(), passando FirstPersonCameraOffset e um novo FRotator configurado como (0.0f, 90.0f, -90.0f). 

// 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));

Para fazer a câmera girar com o personagem durante a interação, defina a propriedade bUsePawnControlRotation de FirstPersonCameraComponent como true. Isso faz com que a câmera herde a rotação do pawn pai, para que quando o personagem se virar, a câmera o seguirá. 

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

Por fim, adicione seu campo de visão para primeira pessoa e escala para primeira pessoa à câmera. Defina as propriedades bEnableFirstPersonFieldOfView e bEnableFirstPersonScale do componente como true. Em seguida, atribua o valores padrão de campo de visão e escala que declarou anteriormente.  

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

O construtor do personagem deve ficar assim:

// 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);

Salve o código e compile clicando em Build no Visual Studio. 

Atribua as malhas no Unreal Editor

Os controles da câmera estão configurados, mas você ainda tem uma etapa a executar: use o editor para adicionar os ativos da Malha esquelética às variáveis declaradas no código. 

Para adicionar uma Malha esquelética a um Blueprint de personagem, siga estas etapas:

1. No Unreal Editor, se ainda não estiver aberto, abra seu Blueprint de personagem.

2. No painel , certifique-se de que o componente-raiz BP_[CharacterName] esteja selecionado.

3. No painel Detalhes, na seção Malhas, o personagem tem dois espaços SkeletalMeshAsset em vez de um, pois o FirstPersonMeshComponent foi criado no código. Clique na seta no menu suspenso de cada propriedade e selecione SKM_Manny_Simple para as duas malhas. 

   

   Quando você define o FirstPersonMeshComponent, sua câmera deve mover-se até a posição atrás da cabeça do personagem.

4. Salve o Blueprint e clicar em Compilar.

Se você jogar seu jogo e olhar para baixo, deverá ver a malha de primeira pessoa do seu personagem! A malha gira conforme o usuário olha ao redor, e a câmera acompanha esse movimento. A malha de terceira pessoa fica oculta no tempo de execução e apenas os jogadores podem vê-la. No entanto, como o personagem ainda está em uma pose estática em T, você usará um Blueprint de animação para adicionar algumas animações ao seu personagem e termine de dar vida a ele.  

Adicione animações ao seu personagem

No código, você pode acessar a lógica de animação por instâncias da classe UAnimInstance, que é um controlador que determina quais animações são mescladas e reproduzidas em uma Malha esquelética com base no estado e em outras variáveis. Os Blueprints de animação também derivam de UAnimInstance, e você pode referenciá-los em C++ com o tipo UAnimBlueprint. 

A criação de uma classe de instância de animação está fora do escopo deste tutorial; em vez disso, adicione o Blueprint de animação pré-compilado do modelo de primeira pessoa ao personagem. Esse Blueprint inclui as animações e a lógica necessárias para que o personagem reproduza diferentes animações de movimento e ociosidade.

As animações na Unreal Engine são definidas por malha, portanto, você precisará de animações separadas para as malhas de primeira e terceira pessoa. Como a malha de terceira pessoa está oculta no início do jogo, você só precisa definir animações na malha de primeira pessoa. 

Para adicionar uma propriedade de animação e um Blueprint de animação ao personagem, siga estas etapas:

1. No topo do arquivo .h do seu personagem, faça a declaração antecipada da classe UAnimBlueprint. Essa classe representa os Blueprints de animação no projeto.

   C++

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

   Copy full snippet(4 lines long)

2. Na seção pública, declare um novo ponteiro UAnimBlueprint chamado FirstPersonDefaultAnim. Aplique a macro UCLASS() com os especificadores EditAnywhere e Category = Animation.

   C++

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

   Copy full snippet(3 lines long)

3. No arquivo .cpp do personagem, em BeginPlay(), chame FirstPersonMeshComponent->SetAnimInstanceClass(). Mesmo que você não tenha definido uma classe de instância de animação no código, pode gerar uma classe a partir do Blueprint de animação usando GeneratedClass.

   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. Salve o código e compile pelo Visual Studio.

5. No Unreal Editor, reabra o Blueprint de personagem e selecione o componente-raiz BP_[CharacterName].

6. No painel Detalhes, em Animação, defina FirstPersonDefaultAnim como ABP_Unarmed.

   

7. Salve seu Blueprint e compile-o.

Teste seu personagem

Pressione Jogar para testar o jogo. Se você olhar para baixo, verá a malha de primeira pessoa animada enquanto se move. Tente se movimentar e pular para ver as diferentes animações controladas por este Blueprint.   

Próxima

Na próxima seção, você aprenderá a criar um item para seu personagem pegar e usar.

Gerencie itens e dados

Aprenda a usar estruturas de dados de itens, ativos de dados e tabelas de dados para definir itens e armazenar e organizar dados de item para escalabilidade.

Código completo

Aqui está o código completo feito nesta seção:

// 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"));