> For the complete documentation index, see [llms.txt](https://dante-3.gitbook.io/dante-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://dante-3.gitbook.io/dante-docs/modular-input-system.md).

# Modular Input System

Quick Start

Every asset type is in the Content Browser: right-click a folder and open **Modular Input System**. Entries are grouped into **Components**, **Data Assets** and **Gates & Processors**.

***

## 1. See It Running

The plugin ships with a working setup under `/ModularInputSystem/Input` (enable **Show Plugin Content** in the Content Browser settings to see it).

{% stepper %}
{% step %}

### Add a Modular Input Component

Open your Character Blueprint and add a **Modular Input Component**.
{% endstep %}

{% step %}

### Set Input Configs

Set **Input Configs** to `DA_MIPS_SampleConfig`.
{% endstep %}

{% step %}

### Set Default Mode

Set **Default Mode** to `DA_MIPS_SampleMode`.
{% endstep %}

{% step %}

### Play the sample

Press Play. **WASD** moves, the **mouse** looks, **Space** jumps, **Left Ctrl** crouches and **Left Shift** sprints.
{% endstep %}
{% endstepper %}

{% hint style="warning" %}
If your character already binds the same keys itself (the Third Person template does, in its Event Graph), remove those bindings first. Otherwise both the template and the plugin move the pawn and movement feels doubled.
{% endhint %}

{% hint style="info" %}
Crouching needs **Can Crouch** enabled under the character movement component's **Nav Movement** settings.
{% endhint %}

***

## 2. Route Your Own Input

{% stepper %}
{% step %}

### Create input tags

Open **Project Settings > Gameplay Tags** and add a tag for each input, for example `Input.Attack` and `Input.Dodge`. A shared parent such as `Input` lets gates and processors match whole groups at once.
{% endstep %}

{% step %}

### Create an Input Config

**Modular Input System > Data Assets > Input Config**, named for example `DA_InputConfig_Hero`.

* Under **Mapping Contexts**, add your Input Mapping Context. It is added to the local player when the component binds and removed when it unbinds.
* Under **Input Actions**, add one row per action: an **Input Tag**, an **Input Action** and the **Trigger Events** to route. The default is *Started, Triggered, Completed*.

Each row shows a one-line summary and a warning icon if something is missing or the action is not mapped by any of the config's mapping contexts.
{% endstep %}

{% step %}

### Create a processor

**Modular Input System > Gates & Processors > Input Processor**, named for example `B_Processor_Attack`. Open it and override **Handle**.

{% tabs %}
{% tab title="Blueprint" %}

```
Event Handle (Context)
  ├─ Get Context Pawn (Context) ──► Cast To BP_Hero ──► Start Attack
  └─ Return Node: Handled
```

<figure><img src="https://4216330531-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FYsGXprPiDJ68FN8HnOaN%2Fuploads%2FbLPxO2OyTC9y6KZx4pjH%2FEkran%20g%C3%B6r%C3%BCnt%C3%BCs%C3%BC%202026-10-01%20151223.png?alt=media&amp;token=0b62c664-487e-40cc-8155-f8caf7aea395" alt=""><figcaption></figcaption></figure>

**Get Input Action Value** returns the value the event carried. Plug it straight into a bool, float or vector pin; Enhanced Input converts it for you.
{% endtab %}

{% tab title="C++" %}
{% code title="MyProcessor\_Attack.h" %}

```cpp
#pragma once

#include "Processors/MIPS_InputProcessor.h"
#include "MyProcessor_Attack.generated.h"

UCLASS(meta=(DisplayName="Attack"))
class UMyProcessor_Attack : public UMIPS_InputProcessor
{
    GENERATED_BODY()

public:
    virtual EMIPS_HandleResult Handle_Implementation(const FMIPS_InputContext& Context) const override
    {
        if (AMyHero* Hero = Cast<AMyHero>(Context.GetPawn()))
        {
            Hero->StartAttack();
            return MakeHandledResult();   // Handled, or HandledAndConsumed if bConsumeInput is set
        }
        return EMIPS_HandleResult::NotHandled;
    }
};
```

{% endcode %}
{% endtab %}
{% endtabs %}

{% hint style="warning" %}
One processor object inside a mode asset serves every player that uses the mode. Keep processors stateless: store per-player state on the pawn, the component or a receiver.
{% endhint %}
{% endstep %}

{% step %}

### Create an Input Mode

**Modular Input System > Data Assets > Input Mode**, named for example `DA_InputMode_OnFoot`.

* In **Processors**, add an entry and pick your processor class.
* On that entry, set **Input Tags** to `Input.Attack` and **Trigger Events** to *Started*, so it only sees attack presses.

You can mix your own processors with the ready-made ones, for example **Move** and **Look** filtered to their own tags.
{% endstep %}

{% step %}

### Add the component

Add a **Modular Input Component** to your pawn (or to your player controller, see [Input on the Player Controller](/dante-docs/modular-input-system/core-concepts/controller-owned-input.md)).

* **Input Configs:** `DA_InputConfig_Hero`
* **Default Mode:** `DA_InputMode_OnFoot`

To reuse the same defaults on several pawns, create **Modular Input System > Components > Modular Input Component** instead. It makes a Blueprint subclass of the component with your defaults filled in.
{% endstep %}

{% step %}

### Play and watch

Press Play, then open **Window > Developer Tools > Modular Input Monitor**. Every press appears on the timeline: green when allowed, amber when held in the buffer, red when blocked. Hover a marker to see the reason, the gate that stopped it and the processor that handled it.
{% endstep %}
{% endstepper %}

***

## What to Try Next

* Add a **Tag Query** gate to the mode so attacks are blocked while the pawn has `State.Stunned`. See [Gates](/dante-docs/modular-input-system/core-concepts/gates.md).
* Push a menu mode on top of the on-foot mode with **Push Input Mode**, and pop it with **Pop Input Mode**. See [Input Modes & the Mode Stack](/dante-docs/modular-input-system/core-concepts/input-modes.md).
* Let an attack queue the next one with a buffer window. See [Buffered Combos with Anim Notifies](/dante-docs/modular-input-system/core-concepts/buffered-combos.md).
* Skip processors entirely and handle input in your pawn with the **Call Input Receiver** processor. See [Handling Input in Actors](/dante-docs/modular-input-system/core-concepts/input-receivers.md).

***

## Next Steps