El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Integrando C++ con Blueprints

Siguiente ►
►

En este tema, aprenderemos cómo integrar C++ con Blueprints en Unreal Engine. Esta integración permite aprovechar la flexibilidad y facilidad de uso de Blueprints junto con la potencia y control de C++. A lo largo de esta sección, cubriremos los siguientes puntos:

  1. Creación de una Clase C++ Base
  2. Exponiendo Funciones y Variables a Blueprints
  3. Llamando Funciones C++ desde Blueprints
  4. Ejemplo Práctico: Creando un Actor Interactivo
  5. Ejercicios Prácticos

  1. Creación de una Clase C++ Base

Paso 1: Crear una Nueva Clase C++

  1. Abre tu proyecto en Unreal Engine.
  2. Ve a File > New C++ Class.
  3. Selecciona Actor como la clase base y haz clic en Next.
  4. Nombra tu clase MyInteractiveActor y haz clic en Create Class.

Estructura de la Clase

// MyInteractiveActor.h
#pragma once

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

UCLASS()
class YOURPROJECT_API AMyInteractiveActor : public AActor
{
    GENERATED_BODY()
    
public:    
    // Sets default values for this actor's properties
    AMyInteractiveActor();

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public:    
    // Called every frame
    virtual void Tick(float DeltaTime) override;
};
// MyInteractiveActor.cpp
#include "MyInteractiveActor.h"

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

// Called when the game starts or when spawned
void AMyInteractiveActor::BeginPlay()
{
    Super::BeginPlay();
}

// Called every frame
void AMyInteractiveActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

  1. Exponiendo Funciones y Variables a Blueprints

Para que Blueprints pueda acceder a las funciones y variables de nuestra clase C++, debemos usar macros específicas de Unreal Engine.

Exponer Variables

// MyInteractiveActor.h

public:
    // Expose a variable to Blueprints
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Interaction")
    FString InteractiveMessage;

Exponer Funciones

// MyInteractiveActor.h

public:
    // Expose a function to Blueprints
    UFUNCTION(BlueprintCallable, Category="Interaction")
    void Interact();
// MyInteractiveActor.cpp

void AMyInteractiveActor::Interact()
{
    UE_LOG(LogTemp, Warning, TEXT("Interacted with: %s"), *InteractiveMessage);
}

  1. Llamando Funciones C++ desde Blueprints

Crear un Blueprint basado en la Clase C++

  1. En el Content Browser, haz clic derecho y selecciona Blueprint Class.
  2. En la ventana que aparece, selecciona All Classes y busca MyInteractiveActor.
  3. Selecciona MyInteractiveActor y haz clic en Select.
  4. Nombra tu Blueprint BP_MyInteractiveActor.

Usar la Función en el Blueprint

  1. Abre BP_MyInteractiveActor.
  2. En el Event Graph, arrastra desde el nodo Event BeginPlay y busca Interact.
  3. Conecta el nodo Interact al nodo Event BeginPlay.

  1. Ejemplo Práctico: Creando un Actor Interactivo

Paso 1: Configurar el Actor

  1. Abre BP_MyInteractiveActor.
  2. En el panel de detalles, establece el valor de InteractiveMessage a "Hello, Unreal!".

Paso 2: Colocar el Actor en el Nivel

  1. Arrastra BP_MyInteractiveActor desde el Content Browser al nivel.

Paso 3: Probar la Interacción

  1. Ejecuta el juego y observa el mensaje en la consola cuando el juego comienza.

  1. Ejercicios Prácticos

Ejercicio 1: Crear un Actor que Cambie de Color

  1. Crea una nueva clase C++ llamada ColorChangingActor.
  2. Expon una variable FLinearColor llamada NewColor a Blueprints.
  3. Expon una función ChangeColor que cambie el color del material del actor.
  4. Crea un Blueprint basado en ColorChangingActor y configura NewColor.
  5. Llama a ChangeColor en Event BeginPlay.

Solución

// ColorChangingActor.h
#pragma once

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

UCLASS()
class YOURPROJECT_API AColorChangingActor : public AActor
{
    GENERATED_BODY()
    
public:    
    AColorChangingActor();

protected:
    virtual void BeginPlay() override;

public:    
    virtual void Tick(float DeltaTime) override;

    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category="Color")
    FLinearColor NewColor;

    UFUNCTION(BlueprintCallable, Category="Color")
    void ChangeColor();
};
// ColorChangingActor.cpp
#include "ColorChangingActor.h"
#include "Materials/MaterialInstanceDynamic.h"

AColorChangingActor::AColorChangingActor()
{
    PrimaryActorTick.bCanEverTick = true;
}

void AColorChangingActor::BeginPlay()
{
    Super::BeginPlay();
}

void AColorChangingActor::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
}

void AColorChangingActor::ChangeColor()
{
    UMaterialInstanceDynamic* DynamicMaterial = CreateAndSetMaterialInstanceDynamic(0);
    if (DynamicMaterial)
    {
        DynamicMaterial->SetVectorParameterValue("BaseColor", NewColor);
    }
}

Resumen

En esta sección, hemos aprendido cómo integrar C++ con Blueprints en Unreal Engine. Hemos cubierto la creación de una clase C++ base, la exposición de funciones y variables a Blueprints, y cómo llamar funciones C++ desde Blueprints. Además, hemos realizado un ejemplo práctico y proporcionado un ejercicio para reforzar los conceptos aprendidos. Con esta base, estarás preparado para aprovechar al máximo la potencia de C++ y la flexibilidad de Blueprints en tus proyectos de Unreal Engine.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados