Namespace Scylla.Input

Classes

AutoResolveChange

Describes a single binding change made by AutoResolveConflicts().

AutoResolveResult

Contains the result of an AutoResolveConflicts() operation, including the list of changes made and the count of resolved vs remaining conflicts.

BindingConflict

Describes a single binding conflict detected when a player attempts to assign an input control path that is already occupied by another action.

BindingStorageSettings

Settings that control how player input bindings are persisted across sessions. These settings are consumed by the Input module during initialization to configure the active IBindingStorage backend.

BridgeSettings

Settings that govern how the Input module's bridge layer dispatches input queries when multiple IScyllaInputBridge implementations are registered. Applied to the IInputBridgeManager during module initialization.

ConfigActionEntry

Represents one action entry in the InputRebindManager data model, containing the action's metadata and one ConfigBindingEntry per configured scheme group.

ConfigActionGroup

A named set of actions that appear together under one heading in an input configuration screen, and that share a conflict scope.

ConfigBindingEntry

Represents a single binding cell in the InputRebindManager data model, corresponding to one action in one scheme group.

ConfigConflict

Represents a detected binding conflict between two actions that share the same input path within the same scheme group.

ConfigGroupExclusion

A declaration that a set of ConfigActionGroup instances are never active at the same time, so bindings shared between them are not conflicts.

ConfigLayout

The complete description of an input configuration screen: its columns, the groups its rows are gathered into, and which of those groups can never be active together.

ConfigLayout.Builder

Fluent builder for a ConfigLayout. Obtained from Create().

ConfigLayoutColumnDefinition

A serialized column of an input configuration screen.

ConfigLayoutConflictScope

Scopes conflicts by the action groups the game declared in its ConfigLayout.

ConfigLayoutDefinition

The serializable form of a ConfigLayout: an input configuration screen's columns, groups and exclusion sets, authored as data rather than as code.

ConfigLayoutExclusionDefinition

A serialized declaration that a set of groups are never active at the same time.

ConfigLayoutGroupDefinition

A serialized group of actions that share a heading and a conflict scope.

ConfigLayoutMemberReference

A reference to a map or action that belongs to a group, keyed by GUID with the name cached alongside.

ConfigSchemeGroup

Defines a control scheme group for the InputRebindManager. Each group corresponds to a column in a typical input configuration screen (e.g., "WASD", "IJKL", "Gamepad").

ContextConflictScope

Scopes conflicts by the input contexts the game registered, treating each action map as its own scope.

ControlScheme

Represents a named grouping of compatible input devices together with display metadata used for button-prompt rendering and input interpretation context.

ControlSchemeChangedEvent

Published via the Scylla Event eXchange System (SEX) when the active control scheme changes, for example when the player switches from keyboard and mouse to a gamepad.

ControlSchemeManager

Concrete implementation of IControlSchemeManager that manages a registry of ControlScheme instances and automatically switches between them based on detected input device activity.

IdentityControlAliasResolver

A resolver that rewrites nothing, for callers that want alias handling switched off.

InputActionCanceledEvent

Published via the Scylla Event eXchange System (SEX) when a registered input action enters its canceled phase, corresponding to the button-release moment or when an interaction that was in progress is aborted.

InputActionManager

Concrete implementation of IInputActionManager that manages the full lifecycle of Scylla input actions and action maps.

InputActionMapNode

An action map, viewed through the underlying InputJSONNode.

InputActionMetadata

Scylla-side data about one action, keyed by the action's action asset GUID.

InputActionNode

A single action inside an action map, viewed through the underlying InputJSONNode.

InputActionPerformedEvent

Published via the Scylla Event eXchange System (SEX) when a registered input action reaches its performed phase, indicating that all interaction conditions (e.g., press threshold, hold duration) have been met.

InputActionStartedEvent

Published via the Scylla Event eXchange System (SEX) when a registered input action enters its started phase, corresponding to the initial button-down moment before any interaction conditions are fully met.

InputActionsDocument

A Unity input action asset held as an editable document that can be written back exactly as it was read.

InputActionsDocumentIO

Reads and writes InputActionsDocument files on disk with the encoding and durability an asset owned by another tool requires.

InputActionsJSONKeys

