Declare, implement and call an interface in C++

Development Programming & Scripting UI
, , , ,
1

I have an interface declared and called in C++. There are implementations in C++ and blueprints.

I am following the documentation (Interfaces in Unreal Engine | Unreal Engine 5.2 Documentation), which doesn’t have an essencial part (how do I call the method?).

So, I declared and implemented as the documentation says, and I am calling using the following code:

IButtonControlledUI::Execute_OnFocusReceivedByFocusManager(FocusedObject, this);

where IButtonControlledUI is my class, OnFocusReceivedByFocusManager is the method and FocusedObject is the owner.

It’s working in blueprints, but not in C++. The implemenation is not being called. The generated code (see the screenshot bellow) is not calling the OnFocusReceivedByFocusManager_Implemenation method. What must I do?

101294-screnshot.png
101294-screnshot.png915×260 9.38 KB

Fore more details, these are the declaration and implementation:

The interface:

UINTERFACE(Blueprintable)
class UButtonControlledUI : public UInterface
{
	GENERATED_UINTERFACE_BODY()
};

class IButtonControlledUI
{
	GENERATED_IINTERFACE_BODY()

public:
	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Button Controlled UI")
	void OnFocusReceivedByFocusManager(AFocusManager* FocusManager);

	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Button Controlled UI")
	void OnFocusLostByFocusManager(AFocusManager* FocusManager);
};

The class that implements the interface (.h):

UCLASS()
class SQUAD51_API UActionMenuItem : public UTextBlock, public IButtonControlledUI
{
	GENERATED_BODY()
	
public:
	virtual void OnFocusReceivedByFocusManager_Implementation(AFocusManager* FocusManager) override;
	virtual void OnFocusLostByFocusManager_Implementation(AFocusManager* FocusManager) override;
};

The class that implements the interface (.cpp, these are the methods that are’t called):

void UActionMenuItem::OnFocusReceivedByFocusManager_Implementation(AFocusManager* FocusManager)
{
	SetOpacity(1.f);
}

void UActionMenuItem::OnFocusLostByFocusManager_Implementation(AFocusManager* FocusManager)
{
	SetOpacity(0.5f);
}

And this is how I called: (FocusedObject appears to be correct, I checked it):

if (FocusedObject->GetClass()->ImplementsInterface(UButtonControlledUI::StaticClass()))
				IButtonControlledUI::Execute_OnFocusReceivedByFocusManager(FocusedObject, this);
2 Likes
2

I am not 100% sure on this, since I never tried it, but I think that you cannot use UObject->FindFunction(FName Name) on compile time.

However, you can just Cast<>() the object to your interface:

IYourInterface* TheInterface = Cast<>(YourObjectThatImplementsTheInterface);

Put IYourInterface inside these <> brackets, for some reason answerhub markup doesn’t allow text inside these brackets

A more detailed example can be found in Ramas Wiki Tutorial

3

DennyR, thanks for the reply. I didn’t use “UObject->FindFunction”, it is part of the generated code. I just put the screenshot to show what the engine is doing.

I think the Rama’s solution doesn’t work with blueprints. :frowning:

I was trying to do a solution that works with both blueprints and C++. In fact, blueprints are working, just the C++ implemenation is not being called at all.

4

Ramas solution does work with blueprint, you just have to make it Blueprintable, like you already have in your example.

UINTERFACE(Blueprintable)
5

But I tried Cast and it returned returns null if I pass the blueprint object. And Ramas solution uses virtual methods, not allowed if I declare a BlueprintImplamentableEvent or BlueprintNativeEvent.

6

Hm, I never had any issues with interfaces in c++. So not sure why your cast returns NULL. I never tried to use a C++ interface in a blueprint class though, so I can’t tell what the issue is.
The BlueprintImplamentableEvent or BlueprintNativeEvent not being allowed to be virtual might be an issue though. It might actually be a design flaw.

7

Well, after some recompiles, editor restarts and more recompiles, I think it is magically working now…

Just to be clear:

  • To declare and implement the interface in C++, follow the documentation: Interfaces in Unreal Engine | Unreal Engine 5.2 Documentation

  • To call the interface in C++, use the following example:

    if (MyObject->GetClass()->ImplementsInterface(UMyInterface::StaticClass()))
    IMyInterface::Execute_MyFunction(MyObject, MyArg);

  • It works with both C++ or blueprints implementations.

  • The Rama’s tutorial may work well with C++, but it doesn’t support blueprints. :wink:

3 Likes
8

The blueprint object doesn’t work the same way C++ object does. This is why the cast doesn’t work. When you configure the blueprint to implement some interface, it doesn’t inherits the interface class.

Anyway, I think it’s working now… I tried to recompile and restart the editor many times before, but I was doing something wrong, I think… because I done it againg and now it’s working…

1 Like
9

Thanks, totally worked for me!

10

Worked for me as well, thank you!

11

The code exactly as written in the “documentation” does not compile. The virtual decorator throws:

error : BlueprintImplementableEvents in Interfaces must not be declared 'virtual'

Gotta love when the example itself does not compile.

1 Like
12

Pure virtual function can’t Implementable at blueprint , how to do resolve it? thanks!!!

13

if that is a question
you can’t there are no pure virtual functions that are implementable in blueprints

you have two options depending on what you want to do:

  1. you want to override the function in C++ and Blueprint
    use BlueprintNativeEvent and give it an empty function body
    UFUNCTION(BlueprintNativeEvent)
    void Something();
    in cpp:
    void Something_Implementation() {}

  2. it’s only used and overridden in blueprints use BlueprintImplementableEvent, which doesn’t force you to do anything else in C++
    UFUNCTION(BlueprintImplementableEvent)
    void Something();

1 Like