Legacy/Interfaces And Blueprints

From UE4: Community Wiki
Jump to: navigation, search


This is a legacy article imported from the old wiki.
An updated version can be found here: Interfaces In C++


Using interfaces with C++ and Blueprints can be a little tricky when the interface is implemented purely in Blueprints. Currently, when a Blueprint implements an Interface the C++ InterfaceCast<> type cast does not work.

Interface Cast Method

auto MyInterface = InterfaceCast<IMyInterface>(ActorInstance);
if (MyInterface)
{
  // Other code
}

What you need to do instead is:

(Originally discovered by Lion032, source)

Implements Interface Method

if (ActorInstance->GetClass()->ImplementsInterface(UMyInterface::StaticClass()))
{
  // Other code
}

This will work for both C++ implemented interfaces and Blueprint implemented interfaces. From here, you can use the static Execute versions of the interface functions.

Header:

UINTERFACE(MinimalAPI)
class UMyInterface : public UInterface
{
  GENERATED_UINTERFACE_BODY()
};
 
class IMyInterface
{
  GENERATED_IINTERFACE_BODY()

public:
  UFUNCTION(BlueprintImplementableEvent)
  void MyInterfaceFunction();
};

Interface function example:

if (ActorInstance->GetClass()->ImplementsInterface(UMyInterface::StaticClass()))
{
  IMyInterface::Execute_MyInterfaceFunction(ActorInstance);
}

It is likely that the static Execute functions are generated by the Unreal Header Tool (UHT) only for interface functions that declare UFUNCTION(). This means that you can't make a virtual interface function which uses UFUNCTION() and intellisense won't pick them up.


More Complete Example (Passing Self as Reference):

MyInterface.H:

class AMyActor;


UINTERFACE(Category = "My Interface", BlueprintType, meta = (DisplayName = "My Interface"))
class MYMODULE_API UMyInterface : public UInterface {
	GENERATED_UINTERFACE_BODY()
};

class MYMODULE_API IMyInterface {
	GENERATED_IINTERFACE_BODY()
public:
	/// My Initialization Interface.
	UFUNCTION(Category = "My Interface", BlueprintNativeEvent, BlueprintCallable, meta = (DisplayName = "On My Interface Execute")
	void OnInitialized(const AMyActor* Context);
};

MyActor.H:

UFUNCTION(Category = "My Interface", BlueprintNativeEvent, BlueprintCallable, meta = (DisplayName = "On My Interface Call"))
void OnInitialized(const AMyActor* Context);

MyActor.CPP:

void AMyActor::OnInitialized_Implementation(const AMyActor* Context) {

	if (Context != this) {return;}

	TArray<AActor*>Interfaces;
	// Pick only Actors with Interface, instead of iterating whole World:
	UGameplayStatics::GetAllActorsWithInterface(this,UMyInterface::StaticClass(),Interfaces);

	for (const auto &amp;Actor : Interfaces) {

		// Try to Execute on C++ layer:
		const auto &amp;Interface = Cast<IMyInterface>(Actor);
		if (Interface) {Interface->Execute_OnInitialized(Actor,Context);} else
		
		// Else, Execute Interface on Blueprint layer instead:
		if (Actor->GetClass()->ImplementsInterface(UMyInterface::StaticClass())) {
			IMyInterface::Execute_OnInitialized(Actor,Context);
		}

	}

}

void AMyActor::BeginPlay() {
	Super::BeginPlay();

	// Fire off the Native Event, which is going to be received by all the other Actors:
	Execute_OnInitialized(this,this);

}

Notes: Example above is implemented with old GENERATED_UCLASS_BODY() instead of new GENERATED_BODY() one. If you want your Actor to receive C++ Interface calls instead of from Blueprint layer, your Actor must inherit from both AActor class and your Interface class, like so:

class MYMODULE_API AMyActor : public AActor, public IMyInterface {...}