The member names used by Unity's input action asset format, and the order in which Unity emits them.

InputAnnotation

The authoring notes attached to any element of an input action asset.

InputAssetInfo

What an action asset is, said in the author's own words: a name, a description, and a version.

InputBindingGroups

Reads and rewrites the semicolon-separated binding-group string on a binding.

InputBindingManager

Default implementation of IInputBindingManager that manages runtime input binding overrides, interactive rebinding operations, conflict detection, and per-profile persistence for the Scylla Input module.

InputBindingMetadata

Scylla-side data about one binding, keyed by the binding's action asset GUID.

InputBindingNode

A single binding inside an action map, viewed through the underlying InputJSONNode.

InputBindingsLoadedEvent

Published via the Scylla Event eXchange System (SEX) when binding overrides are successfully loaded from storage and applied to the registered actions for a given profile. Loading automatically triggers a full hint cache invalidation.

InputBindingsSavedEvent

Published via the Scylla Event eXchange System (SEX) when the current binding overrides are successfully serialized and persisted to storage for a given profile.

InputBridgeManager

Concrete implementation of IInputBridgeManager that coordinates input queries across one or more registered IScyllaInputBridge instances.

InputBufferConsumedEvent

Published via the Scylla Event eXchange System (SEX) when a buffered input entry is retrieved and consumed by a game system, removing it from the buffer.

InputBufferManager

Concrete implementation of IInputBufferManager that stores buffered input events in a fixed-capacity ring buffer and expires them based on configurable per-action or global time windows.

InputBufferedEvent

Published via the Scylla Event eXchange System (SEX) when an input action's value is recorded into the input buffer for deferred consumption by game systems.

InputCodegenSettings

Where and how the constants file for an action asset is generated.

InputCompositeUtil

Locates composites within a map's raw binding array.

InputConflictEngine

Decides whether two bindings collide, using rules that need no live input module.

InputConflictRecordBuilder

Turns live input actions into the flat snapshot InputConflictEngine reads.

InputConflictSet

A snapshot of every non-composite binding in a project, in the order the conflict rules must see them.

InputContext

Represents a named mode of the game (e.g., Gameplay, Menu, Dialog) that controls which Unity Input System action maps are active and whether this mode prevents lower-priority modes from receiving input.

InputContextChangedEvent

Published via the Scylla Event eXchange System (SEX) whenever the top of the input context stack changes, either because a context was pushed or popped, making a different context the active one.

InputContextDefinition

A serializable data object that describes the settings for an InputContext, authored in the Unity Inspector via ScyllaInputContextConfiguration. At runtime, call CreateContext() to convert this definition into a live InputContext that can be registered and pushed onto the context stack.

InputContextExclusivity

Decides whether two contexts, or two action maps, can ever be live at the same time. This is the single rule both conflict detection systems consult when deciding whether a shared control is a real collision or two modes reusing one key.

InputContextManager

Concrete implementation of IInputContextManager that maintains a registry of named InputContext objects and a LIFO stack of active contexts, applying action map changes and publishing Scylla events as contexts are pushed, popped, or removed.

InputContextPoppedEvent

Published via the Scylla Event eXchange System (SEX) when an input context is popped from the context stack, restoring the previously active context (if any) to the top position.

InputContextPushedEvent

Published via the Scylla Event eXchange System (SEX) when an input context is pushed onto the context stack, making it the new active context.

InputControlAliasResolver

Resolves alternative control spellings to one canonical path, using the Input System's layout database.

InputControlPathUtil

Reads the <Device> prefix out of a Unity Input System control path.

InputControlSchemeNode

A control scheme, viewed through the underlying InputJSONNode.

InputDeviceChangedEvent

Published via the Scylla Event eXchange System (SEX) when the most recently used input device changes, for example when a player switches from keyboard to a gamepad mid-session.

InputDeviceConnectedEvent

Published via the Scylla Event eXchange System (SEX) when a new input device is detected and connected to the system.

InputDeviceDisconnectedEvent

Published via the Scylla Event eXchange System (SEX) when a previously connected input device is removed or disconnected.

InputDeviceUtil

Provides centralized helpers for classifying Unity Input System devices and binding path strings into InputDeviceType categories, avoiding duplicated type-switch logic across the Input module's internal managers.

