3 minuto(s) de leitura

1. O que são Enums?

Uma enumeração é um tipo definido pelo usuário que consiste em um conjunto de constantes integrais nomeadas que são conhecidas como enumeradores.

Exemplo:

enum cores = { vermelho,amarelo, azul, verde = 20, preto}

2. Criando Enums no Unreal Engine e Blueprint

Figura: Blueprint e Enum.
Podemos adicionar e remover vários valores.

Execute o comando no menu de contexto Blueprints > Enumeration e logo depois preencha os valores conforme a tela abaixo.

Figura: Blueprint Enum no Context Browser.
Objeto criado EN_Estado e EN_Pedra.

3. Criando Enums no Unreal Engine e C++

Arquivo header.

Visual Studio > Arquivo > Novo > Arquivo > Escolha Visual C++, Arquivo de Cabeçalho (.h)

// EnumName.h
UENUM(BlueprintType)
namespace EStatusEnum {
// Definimos namespace para que não existam conflitos no acesso aos elementos.
    enum Status
    {
        Ligada     UMETA(DisplayName = "Ligada"),
        Desligada      UMETA(DisplayName = "Desligada"),
    };

}

Arquivo de implementação.

// Hero.cpp
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Status)
  TEnumAsByte < EStatusEnum::Status > status;

4. Exemplos de uso - A lâmpada

Vamos verificar e alterar o estado de uma lâmpada utilizando uma variável do tipo boolean.

Figura: Blueprint Verificando o estado de uma lâmpada.
Lógica para determinar se a lâmpada está ligada ou desligada.

5. A lâmpada em C++

void AFirstPersonBaseCodeCharacter::SetupPlayerInputComponent(class UInputComponent* InputComponent)
  {
          // set up gameplay key bindings
          check(InputComponent);
          ...
          InputComponent->BindAxis("AnyKey", this, &AFirstPersonBaseCodeCharacter::AnyKey);
          ...
  }   
void AFirstPersonBaseCodeCharacter::AnyKey(float Value)
  {
    if bLigado
    {
      UE_LOG(LogTemp, Warning, TEXT("Lâmpada ligada."));  
    }    
    else
      UE_LOG(LogTemp, Warning, TEXT("Lâmpada desligada."));
  }

Alterando o componente PointLight para ligar e desligar a iluminação.

Figura: Blueprint Ligando e desligando o PointLight.
Utilizando Flip Flop podemos mudar a propriedade Set Intensity e configurando a variável Ligado para falso ou verdadeiro.

5.1. Arquivo Header da lâmpada em C++

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "ControlLight.generated.h"

UCLASS()
class CPP5_API AControlLight : public AActor
{
    GENERATED_BODY()

public:
    UPROPERTY()
        USceneComponent* Root;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Parameters")
        bool bLigado;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Parameters")
        float fIntensidade;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Parameters")
        class UPointLightComponent* PointLight;

    UPROPERTY(EditAnywhere, Meta = (MakeEditWidget = true))
        FVector TargetLocation;

    AControlLight();

protected:

    virtual void BeginPlay() override;

    void AnyKey();

public:
    virtual void Tick(float DeltaTime) override;
    void InitControl();

    class APlayerController* PlayerControllControlLight;

};

Arquivo de implementação.

#include "ControlLight.h"
#include "Components/PointLightComponent.h"
#include "Kismet/GameplayStatics.h"
#include "Components/InputComponent.h"

// Sets default values
AControlLight::AControlLight()
{
    PrimaryActorTick.bCanEverTick = true;
    Root = CreateDefaultSubobject<USceneComponent>("Root");
    RootComponent = Root;
    PointLight = CreateDefaultSubobject<UPointLightComponent>(TEXT("Ponto de Luz"));
    PointLight->SetRelativeTransform(FTransform(FRotator(0, 0, 0), FVector(250, 0, 0),FVector(0.1f)));
    fIntensidade = 10000;
    bLigado = true;
}

void AControlLight::InitControl()
{
    FVector GlobalLocation = GetTransform().TransformPosition(TargetLocation);
    PointLight->SetWorldLocation(GlobalLocation);
    PointLight->SetIntensity(fIntensidade);
}

// Called when the game starts or when spawned
void AControlLight::BeginPlay()
{
    Super::BeginPlay();
    PlayerControllControlLight = UGameplayStatics::GetPlayerController(this, 0);
    EnableInput(PlayerControllControlLight);
    AControlLight::InitControl();
}

// Called every frame
void AControlLight::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    if (PlayerControllControlLight != NULL)
    {
        if (PlayerControllControlLight->WasInputKeyJustPressed(EKeys::T))
        {
        AnyKey();
        }
    }
}

void AControlLight::AnyKey()
{
    if (bLigado)
    {
        fIntensidade = 0;
        bLigado = false;

    }
    else
    {
        fIntensidade = 10000;
        bLigado = true;
    }
    PointLight->SetIntensity(fIntensidade);
}

6. Verificando o estado utilizando o Enum com Blueprint

Figura: Blueprint Lendo Enum.
Podemos ler o valor corrente de um Enum acessando diretamente a variável.

7. Verificando o estado utilizando o Enum com C++

// Definindo um status no enum.
status = EStatusEnum::Ligada;

UE_LOG(LogTemp, Warning,TEXT("O enum é = %s"), *UEnum::GetValueAsString(status));

8. Ligando e desligando utilizando o Enum com Blueprint

Figura: Blueprint Ligando e desligando usando Enum.
Usamos agora a variável Estado do tipo Enum para configurar o estado da lâmpada.

9. Ligando e desligando utilizando o Enum com C++

...
if (status = EStatusEnum::Ligada) {
  fIntensidade = 0;
  bLigado = false;
  status = EStatusEnum::Desligada;
}
else {
  fIntensidade = 10000;
  bLigado = true;
  status = EStatusEnum::Ligada;
}

10. Exemplos de uso - A pedra das emoções

Vamos verificar e alterar o estado de emocional de uma pedra.

Alterando o estado emocional da pedra.

Figura: Blueprint alterando Enum.
Altera o estado para Feliz, triste, pulando e pensando.
Figura: Blueprint escrevendo o conteúdo do Enum.
Apresentando o estado da pedra.
Figura: Blueprint alterando o material de uma malha utilizando um Enum como parâmetro.
Alterando o material de uma malha utilizando um Enum como parâmetro.