Enhanced Input System: when are input actions set to be executed

[alison5689]

@WSwinks

For context, I am trying to recreate the pistol from the VR template in C++. I have been able to do this; however, certain aspects of the enhanced input system are not entirely clear to me.

From the constructor of the Pistol class, I call the function SetupPistolInputActions(). Inside this function, I bind the IA_Shoot_Left and IA_Shoot_Right input actions to the functions that I want to be executed when these events are triggered. I noticed that for the IA_Shoot_Left, I didn’t have to load the input action, which was defined in Blueprint, because it was already loaded, while for the IA_Shoot_Right, I had to explicitly load the Blueprint input action. How is this possible? For now, I load both input actions explicitly, just to be safe.

When I run the application, I used the showdebug enhancedinput command to see what was happening when I pressed the buttons related to the pistol. I noticed that when I pressed the buttons coupled with the IA_Shoot_Left and IA_Shoot_Right input actions, the inputs were triggered; however, the functions bound to these inputs were not executed. This only happens after I pick up the weapon and add the input mapping context. What exactly does adding the input mapping context do? Does this enable the propagation of the input action to the function it is bound to?

Finally, is it possible to bind two input actions to one function and use a parameter to distinguish which input action called the function, or is this considered not done?

It sounds like you’re working with Unreal Engine’s Enhanced Input System in C++. Let’s break down the questions you’ve raised.

1. Why didn’t you need to load the input action for IA_Shoot_Left, but did for IA_Shoot_Right?

This discrepancy could be due to the way input actions are being initialized or referenced in your Blueprint. If the IA_Shoot_Left input action is already being loaded or referenced somewhere in your Blueprint (perhaps in the Player Controller, Pawn, or a different component that initializes it), it may be automatically available when you create the bindings in C++. On the other hand, if IA_Shoot_Right isn’t referenced or loaded in a similar way, you’d need to explicitly load it in C++.

To be safe, loading both input actions explicitly in your C++ code, as you’re doing now, is a good practice. This ensures that both input actions are correctly loaded and available when you need them.

2. What does adding the input mapping context do?

Adding an Input Mapping Context is crucial in the Enhanced Input System. The input system uses contexts to manage and prioritize input bindings. When you add an input mapping context to a player or a component, you’re effectively enabling the system to recognize and process the input actions defined within that context.

Until you add the input mapping context, the input actions bound in your code might not be recognized by the input system, which is why your bound functions are not executed. Adding the context tells the input system to “listen” for those specific input actions and allows the propagation of the input to the functions you’ve bound.

In short, adding the input mapping context enables the input system to recognize and process the input actions, which then triggers the bound functions.

3. Is it possible to bind two input actions to one function and use a parameter to distinguish between them?

Yes, it is possible to bind multiple input actions to a single function. You can distinguish between the input actions by passing a parameter to the function. One approach is to create a wrapper function that takes an identifier (like an enum or a specific value) as a parameter, indicating which input action triggered the call.

Here’s a simple example:

cpp

Copy code

void APistol::HandleShootInput(FString InputActionName)
{
    if (InputActionName == "IA_Shoot_Left")
    {
        // Handle left shoot
    }
    else if (InputActionName == "IA_Shoot_Right")
    {
        // Handle right shoot
    }
}

You can bind the input actions like this:

cpp

Copy code

PlayerInputComponent->BindAction(IA_Shoot_Left, ETriggerEvent::Triggered, this, &APistol::HandleShootInput).WithLambda([this]() { HandleShootInput("IA_Shoot_Left"); });
PlayerInputComponent->BindAction(IA_Shoot_Right, ETriggerEvent::Triggered, this, &APistol::HandleShootInput).WithLambda([this]() { HandleShootInput("IA_Shoot_Right"); });

This way, the function HandleShootInput knows which input action triggered the call based on the parameter passed to it Vantage ADP.

This approach is valid and often used when you want to consolidate similar functionality but distinguish between different input sources. While it might add some complexity, it can reduce code duplication and help centralize input handling logic.