InputDisabledEvent

Published via the Scylla Event eXchange System (SEX) when global input processing is disabled. All registered input actions will stop generating callbacks until input is re-enabled and the corresponding InputEnabledEvent is published.

InputEnabledEvent

Published via the Scylla Event eXchange System (SEX) when global input processing is enabled after having been disabled. All registered input actions will resume generating callbacks once this event is dispatched.

InputHintChangedEvent

Published via the Scylla Event eXchange System (SEX) when the resolved InputHint for a specific action changes, typically because the binding for that action was rebound or the active icon set changed.

InputHintsManager

Default implementation of IInputHintsManager. Manages dynamic button prompt icons based on the current input bindings and the active control scheme. Provides UI-ready InputHint data with an internal per-action cache that is automatically invalidated when bindings or control schemes change.

InputIconSet

A ScriptableObject asset that maps Unity Input System binding paths to icon sprites and human-readable display strings for a specific platform or device family. Used by InputHintsManager to provide UI-ready button prompt visuals.

InputIconSet.IconMapping

Associates a Unity Input System binding path with an icon sprite and a human-readable display string for use in button-prompt UI.

InputIconSetChangedEvent

Published via the Scylla Event eXchange System (SEX) when the active icon set for a particular control scheme changes, typically in response to a ControlSchemeChangedEvent or an explicit call to SetActiveIconSet(string).

InputInteractionResolver

Answers what an interaction is, from either side: the little that conflict detection needs out of an authored string, and what a live interaction instance is when one fires.

InputJSONNode

A JSON value in a mutable tree that preserves everything needed to write the document back out exactly as it was read.

InputJSONNodeReader

Parses JSON text into a InputJSONNode tree, preserving member order and numeric source text so the document can later be written back unchanged.

InputJSONNodeWriter

Serializes a InputJSONNode tree back to JSON text, matching the formatting Unity's own serializer produces for input action assets.

InputLoggingSettings

Controls which categories of Input module events are written to the Scylla log. All flags default to true to aid debugging during development. Disable individual flags in production builds to reduce log noise.

InputMapMetadata

Scylla-side data about one action map, keyed by the map's action asset GUID.

InputMetadataRebindabilityProvider

Answers rebindability from one or more actions-asset metadata sidecars.

InputMetadataReconciler

Reattaches a ScyllaInputActionsMetadata asset to its action asset after the action asset has changed underneath it.

InputModifierMetadataUtil

Reads how many modifier keys a composite binding requires.

InputOrphanRecord

A metadata record whose element could not be found in the action asset, held aside rather than deleted.

InputRebindCancelledEvent

Published via the Scylla Event eXchange System (SEX) when an interactive rebind operation is cancelled without applying a new binding. The original binding path remains unchanged.

InputRebindCompletedEvent

Published via the Scylla Event eXchange System (SEX) when an interactive rebind operation finishes and a new input has been successfully assigned to the binding.

InputRebindManager

A UI-agnostic facade that provides all the logic needed to build an input configuration/remapping screen in a game. It sits between the raw Scylla Input module managers and any UI implementation, handling data model building, modifier-aware rebinding, conflict detection, batch operations, and persistence integration.

InputRebindOperation

Represents a single interactive rebinding session for one binding slot on a Unity Input System action, providing a fluent configuration API, conflict notification, and automatic action re-enabling upon completion or cancellation.

InputRebindStartedEvent

Published via the Scylla Event eXchange System (SEX) when an interactive rebind operation begins for a specific binding on a registered action. The game should display UI guidance prompting the player to press the desired new input while this operation is in progress.

InputRebindUtils

Stateless utility helpers used by the input rebinding system to classify bindings, format composite-part names, and build display strings for modifier composites. Extracted from InputRebindManager so the manager's public API is focused on rebind orchestration and conflict detection rather than display formatting.

InputReconcileOptions

Knobs controlling how InputMetadataReconciler behaves. The defaults are what an editor wants; the flags exist mainly so tests can isolate one phase at a time.

InputReconcileReport

What reconciliation did, in enough detail to show the user and to debug from.

InputSchemeDeviceNode

One device requirement of a control scheme, viewed through the underlying InputJSONNode.

InputSchemeMetadata

