PlayerControllerHelperMapHelper Class |
Namespace: Rewired
public sealed class MapHelper : CodeHelper
The PlayerControllerHelperMapHelper type exposes the following members.
Name | Description | |
---|---|---|
InputBehaviors |
Gets a list of all InputBehaviors in this Player.
| |
layoutManager |
Manages loading and unloading of Controller Maps in a Player based on user settings to force the specified Layouts to be used.
This must be enabled before use by setting enabled to true, otherwise Controller Map
enabled states in the Player will be unmanaged.
This can be used to make specific Controller Maps be loaded in a Player with specific Layouts, for example when changing from one Controller
Layout to another. These settings will persist and be inherited by new Controllers assigned to the Player.
This will enforce a single Layout per managed Map Category be loaded in the Player. This cannot manage mutliple simultaneous
Layouts in the same Map Category being loaded in the Player.
To manage the enabled states, use mapEnabler.
It is recommended that you use both mapEnabler and layoutManager together to manage
both loading and enabled states of Controller Maps.
When both are enabled, layoutManager will load/unload Controller Maps first, then mapEnabler will enable/disable
the Controller Maps based on the rules you've set up in each..
| |
mapEnabler |
Enforces persistent enabled states on Controller Maps in a Player based on user settings.
This must be enabled before use by setting enabled to true, otherwise Controller Map
enabled states in the Player will be unmanaged.
This can be used to make specific Controller Maps be enabled or disabled in a Player,
for example when changing game modes that require user input to change.
These settings will persist and be inherited by new Controllers assigned to the Player.
Enabled states will be sync'd when new Controllers are added, when Controller Maps are loaded, etc.
When using ControllerMapEnabler, you should not manually set enabled states
on Controller Maps that are managed by this class, but instead change all settings within this class.
|
Name | Description | |
---|---|---|
AddEmptyMap(ControllerType, Int32, Int32, Int32) |
Add an empty controller map to the Player with the specified category and layout.
| |
AddEmptyMap(ControllerType, Int32, String, String) |
Add an empty controller map to the Player with the specified category and layout.
| |
AddEmptyMapT(Int32, Int32, Int32) |
Add an empty controller map to the Player with the specified category and layout.
| |
AddEmptyMapT(Int32, String, String) |
Add an empty controller map to the Player with the specified category and layout.
| |
AddMap(Controller, ControllerMap) |
Adds a controller map to the Player. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement.
| |
AddMap(Controller, ControllerMap, Boolean) |
Adds a controller map to the Player. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement.
| |
AddMap(ControllerType, Int32, ControllerMap) |
Adds a controller map to the Player. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement.
| |
AddMap(ControllerType, Int32, ControllerMap, Boolean) |
Adds a controller map to the Player. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement.
| |
AddMapT(Int32, ControllerMap) |
Adds a controller map to the Player. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement.
| |
AddMapT(Int32, ControllerMap, Boolean) |
Adds a controller map to the Player. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement.
| |
AddMapFromJson(ControllerType, Int32, String) |
Adds a controller map to the Player from Json save data.
| |
AddMapFromJsonT(Int32, String) |
Adds a controller map to the Player from Json save data.
| |
AddMapFromXml(ControllerType, Int32, String) |
Adds a controller map to the Player from Xml save data.
| |
AddMapFromXmlT(Int32, String) |
Adds a controller map to the Player from Xml save data.
| |
AddMapsFromJson(ControllerType, Int32, ListString) |
Adds multiple controller maps to the Player from Json save data.
| |
AddMapsFromJsonT(Int32, ListString) |
Adds multiple controller maps to the Player from Json save data.
| |
AddMapsFromXml(ControllerType, Int32, ListString) |
Adds multiple controller maps to the Player from Xml save data.
| |
AddMapsFromXmlT(Int32, ListString) |
Adds multiple controller maps to the Player from Xml save data.
| |
AxisMapsWithAction(Int32, Boolean) |
Enumerates all axis ActionElementMaps for any controller type that contains a specific Action.
| |
AxisMapsWithAction(String, Boolean) |
Enumerates all axis ActionElementMaps for any controller type that contains a specific Action.
| |
AxisMapsWithAction(Controller, Int32, Boolean) |
Enumerates all axis ActionElementMaps for a specific controller that contains a specific Action.
| |
AxisMapsWithAction(Controller, String, Boolean) |
Enumerates all axis ActionElementMaps for a specific controller that contains a specific Action.
| |
AxisMapsWithAction(ControllerType, Int32, Boolean) |
Enumerates all axis ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
AxisMapsWithAction(ControllerType, String, Boolean) |
Enumerates all axis ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
AxisMapsWithAction(ControllerType, Int32, Int32, Boolean) |
Enumerates all axis ActionElementMaps for a specific controller that contains a specific Action.
| |
AxisMapsWithAction(ControllerType, Int32, String, Boolean) |
Enumerates all axis ActionElementMaps for a specific controller that contains a specific Action.
| |
ButtonMapsWithAction(Int32, Boolean) |
Enumerates all button ActionElementMaps for any controller type that contains a specific Action.
| |
ButtonMapsWithAction(String, Boolean) |
Enumerates all button ActionElementMaps for any controller type that contains a specific Action.
| |
ButtonMapsWithAction(Controller, Int32, Boolean) |
Enumerates all button ActionElementMaps for a specific controller that contains a specific Action.
| |
ButtonMapsWithAction(Controller, String, Boolean) |
Enumerates all button ActionElementMaps for a specific controller that contains a specific Action.
| |
ButtonMapsWithAction(ControllerType, Int32, Boolean) |
Enumerates all button ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
ButtonMapsWithAction(ControllerType, String, Boolean) |
Enumerates all button ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
ButtonMapsWithAction(ControllerType, Int32, Int32, Boolean) |
Enumerates all button ActionElementMaps for a specific controller that contains a specific Action.
| |
ButtonMapsWithAction(ControllerType, Int32, String, Boolean) |
Enumerates all button ActionElementMaps for a specific controller that contains a specific Action.
| |
ClearAllMaps |
Removes all controller maps.
| |
ClearMaps(ControllerType, Boolean) |
Removes all controller maps of a specific type.
| |
ClearMapsT(Boolean) |
Removes all controller maps of a specific type.
| |
ClearMapsForController(ControllerType, Int32, Boolean) |
Removes all controller maps for a specific controller.
| |
ClearMapsForController(ControllerType, Int32, Int32, Boolean) |
Removes all controller maps for a specific controller in a specific category.
| |
ClearMapsForController(ControllerType, Int32, String, Boolean) |
Removes all controller maps for a specific controller in a specific category.
| |
ClearMapsForControllerT(Int32, Boolean) |
Removes all controller maps for a specific controller.
| |
ClearMapsForControllerT(Int32, Int32, Boolean) |
Removes all controller maps for a specific controller in a specific category.
| |
ClearMapsForControllerT(Int32, String, Boolean) |
Removes all controller maps for a specific controller in a specific category.
| |
ClearMapsForControllerInLayout(ControllerType, Int32, Int32, Boolean) |
Removes all controller maps in a specific layout for a specific controllers.
| |
ClearMapsForControllerInLayout(ControllerType, Int32, String, Boolean) |
Removes all controller maps in a specific layout for a specific controllers.
| |
ClearMapsForControllerInLayoutT(Int32, Int32, Boolean) |
Removes all controller maps in a specific layout for a specific controllers.
| |
ClearMapsForControllerInLayoutT(Int32, String, Boolean) |
Removes all controller maps in a specific layout for a specific controllers.
| |
ClearMapsInCategory(Int32, Boolean) |
Removes all controller maps in a specific category for all controllers.
| |
ClearMapsInCategory(String, Boolean) |
Removes all controller maps in a specific category for all controllers.
| |
ClearMapsInCategory(ControllerType, Int32, Boolean) |
Removes all controller maps in a specific category for all controllers of a specific type.
| |
ClearMapsInCategory(ControllerType, String, Boolean) |
Removes all controller maps in a specific category for all controllers of a specific type.
| |
ClearMapsInCategory(ControllerType, Int32, Int32, Boolean) |
Removes all controller maps in a specific category and layout for all controllers of a specific type.
| |
ClearMapsInCategory(ControllerType, String, String, Boolean) |
Removes all controller maps in a specific category and layout for all controllers of a specific type.
| |
ClearMapsInCategoryT(Int32, Boolean) |
Removes all controller maps in a specific category for all controllers of a specific type.
| |
ClearMapsInCategoryT(String, Boolean) |
Removes all controller maps in a specific category for all controllers of a specific type.
| |
ClearMapsInCategoryT(Int32, Int32, Boolean) |
Removes all controller maps in a specific category and layout for all controllers of a specific type.
| |
ClearMapsInCategoryT(String, String, Boolean) |
Removes all controller maps in a specific category and layout for all controllers of a specific type.
| |
ClearMapsInLayout(ControllerType, Int32, Boolean) |
Removes all controller maps in a specific layout for all controllers of a specific type.
| |
ClearMapsInLayout(ControllerType, String, Boolean) |
Removes all controller maps in a specific layout for all controllers of a specific type.
| |
ClearMapsInLayoutT(Int32, Boolean) |
Removes all controller maps in a specific layout for all controllers of a specific type.
| |
ClearMapsInLayoutT(String, Boolean) |
Removes all controller maps in a specific layout for all controllers of a specific type.
| |
ContainsMapInCategory(Int32) |
Determines if any maps exist in a particular Map Category.
| |
ContainsMapInCategory(String) |
Determines if any maps exist in a particular Map Category.
| |
ContainsMapInCategory(InputMapCategory) |
Determines if any maps exist in a particular Map Category.
| |
ContainsMapInCategory(ControllerType, Int32) |
Determines if any maps exist in a particular Map Category for a specific controller type.
| |
ElementMapsWithAction(Int32, Boolean) |
Enumerates all ActionElementMaps for any controller type that contains a specific Action.
| |
ElementMapsWithAction(String, Boolean) |
Enumerates all ActionElementMaps for any controller type that contains a specific Action.
| |
ElementMapsWithAction(Controller, Int32, Boolean) |
Enumerates all ActionElementMaps for a specific controller that contains a specific Action.
| |
ElementMapsWithAction(Controller, String, Boolean) |
Enumerates all ActionElementMaps for a specific controller that contains a specific Action.
| |
ElementMapsWithAction(ControllerType, Int32, Boolean) |
Enumerates all ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
ElementMapsWithAction(ControllerType, String, Boolean) |
Enumerates all ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
ElementMapsWithAction(ControllerType, Int32, Int32, Boolean) |
Enumerates all ActionElementMaps for a specific controller that contains a specific Action.
| |
ElementMapsWithAction(ControllerType, Int32, String, Boolean) |
Enumerates all ActionElementMaps for a specific controller that contains a specific Action.
| |
ElementMapsWithElementTarget(ControllerElementTarget, Boolean) |
Enumarates all ActionElementMaps that map to a specific controller element target.
| |
ElementMapsWithElementTarget(IControllerElementTarget, Boolean) |
Enumarates all ActionElementMaps that map to a specific controller element target.
| |
ElementMapsWithElementTarget(ControllerElementTarget, Int32, Boolean) |
Enumarates all ActionElementMaps that map to a specific controller element target and a specific Action.
| |
ElementMapsWithElementTarget(ControllerElementTarget, String, Boolean) |
Enumarates all ActionElementMaps that map to a specific controller element target and a specific Action.
| |
ElementMapsWithElementTarget(IControllerElementTarget, Int32, Boolean) |
Enumarates all ActionElementMaps that map to a specific controller element target and a specific Action.
| |
ElementMapsWithElementTarget(IControllerElementTarget, String, Boolean) |
Enumarates all ActionElementMaps that map to a specific controller element target and a specific Action.
| |
GetAllMaps |
Enumerates all controller maps assigned to this Player.
| |
GetAllMaps(ListControllerMap) |
Gets all controller maps assigned to this Player.
| |
GetAllMaps(ControllerType) |
Enumerates all controller maps for a specific controller type assigned to this Player.
| |
GetAllMaps(ControllerType, ListControllerMap) |
Gets all controller maps for a specific controller type assigned to this Player.
| |
GetAllMapsT |
Enumerates all controller maps assigned to this Player.
| |
GetAllMapsT(ListT) |
Gets all controller maps assigned to this Player.
| |
GetAllMapSaveData(Boolean) |
Gets all controller map save data. Used for saving/loading.
| |
GetAllMapSaveData(ControllerType, Boolean) |
Gets all controller map save data for a specific controller type. Used for saving/loading.
| |
GetAllMapSaveDataT(Boolean) |
Gets all controller map save data. Used for saving/loading.
| |
GetAllMapsInCategory(Int32) |
Enumerates all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategory(String) |
Enumerates all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategory(Int32, ControllerType) |
Enumerates all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategory(Int32, ListControllerMap) |
Gets a list of all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategory(String, ControllerType) |
Enumerates all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategory(String, ListControllerMap) |
Gets a list of all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategory(Int32, ControllerType, ListControllerMap) |
Gets a list of all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategory(String, ControllerType, ListControllerMap) |
Gets a list of all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategoryT(Int32) |
Enumerates all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategoryT(String) |
Enumerates all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategoryT(Int32, ListT) |
Gets a list of all controller maps assigned to this player in a specific category.
| |
GetAllMapsInCategoryT(String, ListT) |
Gets a list of all controller maps assigned to this player in a specific category.
| |
GetAxisMapsWithAction(Int32, Boolean, ListActionElementMap) |
Gets a list of all axis ActionElementMaps for any controller type that contains a specific Action.
| |
GetAxisMapsWithAction(String, Boolean, ListActionElementMap) |
Gets a list of all axis ActionElementMaps for any controller type that contains a specific Action.
| |
GetAxisMapsWithAction(Controller, Int32, Boolean, ListActionElementMap) |
Gets a list of all axis ActionElementMaps for a specific controller that contains a specific Action.
| |
GetAxisMapsWithAction(Controller, String, Boolean, ListActionElementMap) |
Gets a list of all axis ActionElementMaps for a specific controller that contains a specific Action.
| |
GetAxisMapsWithAction(ControllerType, Int32, Boolean, ListActionElementMap) |
Gets a list of all axis ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetAxisMapsWithAction(ControllerType, String, Boolean, ListActionElementMap) |
Gets a list of all axis ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetAxisMapsWithAction(ControllerType, Int32, Int32, Boolean, ListActionElementMap) |
Gets a list of all axis ActionElementMaps for a specific controller that contains a specific Action.
| |
GetAxisMapsWithAction(ControllerType, Int32, String, Boolean, ListActionElementMap) |
Gets a list of all axis ActionElementMaps for a specific controller that contains a specific Action.
| |
GetButtonMapsWithAction(Int32, Boolean, ListActionElementMap) |
Gets a list of all button ActionElementMaps for any controller type that contains a specific Action.
| |
GetButtonMapsWithAction(String, Boolean, ListActionElementMap) |
Gets a list of all button ActionElementMaps for any controller type that contains a specific Action.
| |
GetButtonMapsWithAction(Controller, Int32, Boolean, ListActionElementMap) |
Gets a list of all button ActionElementMaps for a specific controller that contains a specific Action.
| |
GetButtonMapsWithAction(Controller, String, Boolean, ListActionElementMap) |
Gets a list of all button ActionElementMaps for a specific controller that contains a specific Action.
| |
GetButtonMapsWithAction(ControllerType, Int32, Boolean, ListActionElementMap) |
Gets a list of all button ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetButtonMapsWithAction(ControllerType, String, Boolean, ListActionElementMap) |
Gets a list of all button ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetButtonMapsWithAction(ControllerType, Int32, Int32, Boolean, ListActionElementMap) |
Gets a list of all button ActionElementMaps for a specific controller that contains a specific Action.
| |
GetButtonMapsWithAction(ControllerType, Int32, String, Boolean, ListActionElementMap) |
Gets a list of all button ActionElementMaps for a specific controller that contains a specific Action.
| |
GetElementMapsWithAction(Int32, Boolean, ListActionElementMap) |
Gets a list of all ActionElementMaps for any controller type that contains a specific Action.
| |
GetElementMapsWithAction(String, Boolean, ListActionElementMap) |
Gets a list of all ActionElementMaps for any controller type that contains a specific Action.
| |
GetElementMapsWithAction(Controller, Int32, Boolean, ListActionElementMap) |
Gets a list of all ActionElementMaps for a specific controller that contains a specific Action.
| |
GetElementMapsWithAction(Controller, String, Boolean, ListActionElementMap) |
Gets a list of all ActionElementMaps for a specific controller that contains a specific Action.
| |
GetElementMapsWithAction(ControllerType, Int32, Boolean, ListActionElementMap) |
Gets a list of all ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetElementMapsWithAction(ControllerType, String, Boolean, ListActionElementMap) |
Gets a list of all ActionElementMaps for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetElementMapsWithAction(ControllerType, Int32, Int32, Boolean, ListActionElementMap) |
Gets a list of all ActionElementMaps for a specific controller that contains a specific Action.
| |
GetElementMapsWithAction(ControllerType, Int32, String, Boolean, ListActionElementMap) |
Gets a list of all ActionElementMaps for a specific controller that contains a specific Action.
| |
GetElementMapsWithElementTarget(ControllerElementTarget, Boolean, ListActionElementMap) |
Gets all ActionElementMaps that map to a specific controller element target.
| |
GetElementMapsWithElementTarget(IControllerElementTarget, Boolean, ListActionElementMap) |
Gets all ActionElementMaps that map to a specific controller element target.
| |
GetElementMapsWithElementTarget(ControllerElementTarget, Int32, Boolean, ListActionElementMap) |
Gets all ActionElementMaps that map to a specific controller element target and a specific Action.
| |
GetElementMapsWithElementTarget(ControllerElementTarget, String, Boolean, ListActionElementMap) |
Gets all ActionElementMaps that map to a specific controller element target and a specific Action.
| |
GetElementMapsWithElementTarget(IControllerElementTarget, Int32, Boolean, ListActionElementMap) |
Gets all ActionElementMaps that map to a specific controller element target and a specific Action.
| |
GetElementMapsWithElementTarget(IControllerElementTarget, String, Boolean, ListActionElementMap) |
Gets all ActionElementMaps that map to a specific controller element target and a specific Action.
| |
GetFirstAxisMapWithAction(Int32, Boolean) |
Get the first axis ActionElementMap for any controller type that contains a specific Action.
| |
GetFirstAxisMapWithAction(String, Boolean) |
Get the first axis ActionElementMap for any controller type that contains a specific Action.
| |
GetFirstAxisMapWithAction(Controller, Int32, Boolean) |
Get the first axis ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstAxisMapWithAction(Controller, String, Boolean) |
Get the first axis ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstAxisMapWithAction(ControllerType, Int32, Boolean) |
Get the first axis ActionElementMap for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetFirstAxisMapWithAction(ControllerType, String, Boolean) |
Get the first axis ActionElementMap for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetFirstAxisMapWithAction(ControllerType, Int32, Int32, Boolean) |
Get the first axis ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstAxisMapWithAction(ControllerType, Int32, String, Boolean) |
Get the first axis ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstButtonMapWithAction(Int32, Boolean) |
Get the first button ActionElementMap for any controller type that contains a specific Action.
| |
GetFirstButtonMapWithAction(String, Boolean) |
Get the first button ActionElementMap for any controller type that contains a specific Action.
| |
GetFirstButtonMapWithAction(Controller, Int32, Boolean) |
Get the first button ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstButtonMapWithAction(Controller, String, Boolean) |
Get the first button ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstButtonMapWithAction(ControllerType, Int32, Boolean) |
Get the first button ActionElementMap for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetFirstButtonMapWithAction(ControllerType, String, Boolean) |
Get the first button ActionElementMap for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetFirstButtonMapWithAction(ControllerType, Int32, Int32, Boolean) |
Get the first button ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstButtonMapWithAction(ControllerType, Int32, String, Boolean) |
Get the first button ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstElementMapWithAction(Int32, Boolean) |
Get the first ActionElementMap for any controller type that contains a specific Action.
| |
GetFirstElementMapWithAction(String, Boolean) |
Get the first ActionElementMap for any controller type that contains a specific Action.
| |
GetFirstElementMapWithAction(Controller, Int32, Boolean) |
Get the first ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstElementMapWithAction(Controller, String, Boolean) |
Get the first ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstElementMapWithAction(ControllerType, Int32, Boolean) |
Get the first ActionElementMap for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetFirstElementMapWithAction(ControllerType, String, Boolean) |
Get the first ActionElementMap for a specific controller type that contains a specific Action.
This overload applies to all Controllers of the specified type assigned to the Player.
| |
GetFirstElementMapWithAction(ControllerType, Int32, Int32, Boolean) |
Get the first ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstElementMapWithAction(ControllerType, Int32, String, Boolean) |
Get the first ActionElementMap for a specific controller that contains a specific Action.
| |
GetFirstElementMapWithElementTarget(ControllerElementTarget, Boolean) |
Get the first ActionElementMap found that maps to a specific controller element target.
| |
GetFirstElementMapWithElementTarget(IControllerElementTarget, Boolean) |
Get the first ActionElementMap found that maps to a specific controller element target.
| |
GetFirstElementMapWithElementTarget(ControllerElementTarget, Int32, Boolean) |
Gets the first ActionElementMap found that maps to a specific controller element target and a specific Action.
| |
GetFirstElementMapWithElementTarget(ControllerElementTarget, String, Boolean) |
Gets the first ActionElementMap found that maps to a specific controller element target and a specific Action.
| |
GetFirstElementMapWithElementTarget(IControllerElementTarget, Int32, Boolean) |
Gets the first ActionElementMap found that maps to a specific controller element target and a specific Action.
| |
GetFirstElementMapWithElementTarget(IControllerElementTarget, String, Boolean) |
Gets the first ActionElementMap found that maps to a specific controller element target and a specific Action.
| |
GetFirstMapInCategory(Controller, Int32) |
Gets the first controller map for the specified controller in the matching category assigned to this Player.
| |
GetFirstMapInCategory(Controller, String) |
Gets the first controller map for the specified controller in the matching category assigned to this Player.
| |
GetFirstMapInCategory(ControllerType, Int32, Int32) |
Gets the first controller map for the specified controller in the matching category assigned to this Player.
| |
GetFirstMapInCategory(ControllerType, Int32, String) |
Gets the first controller map for the specified controller in the matching category assigned to this Player.
| |
GetFirstMapInCategoryT(Int32, Int32) |
Gets the first controller map for the specified controller in the matching category assigned to this Player.
| |
GetFirstMapInCategoryT(Int32, String) |
Gets the first controller map for the specified controller in the matching category assigned to this Player.
| |
GetInputBehavior(Int32) |
Gets a specific InputBehavior.
| |
GetInputBehavior(String) |
Gets a specific InputBehavior.
| |
GetMap(Int32) |
Gets a controller map by id assigned to this Player.
| |
GetMap(Controller, Int32) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMap(Controller, Int32, Int32) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMap(Controller, String, String) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMap(ControllerType, Int32, Int32) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMap(ControllerType, Int32, Int32, Int32) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMap(ControllerType, Int32, String, String) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMapT(Int32, Int32) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMapT(Int32, Int32, Int32) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMapT(Int32, String, String) |
Gets a controller map for a specific controller by id assigned to this Player.
| |
GetMaps(Controller) |
Gets a list of controller maps for a specific controller assigned to this Player.
| |
GetMaps(ControllerType, Int32) |
Gets a list of controller maps for a specific controller assigned to this Player.
| |
GetMapsT(Int32) |
Gets a list of controller maps for a specific controller assigned to this Player.
| |
GetMapSaveData(ControllerType, Int32, Boolean) |
Gets controller map save data for a specific controller. Used for saving/loading.
| |
GetMapSaveDataT(Int32, Boolean) |
Gets controller map save data for a specific controller. Used for saving/loading.
| |
GetMapsInCategory(Controller, Int32) |
Enumerates controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategory(Controller, String) |
Enumerates controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategory(Controller, Int32, ListControllerMap) |
Gets a list of controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategory(Controller, String, ListControllerMap) |
Gets a list of controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategory(ControllerType, Int32, Int32) |
Enumerates controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategory(ControllerType, Int32, String) |
Enumerates controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategory(ControllerType, Int32, Int32, ListControllerMap) |
Gets a list of controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategory(ControllerType, Int32, String, ListControllerMap) |
Gets a list of controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategoryT(Int32, Int32) |
Enumerates controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategoryT(Int32, String) |
Enumerates controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategoryT(Int32, Int32, ListT) |
Gets a list of controller maps for a specific controller assigned to this Player in a specific category.
| |
GetMapsInCategoryT(Int32, String, ListT) |
Gets a list of controller maps for a specific controller assigned to this Player in a specific category.
| |
LoadDefaultMaps |
Loads the maps defined in the Rewired Editor and assigned to this player for the specified controller type.
All existing maps will be cleared and replaced with the default maps.
The Enabled state of each map will attempt to be preserved, but if you have
added or removed maps through scripting, the result may not be as expected and you should set the Enabled states manually.
For Joysticks that have been previously assigned to this Player but are no longer assigned at the time this method is called, the Joystick Map history for
these Joysticks will be cleared so the next time the Joystick is assigned to this Player, the default Joystick Maps will be loaded instead of Joystick Maps
stored in the history.
If ControllerMapEnabler.enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings.
| |
LoadMap(ControllerType, Int32, Int32, Int32) |
Loads a controller map from the maps defined in the Rewired Editor. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement. Otherwise, map starts disabled and must be enabled before it can contribute to input.
If ControllerMapEnabler.enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings.
| |
LoadMap(ControllerType, Int32, String, String) |
Loads a controller map from the maps defined in the Rewired Editor. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement. Otherwise, map starts disabled and must be enabled before it can contribute to input.
If ControllerMapEnabler.enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings.
| |
LoadMap(ControllerType, Int32, Int32, Int32, Boolean) |
Loads a controller map from the maps defined in the Rewired Editor. Replaces if a map already exists with the same category and layout.
If enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings overriding the startEnabled setting passed into the function.
| |
LoadMap(ControllerType, Int32, String, String, Boolean) |
Loads a controller map from the maps defined in the Rewired Editor. Replaces if a map already exists with the same category and layout.
If enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings overriding the startEnabled setting passed into the function.
| |
LoadMapT(Int32, Int32, Int32) |
Loads a controller map from the maps defined in the Rewired Editor. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement. Otherwise, map starts disabled and must be enabled before it can contribute to input.
If ControllerMapEnabler.enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings.
| |
LoadMapT(Int32, String, String) |
Loads a controller map from the maps defined in the Rewired Editor. Replaces if a map already exists with the same category and layout.
When replaced, map enabled state is copied from the existing map into the replacement. Otherwise, map starts disabled and must be enabled before it can contribute to input.
If ControllerMapEnabler.enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings.
| |
LoadMapT(Int32, Int32, Int32, Boolean) |
Loads a controller map from the maps defined in the Rewired Editor. Replaces if a map already exists with the same category and layout.
If enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings overriding the startEnabled setting passed into the function.
| |
LoadMapT(Int32, String, String, Boolean) |
Loads a controller map from the maps defined in the Rewired Editor. Replaces if a map already exists with the same category and layout.
If enabled is set to true and rules exist that apply to the map, the enabled state will be set based on those settings overriding the startEnabled setting passed into the function.
| |
RemoveMap(ControllerType, Int32, Int32) |
Removes a controller map for a specific controller.
| |
RemoveMap(ControllerType, Int32, Int32, Int32) |
Removes a controller map for a specific controller.
| |
RemoveMap(ControllerType, Int32, String, String) |
Removes a controller map for a specific controller.
| |
RemoveMapT(Int32, Int32) |
Removes a controller map for a specific controller.
| |
RemoveMapT(Int32, Int32, Int32) |
Removes a controller map for a specific controller.
| |
RemoveMapT(Int32, String, String) |
Removes a controller map for a specific controller.
| |
SetAllMapsEnabled(Boolean) |
Set the enabled state in all controller maps.
NOTE: This method is not a persistent flag in Player that will set controller maps
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetAllMapsEnabled(Boolean, Controller) |
Set the enabled state in all controller maps for a particular controller.
NOTE: This method is not a persistent flag in Player that will set controller maps
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetAllMapsEnabled(Boolean, ControllerType) |
Set the enabled state in all controller maps for a particular controller type.
NOTE: This method is not a persistent flag in Player that will set controller maps
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetAllMapsEnabled(Boolean, ControllerType, Int32) |
Set the enabled state in all controller maps for a particular controller.
NNOTE: This method is not a persistent flag in Player that will set controller maps
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, Int32) |
Set the enabled state in all controller maps in a particular category.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, String) |
Set the enabled state in all controller maps in a particular category.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, Controller, Int32) |
Set the enabled state in all controller maps in a category and layout for a particular controller.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, Controller, String) |
Set the enabled state in all controller maps in a category and layout for a particular controller.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, ControllerType, Int32) |
Set the enabled state in all controller maps in a category for a particular controller type.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, ControllerType, String) |
Set the enabled state in all controller maps in a category for a particular controller type.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, String, String) |
Set the enabled state in all controller maps in a particular category and layout.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, Controller, Int32, Int32) |
Set the enabled state in all controller maps in a category and layout for a particular controller.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, Controller, String, String) |
Set the enabled state in all controller maps in a category and layout for a particular controller.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, ControllerType, Int32, Int32) |
Set the enabled state in all controller maps in a category and layout for a particular controller type.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
| |
SetMapsEnabled(Boolean, ControllerType, String, String) |
Set the enabled state in all controller maps in a category and layout for a particular controller type.
NOTE: This method is not a persistent flag in Player that will set a certain category of map
enabled/disabled upon loading. It is simply a shortcut for the iterating the controller maps
currently loaded in the Player and set them enabled/disabled at the time the method is called.
When new Controller Maps are loaded in the Player, either manually or when a Joystick is assigned,
the newly loaded maps will be enabled/disabled based on the default enabled state settings for
these maps on the Player page in the Rewired Input Manager, not based on previous calls to
SetMapsEnabled. Read the documentation on Controller Maps for more information.
If you need persistent enabled state management, use ControllerMapEnabler.
If enabled is set to true and rules exist that affect the Controller Maps you are attempting to change the enabled state on, you should not use this function and instead use the functions in ControllerMapEnabler.
|