Overview
Generic Input System is an input-management plugin for Unreal Enhanced Input projects. Through a Pawn-owned component and data-driven configuration, it centralizes which inputs are available in the current state, which should be blocked, and which should be buffered until the right moment. It fits action, combat, interaction, ability, UI, and StateTree-driven projects that need input rules to stay clear and reusable as the game grows.
Documentation and Support
Documentation Path
Start here
- Quick Start and Integration: configure Enhanced Input assets and add the component to a Pawn.
Core topics
- Feature List
- Input System Component
- Input Control Setup
- Input Buffering System
Debugging and questions
- Debugging Guide
- Best Practices and FAQ
Version history
- Release Notes
Why Generic Input System?
Input handling often starts simple: an input action fires, then the action decides whether it can run. Once combat, interaction, abilities, and UI begin to overlap, input becomes shaped by character state, animation timing, current mode, and priority. Can the player jump during an attack? Should a roll input be accepted during recovery? Does a combo window remember an early button press? Should interaction confirmation take priority over combat input? Without a shared flow, those rules tend to spread across character, ability, animation, and UI code.
- How do existing input actions become a shared gameplay vocabulary for combat, interaction, abilities, and UI?
- How do character states enable or disable whole groups of inputs as they enter and leave?
- How do combo, roll, ability pre-input, or interaction windows buffer input and release it by policy?
- How do Blueprint, C++, StateTree, and debugging tools observe the same input path?
GIPS separates input receiving, permission checks, response handling, and buffering into stable steps, so projects can manage input flow through data and extensible objects.
Key Features
Give input actions stable gameplay meaning
Input Config maps existing UInputAction assets to Gameplay Tags, and the component dispatches Enhanced Input trigger phases by tag. You keep your own Input Actions and Mapping Contexts while giving combat, ability, interaction, and UI systems a shared input vocabulary.
Let input permissions follow state changes
Input Control Setups combine always-allowed entries, checkers, processors, buffer policy, and processor order. Push a setup when a state begins and pop it when the state ends, so current input permissions live in reusable data and objects rather than scattered callback branches.
Buffer and release input at the right time
Named buffer windows can be opened and closed from Blueprint or C++. LastInput releases the latest matching input on close, while Instant releases a match as soon as it arrives. The current HighestPriority implementation can be overwritten by later input, so do not rely on its priority result yet. Window-state and fired-input events support combo timing, roll buffering, ability pre-input, and interaction confirmation.
Extend response behavior through Blueprint, C++, and StateTree
Projects can derive UGIPS_InputChecker and UGIPS_InputProcessor to validate and respond by tags, trigger events, or Actor Gameplay Tags. StateTree tasks can scope control setups, manage buffer windows, wait for window changes, or test the latest buffered input as part of state lifecycle.
Diagnose the input path at runtime
Async Blueprint listeners observe normal or buffered input. Gameplay Debugger integration and LogGIPS help inspect passed, blocked, buffered, and active-window state during play, reducing the cost of tracking why an input did or did not fire.
Best Fit For
- Action, combat, adventure, fighting, character-driven, or state-heavy games
- Enhanced Input and Gameplay Tag projects that need reusable input permissions
- Combo, recovery, interaction, ability, or UI flows that need input gating or buffering
- StateTree projects where input control should enter and leave with state lifecycle
- Blueprint and C++ teams extending validation and response behavior
Attach the core component to a Pawn; local-player Enhanced Input is bound on that Pawn. PlayerController and AIController ownership are unsupported. GIPS manages local input permission and buffering; it is not a raw hardware-input replication protocol. Multiplayer games must synchronize and validate the project-level actions produced by input.
✨ Reduce Copy-Pasting
Before: Repeatedly copy-pasting similar input code
After: GIPS unifies input logic, eliminating redundant code
A win for OCD developers!
✨ Simplify Logic Determination
For combat systems, GIPS removes the need for extensive If/Else statements to handle complex logic (e.g., whether a normal attack allows jumping or switching between ground/air attacks).
You can Shifts complexity to the input layer, reducing downstream system complexity.
🛠️Example
Configure input logic with GIPS:
The more complex the task, the greater GIPS’s benefits!
Technical Details
Code Modules:
GenericInputSystem(Runtime)
Plugin Dependencies:
EnhancedInputStateTree
Number of Blueprints: Provided with the companion project
Number of C++ Classes: 8+
Network Replicated: No
Supported Development Platforms: Win64, Mac, Android, Linux
Supported Target Build Platforms: Win64, Mac, Android, Linux
Companion Project: Provided after purchase through purchase verification
Important/Additional Notes: See my overall product design