Scylla-side data about one control scheme, keyed by name.

JSONFileBindingStorage

An IBindingStorage implementation that persists input binding overrides as individual JSON files on the file system, one file per profile.

ManagedRebindCancelledEvent

Published by InputRebindManager when a managed rebind operation is cancelled (by the player pressing escape, timeout, or programmatic cancellation).

ManagedRebindCompletedEvent

Published by InputRebindManager when a managed rebind operation completes (successfully or not). This is a higher-level event than InputRebindCompletedEvent, carrying modifier information.

ManagedRebindDataRefreshedEvent

Published by InputRebindManager when its data model is rebuilt (e.g., after RefreshAll() or Initialize(ConfigLayout)).

ManagedRebindStartedEvent

Published by InputRebindManager when a managed rebind operation starts. This is a higher-level event than InputRebindStartedEvent, carrying additional context such as the scheme group.

PlayerPrefsBindingStorage

An IBindingStorage implementation that persists input binding overrides using Unity's PlayerPrefs registry.

RebindSettings

Default settings applied to every interactive rebinding operation initiated through the Input module. Individual operations may override these defaults programmatically.

ScyllaInput

The Scylla Input module. Provides centralized input handling for keyboard, mouse, gamepad, touchscreen, joystick, and pen devices using Unity's Input System as the underlying transport layer.

ScyllaInputAction

Wraps a Unity InputAction with Scylla-specific state tracking, callback routing, and modifier-key disambiguation support.

ScyllaInputActionMap

A named, enable/disable-capable container for a logically related set of ScyllaInputAction objects, corresponding to a single Unity InputActionMap.

ScyllaInputActionsMetadata

Everything Scylla knows about an input action asset that the action asset itself cannot hold: authoring notes, protected-action flags, and the configuration screen layout.

ScyllaInputActionsMetadataMigrator

Brings a ScyllaInputActionsMetadata asset forward to the schema version this build understands.

ScyllaInputBinding

A snapshot wrapper around a single Unity InputBinding, providing convenient access to binding metadata, override state, display strings, and device type classification.

ScyllaInputConfiguration

ScriptableObject configuration asset for the Scylla Input module. Create one instance via Assets → Create → Scylla → Input → Input Configuration and assign it to the ScyllaInput component in the Inspector.

ScyllaInputContextConfiguration

ScriptableObject configuration asset that holds a list of InputContextDefinition objects. Each definition is converted to an InputContext and registered with the IInputContextManager automatically when the Scylla Input module initializes. Create an instance via Assets → Create → Scylla → Input → Context Configuration.

ScyllaKeyConverter

Provides bidirectional conversion between ScyllaKey and Unity's UnityEngine.InputSystem.Key enum, insulating game code from a direct compile-time dependency on the Input System package.

UnityInputSystemBridge

The default IScyllaInputBridge implementation that wraps Unity's Input System package to provide keyboard, mouse, and gamepad input to the Scylla Input module.

Structs

BufferedInput

An immutable snapshot of a single buffered input event, capturing the action identifier, value, timestamp, and originating device at the moment the input occurred.

ConfigLayoutValidationMessage

One problem found by Validate(IReadOnlyList<string>, IReadOnlyList<string>, IReadOnlyList<string>).

ContextValidationMessage

An immutable diagnostic message produced by Validate(int). Contains the severity, a human-readable description, and the name of the field that triggered the message.

InputConflictPair

One detected conflict, as a pair of positions into an InputConflictSet.

InputConflictPolicy

Which of the conflict rules apply, and how paths are compared.

InputConflictRecord

One non-composite binding, reduced to exactly the values the conflict predicate reads.

InputControlAliasEntry

One entry of a resolver's index, exposed so a test can assert the whole table.

InputHint

An immutable, UI-ready snapshot of the button prompt data for a single input action under a specific control scheme. Bundles the display text, icon sprite, raw binding path, scheme type, and icon set origin into a single value.

InputInteractionSignature

What drives a binding, reduced to the little that conflict detection needs.

InputJSONMember

One key and value pair inside a InputJSONNode of type Object.

InputReconcileReport.Entry

One thing that happened during reconciliation.

ScyllaInput.Meta

