> 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/core-concepts/processors.md). # Processors | Class | Header | Parent | Create from | | ---------------------- | ---------------------------------- | ----------------- | --------------------------------------------------------------- | | `UMIPS_InputProcessor` | `Processors/MIPS_InputProcessor.h` | `UMIPS_InputStep` | **Modular Input System > Gates & Processors > Input Processor** | ## Overview A processor acts on input events a mode has allowed. The mode offers each allowed event to its processors in order. A processor sees the event when: 1. its **Input Tags** and **Trigger Events** filter matches, and 2. **Should Handle** returns true (default: always). **Handle** then does the work and returns **Not Handled**, **Handled** or **Handled And Consumed**. What happens next depends on the mode's dispatch policy. ### Common Properties | Property | Default | Description | | ------------------ | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Input Tags** | empty | Inputs the processor reacts to. Empty means every input; a parent tag covers its children. | | **Trigger Events** | all *(unless the processor sets its own default)* | Trigger events the processor reacts to. | | **Consume Input** | Off | Stops later processors from seeing events this processor handles, under the *Until Consumed* policy. **Make Handled Result** returns *Handled And Consumed* when this is on. | {% hint style="warning" %} Processors are shared by every player using the mode. They keep no per-player state: the built-in ones read state from the character itself (crouched, walk speed) so several players can use one instance. {% endhint %} ## Gameplay Processors ### Move `UMIPS_InputProcessor_Move`: feeds the pawn's movement input, the way a character's move action normally does. Works with any pawn that has a movement component. **Default trigger events:** Triggered. | Property | Default | Description | | --------------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Space** | Control Rotation Yaw | Which rotation forward and right are measured against: **Control Rotation Yaw** (camera without pitch, for walking characters), **Control Rotation** (pitch included: flying, swimming, space), **Pawn Yaw** (tank controls) or **World** (fixed cameras, top-down). | | **Scale** | 1.0 | Scales the movement input, e.g. 0.5 for a walk-only mode. | | **Minimum Magnitude** | 0.0 | Stick input at or below this is ignored, so a resting stick does not creep. | The action value's **X** moves right and **Y** moves forward, matching Enhanced Input's 2D axis convention. In C++, `MIPS::ComputeMoveDirection(Space, ControlRotation, PawnRotation, AxisValue)` returns the same world direction. ### Look `UMIPS_InputProcessor_Look`: turns the camera. X turns, Y looks up and down. **Default trigger events:** Triggered. | Property | Default | Description | | -------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Turn** / **Look Up** | On / On | Which axes are applied. | | **Turn Rate** / **Look Up Rate** | 1.0 / 1.0 | Multipliers for each axis. | | **Invert Look Up** | Off | Pushing the stick or mouse up looks down instead. | | **Scale By Delta Time** | Off | Multiplies by the frame time. Leave it off for mouse input, which is already frame-independent; turn it on for gamepad sticks, where the rates are degrees per second. | | **Minimum Magnitude** | 0.0 | Input at or below this is ignored. | For player-controlled invert and sensitivity, use the [look settings modifiers](/dante-docs/modular-input-system/core-concepts/settings-and-rebinding.md) on the mapping instead of changing these values. ### Jump `UMIPS_InputProcessor_Jump`: jumps on press and, by default, stops holding the jump on release, which gives a character its variable jump height. Needs an `ACharacter`. **Default trigger events:** Started, Completed, Canceled. | Property | Default | Description | | ------------------------ | ------- | ---------------------------------------------------------------- | | **Stop Jump On Release** | On | Release ends the jump hold. Turn it off for a fixed jump height. | ### Crouch `UMIPS_InputProcessor_Crouch`: crouches and stands the character up. Needs an `ACharacter` with **Can Crouch** on its movement component. **Default trigger events:** Started, Completed, Canceled. | Property | Default | Description | | -------- | ------- | -------------------------------------------------------------------------------------------------------------------------------- | | **Mode** | Hold | **Hold** crouches while the input is held; **Toggle** flips on each press. The character's own crouch state is the toggle state. | ### Sprint `UMIPS_InputProcessor_Sprint`: switches the character's walk speed while sprinting. Needs an `ACharacter` with a Character Movement Component. **Default trigger events:** Triggered, Completed, Canceled. | Property | Default | Description | | ---------------- | ------- | ------------------------------------------------------------------------------------- | | **Mode** | Hold | **Hold** sprints while the input is held; **Toggle** flips on each *Triggered* event. | | **Sprint Speed** | 600 | Max Walk Speed while sprinting. | | **Normal Speed** | 0 | Speed to go back to. Zero uses the speed the character class was set up with. | The speed itself is the state: the character is sprinting when its Max Walk Speed equals Sprint Speed. Games that track stamina, or that want a gameplay tag instead, are better served by a **Broadcast Tag Event** or **Call Input Receiver** processor. {% hint style="info" %} An action with no triggers raises *Triggered* every frame while held. For **Toggle**, give the Sprint action a **Pressed** trigger so each press raises Triggered once. {% endhint %} ### Call Input Receiver `UMIPS_InputProcessor_CallInputReceiver`: hands the event to the first object in the owner chain that implements `IMIPS_InputReceiver`: the owner, the pawn, the controller, the player state, or any component on them, in that order, until one reports the event as handled. **Default trigger events:** all. | Property | Description | | ------------- | ------------------------------------------------------------- | | **Event Tag** | Tag handed to the receiver. Empty sends the input tag itself. | Use it to act on input in a pawn or component Blueprint without writing a processor per action. ## Utility Processors ### Broadcast Tag Event `UMIPS_InputProcessor_BroadcastTagEvent`: fires the component's **On Tag Event** with a gameplay tag. Lets gameplay code listen for meaning (`Event.Jump`) instead of raw input, and lets each mode decide which input produces which event. **Default trigger events:** all. | Property | Description | | ------------- | -------------------------------------------------------- | | **Event Tag** | Tag to broadcast. Empty broadcasts the input tag itself. | ### Push Mode `UMIPS_InputProcessor_PushMode`: pushes a mode onto the component's stack. **Default trigger events:** Started. **Consume Input:** on. | Property | Default | Description | | -------------------- | ------- | --------------------------------------------------------------------------------------------------------- | | **Mode** | | The mode to push. Required. | | **Priority** | 0 | Priority of the pushed entry. | | **Skip If On Stack** | On | Does nothing (Not Handled) when the mode is already on the stack, so repeated presses do not stack it up. | ### Pop Mode `UMIPS_InputProcessor_PopMode`: removes the most recently pushed entry of a mode. **Default trigger events:** Started. **Consume Input:** on. | Property | Description | | -------- | ----------------------------------------------------------------------------------- | | **Mode** | The mode to pop. Empty pops the mode this processor belongs to ("leave this menu"). | Returns Not Handled when the mode was not on the stack. ### Open Buffer Window `UMIPS_InputProcessor_OpenBufferWindow`: opens a buffer window defined in one of the component's configs. Handy for input-driven windows; animation-driven windows are usually opened from the **Input Buffer Window** anim notify state instead. **Default trigger events:** Started. | Property | Default | Description | | -------------- | ------- | ---------------------------------------------------------------------------------------- | | **Window Tag** | | The window to open. Required. | | **Duration** | 0.3 s | Seconds until the window closes by itself. Zero keeps it open until something closes it. | ### Debug String `UMIPS_InputProcessor_DebugString`: prints the event on screen while you set a mode up. Does nothing in Shipping builds. **Default trigger events:** all. | Property | Default | Description | | ------------ | ------------------------- | -------------------------------------------------------------------------------- | | **Text** | `{tag} {trigger} {value}` | The message. Placeholders: `{tag}`, `{trigger}`, `{value}`, `{owner}`, `{mode}`. | | **Duration** | 2.0 s | How long the message stays. | | **Color** | Green | Text colour. | ## Writing Your Own Override **Handle** (and optionally **Should Handle**) in a Blueprint or C++ subclass. See [Writing Gates & Processors](/dante-docs/modular-input-system/core-concepts/custom-gates-and-processors.md). ## Next Steps