Compile-time constant metadata for the ScyllaInput module. These values are consumed by Scylla.Core.Modules.ScyllaModuleInfo and referenced in log messages throughout the module.

Interfaces

IBindingStorage

Defines a backend for storing and retrieving serialized input binding overrides on a per-profile basis.

IControlSchemeManager

Defines the contract for a control scheme manager that tracks and switches between named input device groupings such as keyboard/mouse, gamepad, and touch.

IInputActionManager

Defines the contract for the Scylla input action management subsystem.

IInputBindingManager

Defines the contract for the input binding subsystem, which handles runtime rebinding, per-profile persistence, conflict detection, and JSON export/import of binding overrides.

IInputBridgeManager

Manages the collection of registered IScyllaInputBridge instances and routes all input queries to the appropriate bridge based on the configured query strategy.

IInputBufferManager

Manages a time-windowed ring buffer of BufferedInput entries that allows game systems to detect and consume player inputs that occurred slightly before the system was ready to process them.

IInputConflictScope

Answers whether two parts of a game can be live at the same time.

IInputContextManager

Defines the contract for a stack-based input context manager that controls which Unity Input System action maps are active at any given time and which contexts are permitted to process input based on a priority-and-blocking model.

IInputControlAliasResolver

Rewrites a control path to a canonical spelling, so two paths naming one physical control compare equal.

IInputHintsManager

Defines the contract for a service that provides UI-ready button prompt data based on the current input bindings and the active control scheme.

IInputListener

Defines a direct-callback interface for objects that need to observe low-level input lifecycle events such as device connections, disconnections, or global input enable/disable.

IInputRebindabilityProvider

Answers whether a player may rebind a given action, and whether it should be offered at all.

IScyllaInputBridge

Defines the contract for input bridges that translate raw hardware input into the normalized Scylla input abstraction layer.

Enums

BindingStorageType

Specifies the persistence backend that the input binding system uses to save and load player-customized key and button assignments.

ConfigLayoutGroupMode

How a ConfigLayoutGroupDefinition declares its membership.

ConfigLayoutValidationSeverity

Severity of a ConfigLayoutValidationMessage.

ContextValidationSeverity

Classifies the severity of a diagnostic message produced by Validate(int). Maps to Scylla.Core.Config.ValidationSeverity when converted for use with the Scylla configuration validation system via Validate().

ControlSchemeType

Identifies the high-level category of a ControlScheme, determining how input is interpreted and which button-prompt icons are displayed to the player.

GamepadButton

Platform-agnostic identifiers for the standard buttons found on a modern gamepad controller.

GamepadType

Identifies the manufacturer or platform family of a connected gamepad controller, enabling the input hints system to select the appropriate button-prompt icon set.

InputBridgeQueryMode

Controls how the IInputBridgeManager resolves input queries when more than one IScyllaInputBridge is registered.

InputConflictReason

Why a pair of bindings was, or was not, reported as a conflict.

InputConflictResolution

Specifies the strategy used to resolve conflicts when multiple IScyllaInputBridge instances provide simultaneous values for the same input query.

InputControlAliasScope

Which alternative spellings InputControlAliasResolver treats as equivalent.

InputDeviceType

Classifies a physical input device by its primary interaction modality.

InputEventType

Categorizes the input-system lifecycle and device-state notifications received by the IInputListener interface.

InputInteractionKind

Which of Unity's interaction state machines drives a binding.

InputJSONNodeType

The kind of value a InputJSONNode holds.

InputMetadataRecordKind

Which kind of element an orphaned metadata record described.

InputRebindability

Whether a player is allowed to rebind something.

InputReconcileAction

What happened to one metadata record during reconciliation.

RebindMode

Identifies which rebinding strategy an InputRebindOperation uses to capture player input. Selected via WithModifierSupport(bool) or WithDeltaPolling(bool); defaults to Native.

ScyllaKey

Keyboard key enumeration for the Scylla Input module. Provides a framework-owned abstraction over Unity's InputSystem.Key enum, allowing game code and other Scylla modules to reference keyboard keys without taking a direct compile-time dependency on the Unity Input System package.

ScyllaModifier

A [Flags] enumeration that represents the set of logical keyboard modifier keys - Shift, Ctrl, and Alt - held simultaneously during a keyboard shortcut.