6018 lines
351 KiB
C#
6018 lines
351 KiB
C#
|
using System.Collections.Generic;
|
|||
|
using UnityEngine;
|
|||
|
using UnityEditor;
|
|||
|
#if SSC_REWIRED
|
|||
|
using Rewired;
|
|||
|
#endif
|
|||
|
#if VIU_PLUGIN
|
|||
|
using HTC.UnityPlugin.Vive;
|
|||
|
#endif
|
|||
|
#if SCSM_XR
|
|||
|
using UnityEngine.XR;
|
|||
|
// using UnityEngine.XR.Management; // NOT IN 2021.2+
|
|||
|
#endif
|
|||
|
|
|||
|
// Sci-Fi Ship Controller. Copyright (c) 2018-2022 SCSM Pty Ltd. All rights reserved.
|
|||
|
namespace SciFiShipController
|
|||
|
{
|
|||
|
[CustomEditor(typeof(PlayerInputModule))]
|
|||
|
public class PlayerInputModuleEditor : Editor
|
|||
|
{
|
|||
|
#region Enumerations
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Used internally in PlayerInputModuleEditor only
|
|||
|
/// </summary>
|
|||
|
public enum PIMCategory
|
|||
|
{
|
|||
|
Horizontal = 0,
|
|||
|
Vertical = 1,
|
|||
|
Longitidinal = 2,
|
|||
|
Pitch = 3,
|
|||
|
Yaw = 4,
|
|||
|
Roll = 5,
|
|||
|
PrimaryFire = 10,
|
|||
|
SecondaryFire = 11,
|
|||
|
CustomPlayerInput = 21
|
|||
|
};
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Custom Editor private variables
|
|||
|
private PlayerInputModule playerInputModule = null;
|
|||
|
private bool isStylesInitialised = false;
|
|||
|
private bool isRefreshing = false;
|
|||
|
private bool isDebuggingEnabled = false;
|
|||
|
private ShipInput shipInput = null; // used for debugging
|
|||
|
private ShipControlModule shipControlModule = null;
|
|||
|
|
|||
|
private readonly static string emptyString = "";
|
|||
|
|
|||
|
// Formatting and style variables
|
|||
|
//private string txtColourName = "Black";
|
|||
|
//private Color defaultTextColour = Color.black;
|
|||
|
private string labelText;
|
|||
|
private GUIStyle labelFieldRichText;
|
|||
|
private GUIStyle headingFieldRichText;
|
|||
|
private GUIStyle helpBoxRichText;
|
|||
|
private GUIStyle foldoutStyleNoLabel;
|
|||
|
private GUIStyle buttonCompact;
|
|||
|
private float defaultEditorLabelWidth = 0f;
|
|||
|
private float defaultEditorFieldWidth = 0f;
|
|||
|
|
|||
|
#if SSC_OVR
|
|||
|
private string ovrPluginVersion = "";
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_UIS
|
|||
|
// Unity Input System variables
|
|||
|
// Ref to a Player Input component that should be attached to the same gameobject
|
|||
|
// Refresh this by calling playerInputModule.GetUISPlayerInput().
|
|||
|
private UnityEngine.InputSystem.PlayerInput uisPlayerInput = null;
|
|||
|
private string uisVersion = "";
|
|||
|
private string[] uisActionNames;
|
|||
|
private string[] uisActionIDs;
|
|||
|
private GUIContent[] uisActionGUIContent;
|
|||
|
private readonly static string uisDropDownNone = "<None>";
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_REWIRED
|
|||
|
// Rewired variables
|
|||
|
private string rwVersion = "";
|
|||
|
private string[] actionCategories;
|
|||
|
private int[] actionCategoryIDs;
|
|||
|
private GUIContent[] ActionCategoryGUIContent;
|
|||
|
private int[] actionIDsHorizPositive, actionIDsHorizNegative;
|
|||
|
private GUIContent[] ActionGUIContentHorizPositive, ActionGUIContentHorizNegative;
|
|||
|
private int[] actionIDsVertPositive, actionIDsVertNegative;
|
|||
|
private GUIContent[] ActionGUIContentVertPositive, ActionGUIContentVertNegative;
|
|||
|
private int[] actionIDsLngtdlPositive, actionIDsLngtdlNegative;
|
|||
|
private GUIContent[] ActionGUIContentLngtdlPositive, ActionGUIContentLngtdlNegative;
|
|||
|
private int[] actionIDsPitchPositive, actionIDsPitchNegative;
|
|||
|
private GUIContent[] ActionGUIContentPitchPositive, ActionGUIContentPitchNegative;
|
|||
|
private int[] actionIDsYawPositive, actionIDsYawNegative;
|
|||
|
private GUIContent[] ActionGUIContentYawPositive, ActionGUIContentYawNegative;
|
|||
|
private int[] actionIDsRollPositive, actionIDsRollNegative;
|
|||
|
private GUIContent[] ActionGUIContentRollPositive, ActionGUIContentRollNegative;
|
|||
|
private int[] actionIDsPrimaryFire, actionIDsSecondaryFire, actionIDsDocking;
|
|||
|
private GUIContent[] ActionGUIContentPrimaryFire, ActionGUIContentSecondaryFire, ActionGUIContentDocking;
|
|||
|
|
|||
|
private Rewired.InputManager rewiredInputManager = null;
|
|||
|
private Rewired.Data.UserData rewiredUserData = null;
|
|||
|
// Re-usable list to construct rewired action arrays
|
|||
|
private List<int> actionIDList = new List<int>(20);
|
|||
|
private List<GUIContent> ActionGUIContentList = new List<GUIContent>(20);
|
|||
|
private readonly static string dropDownNone = "None";
|
|||
|
#endif
|
|||
|
|
|||
|
#if VIU_PLUGIN
|
|||
|
private string viveVersion = "";
|
|||
|
#endif
|
|||
|
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
private string xrVersion = "";
|
|||
|
private string openXRVersion = "";
|
|||
|
private string oculusXRVersion = "";
|
|||
|
private string[] xrActionMapIDs;
|
|||
|
private List<string> xrActionNameList = null;
|
|||
|
private List<string> xrActionIDList = null;
|
|||
|
private List<GUIContent> xrActionGUIContentList = null;
|
|||
|
private string xrCurrentActionMapId = string.Empty;
|
|||
|
private bool xrForceActionRefresh = true;
|
|||
|
private readonly static string xrHandsOffsetName = "XR Hands Offset";
|
|||
|
private readonly static string xrLeftHandName = "XR Left Hand";
|
|||
|
private readonly static string xrRightHandName = "XR Right Hand";
|
|||
|
private readonly static string xrPluginNotInstalled = "Not Installed";
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
// custom player input variables
|
|||
|
private int cpiDeletePos = -1;
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Static GUIContent
|
|||
|
|
|||
|
#region GUIContent - Headers
|
|||
|
|
|||
|
private readonly static GUIContent headerContent = new GUIContent("Player Input Module\n\nThis module enables you to " +
|
|||
|
"map inputs from different input systems to the six axes of the ship: Horizontal (left/right movement), " +
|
|||
|
"Vertical (up/down movement), Longitudinal (forwards/backwards movement), Pitch (rotation on the local " +
|
|||
|
"x-axis), Yaw (rotation on the local y-axis) and Roll (rotation on the local z-axis). It also enables you to " +
|
|||
|
"map inputs for the weapon system and call custom code from any supported input type.");
|
|||
|
private readonly static GUIContent inputModeContent = new GUIContent(" Input Mode", "How input is received from the user. When " +
|
|||
|
"Direct Keyboard is selected, keyboard is received directly from the keyboard. When Legacy Unity is selected, input is received " +
|
|||
|
"from the axes defined in the legacy input manager.");
|
|||
|
private readonly static GUIContent horizontalHeaderContent = new GUIContent("Horizontal Input Axis");
|
|||
|
private readonly static GUIContent verticalHeaderContent = new GUIContent("Vertical Input Axis");
|
|||
|
private readonly static GUIContent longitudinalHeaderContent = new GUIContent("Longitudinal Input Axis");
|
|||
|
private readonly static GUIContent pitchHeaderContent = new GUIContent("Pitch Input Axis");
|
|||
|
private readonly static GUIContent yawHeaderContent = new GUIContent("Yaw Input Axis");
|
|||
|
private readonly static GUIContent rollHeaderContent = new GUIContent("Roll Input Axis");
|
|||
|
private readonly static GUIContent primaryFireHeaderContent = new GUIContent("Primary Fire Input Button");
|
|||
|
private readonly static GUIContent secondaryFireHeaderContent = new GUIContent("Secondary Fire Input Button");
|
|||
|
private readonly static GUIContent dockingHeaderContent = new GUIContent("Docking Input Button");
|
|||
|
private readonly static GUIContent rumbleHeaderContent = new GUIContent("Rumble Device Output");
|
|||
|
private readonly static GUIContent cpiHeaderContent = new GUIContent("Custom Player Inputs");
|
|||
|
|
|||
|
#endregion GUIContent - Headers
|
|||
|
|
|||
|
#region GUIContent - General
|
|||
|
|
|||
|
private readonly static GUIContent initialiseOnAwakeContent = new GUIContent(" Initialise on Awake", "If enabled, Initialise() will be called as soon as Awake() runs. This should be disabled if you want to control when the Player Input Module is enabled through code. [Default: ON]");
|
|||
|
private readonly static GUIContent isEnabledOnInitialiseContent = new GUIContent(" Enable on Initialise", "Is input enabled when the module is first initialised? See also EnableInput() and DisableInput(). [Default: ON]");
|
|||
|
private readonly static GUIContent isCustomInputsOnlyOnInitialiseContent = new GUIContent(" Custom Inputs Only", "Are only the custom player inputs enabled when the module is first initialised? [Default: OFF]");
|
|||
|
private readonly static GUIContent isAutoCruiseEnabledContent = new GUIContent(" Auto Cruise", "The ship will attempt to maintain the same forward speed based on the last player longitudinal input [Default: OFF]");
|
|||
|
private readonly static string brakeAssistWarningContent = "Auto Cruise overrides Brake Flight Assist when moving forwards";
|
|||
|
private readonly static GUIContent fireCanBeHeldContent = new GUIContent(" Can Be Held", "When enabled, holding the key or button down will cause fire events to be sent continuously.");
|
|||
|
private readonly static GUIContent maxRumble1Content = new GUIContent(" Max Rumble Motor 1", "The maximum output to the first device rumble motor. On a gamepad this would typically be the left low frequency force feedback or vibration motor.");
|
|||
|
private readonly static GUIContent maxRumble2Content = new GUIContent(" Max Rumble Motor 2", "The maximum output to the second device rumble motor. On a gamepad this would typically be the right high frequency force feedback or vibration motor.");
|
|||
|
private readonly static GUIContent sensitivityEnabledContent = new GUIContent(" Use Sensitivity", "Should axis sensitivity and gravity be applied to this axis?");
|
|||
|
private readonly static GUIContent sensitivityContent = new GUIContent(" Sensitivity", "Speed to move towards target values. Lower values make it less sensitive");
|
|||
|
private readonly static GUIContent gravityContent = new GUIContent(" Gravity", "The rate at which the values return to the middle or neutral position");
|
|||
|
private readonly static GUIContent discardDataContent = new GUIContent(" Override in Code", "[DEFAULT: OFF] Discard the data from this axis or button and update in custom code with shipControlModule.SendInput(..). See manual for help.");
|
|||
|
private readonly static GUIContent cpiEventContent = new GUIContent(" Callback Method", "This is your method that gets called when the input event occurs.");
|
|||
|
private readonly static GUIContent cpiIsButtonContent = new GUIContent(" Is Button", "Is this input a pressable button");
|
|||
|
private readonly static GUIContent cpiCanBeHeldDownContent = new GUIContent(" Can Be Held Down", "Can this button be continuously held down?");
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region GUIContent - Direct Keyboard Input
|
|||
|
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
private readonly static GUIContent positiveKeycodeContent = new GUIContent(" Positive Key", "The key mapped to positive input " +
|
|||
|
"on this axis. Select None if you don't want to receive positive input on this axis.");
|
|||
|
private readonly static GUIContent negativeKeycodeContent = new GUIContent(" Negative Key", "The key mapped to negative input " +
|
|||
|
"on this axis. Select None if you don't want to receive positive input on this axis.");
|
|||
|
private readonly static string identicalKeycodesWarningContent = "Positive and negative keycodes are required to be different.";
|
|||
|
private readonly static GUIContent singleKeycodeContent = new GUIContent(" Key", "The key mapped to input " +
|
|||
|
"on this axis. Select None if you don't want to receive input on this axis.");
|
|||
|
|
|||
|
private readonly static GUIContent dkiPitchInputMouseContent = new GUIContent(" Use Mouse");
|
|||
|
private readonly static GUIContent dkiYawInputMouseContent = new GUIContent(" Use Mouse");
|
|||
|
|
|||
|
private readonly static GUIContent dkiPitchSensitivityContent = new GUIContent(" Mouse sensitivity");
|
|||
|
private readonly static GUIContent dkiYawSensitivityContent = new GUIContent(" Mouse sensitivity");
|
|||
|
private readonly static GUIContent dkiPitchDeadzoneContent = new GUIContent(" Mouse deadzone");
|
|||
|
private readonly static GUIContent dkiYawDeadzoneContent = new GUIContent(" Mouse deadzone");
|
|||
|
#endif
|
|||
|
|
|||
|
#endregion GUIContent - Direct Keyboard Input
|
|||
|
|
|||
|
#region GUIContent - Legacy Unity Input System or (Rewired or Oculus without Legacy Unity Input System)
|
|||
|
#if (ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER) || SSC_OVR || VIU_PLUGIN || SSC_REWIRED
|
|||
|
private readonly static GUIContent inputAxisModeContent = new GUIContent(" Axis Mode", "How input will be received from the input " +
|
|||
|
"manager. When No Input is selected, no input will be received from the input manager on that axis (use this option if you " +
|
|||
|
"don't want the player to be able to control that axis of movement). When Single Axis is selected, input will be received " +
|
|||
|
"from a single axis specified in the input manager. When Combined Axis is selected, input will be received from two axes " +
|
|||
|
"specified in the input manager and added together to give the final input.");
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region GUIContent - Shared (Legacy Unity Input System, New Input System)
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || SSC_UIS
|
|||
|
private readonly static GUIContent invertInputAxisContent = new GUIContent(" Invert Axis", "When enabled, the input received from " +
|
|||
|
"this axis will be inverted.");
|
|||
|
#endif
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region GUIContent - Legacy Unity Input System
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
private readonly static GUIContent singleAxisNameContent = new GUIContent(" Axis Name", "The name of this axis in the input manager.");
|
|||
|
private readonly static GUIContent positiveAxisNameContent = new GUIContent(" Positive Axis Name", "The name of the positive axis " +
|
|||
|
"in the input manager.");
|
|||
|
private readonly static GUIContent negativeAxisNameContent = new GUIContent(" Negative Axis Name", "The name of the negative axis " +
|
|||
|
"in the input manager.");
|
|||
|
private readonly static string identicalAxisNamesWarningContent = "Positive and negative axis names are required to be different.";
|
|||
|
private readonly static string invalidLegacyAxisNameWarningContent = "The axis is undefined. Check the input manager.";
|
|||
|
|
|||
|
private readonly static GUIContent lisPitchInputMouseContent = new GUIContent(" Use Mouse");
|
|||
|
private readonly static GUIContent lisYawInputMouseContent = new GUIContent(" Use Mouse");
|
|||
|
|
|||
|
private readonly static GUIContent lisPitchSensitivityContent = new GUIContent(" Mouse sensitivity");
|
|||
|
private readonly static GUIContent lisYawSensitivityContent = new GUIContent(" Mouse sensitivity");
|
|||
|
private readonly static GUIContent lisPitchDeadzoneContent = new GUIContent(" Mouse deadzone");
|
|||
|
private readonly static GUIContent lisYawDeadzoneContent = new GUIContent(" Mouse deadzone");
|
|||
|
#endif
|
|||
|
#endregion GUIContent - Legacy Unity Input System
|
|||
|
|
|||
|
#region GUIContent - Debug
|
|||
|
private readonly static GUIContent debugModeContent = new GUIContent("Debug Mode", "Use this to display the data being set to the Ship Control Module at runtime in the editor.");
|
|||
|
private readonly static GUIContent debugIsInitialisedContent = new GUIContent("Is Initialised?");
|
|||
|
private readonly static GUIContent debugIsInputEnabledContent = new GUIContent("Is Input Enabled?");
|
|||
|
private readonly static GUIContent debugIsCustomPlayerInputOnlyEnabledContent = new GUIContent("Is Custom Input Only?");
|
|||
|
private readonly static GUIContent debugIsShipAIModeEnabledContent = new GUIContent("Is Ship AI Mode Enabled?");
|
|||
|
private readonly static GUIContent debugHorizontalContent = new GUIContent("Horizontal");
|
|||
|
private readonly static GUIContent debugVerticalContent = new GUIContent("Vertical");
|
|||
|
private readonly static GUIContent debugLongitudinalContent = new GUIContent("Longitudinal");
|
|||
|
private readonly static GUIContent debugPitchContent = new GUIContent("Pitch");
|
|||
|
private readonly static GUIContent debugYawContent = new GUIContent("Yaw");
|
|||
|
private readonly static GUIContent debugRollContent = new GUIContent("Roll");
|
|||
|
private readonly static GUIContent debugPrimaryFireContent = new GUIContent("Primary Fire");
|
|||
|
private readonly static GUIContent debugSecondaryFireContent = new GUIContent("Secondary Fire");
|
|||
|
private readonly static GUIContent debugDockingContent = new GUIContent("Docking");
|
|||
|
private readonly static GUIContent debugShipSpeedContent = new GUIContent("Ship Speed km/h");
|
|||
|
#endregion GUIContent - Debug
|
|||
|
|
|||
|
#region GUIContent - Oculus API
|
|||
|
#if SSC_OVR
|
|||
|
private readonly static GUIContent ovrHorizontalInputTypeContent = new GUIContent(" Input Type", "Button, Axis or (HMD) Pose. The later requires the OVRManager in the scene.");
|
|||
|
private readonly static GUIContent ovrVerticalInputTypeContent = new GUIContent(" Input Type", "Button, Axis or (HMD) Pose. The later requires the OVRManager in the scene.");
|
|||
|
private readonly static GUIContent ovrLongitudinalInputTypeContent = new GUIContent(" Input Type", "Button, Axis or (HMD) Pose. The later requires the OVRManager in the scene.");
|
|||
|
private readonly static GUIContent ovrPitchInputTypeContent = new GUIContent(" Input Type", "Button, Axis or (HMD) Pose. The later requires the OVRManager in the scene.");
|
|||
|
private readonly static GUIContent ovrYawInputTypeContent = new GUIContent(" Input Type", "Button, Axis or (HMD) Pose. The later requires the OVRManager in the scene.");
|
|||
|
private readonly static GUIContent ovrRollInputTypeContent = new GUIContent(" Input Type", "Button, Axis or (HMD) Pose. The later requires the OVRManager in the scene.");
|
|||
|
private readonly static GUIContent ovrCustomInputTypeContent = new GUIContent(" Input Type", "Button, Axis or (HMD) Pose. The later requires the OVRManager in the scene.");
|
|||
|
|
|||
|
private readonly string identicalOVRInputWarningContent = "Positive and negative input sources are required to be different.";
|
|||
|
|
|||
|
private readonly static GUIContent ovrIsInputUpdateRequiredContent = new GUIContent("Update Input", "If the OVRManager is not located in the scene, OVRInput.Update() needs to be called on 1 PlayerInputModule. If OVRManager is added or removed at runtime, you need to call PlayerInputModule.CheckOVRManager() in your code.");
|
|||
|
private readonly static GUIContent ovrHorizontalPositiveInputContent = new GUIContent(" Positive Input", "Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent ovrHorizontalNegativeInputContent = new GUIContent(" Negative Input", "Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent ovrHorizontalInputContent = new GUIContent(" Input", "Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent ovrVerticalPositiveInputContent = new GUIContent(" Positive Input", "Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent ovrVerticalNegativeInputContent = new GUIContent(" Negative Input", "Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent ovrVerticalInputContent = new GUIContent(" Input", "Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent ovrLongitudinalPositiveInputContent = new GUIContent(" Positive Input", "Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent ovrLongitudinalNegativeInputContent = new GUIContent(" Negative Input", "Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent ovrLongitudinalInputContent = new GUIContent(" Input", "Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent ovrPitchPositiveInputContent = new GUIContent(" Positive Input", "Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent ovrPitchNegativeInputContent = new GUIContent(" Negative Input", "Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent ovrPitchInputContent = new GUIContent(" Input", "Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent ovrYawPositiveInputContent = new GUIContent(" Positive Input", "Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent ovrYawNegativeInputContent = new GUIContent(" Negative Input", "Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent ovrYawInputContent = new GUIContent(" Input", "Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent ovrRollPositiveInputContent = new GUIContent(" Positive Input", "Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent ovrRollNegativeInputContent = new GUIContent(" Negative Input", "Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent ovrRollInputContent = new GUIContent(" Input", "Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent ovrCustomInputContent = new GUIContent(" Input", "Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent ovrCustomPositiveInputContent = new GUIContent(" Positive Input", "Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent ovrCustomNegativeInputContent = new GUIContent(" Negative Input", "Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent ovrCustomButtonInputContent = new GUIContent(" Button Input", "Button used for input");
|
|||
|
|
|||
|
private readonly static GUIContent ovrPrimaryFireEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent ovrPrimaryFireInputContent = new GUIContent(" Input", "Button used for input");
|
|||
|
private readonly static GUIContent ovrSecondaryFireEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent ovrSecondaryFireInputContent = new GUIContent(" Input", "Button used for input");
|
|||
|
private readonly static GUIContent ovrDockingEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent ovrDockingInputContent = new GUIContent(" Input", "Button used for input");
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion GUIContent - Oculus API
|
|||
|
|
|||
|
#region GUIContent - Unity Input System (from package manager)
|
|||
|
#if SSC_UIS
|
|||
|
private readonly static GUIContent inputSystemAxisModeContent = new GUIContent(" Axis Mode", "How input will be received from the Unity " +
|
|||
|
"Input System. When No Input is selected, no input will be received on that axis (use this option if you don't want the player " +
|
|||
|
"to be able to control that axis of movement). When Single Axis is selected, input will be received from a single Action configured " +
|
|||
|
"in the Input Action Importer Editor. Combined Axis is not used with Unity Input System because a single Action can be configured with Composite Bindings.");
|
|||
|
|
|||
|
private readonly static GUIContent[] uisDataSlots2 = { new GUIContent("Slot1"), new GUIContent("Slot2") };
|
|||
|
private readonly static GUIContent[] uisDataSlots3 = { new GUIContent("Slot1"), new GUIContent("Slot2"), new GUIContent("Slot3") };
|
|||
|
|
|||
|
private readonly static GUIContent uisInputATypeContent = new GUIContent(" Action Type");
|
|||
|
private readonly static GUIContent uisInputCTypeContent = new GUIContent(" Control Type", "Supported Control Types are Button, Axis, Vector2/Dpad and Vector3");
|
|||
|
private readonly static GUIContent uisInputDataSlotContent = new GUIContent(" Data Slot", "The slot or position of the value being used in the returned Control Type. For example a Vector2 returns two floats. To use the first float use Slot1.");
|
|||
|
|
|||
|
private readonly static GUIContent uisHorizontalInputAContent = new GUIContent(" Action");
|
|||
|
private readonly static GUIContent uisVerticalInputAContent = new GUIContent(" Action");
|
|||
|
private readonly static GUIContent uisLongitudinalInputAContent = new GUIContent(" Action");
|
|||
|
private readonly static GUIContent uisPitchInputAContent = new GUIContent(" Action");
|
|||
|
private readonly static GUIContent uisYawInputAContent = new GUIContent(" Action");
|
|||
|
private readonly static GUIContent uisRollInputAContent = new GUIContent(" Action");
|
|||
|
|
|||
|
private readonly static GUIContent uisPrimaryFireEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent uisPrimaryFireInputAContent = new GUIContent(" Action");
|
|||
|
private readonly static GUIContent uisSecondaryFireEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent uisSecondaryFireInputAContent = new GUIContent(" Action");
|
|||
|
private readonly static GUIContent uisDockingEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent uisDockingInputAContent = new GUIContent(" Action");
|
|||
|
|
|||
|
private readonly static GUIContent uisPitchInputMouseContent = new GUIContent(" Use Mouse");
|
|||
|
private readonly static GUIContent uisYawInputMouseContent = new GUIContent(" Use Mouse");
|
|||
|
|
|||
|
private readonly static GUIContent uisPitchSensitivityContent = new GUIContent(" Mouse sensitivity");
|
|||
|
private readonly static GUIContent uisYawSensitivityContent = new GUIContent(" Mouse sensitivity");
|
|||
|
private readonly static GUIContent uisPitchDeadzoneContent = new GUIContent(" Mouse deadzone");
|
|||
|
private readonly static GUIContent uisYawDeadzoneContent = new GUIContent(" Mouse deadzone");
|
|||
|
|
|||
|
private readonly static GUIContent uisCustomEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent uisCustomInputAContent = new GUIContent(" Action");
|
|||
|
|
|||
|
private readonly static GUIContent uisDebugApplyChangedContent = new GUIContent("Apply Changes", "Apply Axis setup changes");
|
|||
|
|
|||
|
private readonly static GUIContent uisAddActionsContent = new GUIContent(" Add Actions", "Add a typical set of actions to the Default Map in the attached Unity Player Input component. Does not override existing Actions. Will then configure all Axes.");
|
|||
|
private readonly static GUIContent uisOnScreenControlsContent = new GUIContent(" On-Screen Controls", "Add or configure on-screen controls");
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region GUIContent - Rewired
|
|||
|
#if SSC_REWIRED
|
|||
|
// Rewired
|
|||
|
private readonly static string rwidenticalAxisIdWarningContent = "Positive and negative axis actions are required to be different.";
|
|||
|
|
|||
|
private readonly static GUIContent rwPlayerNumberContent = new GUIContent(" Player Number", "The human player controlling this ship. " +
|
|||
|
"0 = unassigned. Typically 1,2,3,4 etc. If the Rewired player is set using PlayerInputModule .SetRewiredPlayer(..) in your code, leave it as 0 here. " +
|
|||
|
"NOTE: At runtime, Players must be first assigned in Rewired.");
|
|||
|
|
|||
|
private readonly static GUIContent rwVersionContent = new GUIContent(" Rewired version");
|
|||
|
private readonly static GUIContent rwHorizontalInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwHorizontalInputACPositiveContent = new GUIContent(" Positive Action Category");
|
|||
|
private readonly static GUIContent rwHorizontalInputACNegativeContent = new GUIContent(" Negative Action Category");
|
|||
|
private readonly static GUIContent rwHorizontalInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwHorizontalInputAIPositiveContent = new GUIContent(" Positive Action Input");
|
|||
|
private readonly static GUIContent rwHorizontalInputAINegativeContent = new GUIContent(" Negative Action Input");
|
|||
|
|
|||
|
private readonly static GUIContent rwVerticalInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwVerticalInputACPositiveContent = new GUIContent(" Positive Action Category");
|
|||
|
private readonly static GUIContent rwVerticalInputACNegativeContent = new GUIContent(" Negative Action Category");
|
|||
|
private readonly static GUIContent rwVerticalInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwVerticalInputAIPositiveContent = new GUIContent(" Positive Action Input");
|
|||
|
private readonly static GUIContent rwVerticalInputAINegativeContent = new GUIContent(" Negative Action Input");
|
|||
|
|
|||
|
private readonly static GUIContent rwLongitudinalInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwLongitudinalInputACPositiveContent = new GUIContent(" Positive Action Category");
|
|||
|
private readonly static GUIContent rwLongitudinalInputACNegativeContent = new GUIContent(" Negative Action Category");
|
|||
|
private readonly static GUIContent rwLongitudinalInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwLongitudinalInputAIPositiveContent = new GUIContent(" Positive Action Input");
|
|||
|
private readonly static GUIContent rwLongitudinalInputAINegativeContent = new GUIContent(" Negative Action Input");
|
|||
|
|
|||
|
private readonly static GUIContent rwPitchInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwPitchInputACPositiveContent = new GUIContent(" Positive Action Category");
|
|||
|
private readonly static GUIContent rwPitchInputACNegativeContent = new GUIContent(" Negative Action Category");
|
|||
|
private readonly static GUIContent rwPitchInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwPitchInputAIPositiveContent = new GUIContent(" Positive Action Input");
|
|||
|
private readonly static GUIContent rwPitchInputAINegativeContent = new GUIContent(" Negative Action Input");
|
|||
|
|
|||
|
private readonly static GUIContent rwYawInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwYawInputACPositiveContent = new GUIContent(" Positive Action Category");
|
|||
|
private readonly static GUIContent rwYawInputACNegativeContent = new GUIContent(" Negative Action Category");
|
|||
|
private readonly static GUIContent rwYawInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwYawInputAIPositiveContent = new GUIContent(" Positive Action Input");
|
|||
|
private readonly static GUIContent rwYawInputAINegativeContent = new GUIContent(" Negative Action Input");
|
|||
|
|
|||
|
private readonly static GUIContent rwRollInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwRollInputACPositiveContent = new GUIContent(" Positive Action Category");
|
|||
|
private readonly static GUIContent rwRollInputACNegativeContent = new GUIContent(" Negative Action Category");
|
|||
|
private readonly static GUIContent rwRollInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwRollInputAIPositiveContent = new GUIContent(" Positive Action Input");
|
|||
|
private readonly static GUIContent rwRollInputAINegativeContent = new GUIContent(" Negative Action Input");
|
|||
|
|
|||
|
private readonly static GUIContent rwPrimaryFireEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent rwPrimaryFireInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwPrimaryFireInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwSecondaryFireEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent rwSecondaryFireInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwSecondaryFireInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwDockingEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent rwDockingInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwDockingInputAIContent = new GUIContent(" Action Input");
|
|||
|
|
|||
|
private readonly static GUIContent rwCustomEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent rwCustomInputACContent = new GUIContent(" Action Category");
|
|||
|
private readonly static GUIContent rwCustomInputAIContent = new GUIContent(" Action Input");
|
|||
|
private readonly static GUIContent rwCustomInputACPositiveContent = new GUIContent(" Positive Action Category");
|
|||
|
private readonly static GUIContent rwCustomInputACNegativeContent = new GUIContent(" Negative Action Category");
|
|||
|
private readonly static GUIContent rwCustomInputAIPositiveContent = new GUIContent(" Positive Action Input");
|
|||
|
private readonly static GUIContent rwCustomInputAINegativeContent = new GUIContent(" Negative Action Input");
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region GUIContent - Vive
|
|||
|
#if VIU_PLUGIN
|
|||
|
private readonly static GUIContent viveHorizontalInputTypeContent = new GUIContent(" Input Type", "Button, Axis or Pose (single axis only)");
|
|||
|
private readonly static GUIContent viveVerticalInputTypeContent = new GUIContent(" Input Type", "Button, Axis or Pose (single axis only)");
|
|||
|
private readonly static GUIContent viveLongitudinalInputTypeContent = new GUIContent(" Input Type", "Button, Axis or Pose (single axis only)");
|
|||
|
private readonly static GUIContent vivePitchInputTypeContent = new GUIContent(" Input Type", "Button, Axis or Pose (single axis only)");
|
|||
|
private readonly static GUIContent viveYawInputTypeContent = new GUIContent(" Input Type", "Button, Axis or Pose (single axis only)");
|
|||
|
private readonly static GUIContent viveRollInputTypeContent = new GUIContent(" Input Type", "Button, Axis or Pose (single axis only)");
|
|||
|
private readonly static GUIContent viveCustomInputTypeContent = new GUIContent(" Input Type", "Button, Axis or Pose (single axis only)");
|
|||
|
private readonly static GUIContent viveHorizontalRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent viveVerticalRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent viveLongitudinalRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent vivePitchRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent viveYawRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent viveRollRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent vivePrimaryFireEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent vivePrimaryFireRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent viveSecondaryFireEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent viveSecondaryFireRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent viveDockingRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent viveDockingEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
private readonly static GUIContent viveCustomRoleTypeContent = new GUIContent(" Vive Role Type", "");
|
|||
|
private readonly static GUIContent viveCustomEnabledContent = new GUIContent(" Is Enabled");
|
|||
|
|
|||
|
private readonly static GUIContent viveHorizontalPositiveRoleIdContent = new GUIContent(" Positive Controller Role", "The Vive Role for this Controller used for positive input");
|
|||
|
private readonly static GUIContent viveHorizontalNegativeRoleIdContent = new GUIContent(" Negative Controller Role", "The Vive Role for this Controller used for negative input");
|
|||
|
private readonly static GUIContent viveHorizontalRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent viveVerticalPositiveRoleIdContent = new GUIContent(" Positive Controller Role", "The Vive Role for this Controller used for positive input");
|
|||
|
private readonly static GUIContent viveVerticalNegativeRoleIdContent = new GUIContent(" Negative Controller Role", "The Vive Role for this Controller for negative input");
|
|||
|
private readonly static GUIContent viveVerticalRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent viveLongitudinalPositiveRoleIdContent = new GUIContent(" Positive Controller Role", "The Vive Role for this Controller used for positive input");
|
|||
|
private readonly static GUIContent viveLongitudinalNegativeRoleIdContent = new GUIContent(" Negative Controller Role", "The Vive Role for this Controller used for negative input");
|
|||
|
private readonly static GUIContent viveLongitudinalRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent vivePitchPositiveRoleIdContent = new GUIContent(" Positive Controller Role", "The Vive Role for this Controller used for positive input");
|
|||
|
private readonly static GUIContent vivePitchNegativeRoleIdContent = new GUIContent(" Negative Controller Role", "The Vive Role for this Controller used for negative input");
|
|||
|
private readonly static GUIContent vivePitchRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent viveYawPositiveRoleIdContent = new GUIContent(" Positive Controller Role", "The Vive Role for this Controller used for positive input");
|
|||
|
private readonly static GUIContent viveYawNegativeRoleIdContent = new GUIContent(" Negative Controller Role", "The Vive Role for this Controller used for negative input");
|
|||
|
private readonly static GUIContent viveYawRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent viveRollPositiveRoleIdContent = new GUIContent(" Positive Controller Role", "The Vive Role for this Controller used for positive input");
|
|||
|
private readonly static GUIContent viveRollNegativeRoleIdContent = new GUIContent(" Negative Controller Role", "The Vive Role for this Controller used for negative input");
|
|||
|
private readonly static GUIContent viveRollRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent vivePrimaryFireRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent viveSecondaryFireRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent viveDockingRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
private readonly static GUIContent viveCustomPositiveRoleIdContent = new GUIContent(" Positive Controller Role", "The Vive Role for this Controller used for positive input");
|
|||
|
private readonly static GUIContent viveCustomNegativeRoleIdContent = new GUIContent(" Negative Controller Role", "The Vive Role for this Controller used for negative input");
|
|||
|
private readonly static GUIContent viveCustomRoleIdContent = new GUIContent(" Controller Role", "The Vive Role for this Controller");
|
|||
|
|
|||
|
|
|||
|
private readonly string identicalViveInputWarningContent = "Positive and negative input sources are required to be different.";
|
|||
|
|
|||
|
private readonly static GUIContent viveHorizontalPositiveInputCtrlContent = new GUIContent(" Positive Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for positive input.");
|
|||
|
private readonly static GUIContent viveHorizontalNegativeInputCtrlContent = new GUIContent(" Negative Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent viveHorizontalInputCtrlContent = new GUIContent(" Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent viveVerticalPositiveInputCtrlContent = new GUIContent(" Positive Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent viveVerticalNegativeInputCtrlContent = new GUIContent(" Negative Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent viveVerticalInputCtrlContent = new GUIContent(" Controller", "The device Controller Button or Axis used for input");
|
|||
|
private readonly static GUIContent viveLongitudinalPositiveInputCtrlContent = new GUIContent(" Positive Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent viveLongitudinalNegativeInputCtrlContent = new GUIContent(" Negative Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent viveLongitudinalInputCtrlContent = new GUIContent(" Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent vivePitchPositiveInputCtrlContent = new GUIContent(" Positive Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent vivePitchNegativeInputCtrlContent = new GUIContent(" Negative Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent vivePitchInputCtrlContent = new GUIContent(" Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent viveYawPositiveInputCtrlContent = new GUIContent(" Positive Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent viveYawNegativeInputCtrlContent = new GUIContent(" Negative Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent viveYawInputCtrlContent = new GUIContent(" Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent viveRollPositiveInputCtrlContent = new GUIContent(" Positive Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent viveRollNegativeInputCtrlContent = new GUIContent(" Negative Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent viveRollInputCtrlContent = new GUIContent(" Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
private readonly static GUIContent vivePrimaryFireInputCtrlContent = new GUIContent(" Controller", "The device Controller Button used for input");
|
|||
|
private readonly static GUIContent viveSecondaryFireInputCtrlContent = new GUIContent(" Controller", "The device Controller Button used for input");
|
|||
|
private readonly static GUIContent viveDockingInputCtrlContent = new GUIContent(" Controller", "The device Controller Button used for input");
|
|||
|
private readonly static GUIContent viveCustomPositiveInputCtrlContent = new GUIContent(" Positive Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for positive input");
|
|||
|
private readonly static GUIContent viveCustomNegativeInputCtrlContent = new GUIContent(" Negative Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for negative input");
|
|||
|
private readonly static GUIContent viveCustomInputCtrlContent = new GUIContent(" Controller", "The device Controller Button, Axis, or Pose Rotation Axis used for input");
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion GUIContent - Vive
|
|||
|
|
|||
|
#region GUIContent - XR
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
private readonly static GUIContent xrPluginVersionContent = new GUIContent(" XR Plugin version", "The version of the Unity XR Management plugin installed from Package Manager");
|
|||
|
private readonly static GUIContent xrOpenXRVersionContent = new GUIContent(" OpenXR version", "The version of the OpenXR plugin installed from Package Manager");
|
|||
|
private readonly static GUIContent xrOculusXRVersionContent = new GUIContent(" Oculus version", "The version of the Oculus plugin installed from Package Manager");
|
|||
|
private readonly static GUIContent xrInputActionAssetContent = new GUIContent(" Input Action Asset", "An scriptableobject asset containing Unity Input System action maps and control schemes. ");
|
|||
|
private readonly static GUIContent xrFirstPersonTransform1Content = new GUIContent(" XR Camera Transform", "The transform of the XR first person camera.");
|
|||
|
private readonly static GUIContent xrFirstPersonCamera1Content = new GUIContent(" XR Camera", "The transform of the XR first person camera.");
|
|||
|
private readonly static GUIContent xrLeftHandTransformContent = new GUIContent(" Left Hand", "The transform of the XR left hand");
|
|||
|
private readonly static GUIContent xrRightHandTransformContent = new GUIContent(" Right Hand", "The transform of the XR right hand");
|
|||
|
private readonly static GUIContent xrFirstPersonNewCamera1Content = new GUIContent("New", "Create a new XR first person camera as a child of the ship controller");
|
|||
|
private readonly static GUIContent xrNewHandContent = new GUIContent("New", "Create a new XR hand as a child of the ship controller");
|
|||
|
private readonly static GUIContent xrInputAMContent = new GUIContent(" Action Map", "Unity Input System Action Map in the Input Action Asset");
|
|||
|
private static GUIContent[] xrActionMapGUIContent;
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region SerializedProperties - General
|
|||
|
|
|||
|
private SerializedProperty inputModeProp;
|
|||
|
private SerializedProperty initialiseOnAwakeProp;
|
|||
|
private SerializedProperty isEnabledOnInitialiseProp;
|
|||
|
private SerializedProperty isCustomInputsOnlyOnInitialiseProp;
|
|||
|
private SerializedProperty isAutoCruiseEnabledProp;
|
|||
|
private SerializedProperty horizontalShowInEditorProp;
|
|||
|
private SerializedProperty verticalShowInEditorProp;
|
|||
|
private SerializedProperty longitudinalShowInEditorProp;
|
|||
|
private SerializedProperty pitchShowInEditorProp;
|
|||
|
private SerializedProperty yawShowInEditorProp;
|
|||
|
private SerializedProperty rollShowInEditorProp;
|
|||
|
private SerializedProperty primaryFireShowInEditorProp;
|
|||
|
private SerializedProperty secondaryFireShowInEditorProp;
|
|||
|
private SerializedProperty dockingShowInEditorProp;
|
|||
|
private SerializedProperty rumbleShowInEditorProp;
|
|||
|
private SerializedProperty primaryFireCanBeHeldProp;
|
|||
|
private SerializedProperty secondaryFireCanBeHeldProp;
|
|||
|
private SerializedProperty maxRumble1Prop;
|
|||
|
private SerializedProperty maxRumble2Prop;
|
|||
|
private SerializedProperty isSensitivityForHorizontalEnabledProp;
|
|||
|
private SerializedProperty isSensitivityForVerticalEnabledProp;
|
|||
|
private SerializedProperty isSensitivityForLongitudinalEnabledProp;
|
|||
|
private SerializedProperty isSensitivityForPitchEnabledProp;
|
|||
|
private SerializedProperty isSensitivityForYawEnabledProp;
|
|||
|
private SerializedProperty isSensitivityForRollEnabledProp;
|
|||
|
private SerializedProperty horizontalAxisSensitivityProp;
|
|||
|
private SerializedProperty verticalAxisSensitivityProp;
|
|||
|
private SerializedProperty longitudinalAxisSensitivityProp;
|
|||
|
private SerializedProperty pitchAxisSensitivityProp;
|
|||
|
private SerializedProperty yawAxisSensitivityProp;
|
|||
|
private SerializedProperty rollAxisSensitivityProp;
|
|||
|
private SerializedProperty horizontalAxisGravityProp;
|
|||
|
private SerializedProperty verticalAxisGravityProp;
|
|||
|
private SerializedProperty longitudinalAxisGravityProp;
|
|||
|
private SerializedProperty pitchAxisGravityProp;
|
|||
|
private SerializedProperty yawAxisGravityProp;
|
|||
|
private SerializedProperty rollAxisGravityProp;
|
|||
|
|
|||
|
private SerializedProperty isHorizontalDataDiscardedProp;
|
|||
|
private SerializedProperty isVerticalDataDiscardedProp;
|
|||
|
private SerializedProperty isLongitudinalDataDiscardedProp;
|
|||
|
private SerializedProperty isPitchDataDiscardedProp;
|
|||
|
private SerializedProperty isYawDataDiscardedProp;
|
|||
|
private SerializedProperty isRollDataDiscardedProp;
|
|||
|
private SerializedProperty isPrimaryFireDataDiscardedProp;
|
|||
|
private SerializedProperty isSecondaryFireDataDiscardedProp;
|
|||
|
private SerializedProperty isDockDataDiscardedProp;
|
|||
|
|
|||
|
#endregion SerializedProperties - General
|
|||
|
|
|||
|
#region SerializedProperties - Shared (Legacy Unity Input System, New Input System, Rewired, XR)
|
|||
|
private SerializedProperty horizontalInputAxisModeProp;
|
|||
|
private SerializedProperty verticalInputAxisModeProp;
|
|||
|
private SerializedProperty longitudinalInputAxisModeProp;
|
|||
|
private SerializedProperty pitchInputAxisModeProp;
|
|||
|
private SerializedProperty yawInputAxisModeProp;
|
|||
|
private SerializedProperty rollInputAxisModeProp;
|
|||
|
#endregion
|
|||
|
|
|||
|
#region SerializedProperties - Shared (Legacy Unity Input System, New Input System)
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || SSC_UIS
|
|||
|
private SerializedProperty invertHorizontalInputAxisProp;
|
|||
|
private SerializedProperty invertVerticalInputAxisProp;
|
|||
|
private SerializedProperty invertLongitudinalInputAxisProp;
|
|||
|
private SerializedProperty invertPitchInputAxisProp;
|
|||
|
private SerializedProperty invertYawInputAxisProp;
|
|||
|
private SerializedProperty invertRollInputAxisProp;
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region SerializedProperties - Direct Keyboard Input
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
private SerializedProperty horizontalInputPositiveKeycodeProp;
|
|||
|
private SerializedProperty horizontalInputNegativeKeycodeProp;
|
|||
|
private SerializedProperty verticalInputPositiveKeycodeProp;
|
|||
|
private SerializedProperty verticalInputNegativeKeycodeProp;
|
|||
|
private SerializedProperty longitudinalInputPositiveKeycodeProp;
|
|||
|
private SerializedProperty longitudinalInputNegativeKeycodeProp;
|
|||
|
private SerializedProperty pitchInputPositiveKeycodeProp;
|
|||
|
private SerializedProperty pitchInputNegativeKeycodeProp;
|
|||
|
private SerializedProperty yawInputPositiveKeycodeProp;
|
|||
|
private SerializedProperty yawInputNegativeKeycodeProp;
|
|||
|
private SerializedProperty rollInputPositiveKeycodeProp;
|
|||
|
private SerializedProperty rollInputNegativeKeycodeProp;
|
|||
|
private SerializedProperty primaryFireInputKeycodeProp;
|
|||
|
private SerializedProperty secondaryFireInputKeycodeProp;
|
|||
|
private SerializedProperty dockingInputKeycodeProp;
|
|||
|
|
|||
|
private SerializedProperty isMouseForPitchEnabledDKIProp;
|
|||
|
private SerializedProperty isMouseForYawEnabledDKIProp;
|
|||
|
private SerializedProperty pitchSensitivityDKIProp;
|
|||
|
private SerializedProperty yawSensitivityDKIProp;
|
|||
|
private SerializedProperty pitchDeadzoneDKIProp;
|
|||
|
private SerializedProperty yawDeadzoneDKIProp;
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region SerializedProperties - Legacy Unity Input System
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
private SerializedProperty positiveHorizontalInputAxisNameProp;
|
|||
|
private SerializedProperty negativeHorizontalInputAxisNameProp;
|
|||
|
private SerializedProperty positiveVerticalInputAxisNameProp;
|
|||
|
private SerializedProperty negativeVerticalInputAxisNameProp;
|
|||
|
private SerializedProperty positiveLongitudinalInputAxisNameProp;
|
|||
|
private SerializedProperty negativeLongitudinalInputAxisNameProp;
|
|||
|
private SerializedProperty positivePitchInputAxisNameProp;
|
|||
|
private SerializedProperty negativePitchInputAxisNameProp;
|
|||
|
private SerializedProperty positiveYawInputAxisNameProp;
|
|||
|
private SerializedProperty negativeYawInputAxisNameProp;
|
|||
|
private SerializedProperty positiveRollInputAxisNameProp;
|
|||
|
private SerializedProperty negativeRollInputAxisNameProp;
|
|||
|
private SerializedProperty primaryFireInputAxisNameProp;
|
|||
|
private SerializedProperty secondaryFireInputAxisNameProp;
|
|||
|
private SerializedProperty dockingInputAxisNameProp;
|
|||
|
private SerializedProperty isPositiveHorizontalInputAxisValidProp;
|
|||
|
private SerializedProperty isNegativeHorizontalInputAxisValidProp;
|
|||
|
private SerializedProperty isPositiveVerticalInputAxisValidProp;
|
|||
|
private SerializedProperty isNegativeVerticalInputAxisValidProp;
|
|||
|
private SerializedProperty isPositiveLongitudinalInputAxisValidProp;
|
|||
|
private SerializedProperty isNegativeLongitudinalInputAxisValidProp;
|
|||
|
private SerializedProperty isPositivePitchInputAxisValidProp;
|
|||
|
private SerializedProperty isNegativePitchInputAxisValidProp;
|
|||
|
private SerializedProperty isPositiveYawInputAxisValidProp;
|
|||
|
private SerializedProperty isNegativeYawInputAxisValidProp;
|
|||
|
private SerializedProperty isPositiveRollInputAxisValidProp;
|
|||
|
private SerializedProperty isNegativeRollInputAxisValidProp;
|
|||
|
private SerializedProperty isPrimaryFireInputAxisValidProp;
|
|||
|
private SerializedProperty isSecondaryFireInputAxisValidProp;
|
|||
|
private SerializedProperty isDockingInputAxisValidProp;
|
|||
|
|
|||
|
private SerializedProperty isMouseForPitchEnabledLISProp;
|
|||
|
private SerializedProperty isMouseForYawEnabledLISProp;
|
|||
|
private SerializedProperty pitchSensitivityLISProp;
|
|||
|
private SerializedProperty yawSensitivityLISProp;
|
|||
|
private SerializedProperty pitchDeadzoneLISProp;
|
|||
|
private SerializedProperty yawDeadzoneLISProp;
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region SerializedProperties - Unity Input System (and XR)
|
|||
|
#if SSC_UIS
|
|||
|
private SerializedProperty positiveHorizontalInputActionIdUISProp;
|
|||
|
private SerializedProperty positiveHorizontalInputActionDataSlotUISProp;
|
|||
|
private SerializedProperty positiveVerticalInputActionIdUISProp;
|
|||
|
private SerializedProperty positiveVerticalInputActionDataSlotUISProp;
|
|||
|
private SerializedProperty positiveLongitudinalInputActionIdUISProp;
|
|||
|
private SerializedProperty positiveLongitudinalInputActionDataSlotUISProp;
|
|||
|
private SerializedProperty positivePitchInputActionIdUISProp;
|
|||
|
private SerializedProperty positivePitchInputActionDataSlotUISProp;
|
|||
|
private SerializedProperty positiveYawInputActionIdUISProp;
|
|||
|
private SerializedProperty positiveYawInputActionDataSlotUISProp;
|
|||
|
private SerializedProperty positiveRollInputActionIdUISProp;
|
|||
|
private SerializedProperty positiveRollInputActionDataSlotUISProp;
|
|||
|
private SerializedProperty primaryFireInputActionIdUISProp;
|
|||
|
private SerializedProperty primaryFireInputActionDataSlotUISProp;
|
|||
|
private SerializedProperty secondaryFireInputActionIdUISProp;
|
|||
|
private SerializedProperty secondaryFireInputActionDataSlotUISProp;
|
|||
|
private SerializedProperty dockingInputActionIdUISProp;
|
|||
|
private SerializedProperty dockingInputActionDataSlotUISProp;
|
|||
|
|
|||
|
private SerializedProperty isMouseForPitchEnabledUISProp;
|
|||
|
private SerializedProperty isMouseForYawEnabledUISProp;
|
|||
|
private SerializedProperty pitchSensitivityUISProp;
|
|||
|
private SerializedProperty yawSensitivityUISProp;
|
|||
|
private SerializedProperty pitchDeadzoneUISProp;
|
|||
|
private SerializedProperty yawDeadzoneUISProp;
|
|||
|
private SerializedProperty onscreenControlsShowInEditorProp;
|
|||
|
#endif
|
|||
|
#endregion SerializedProperties - Unity Input System
|
|||
|
|
|||
|
#region SerializedProperties - Oculus API
|
|||
|
#if SSC_OVR
|
|||
|
private SerializedProperty isOVRInputUpdatedIfRequiredProp;
|
|||
|
private SerializedProperty ovrHorizontalInputTypeProp;
|
|||
|
private SerializedProperty ovrVerticalInputTypeProp;
|
|||
|
private SerializedProperty ovrLongitudinalInputTypeProp;
|
|||
|
private SerializedProperty ovrPitchInputTypeProp;
|
|||
|
private SerializedProperty ovrYawInputTypeProp;
|
|||
|
private SerializedProperty ovrRollInputTypeProp;
|
|||
|
private SerializedProperty positiveHorizontalInputOVRProp;
|
|||
|
private SerializedProperty negativeHorizontalInputOVRProp;
|
|||
|
private SerializedProperty positiveVerticalInputOVRProp;
|
|||
|
private SerializedProperty negativeVerticalInputOVRProp;
|
|||
|
private SerializedProperty positiveLongitudinalInputOVRProp;
|
|||
|
private SerializedProperty negativeLongitudinalInputOVRProp;
|
|||
|
private SerializedProperty positivePitchInputOVRProp;
|
|||
|
private SerializedProperty negativePitchInputOVRProp;
|
|||
|
private SerializedProperty positiveYawInputOVRProp;
|
|||
|
private SerializedProperty negativeYawInputOVRProp;
|
|||
|
private SerializedProperty positiveRollInputOVRProp;
|
|||
|
private SerializedProperty negativeRollInputOVRProp;
|
|||
|
private SerializedProperty primaryFireInputOVRProp;
|
|||
|
private SerializedProperty secondaryFireInputOVRProp;
|
|||
|
private SerializedProperty dockingInputOVRProp;
|
|||
|
#endif
|
|||
|
#endregion SerializedProperties - Oculus API
|
|||
|
|
|||
|
#region SerializedProperties - Rewired
|
|||
|
#if SSC_REWIRED
|
|||
|
private SerializedProperty rewiredPlayerNumberProp;
|
|||
|
private SerializedProperty positiveHorizontalInputActionIdProp;
|
|||
|
private SerializedProperty negativeHorizontalInputActionIdProp;
|
|||
|
private SerializedProperty positiveVerticalInputActionIdProp;
|
|||
|
private SerializedProperty negativeVerticalInputActionIdProp;
|
|||
|
private SerializedProperty positiveLongitudinalInputActionIdProp;
|
|||
|
private SerializedProperty negativeLongitudinalInputActionIdProp;
|
|||
|
private SerializedProperty positivePitchInputActionIdProp;
|
|||
|
private SerializedProperty negativePitchInputActionIdProp;
|
|||
|
private SerializedProperty positiveYawInputActionIdProp;
|
|||
|
private SerializedProperty negativeYawInputActionIdProp;
|
|||
|
private SerializedProperty positiveRollInputActionIdProp;
|
|||
|
private SerializedProperty negativeRollInputActionIdProp;
|
|||
|
private SerializedProperty primaryFireInputActionIdProp;
|
|||
|
private SerializedProperty secondaryFireInputActionIdProp;
|
|||
|
private SerializedProperty dockingInputActionIdProp;
|
|||
|
#endif
|
|||
|
#endregion SerializedProperties - Rewired
|
|||
|
|
|||
|
#region SerializedProperties - Vive
|
|||
|
#if VIU_PLUGIN
|
|||
|
private SerializedProperty viveHorizontalInputTypeProp;
|
|||
|
private SerializedProperty viveVerticalInputTypeProp;
|
|||
|
private SerializedProperty viveLongitudinalInputTypeProp;
|
|||
|
private SerializedProperty vivePitchInputTypeProp;
|
|||
|
private SerializedProperty viveYawInputTypeProp;
|
|||
|
private SerializedProperty viveRollInputTypeProp;
|
|||
|
private SerializedProperty viveHorizontalRoleTypeProp;
|
|||
|
private SerializedProperty viveVerticalRoleTypeProp;
|
|||
|
private SerializedProperty viveLongitudinalRoleTypeProp;
|
|||
|
private SerializedProperty vivePitchRoleTypeProp;
|
|||
|
private SerializedProperty viveYawRoleTypeProp;
|
|||
|
private SerializedProperty viveRollRoleTypeProp;
|
|||
|
private SerializedProperty vivePrimaryFireRoleTypeProp;
|
|||
|
private SerializedProperty viveSecondaryFireRoleTypeProp;
|
|||
|
private SerializedProperty viveDockingRoleTypeProp;
|
|||
|
|
|||
|
private SerializedProperty positiveHorizontalInputRoleIdProp;
|
|||
|
private SerializedProperty negativeHorizontalInputRoleIdProp;
|
|||
|
private SerializedProperty positiveVerticalInputRoleIdProp;
|
|||
|
private SerializedProperty negativeVerticalInputRoleIdProp;
|
|||
|
private SerializedProperty positiveLongitudinalInputRoleIdProp;
|
|||
|
private SerializedProperty negativeLongitudinalInputRoleIdProp;
|
|||
|
private SerializedProperty positivePitchInputRoleIdProp;
|
|||
|
private SerializedProperty negativePitchInputRoleIdProp;
|
|||
|
private SerializedProperty positiveYawInputRoleIdProp;
|
|||
|
private SerializedProperty negativeYawInputRoleIdProp;
|
|||
|
private SerializedProperty positiveRollInputRoleIdProp;
|
|||
|
private SerializedProperty negativeRollInputRoleIdProp;
|
|||
|
private SerializedProperty primaryFireInputRoleIdProp;
|
|||
|
private SerializedProperty secondaryFireInputRoleIdProp;
|
|||
|
private SerializedProperty dockingInputRoleIdProp;
|
|||
|
|
|||
|
private SerializedProperty positiveHorizontalInputCtrlViveProp;
|
|||
|
private SerializedProperty negativeHorizontalInputCtrlViveProp;
|
|||
|
private SerializedProperty positiveVerticalInputCtrlViveProp;
|
|||
|
private SerializedProperty negativeVerticalInputCtrlViveProp;
|
|||
|
private SerializedProperty positiveLongitudinalInputCtrlViveProp;
|
|||
|
private SerializedProperty negativeLongitudinalInputCtrlViveProp;
|
|||
|
private SerializedProperty positivePitchInputCtrlViveProp;
|
|||
|
private SerializedProperty negativePitchInputCtrlViveProp;
|
|||
|
private SerializedProperty positiveYawInputCtrlViveProp;
|
|||
|
private SerializedProperty negativeYawInputCtrlViveProp;
|
|||
|
private SerializedProperty positiveRollInputCtrlViveProp;
|
|||
|
private SerializedProperty negativeRollInputCtrlViveProp;
|
|||
|
private SerializedProperty primaryFireInputCtrlViveProp;
|
|||
|
private SerializedProperty secondaryFireInputCtrlViveProp;
|
|||
|
private SerializedProperty dockingInputCtrlViveProp;
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region SerializedProperties - XR
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
private SerializedProperty inputActionAssetXRProp;
|
|||
|
private SerializedProperty firstPersonTransform1XRProp;
|
|||
|
private SerializedProperty firstPersonCamera1XRProp;
|
|||
|
private SerializedProperty leftHandTransformXRProp;
|
|||
|
private SerializedProperty rightHandTransformXRProp;
|
|||
|
|
|||
|
private SerializedProperty positiveHorizontalInputActionMapIdXRProp;
|
|||
|
private SerializedProperty positiveVerticalInputActionMapIdXRProp;
|
|||
|
private SerializedProperty positiveLongitudinalInputActionMapIdXRProp;
|
|||
|
private SerializedProperty positivePitchInputActionMapIdXRProp;
|
|||
|
private SerializedProperty positiveYawInputActionMapIdXRProp;
|
|||
|
private SerializedProperty positiveRollInputActionMapIdXRProp;
|
|||
|
private SerializedProperty primaryFireInputActionMapIdXRProp;
|
|||
|
private SerializedProperty secondaryFireInputActionMapIdXRProp;
|
|||
|
private SerializedProperty dockingInputActionMapIdXRProp;
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region SerializedProperties - Oculus or Vive or Rewired or Unity Input System
|
|||
|
#if SSC_OVR || SSC_REWIRED || VIU_PLUGIN || SSC_UIS
|
|||
|
private SerializedProperty primaryFireButtonEnabledProp;
|
|||
|
private SerializedProperty secondaryFireButtonEnabledProp;
|
|||
|
private SerializedProperty dockingButtonEnabledProp;
|
|||
|
#endif
|
|||
|
#endregion SerializedProperties - Oculus or Vive or Rewired
|
|||
|
|
|||
|
#region SerializedProperties - Custom Player Inputs (cpi)
|
|||
|
|
|||
|
private SerializedProperty cpiListProp;
|
|||
|
private SerializedProperty cpiItemProp;
|
|||
|
private SerializedProperty cpiItemShowInEditorProp;
|
|||
|
private SerializedProperty cpiShowInEditorProp;
|
|||
|
private SerializedProperty cpiIsListExpandedProp;
|
|||
|
private SerializedProperty cpiEventProp;
|
|||
|
private SerializedProperty cpiIsButtonProp;
|
|||
|
private SerializedProperty cpiCanBeHeldDownProp;
|
|||
|
private SerializedProperty cpiInputAxisModeProp;
|
|||
|
private SerializedProperty cpiIsSensitivityEnabledProp;
|
|||
|
private SerializedProperty cpiSensitivityProp;
|
|||
|
private SerializedProperty cpiGravityProp;
|
|||
|
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
private SerializedProperty cpidkmPositiveKeycodeProp;
|
|||
|
private SerializedProperty cpidkmNegativeKeycodeProp;
|
|||
|
private SerializedProperty cpilisPositiveAxisNameProp;
|
|||
|
private SerializedProperty cpilisNegativeAxisNameProp;
|
|||
|
private SerializedProperty cpilisInvertAxisProp;
|
|||
|
private SerializedProperty cpilisIsPositiveAxisValidProp;
|
|||
|
private SerializedProperty cpilisIsNegativeAxisValidProp;
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_UIS
|
|||
|
private SerializedProperty cpiuisPositiveInputActionIdProp;
|
|||
|
private SerializedProperty cpiuisPositiveInputActionDataSlotProp;
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_OVR
|
|||
|
private SerializedProperty cpiovrInputTypeProp;
|
|||
|
private SerializedProperty cpiovrPositiveInputProp;
|
|||
|
private SerializedProperty cpiovrNegativeInputProp;
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_REWIRED
|
|||
|
private SerializedProperty cpirwdPositiveInputActionIdProp;
|
|||
|
private SerializedProperty cpirwdNegativeInputActionIdProp;
|
|||
|
#endif
|
|||
|
|
|||
|
#if VIU_PLUGIN
|
|||
|
private SerializedProperty cpiviveInputTypeProp;
|
|||
|
private SerializedProperty cpiviveRoleTypeProp;
|
|||
|
private SerializedProperty cpivivePositiveInputRoleIdProp;
|
|||
|
private SerializedProperty cpiviveNegativeInputRoleIdProp;
|
|||
|
private SerializedProperty cpivivePositiveInputCtrlProp;
|
|||
|
private SerializedProperty cpiviveNegativeInputCtrlProp;
|
|||
|
#endif
|
|||
|
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
private SerializedProperty cpixrPositiveInputActionMapIdProp;
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_UIS || SSC_REWIRED || VIU_PLUGIN
|
|||
|
private SerializedProperty cpiIsButtonEnabledProp;
|
|||
|
#endif
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Events
|
|||
|
|
|||
|
public void OnEnable()
|
|||
|
{
|
|||
|
isRefreshing = true;
|
|||
|
playerInputModule = (PlayerInputModule)target;
|
|||
|
|
|||
|
defaultEditorLabelWidth = 160f;
|
|||
|
defaultEditorFieldWidth = EditorGUIUtility.fieldWidth;
|
|||
|
|
|||
|
// Initialise properties
|
|||
|
|
|||
|
#region Find Properties - General
|
|||
|
|
|||
|
inputModeProp = serializedObject.FindProperty("inputMode");
|
|||
|
initialiseOnAwakeProp = serializedObject.FindProperty("initialiseOnAwake");
|
|||
|
isEnabledOnInitialiseProp = serializedObject.FindProperty("isEnabledOnInitialise");
|
|||
|
isCustomInputsOnlyOnInitialiseProp = serializedObject.FindProperty("isCustomInputsOnlyOnInitialise");
|
|||
|
isAutoCruiseEnabledProp = serializedObject.FindProperty("isAutoCruiseEnabled");
|
|||
|
horizontalShowInEditorProp = serializedObject.FindProperty("horizontalShowInEditor");
|
|||
|
verticalShowInEditorProp = serializedObject.FindProperty("verticalShowInEditor");
|
|||
|
longitudinalShowInEditorProp = serializedObject.FindProperty("longitudinalShowInEditor");
|
|||
|
pitchShowInEditorProp = serializedObject.FindProperty("pitchShowInEditor");
|
|||
|
yawShowInEditorProp = serializedObject.FindProperty("yawShowInEditor");
|
|||
|
rollShowInEditorProp = serializedObject.FindProperty("rollShowInEditor");
|
|||
|
primaryFireShowInEditorProp = serializedObject.FindProperty("primaryFireShowInEditor");
|
|||
|
secondaryFireShowInEditorProp = serializedObject.FindProperty("secondaryFireShowInEditor");
|
|||
|
dockingShowInEditorProp = serializedObject.FindProperty("dockingShowInEditor");
|
|||
|
rumbleShowInEditorProp = serializedObject.FindProperty("rumbleShowInEditor");
|
|||
|
primaryFireCanBeHeldProp = serializedObject.FindProperty("primaryFireCanBeHeld");
|
|||
|
secondaryFireCanBeHeldProp = serializedObject.FindProperty("secondaryFireCanBeHeld");
|
|||
|
maxRumble1Prop = serializedObject.FindProperty("maxRumble1");
|
|||
|
maxRumble2Prop = serializedObject.FindProperty("maxRumble2");
|
|||
|
|
|||
|
// Keep compiler happy for inputModes that don't support Rumble
|
|||
|
if (rumbleShowInEditorProp.boolValue) { }
|
|||
|
if (maxRumble1Prop.floatValue > 0f || maxRumble2Prop.floatValue > 0f) { }
|
|||
|
if (rumbleHeaderContent != null && maxRumble1Content != null || maxRumble2Content != null) { }
|
|||
|
|
|||
|
isSensitivityForHorizontalEnabledProp = serializedObject.FindProperty("isSensitivityForHorizontalEnabled");
|
|||
|
isSensitivityForVerticalEnabledProp = serializedObject.FindProperty("isSensitivityForVerticalEnabled");
|
|||
|
isSensitivityForLongitudinalEnabledProp = serializedObject.FindProperty("isSensitivityForLongitudinalEnabled");
|
|||
|
isSensitivityForPitchEnabledProp = serializedObject.FindProperty("isSensitivityForPitchEnabled");
|
|||
|
isSensitivityForYawEnabledProp = serializedObject.FindProperty("isSensitivityForYawEnabled");
|
|||
|
isSensitivityForRollEnabledProp = serializedObject.FindProperty("isSensitivityForRollEnabled");
|
|||
|
|
|||
|
horizontalAxisSensitivityProp = serializedObject.FindProperty("horizontalAxisSensitivity");
|
|||
|
verticalAxisSensitivityProp = serializedObject.FindProperty("verticalAxisSensitivity");
|
|||
|
longitudinalAxisSensitivityProp = serializedObject.FindProperty("longitudinalAxisSensitivity");
|
|||
|
pitchAxisSensitivityProp = serializedObject.FindProperty("pitchAxisSensitivity");
|
|||
|
yawAxisSensitivityProp = serializedObject.FindProperty("yawAxisSensitivity");
|
|||
|
rollAxisSensitivityProp = serializedObject.FindProperty("rollAxisSensitivity");
|
|||
|
|
|||
|
horizontalAxisGravityProp = serializedObject.FindProperty("horizontalAxisGravity");
|
|||
|
verticalAxisGravityProp = serializedObject.FindProperty("verticalAxisGravity");
|
|||
|
longitudinalAxisGravityProp = serializedObject.FindProperty("longitudinalAxisGravity");
|
|||
|
pitchAxisGravityProp = serializedObject.FindProperty("pitchAxisGravity");
|
|||
|
yawAxisGravityProp = serializedObject.FindProperty("yawAxisGravity");
|
|||
|
rollAxisGravityProp = serializedObject.FindProperty("rollAxisGravity");
|
|||
|
|
|||
|
isHorizontalDataDiscardedProp = serializedObject.FindProperty("isHorizontalDataDiscarded");
|
|||
|
isVerticalDataDiscardedProp = serializedObject.FindProperty("isVerticalDataDiscarded");
|
|||
|
isLongitudinalDataDiscardedProp = serializedObject.FindProperty("isLongitudinalDataDiscarded");
|
|||
|
isPitchDataDiscardedProp = serializedObject.FindProperty("isPitchDataDiscarded");
|
|||
|
isYawDataDiscardedProp = serializedObject.FindProperty("isYawDataDiscarded");
|
|||
|
isRollDataDiscardedProp = serializedObject.FindProperty("isRollDataDiscarded");
|
|||
|
isPrimaryFireDataDiscardedProp = serializedObject.FindProperty("isPrimaryFireDataDiscarded");
|
|||
|
isSecondaryFireDataDiscardedProp = serializedObject.FindProperty("isSecondaryFireDataDiscarded");
|
|||
|
isDockDataDiscardedProp = serializedObject.FindProperty("isDockDataDiscarded");
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - keyboard
|
|||
|
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
horizontalInputPositiveKeycodeProp = serializedObject.FindProperty("horizontalInputPositiveKeycode");
|
|||
|
horizontalInputNegativeKeycodeProp = serializedObject.FindProperty("horizontalInputNegativeKeycode");
|
|||
|
verticalInputPositiveKeycodeProp = serializedObject.FindProperty("verticalInputPositiveKeycode");
|
|||
|
verticalInputNegativeKeycodeProp = serializedObject.FindProperty("verticalInputNegativeKeycode");
|
|||
|
longitudinalInputPositiveKeycodeProp = serializedObject.FindProperty("longitudinalInputPositiveKeycode");
|
|||
|
longitudinalInputNegativeKeycodeProp = serializedObject.FindProperty("longitudinalInputNegativeKeycode");
|
|||
|
pitchInputPositiveKeycodeProp = serializedObject.FindProperty("pitchInputPositiveKeycode");
|
|||
|
pitchInputNegativeKeycodeProp = serializedObject.FindProperty("pitchInputNegativeKeycode");
|
|||
|
yawInputPositiveKeycodeProp = serializedObject.FindProperty("yawInputPositiveKeycode");
|
|||
|
yawInputNegativeKeycodeProp = serializedObject.FindProperty("yawInputNegativeKeycode");
|
|||
|
rollInputPositiveKeycodeProp = serializedObject.FindProperty("rollInputPositiveKeycode");
|
|||
|
rollInputNegativeKeycodeProp = serializedObject.FindProperty("rollInputNegativeKeycode");
|
|||
|
primaryFireInputKeycodeProp = serializedObject.FindProperty("primaryFireKeycode");
|
|||
|
secondaryFireInputKeycodeProp = serializedObject.FindProperty("secondaryFireKeycode");
|
|||
|
dockingInputKeycodeProp = serializedObject.FindProperty("dockingKeycode");
|
|||
|
|
|||
|
isMouseForPitchEnabledDKIProp = serializedObject.FindProperty("isMouseForPitchEnabledDKI");
|
|||
|
isMouseForYawEnabledDKIProp = serializedObject.FindProperty("isMouseForYawEnabledDKI");
|
|||
|
|
|||
|
pitchSensitivityDKIProp = serializedObject.FindProperty("pitchSensitivityDKI");
|
|||
|
yawSensitivityDKIProp = serializedObject.FindProperty("yawSensitivityDKI");
|
|||
|
pitchDeadzoneDKIProp = serializedObject.FindProperty("pitchDeadzoneDKI");
|
|||
|
yawDeadzoneDKIProp = serializedObject.FindProperty("yawDeadzoneDKI");
|
|||
|
#endif
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - Shared (Legacy Input, Unity Input System, Rewired)
|
|||
|
horizontalInputAxisModeProp = serializedObject.FindProperty("horizontalInputAxisMode");
|
|||
|
verticalInputAxisModeProp = serializedObject.FindProperty("verticalInputAxisMode");
|
|||
|
longitudinalInputAxisModeProp = serializedObject.FindProperty("longitudinalInputAxisMode");
|
|||
|
pitchInputAxisModeProp = serializedObject.FindProperty("pitchInputAxisMode");
|
|||
|
yawInputAxisModeProp = serializedObject.FindProperty("yawInputAxisMode");
|
|||
|
rollInputAxisModeProp = serializedObject.FindProperty("rollInputAxisMode");
|
|||
|
#endregion Find Properties - Shared (Legacy Input, Unity Input System, Rewired)
|
|||
|
|
|||
|
#region Find Properties - Shared (Legacy Unity Input System, New Input System)
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || SSC_UIS
|
|||
|
invertHorizontalInputAxisProp = serializedObject.FindProperty("invertHorizontalInputAxis");
|
|||
|
invertVerticalInputAxisProp = serializedObject.FindProperty("invertVerticalInputAxis");
|
|||
|
invertLongitudinalInputAxisProp = serializedObject.FindProperty("invertLongitudinalInputAxis");
|
|||
|
invertPitchInputAxisProp = serializedObject.FindProperty("invertPitchInputAxis");
|
|||
|
invertYawInputAxisProp = serializedObject.FindProperty("invertYawInputAxis");
|
|||
|
invertRollInputAxisProp = serializedObject.FindProperty("invertRollInputAxis");
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - Legacy Input system
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
positiveHorizontalInputAxisNameProp = serializedObject.FindProperty("positiveHorizontalInputAxisName");
|
|||
|
negativeHorizontalInputAxisNameProp = serializedObject.FindProperty("negativeHorizontalInputAxisName");
|
|||
|
positiveVerticalInputAxisNameProp = serializedObject.FindProperty("positiveVerticalInputAxisName");
|
|||
|
negativeVerticalInputAxisNameProp = serializedObject.FindProperty("negativeVerticalInputAxisName");
|
|||
|
positiveLongitudinalInputAxisNameProp = serializedObject.FindProperty("positiveLongitudinalInputAxisName");
|
|||
|
negativeLongitudinalInputAxisNameProp = serializedObject.FindProperty("negativeLongitudinalInputAxisName");
|
|||
|
positivePitchInputAxisNameProp = serializedObject.FindProperty("positivePitchInputAxisName");
|
|||
|
negativePitchInputAxisNameProp = serializedObject.FindProperty("negativePitchInputAxisName");
|
|||
|
positiveYawInputAxisNameProp = serializedObject.FindProperty("positiveYawInputAxisName");
|
|||
|
negativeYawInputAxisNameProp = serializedObject.FindProperty("negativeYawInputAxisName");
|
|||
|
positiveRollInputAxisNameProp = serializedObject.FindProperty("positiveRollInputAxisName");
|
|||
|
negativeRollInputAxisNameProp = serializedObject.FindProperty("negativeRollInputAxisName");
|
|||
|
primaryFireInputAxisNameProp = serializedObject.FindProperty("primaryFireInputAxisName");
|
|||
|
secondaryFireInputAxisNameProp = serializedObject.FindProperty("secondaryFireInputAxisName");
|
|||
|
dockingInputAxisNameProp = serializedObject.FindProperty("dockingInputAxisName");
|
|||
|
isPositiveHorizontalInputAxisValidProp = serializedObject.FindProperty("isPositiveHorizontalInputAxisValid");
|
|||
|
isNegativeHorizontalInputAxisValidProp = serializedObject.FindProperty("isNegativeHorizontalInputAxisValid");
|
|||
|
isPositiveVerticalInputAxisValidProp = serializedObject.FindProperty("isPositiveVerticalInputAxisValid");
|
|||
|
isNegativeVerticalInputAxisValidProp = serializedObject.FindProperty("isNegativeVerticalInputAxisValid");
|
|||
|
isPositiveLongitudinalInputAxisValidProp = serializedObject.FindProperty("isPositiveLongitudinalInputAxisValid");
|
|||
|
isNegativeLongitudinalInputAxisValidProp = serializedObject.FindProperty("isNegativeLongitudinalInputAxisValid");
|
|||
|
isPositivePitchInputAxisValidProp = serializedObject.FindProperty("isPositivePitchInputAxisValid");
|
|||
|
isNegativePitchInputAxisValidProp = serializedObject.FindProperty("isNegativePitchInputAxisValid");
|
|||
|
isPositiveYawInputAxisValidProp = serializedObject.FindProperty("isPositiveYawInputAxisValid");
|
|||
|
isNegativeYawInputAxisValidProp = serializedObject.FindProperty("isNegativeYawInputAxisValid");
|
|||
|
isPositiveRollInputAxisValidProp = serializedObject.FindProperty("isPositiveRollInputAxisValid");
|
|||
|
isNegativeRollInputAxisValidProp = serializedObject.FindProperty("isNegativeRollInputAxisValid");
|
|||
|
isPrimaryFireInputAxisValidProp = serializedObject.FindProperty("isPrimaryFireInputAxisValid");
|
|||
|
isSecondaryFireInputAxisValidProp = serializedObject.FindProperty("isSecondaryFireInputAxisValid");
|
|||
|
isDockingInputAxisValidProp = serializedObject.FindProperty("isDockingInputAxisValid");
|
|||
|
|
|||
|
isMouseForPitchEnabledLISProp = serializedObject.FindProperty("isMouseForPitchEnabledLIS");
|
|||
|
isMouseForYawEnabledLISProp = serializedObject.FindProperty("isMouseForYawEnabledLIS");
|
|||
|
|
|||
|
pitchSensitivityLISProp = serializedObject.FindProperty("pitchSensitivityLIS");
|
|||
|
yawSensitivityLISProp = serializedObject.FindProperty("yawSensitivityLIS");
|
|||
|
pitchDeadzoneLISProp = serializedObject.FindProperty("pitchDeadzoneLIS");
|
|||
|
yawDeadzoneLISProp = serializedObject.FindProperty("yawDeadzoneLIS");
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - Unity Input System (from Package Manager)
|
|||
|
#if SSC_UIS
|
|||
|
positiveHorizontalInputActionIdUISProp = serializedObject.FindProperty("positiveHorizontalInputActionIdUIS");
|
|||
|
positiveVerticalInputActionIdUISProp = serializedObject.FindProperty("positiveVerticalInputActionIdUIS");
|
|||
|
positiveLongitudinalInputActionIdUISProp = serializedObject.FindProperty("positiveLongitudinalInputActionIdUIS");
|
|||
|
positivePitchInputActionIdUISProp = serializedObject.FindProperty("positivePitchInputActionIdUIS");
|
|||
|
positiveYawInputActionIdUISProp = serializedObject.FindProperty("positiveYawInputActionIdUIS");
|
|||
|
positiveRollInputActionIdUISProp = serializedObject.FindProperty("positiveRollInputActionIdUIS");
|
|||
|
primaryFireInputActionIdUISProp = serializedObject.FindProperty("primaryFireInputActionIdUIS");
|
|||
|
secondaryFireInputActionIdUISProp = serializedObject.FindProperty("secondaryFireInputActionIdUIS");
|
|||
|
dockingInputActionIdUISProp = serializedObject.FindProperty("dockingInputActionIdUIS");
|
|||
|
|
|||
|
isMouseForPitchEnabledUISProp = serializedObject.FindProperty("isMouseForPitchEnabledUIS");
|
|||
|
isMouseForYawEnabledUISProp = serializedObject.FindProperty("isMouseForYawEnabledUIS");
|
|||
|
|
|||
|
pitchSensitivityUISProp = serializedObject.FindProperty("pitchSensitivityUIS");
|
|||
|
yawSensitivityUISProp = serializedObject.FindProperty("yawSensitivityUIS");
|
|||
|
pitchDeadzoneUISProp = serializedObject.FindProperty("pitchDeadzoneUIS");
|
|||
|
yawDeadzoneUISProp = serializedObject.FindProperty("yawDeadzoneUIS");
|
|||
|
|
|||
|
positiveHorizontalInputActionDataSlotUISProp = serializedObject.FindProperty("positiveHorizontalInputActionDataSlotUIS");
|
|||
|
positiveVerticalInputActionDataSlotUISProp = serializedObject.FindProperty("positiveVerticalInputActionDataSlotUIS");
|
|||
|
positiveLongitudinalInputActionDataSlotUISProp = serializedObject.FindProperty("positiveLongitudinalInputActionDataSlotUIS");
|
|||
|
positivePitchInputActionDataSlotUISProp = serializedObject.FindProperty("positivePitchInputActionDataSlotUIS");
|
|||
|
positiveYawInputActionDataSlotUISProp = serializedObject.FindProperty("positiveYawInputActionDataSlotUIS");
|
|||
|
positiveRollInputActionDataSlotUISProp = serializedObject.FindProperty("positiveRollInputActionDataSlotUIS");
|
|||
|
primaryFireInputActionDataSlotUISProp = serializedObject.FindProperty("primaryFireInputActionDataSlotUIS");
|
|||
|
secondaryFireInputActionDataSlotUISProp = serializedObject.FindProperty("secondaryFireInputActionDataSlotUIS");
|
|||
|
dockingInputActionDataSlotUISProp = serializedObject.FindProperty("dockingInputActionDataSlotUIS");
|
|||
|
|
|||
|
onscreenControlsShowInEditorProp = serializedObject.FindProperty("onscreenControlsShowInEditor");
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - Oculus API
|
|||
|
#if SSC_OVR
|
|||
|
isOVRInputUpdatedIfRequiredProp = serializedObject.FindProperty("isOVRInputUpdatedIfRequired");
|
|||
|
|
|||
|
ovrHorizontalInputTypeProp = serializedObject.FindProperty("ovrHorizontalInputType");
|
|||
|
ovrVerticalInputTypeProp = serializedObject.FindProperty("ovrVerticalInputType");
|
|||
|
ovrLongitudinalInputTypeProp = serializedObject.FindProperty("ovrLongitudinalInputType");
|
|||
|
ovrPitchInputTypeProp = serializedObject.FindProperty("ovrPitchInputType");
|
|||
|
ovrYawInputTypeProp = serializedObject.FindProperty("ovrYawInputType");
|
|||
|
ovrRollInputTypeProp = serializedObject.FindProperty("ovrRollInputType");
|
|||
|
|
|||
|
positiveHorizontalInputOVRProp = serializedObject.FindProperty("positiveHorizontalInputOVR");
|
|||
|
negativeHorizontalInputOVRProp = serializedObject.FindProperty("negativeHorizontalInputOVR");
|
|||
|
positiveVerticalInputOVRProp = serializedObject.FindProperty("positiveVerticalInputOVR");
|
|||
|
negativeVerticalInputOVRProp = serializedObject.FindProperty("negativeVerticalInputOVR");
|
|||
|
positiveLongitudinalInputOVRProp = serializedObject.FindProperty("positiveLongitudinalInputOVR");
|
|||
|
negativeLongitudinalInputOVRProp = serializedObject.FindProperty("negativeLongitudinalInputOVR");
|
|||
|
positivePitchInputOVRProp = serializedObject.FindProperty("positivePitchInputOVR");
|
|||
|
negativePitchInputOVRProp = serializedObject.FindProperty("negativePitchInputOVR");
|
|||
|
positiveYawInputOVRProp = serializedObject.FindProperty("positiveYawInputOVR");
|
|||
|
negativeYawInputOVRProp = serializedObject.FindProperty("negativeYawInputOVR");
|
|||
|
positiveRollInputOVRProp = serializedObject.FindProperty("positiveRollInputOVR");
|
|||
|
negativeRollInputOVRProp = serializedObject.FindProperty("negativeRollInputOVR");
|
|||
|
primaryFireInputOVRProp = serializedObject.FindProperty("primaryFireInputOVR");
|
|||
|
secondaryFireInputOVRProp = serializedObject.FindProperty("secondaryFireInputOVR");
|
|||
|
dockingInputOVRProp = serializedObject.FindProperty("dockingInputOVR");
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - Rewired
|
|||
|
#if SSC_REWIRED
|
|||
|
rewiredPlayerNumberProp = serializedObject.FindProperty("rewiredPlayerNumber");
|
|||
|
positiveHorizontalInputActionIdProp = serializedObject.FindProperty("positiveHorizontalInputActionId");
|
|||
|
negativeHorizontalInputActionIdProp = serializedObject.FindProperty("negativeHorizontalInputActionId");
|
|||
|
positiveVerticalInputActionIdProp = serializedObject.FindProperty("positiveVerticalInputActionId");
|
|||
|
negativeVerticalInputActionIdProp = serializedObject.FindProperty("negativeVerticalInputActionId");
|
|||
|
positiveLongitudinalInputActionIdProp = serializedObject.FindProperty("positiveLongitudinalInputActionId");
|
|||
|
negativeLongitudinalInputActionIdProp = serializedObject.FindProperty("negativeLongitudinalInputActionId");
|
|||
|
positivePitchInputActionIdProp = serializedObject.FindProperty("positivePitchInputActionId");
|
|||
|
negativePitchInputActionIdProp = serializedObject.FindProperty("negativePitchInputActionId");
|
|||
|
positiveYawInputActionIdProp = serializedObject.FindProperty("positiveYawInputActionId");
|
|||
|
negativeYawInputActionIdProp = serializedObject.FindProperty("negativeYawInputActionId");
|
|||
|
positiveRollInputActionIdProp = serializedObject.FindProperty("positiveRollInputActionId");
|
|||
|
negativeRollInputActionIdProp = serializedObject.FindProperty("negativeRollInputActionId");
|
|||
|
primaryFireInputActionIdProp = serializedObject.FindProperty("primaryFireInputActionId");
|
|||
|
secondaryFireInputActionIdProp = serializedObject.FindProperty("secondaryFireInputActionId");
|
|||
|
dockingInputActionIdProp = serializedObject.FindProperty("dockingInputActionId");
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - Vive
|
|||
|
#if VIU_PLUGIN
|
|||
|
viveHorizontalInputTypeProp = serializedObject.FindProperty("viveHorizontalInputType");
|
|||
|
viveVerticalInputTypeProp = serializedObject.FindProperty("viveVerticalInputType");
|
|||
|
viveLongitudinalInputTypeProp = serializedObject.FindProperty("viveLongitudinalInputType");
|
|||
|
vivePitchInputTypeProp = serializedObject.FindProperty("vivePitchInputType");
|
|||
|
viveYawInputTypeProp = serializedObject.FindProperty("viveYawInputType");
|
|||
|
viveRollInputTypeProp = serializedObject.FindProperty("viveRollInputType");
|
|||
|
viveHorizontalRoleTypeProp = serializedObject.FindProperty("viveHorizontalRoleType");
|
|||
|
viveVerticalRoleTypeProp = serializedObject.FindProperty("viveVerticalRoleType");
|
|||
|
viveLongitudinalRoleTypeProp = serializedObject.FindProperty("viveLongitudinalRoleType");
|
|||
|
vivePitchRoleTypeProp = serializedObject.FindProperty("vivePitchRoleType");
|
|||
|
viveYawRoleTypeProp = serializedObject.FindProperty("viveYawRoleType");
|
|||
|
viveRollRoleTypeProp = serializedObject.FindProperty("viveRollRoleType");
|
|||
|
vivePrimaryFireRoleTypeProp = serializedObject.FindProperty("vivePrimaryFireRoleType");
|
|||
|
viveSecondaryFireRoleTypeProp = serializedObject.FindProperty("viveSecondaryFireRoleType");
|
|||
|
viveDockingRoleTypeProp = serializedObject.FindProperty("viveDockingRoleType");
|
|||
|
|
|||
|
positiveHorizontalInputRoleIdProp = serializedObject.FindProperty("positiveHorizontalInputRoleId");
|
|||
|
negativeHorizontalInputRoleIdProp = serializedObject.FindProperty("negativeHorizontalInputRoleId");
|
|||
|
positiveVerticalInputRoleIdProp = serializedObject.FindProperty("positiveVerticalInputRoleId");
|
|||
|
negativeVerticalInputRoleIdProp = serializedObject.FindProperty("negativeVerticalInputRoleId");
|
|||
|
positiveLongitudinalInputRoleIdProp = serializedObject.FindProperty("positiveLongitudinalInputRoleId");
|
|||
|
negativeLongitudinalInputRoleIdProp = serializedObject.FindProperty("negativeLongitudinalInputRoleId");
|
|||
|
positivePitchInputRoleIdProp = serializedObject.FindProperty("positivePitchInputRoleId");
|
|||
|
negativePitchInputRoleIdProp = serializedObject.FindProperty("negativePitchInputRoleId");
|
|||
|
positiveYawInputRoleIdProp = serializedObject.FindProperty("positiveYawInputRoleId");
|
|||
|
negativeYawInputRoleIdProp = serializedObject.FindProperty("negativeYawInputRoleId");
|
|||
|
positiveRollInputRoleIdProp = serializedObject.FindProperty("positiveRollInputRoleId");
|
|||
|
negativeRollInputRoleIdProp = serializedObject.FindProperty("negativeRollInputRoleId");
|
|||
|
primaryFireInputRoleIdProp = serializedObject.FindProperty("primaryFireInputRoleId");
|
|||
|
secondaryFireInputRoleIdProp = serializedObject.FindProperty("secondaryFireInputRoleId");
|
|||
|
dockingInputRoleIdProp = serializedObject.FindProperty("dockingInputRoleId");
|
|||
|
|
|||
|
positiveHorizontalInputCtrlViveProp = serializedObject.FindProperty("positiveHorizontalInputCtrlVive");
|
|||
|
negativeHorizontalInputCtrlViveProp = serializedObject.FindProperty("negativeHorizontalInputCtrlVive");
|
|||
|
positiveVerticalInputCtrlViveProp = serializedObject.FindProperty("positiveVerticalInputCtrlVive");
|
|||
|
negativeVerticalInputCtrlViveProp = serializedObject.FindProperty("negativeVerticalInputCtrlVive");
|
|||
|
positiveLongitudinalInputCtrlViveProp = serializedObject.FindProperty("positiveLongitudinalInputCtrlVive");
|
|||
|
negativeLongitudinalInputCtrlViveProp = serializedObject.FindProperty("negativeLongitudinalInputCtrlVive");
|
|||
|
positivePitchInputCtrlViveProp = serializedObject.FindProperty("positivePitchInputCtrlVive");
|
|||
|
negativePitchInputCtrlViveProp = serializedObject.FindProperty("negativePitchInputCtrlVive");
|
|||
|
positiveYawInputCtrlViveProp = serializedObject.FindProperty("positiveYawInputCtrlVive");
|
|||
|
negativeYawInputCtrlViveProp = serializedObject.FindProperty("negativeYawInputCtrlVive");
|
|||
|
positiveRollInputCtrlViveProp = serializedObject.FindProperty("positiveRollInputCtrlVive");
|
|||
|
negativeRollInputCtrlViveProp = serializedObject.FindProperty("negativeRollInputCtrlVive");
|
|||
|
primaryFireInputCtrlViveProp = serializedObject.FindProperty("primaryFireInputCtrlVive");
|
|||
|
secondaryFireInputCtrlViveProp = serializedObject.FindProperty("secondaryFireInputCtrlVive");
|
|||
|
dockingInputCtrlViveProp = serializedObject.FindProperty("dockingInputCtrlVive");
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - XR
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
inputActionAssetXRProp = serializedObject.FindProperty("inputActionAssetXR");
|
|||
|
firstPersonTransform1XRProp = serializedObject.FindProperty("firstPersonTransform1XR");
|
|||
|
firstPersonCamera1XRProp = serializedObject.FindProperty("firstPersonCamera1XR");
|
|||
|
leftHandTransformXRProp = serializedObject.FindProperty("leftHandTransformXR");
|
|||
|
rightHandTransformXRProp = serializedObject.FindProperty("rightHandTransformXR");
|
|||
|
|
|||
|
positiveHorizontalInputActionMapIdXRProp = serializedObject.FindProperty("positiveHorizontalInputActionMapIdXR");
|
|||
|
positiveVerticalInputActionMapIdXRProp = serializedObject.FindProperty("positiveVerticalInputActionMapIdXR");
|
|||
|
positiveLongitudinalInputActionMapIdXRProp = serializedObject.FindProperty("positiveLongitudinalInputActionMapIdXR");
|
|||
|
positivePitchInputActionMapIdXRProp = serializedObject.FindProperty("positivePitchInputActionMapIdXR");
|
|||
|
positiveYawInputActionMapIdXRProp = serializedObject.FindProperty("positiveYawInputActionMapIdXR");
|
|||
|
positiveRollInputActionMapIdXRProp = serializedObject.FindProperty("positiveRollInputActionMapIdXR");
|
|||
|
primaryFireInputActionMapIdXRProp = serializedObject.FindProperty("primaryFireInputActionMapIdXR");
|
|||
|
secondaryFireInputActionMapIdXRProp = serializedObject.FindProperty("secondaryFireInputActionMapIdXR");
|
|||
|
dockingInputActionMapIdXRProp = serializedObject.FindProperty("dockingInputActionMapIdXR");
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Find Properties - Oculus or Vive or Rewired or Unity Input System
|
|||
|
#if SSC_OVR || SSC_REWIRED || VIU_PLUGIN || SSC_UIS
|
|||
|
primaryFireButtonEnabledProp = serializedObject.FindProperty("primaryFireButtonEnabled");
|
|||
|
secondaryFireButtonEnabledProp = serializedObject.FindProperty("secondaryFireButtonEnabled");
|
|||
|
dockingButtonEnabledProp = serializedObject.FindProperty("dockingButtonEnabled");
|
|||
|
#endif
|
|||
|
#endregion SerializedProperties - Oculus or Vive or Rewired
|
|||
|
|
|||
|
#region Properties - Custom Player Input
|
|||
|
cpiListProp = serializedObject.FindProperty("customPlayerInputList");
|
|||
|
cpiShowInEditorProp = serializedObject.FindProperty("customPlayerInputsShowInEditor");
|
|||
|
cpiIsListExpandedProp = serializedObject.FindProperty("isCustomPlayerInputListExpanded");
|
|||
|
#endregion
|
|||
|
|
|||
|
playerInputModule.ValidateLegacyInput();
|
|||
|
|
|||
|
#if SSC_OVR
|
|||
|
// Get once
|
|||
|
ovrPluginVersion = OVRPlugin.version.ToString();
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_UIS
|
|||
|
uisPlayerInput = playerInputModule.GetUISPlayerInput();
|
|||
|
uisVersion = SSCSetup.GetPackageVersion("Packages/com.unity.inputsystem/package.json");
|
|||
|
UISRefreshActions();
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_REWIRED
|
|||
|
FindRewiredInputManager();
|
|||
|
// Populate arrays for rewired input options
|
|||
|
RWRefreshActionCategories();
|
|||
|
RWRefreshActionsAll();
|
|||
|
#endif
|
|||
|
|
|||
|
#if VIU_PLUGIN
|
|||
|
// Get once
|
|||
|
viveVersion = VIUVersion.current.ToString();
|
|||
|
#endif
|
|||
|
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
xrVersion = SSCSetup.GetPackageVersion("Packages/com.unity.xr.management/package.json");
|
|||
|
openXRVersion = SSCSetup.GetPackageVersion("Packages/com.unity.xr.openxr/package.json");
|
|||
|
oculusXRVersion = SSCSetup.GetPackageVersion("Packages/com.unity.xr.oculus/package.json");
|
|||
|
if (playerInputModule.inputMode == PlayerInputModule.InputMode.UnityXR)
|
|||
|
{
|
|||
|
XRRefreshActionMaps();
|
|||
|
xrForceActionRefresh = true;
|
|||
|
}
|
|||
|
#endif
|
|||
|
|
|||
|
// Get a reference to the ShipInput class instance used
|
|||
|
// to set data to the ShipControlModule. Used for debugging
|
|||
|
shipInput = playerInputModule.GetShipInput;
|
|||
|
|
|||
|
shipControlModule = playerInputModule.GetComponent<ShipControlModule>();
|
|||
|
|
|||
|
isRefreshing = false;
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Called when the gameobject loses focus or Unity Editor enters/exits
|
|||
|
/// play mode
|
|||
|
/// </summary>
|
|||
|
void OnDestroy()
|
|||
|
{
|
|||
|
//#if UNITY_2019_1_OR_NEWER
|
|||
|
//SceneView.duringSceneGui -= SceneGUI;
|
|||
|
//#else
|
|||
|
//SceneView.onSceneGUIDelegate -= SceneGUI;
|
|||
|
//#endif
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Gets called automatically 10 times per second
|
|||
|
/// Comment out if not required
|
|||
|
/// </summary>
|
|||
|
void OnInspectorUpdate()
|
|||
|
{
|
|||
|
// OnInspectorGUI() only registers events when the mouse is positioned over the custom editor window
|
|||
|
// This code forces OnInspectorGUI() to run every frame, so it registers events even when the mouse
|
|||
|
// is positioned over the scene view
|
|||
|
if (playerInputModule.allowRepaint) { Repaint(); }
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region OnInspectorGUI
|
|||
|
// This function overides what is normally seen in the inspector window
|
|||
|
// This allows stuff like buttons to be drawn there
|
|||
|
public override void OnInspectorGUI()
|
|||
|
{
|
|||
|
#region Initialise
|
|||
|
|
|||
|
playerInputModule.allowRepaint = false;
|
|||
|
|
|||
|
EditorGUIUtility.labelWidth = defaultEditorLabelWidth;
|
|||
|
EditorGUIUtility.fieldWidth = defaultEditorFieldWidth;
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Configure Buttons and Styles
|
|||
|
|
|||
|
// Set up rich text GUIStyles
|
|||
|
if (!isStylesInitialised)
|
|||
|
{
|
|||
|
helpBoxRichText = new GUIStyle("HelpBox");
|
|||
|
helpBoxRichText.richText = true;
|
|||
|
|
|||
|
labelFieldRichText = new GUIStyle("Label");
|
|||
|
labelFieldRichText.richText = true;
|
|||
|
|
|||
|
headingFieldRichText = new GUIStyle(UnityEditor.EditorStyles.miniLabel);
|
|||
|
headingFieldRichText.richText = true;
|
|||
|
headingFieldRichText.normal.textColor = helpBoxRichText.normal.textColor;
|
|||
|
|
|||
|
// Overide default styles
|
|||
|
EditorStyles.foldout.fontStyle = FontStyle.Bold;
|
|||
|
|
|||
|
// When using a no-label foldout, don't forget to set the global
|
|||
|
// EditorGUIUtility.fieldWidth to a small value like 15, then back
|
|||
|
// to the original afterward.
|
|||
|
foldoutStyleNoLabel = new GUIStyle(EditorStyles.foldout);
|
|||
|
foldoutStyleNoLabel.fixedWidth = 0.01f;
|
|||
|
|
|||
|
buttonCompact = new GUIStyle("Button");
|
|||
|
buttonCompact.fontSize = 10;
|
|||
|
|
|||
|
isStylesInitialised = true;
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
// Read in all the properties
|
|||
|
serializedObject.Update();
|
|||
|
|
|||
|
EditorGUILayout.LabelField(headerContent, helpBoxRichText);
|
|||
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(initialiseOnAwakeProp, initialiseOnAwakeContent);
|
|||
|
EditorGUILayout.PropertyField(isEnabledOnInitialiseProp, isEnabledOnInitialiseContent);
|
|||
|
if (isEnabledOnInitialiseProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isCustomInputsOnlyOnInitialiseProp, isCustomInputsOnlyOnInitialiseContent);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(inputModeProp, inputModeContent, GUILayout.MaxWidth(300f));
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.UnityXR)
|
|||
|
{
|
|||
|
xrForceActionRefresh = true;
|
|||
|
XRRefreshActionMaps();
|
|||
|
}
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.UnityInputSystem)
|
|||
|
{
|
|||
|
UISRefreshActions();
|
|||
|
}
|
|||
|
#endif
|
|||
|
}
|
|||
|
|
|||
|
if (isAutoCruiseEnabledProp.boolValue && shipControlModule != null && shipControlModule.shipInstance != null && shipControlModule.shipInstance.brakeFlightAssistStrength > 0f)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(brakeAssistWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(isAutoCruiseEnabledProp, isAutoCruiseEnabledContent);
|
|||
|
|
|||
|
#region Direct Keyboard Input
|
|||
|
|
|||
|
if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.DirectKeyboard)
|
|||
|
{
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
#region Direct Keyboard Horizontal input
|
|||
|
DrawFoldoutWithLabel(horizontalShowInEditorProp, horizontalHeaderContent);
|
|||
|
if (horizontalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(horizontalInputPositiveKeycodeProp, positiveKeycodeContent);
|
|||
|
EditorGUILayout.PropertyField(horizontalInputNegativeKeycodeProp, negativeKeycodeContent);
|
|||
|
if (horizontalInputPositiveKeycodeProp.intValue == horizontalInputNegativeKeycodeProp.intValue
|
|||
|
&& horizontalInputPositiveKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalKeycodesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
if (horizontalInputPositiveKeycodeProp.intValue != 0 || horizontalInputNegativeKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
VerifyThrusterPresent(PIMCategory.Horizontal);
|
|||
|
}
|
|||
|
|
|||
|
DrawSensitivity(horizontalInputPositiveKeycodeProp, horizontalInputNegativeKeycodeProp,
|
|||
|
isSensitivityForHorizontalEnabledProp, sensitivityEnabledContent,
|
|||
|
horizontalAxisSensitivityProp, sensitivityContent,
|
|||
|
horizontalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isHorizontalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Direct Keybaord Vertical input
|
|||
|
DrawFoldoutWithLabel(verticalShowInEditorProp, verticalHeaderContent);
|
|||
|
if (verticalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(verticalInputPositiveKeycodeProp, positiveKeycodeContent);
|
|||
|
EditorGUILayout.PropertyField(verticalInputNegativeKeycodeProp, negativeKeycodeContent);
|
|||
|
if (verticalInputPositiveKeycodeProp.intValue == verticalInputNegativeKeycodeProp.intValue
|
|||
|
&& verticalInputPositiveKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalKeycodesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
if (verticalInputPositiveKeycodeProp.intValue != 0 || verticalInputNegativeKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
VerifyThrusterPresent(PIMCategory.Vertical);
|
|||
|
}
|
|||
|
|
|||
|
DrawSensitivity(verticalInputPositiveKeycodeProp, verticalInputNegativeKeycodeProp,
|
|||
|
isSensitivityForVerticalEnabledProp, sensitivityEnabledContent,
|
|||
|
verticalAxisSensitivityProp, sensitivityContent,
|
|||
|
verticalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isVerticalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Direct keyboard Longitudinal input
|
|||
|
DrawFoldoutWithLabel(longitudinalShowInEditorProp, longitudinalHeaderContent);
|
|||
|
if (longitudinalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(longitudinalInputPositiveKeycodeProp, positiveKeycodeContent);
|
|||
|
EditorGUILayout.PropertyField(longitudinalInputNegativeKeycodeProp, negativeKeycodeContent);
|
|||
|
if (longitudinalInputPositiveKeycodeProp.intValue == longitudinalInputNegativeKeycodeProp.intValue
|
|||
|
&& longitudinalInputPositiveKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalKeycodesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
if (longitudinalInputPositiveKeycodeProp.intValue != 0 || longitudinalInputNegativeKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
VerifyThrusterPresent(PIMCategory.Longitidinal);
|
|||
|
}
|
|||
|
|
|||
|
DrawSensitivity(longitudinalInputPositiveKeycodeProp, longitudinalInputNegativeKeycodeProp,
|
|||
|
isSensitivityForLongitudinalEnabledProp, sensitivityEnabledContent,
|
|||
|
longitudinalAxisSensitivityProp, sensitivityContent,
|
|||
|
longitudinalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isLongitudinalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Direct Keyboard Pitch input
|
|||
|
DrawFoldoutWithLabel(pitchShowInEditorProp, pitchHeaderContent);
|
|||
|
if (pitchShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isMouseForPitchEnabledDKIProp, dkiPitchInputMouseContent);
|
|||
|
if (isMouseForPitchEnabledDKIProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(pitchSensitivityDKIProp, dkiPitchSensitivityContent);
|
|||
|
EditorGUILayout.PropertyField(pitchDeadzoneDKIProp, dkiPitchDeadzoneContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(pitchInputPositiveKeycodeProp, positiveKeycodeContent);
|
|||
|
EditorGUILayout.PropertyField(pitchInputNegativeKeycodeProp, negativeKeycodeContent);
|
|||
|
if (pitchInputPositiveKeycodeProp.intValue == pitchInputNegativeKeycodeProp.intValue
|
|||
|
&& pitchInputPositiveKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalKeycodesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
DrawSensitivity(pitchInputPositiveKeycodeProp, pitchInputNegativeKeycodeProp,
|
|||
|
isSensitivityForPitchEnabledProp, sensitivityEnabledContent,
|
|||
|
pitchAxisSensitivityProp, sensitivityContent,
|
|||
|
pitchAxisGravityProp, gravityContent);
|
|||
|
}
|
|||
|
DrawDiscardData(isPitchDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Direct Keyboard Yaw input
|
|||
|
DrawFoldoutWithLabel(yawShowInEditorProp, yawHeaderContent);
|
|||
|
if (yawShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isMouseForYawEnabledDKIProp, dkiYawInputMouseContent);
|
|||
|
if (isMouseForYawEnabledDKIProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(yawSensitivityDKIProp, dkiYawSensitivityContent);
|
|||
|
EditorGUILayout.PropertyField(yawDeadzoneDKIProp, dkiYawDeadzoneContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(yawInputPositiveKeycodeProp, positiveKeycodeContent);
|
|||
|
EditorGUILayout.PropertyField(yawInputNegativeKeycodeProp, negativeKeycodeContent);
|
|||
|
if (yawInputPositiveKeycodeProp.intValue == yawInputNegativeKeycodeProp.intValue
|
|||
|
&& yawInputPositiveKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalKeycodesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
DrawSensitivity(yawInputPositiveKeycodeProp, yawInputNegativeKeycodeProp,
|
|||
|
isSensitivityForYawEnabledProp, sensitivityEnabledContent,
|
|||
|
yawAxisSensitivityProp, sensitivityContent,
|
|||
|
yawAxisGravityProp, gravityContent);
|
|||
|
}
|
|||
|
DrawDiscardData(isYawDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Direct Keyboard Roll input
|
|||
|
DrawFoldoutWithLabel(rollShowInEditorProp, rollHeaderContent);
|
|||
|
if (rollShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(rollInputPositiveKeycodeProp, positiveKeycodeContent);
|
|||
|
EditorGUILayout.PropertyField(rollInputNegativeKeycodeProp, negativeKeycodeContent);
|
|||
|
if (rollInputPositiveKeycodeProp.intValue == rollInputNegativeKeycodeProp.intValue
|
|||
|
&& rollInputPositiveKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalKeycodesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
DrawSensitivity(rollInputPositiveKeycodeProp, rollInputNegativeKeycodeProp,
|
|||
|
isSensitivityForRollEnabledProp, sensitivityEnabledContent,
|
|||
|
rollAxisSensitivityProp, sensitivityContent,
|
|||
|
rollAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isRollDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Direct Keyboard Primary fire input
|
|||
|
DrawFoldoutWithLabel(primaryFireShowInEditorProp, primaryFireHeaderContent);
|
|||
|
if (primaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(primaryFireInputKeycodeProp, singleKeycodeContent);
|
|||
|
EditorGUILayout.PropertyField(primaryFireCanBeHeldProp, fireCanBeHeldContent);
|
|||
|
DrawDiscardData(isPrimaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Direct Keyboard Secondary fire input
|
|||
|
DrawFoldoutWithLabel(secondaryFireShowInEditorProp, secondaryFireHeaderContent);
|
|||
|
if (secondaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(secondaryFireInputKeycodeProp, singleKeycodeContent);
|
|||
|
EditorGUILayout.PropertyField(secondaryFireCanBeHeldProp, fireCanBeHeldContent);
|
|||
|
DrawDiscardData(isSecondaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Direct Keyboard Docking input
|
|||
|
DrawFoldoutWithLabel(dockingShowInEditorProp, dockingHeaderContent);
|
|||
|
if (dockingShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(dockingInputKeycodeProp, singleKeycodeContent);
|
|||
|
DrawDiscardData(isDockDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#else
|
|||
|
EditorGUILayout.HelpBox("Legacy Unity Input is not enabled in the project.", MessageType.Warning, true);
|
|||
|
#endif
|
|||
|
}
|
|||
|
|
|||
|
#endregion Direct Keyboard Input
|
|||
|
|
|||
|
#region Legacy Unity Input System
|
|||
|
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.LegacyUnity)
|
|||
|
{
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
#region Horizontal input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(horizontalShowInEditorProp, horizontalHeaderContent);
|
|||
|
if (horizontalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(horizontalInputAxisModeProp, inputAxisModeContent);
|
|||
|
if (horizontalInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else if (horizontalInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.SingleAxis)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveHorizontalInputAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveHorizontalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveHorizontalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveHorizontalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
EditorGUILayout.PropertyField(invertHorizontalInputAxisProp, invertInputAxisContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveHorizontalInputAxisNameProp, positiveAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveHorizontalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveHorizontalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveHorizontalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(negativeHorizontalInputAxisNameProp, negativeAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isNegativeHorizontalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(negativeHorizontalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isNegativeHorizontalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
if (positiveHorizontalInputAxisNameProp.stringValue == negativeHorizontalInputAxisNameProp.stringValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalAxisNamesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (horizontalInputAxisModeProp.intValue != (int)PlayerInputModule.InputAxisMode.NoInput) { VerifyThrusterPresent(PIMCategory.Horizontal); }
|
|||
|
|
|||
|
DrawSensitivity(horizontalInputAxisModeProp,
|
|||
|
isSensitivityForHorizontalEnabledProp, sensitivityEnabledContent,
|
|||
|
horizontalAxisSensitivityProp, sensitivityContent,
|
|||
|
horizontalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isHorizontalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Vertical input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(verticalShowInEditorProp, verticalHeaderContent);
|
|||
|
if (verticalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(verticalInputAxisModeProp, inputAxisModeContent);
|
|||
|
if (verticalInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else if (verticalInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.SingleAxis)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveVerticalInputAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveVerticalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveVerticalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveVerticalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
EditorGUILayout.PropertyField(invertVerticalInputAxisProp, invertInputAxisContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveVerticalInputAxisNameProp, positiveAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveVerticalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveVerticalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveVerticalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(negativeVerticalInputAxisNameProp, negativeAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isNegativeVerticalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(negativeVerticalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isNegativeVerticalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
if (positiveVerticalInputAxisNameProp.stringValue == negativeVerticalInputAxisNameProp.stringValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalAxisNamesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (verticalInputAxisModeProp.intValue != (int)PlayerInputModule.InputAxisMode.NoInput) { VerifyThrusterPresent(PIMCategory.Vertical); }
|
|||
|
|
|||
|
DrawSensitivity(verticalInputAxisModeProp,
|
|||
|
isSensitivityForVerticalEnabledProp, sensitivityEnabledContent,
|
|||
|
verticalAxisSensitivityProp, sensitivityContent,
|
|||
|
verticalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isVerticalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Longitudinal input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(longitudinalShowInEditorProp, longitudinalHeaderContent);
|
|||
|
if (longitudinalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(longitudinalInputAxisModeProp, inputAxisModeContent);
|
|||
|
if (longitudinalInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else if (longitudinalInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.SingleAxis)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveLongitudinalInputAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveLongitudinalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveLongitudinalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveLongitudinalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(invertLongitudinalInputAxisProp, invertInputAxisContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveLongitudinalInputAxisNameProp, positiveAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveLongitudinalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveLongitudinalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveLongitudinalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(negativeLongitudinalInputAxisNameProp, negativeAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isNegativeLongitudinalInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(negativeLongitudinalInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isNegativeLongitudinalInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
if (positiveLongitudinalInputAxisNameProp.stringValue == negativeLongitudinalInputAxisNameProp.stringValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalAxisNamesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (longitudinalInputAxisModeProp.intValue != (int)PlayerInputModule.InputAxisMode.NoInput) { VerifyThrusterPresent(PIMCategory.Longitidinal); }
|
|||
|
|
|||
|
DrawSensitivity(longitudinalInputAxisModeProp,
|
|||
|
isSensitivityForLongitudinalEnabledProp, sensitivityEnabledContent,
|
|||
|
longitudinalAxisSensitivityProp, sensitivityContent,
|
|||
|
longitudinalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isLongitudinalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Pitch input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(pitchShowInEditorProp, pitchHeaderContent);
|
|||
|
if (pitchShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isMouseForPitchEnabledLISProp, lisPitchInputMouseContent);
|
|||
|
if (isMouseForPitchEnabledLISProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(pitchSensitivityLISProp, lisPitchSensitivityContent);
|
|||
|
EditorGUILayout.PropertyField(pitchDeadzoneLISProp, lisPitchDeadzoneContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(pitchInputAxisModeProp, inputAxisModeContent);
|
|||
|
if (pitchInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else if (pitchInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.SingleAxis)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positivePitchInputAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositivePitchInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positivePitchInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositivePitchInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(invertPitchInputAxisProp, invertInputAxisContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positivePitchInputAxisNameProp, positiveAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositivePitchInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positivePitchInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositivePitchInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(negativePitchInputAxisNameProp, negativeAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isNegativePitchInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(negativePitchInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isNegativePitchInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
if (positivePitchInputAxisNameProp.stringValue == negativePitchInputAxisNameProp.stringValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalAxisNamesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
DrawSensitivity(pitchInputAxisModeProp,
|
|||
|
isSensitivityForPitchEnabledProp, sensitivityEnabledContent,
|
|||
|
pitchAxisSensitivityProp, sensitivityContent,
|
|||
|
pitchAxisGravityProp, gravityContent);
|
|||
|
}
|
|||
|
DrawDiscardData(isPitchDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Yaw input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(yawShowInEditorProp, yawHeaderContent);
|
|||
|
if (yawShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isMouseForYawEnabledLISProp, lisYawInputMouseContent);
|
|||
|
if (isMouseForYawEnabledLISProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(yawSensitivityLISProp, lisYawSensitivityContent);
|
|||
|
EditorGUILayout.PropertyField(yawDeadzoneLISProp, lisYawDeadzoneContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(yawInputAxisModeProp, inputAxisModeContent);
|
|||
|
if (yawInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else if (yawInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.SingleAxis)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveYawInputAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveYawInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveYawInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveYawInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(invertYawInputAxisProp, invertInputAxisContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveYawInputAxisNameProp, positiveAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveYawInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveYawInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveYawInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(negativeYawInputAxisNameProp, negativeAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isNegativeYawInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(negativeYawInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isNegativeYawInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
if (positiveYawInputAxisNameProp.stringValue == negativeYawInputAxisNameProp.stringValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalAxisNamesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
DrawSensitivity(yawInputAxisModeProp,
|
|||
|
isSensitivityForYawEnabledProp, sensitivityEnabledContent,
|
|||
|
yawAxisSensitivityProp, sensitivityContent,
|
|||
|
yawAxisGravityProp, gravityContent);
|
|||
|
}
|
|||
|
DrawDiscardData(isYawDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Roll input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(rollShowInEditorProp, rollHeaderContent);
|
|||
|
if (rollShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(rollInputAxisModeProp, inputAxisModeContent);
|
|||
|
if (rollInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else if (rollInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.SingleAxis)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveRollInputAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveRollInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveRollInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveRollInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
EditorGUILayout.PropertyField(invertRollInputAxisProp, invertInputAxisContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(positiveRollInputAxisNameProp, positiveAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPositiveRollInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(positiveRollInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPositiveRollInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(negativeRollInputAxisNameProp, negativeAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isNegativeRollInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(negativeRollInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isNegativeRollInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
if (positiveRollInputAxisNameProp.stringValue == negativeRollInputAxisNameProp.stringValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalAxisNamesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
DrawSensitivity(rollInputAxisModeProp,
|
|||
|
isSensitivityForRollEnabledProp, sensitivityEnabledContent,
|
|||
|
rollAxisSensitivityProp, sensitivityContent,
|
|||
|
rollAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isRollDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Primary Fire Input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(primaryFireShowInEditorProp, primaryFireHeaderContent);
|
|||
|
if (primaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(primaryFireInputAxisNameProp, singleAxisNameContent);
|
|||
|
EditorGUILayout.PropertyField(primaryFireCanBeHeldProp, fireCanBeHeldContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isPrimaryFireInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(primaryFireInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isPrimaryFireInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
DrawDiscardData(isPrimaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Secondary Fire Input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(secondaryFireShowInEditorProp, secondaryFireHeaderContent);
|
|||
|
if (secondaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(secondaryFireInputAxisNameProp, singleAxisNameContent);
|
|||
|
EditorGUILayout.PropertyField(secondaryFireCanBeHeldProp, fireCanBeHeldContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isSecondaryFireInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(secondaryFireInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isSecondaryFireInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
DrawDiscardData(isSecondaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Docking Input
|
|||
|
|
|||
|
DrawFoldoutWithLabel(dockingShowInEditorProp, dockingHeaderContent);
|
|||
|
if (dockingShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(dockingInputAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
isDockingInputAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(dockingInputAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!isDockingInputAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
DrawDiscardData(isDockDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
#else
|
|||
|
EditorGUILayout.HelpBox("Legacy Unity Input is not enabled in the project.", MessageType.Warning, true);
|
|||
|
#endif
|
|||
|
}
|
|||
|
|
|||
|
#endregion Legacy Unity Input System
|
|||
|
|
|||
|
#region Unity Input System (add with Unity package manager)
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.UnityInputSystem)
|
|||
|
{
|
|||
|
#if SSC_UIS
|
|||
|
|
|||
|
if (uisPlayerInput != null)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("Setup the attached Player Input component, refresh the Available Actions, then configure the Input Axis as required.", MessageType.Info, true);
|
|||
|
}
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(" Input System version", GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(uisVersion);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
if (uisPlayerInput == null)
|
|||
|
{
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.HelpBox("The Unity Input System Player Input component is missing.", MessageType.Error, true);
|
|||
|
if (GUILayout.Button("Fix Now", GUILayout.MaxWidth(70f), GUILayout.MaxHeight(35f)) )
|
|||
|
{
|
|||
|
Undo.AddComponent(playerInputModule.gameObject, typeof(UnityEngine.InputSystem.PlayerInput));
|
|||
|
// Ensure the PlayerInputModule reference is updated for this PlayerInput component
|
|||
|
uisPlayerInput = playerInputModule.GetUISPlayerInput();
|
|||
|
if (uisPlayerInput != null) { uisPlayerInput.notificationBehavior = UnityEngine.InputSystem.PlayerNotifications.InvokeUnityEvents; }
|
|||
|
}
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
}
|
|||
|
else if (uisPlayerInput.actions == null)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("The Unity Input System Player Input component requires an Input Action Asset.", MessageType.Error, true);
|
|||
|
}
|
|||
|
else if (uisPlayerInput.notificationBehavior != UnityEngine.InputSystem.PlayerNotifications.InvokeUnityEvents)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("This version of Sci-Fi Ship Controller only supports a Behaviour of Invoke Unity Events on the Player Input component", MessageType.Error, true);
|
|||
|
}
|
|||
|
else if (string.IsNullOrEmpty(uisPlayerInput.defaultActionMap))
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("The Unity Input System Player Input component requires a Default Map", MessageType.Error, true);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(" Available Actions", GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
if (GUILayout.Button("Refresh", GUILayout.MaxWidth(70f))) { UISRefreshActions(); }
|
|||
|
if (GUILayout.Button(uisAddActionsContent, GUILayout.MaxWidth(90f)))
|
|||
|
{
|
|||
|
#region Add Default Events
|
|||
|
if (UISAddDefaultEvents())
|
|||
|
{
|
|||
|
UISRefreshActions();
|
|||
|
|
|||
|
horizontalInputAxisModeProp.intValue = (int)PlayerInputModule.InputAxisMode.NoInput;
|
|||
|
verticalInputAxisModeProp.intValue = (int)PlayerInputModule.InputAxisMode.SingleAxis;
|
|||
|
longitudinalInputAxisModeProp.intValue = (int)PlayerInputModule.InputAxisMode.SingleAxis;
|
|||
|
pitchInputAxisModeProp.intValue = (int)PlayerInputModule.InputAxisMode.SingleAxis;
|
|||
|
yawInputAxisModeProp.intValue = (int)PlayerInputModule.InputAxisMode.SingleAxis;
|
|||
|
primaryFireButtonEnabledProp.intValue = (int)PlayerInputModule.InputAxisMode.SingleAxis;
|
|||
|
secondaryFireButtonEnabledProp.intValue = (int)PlayerInputModule.InputAxisMode.SingleAxis;
|
|||
|
dockingButtonEnabledProp.intValue = (int)PlayerInputModule.InputAxisMode.NoInput;
|
|||
|
|
|||
|
isMouseForPitchEnabledUISProp.boolValue = false;
|
|||
|
isMouseForYawEnabledUISProp.boolValue = false;
|
|||
|
|
|||
|
UISSetActionId("Vertical", 0, positiveVerticalInputActionIdUISProp, positiveVerticalInputActionDataSlotUISProp);
|
|||
|
UISSetActionId("Longitudinal", 0, positiveLongitudinalInputActionIdUISProp, positiveLongitudinalInputActionDataSlotUISProp);
|
|||
|
UISSetActionId("Pitch", 0, positivePitchInputActionIdUISProp, positivePitchInputActionDataSlotUISProp);
|
|||
|
UISSetActionId("Yaw", 0, positiveYawInputActionIdUISProp, positiveYawInputActionDataSlotUISProp);
|
|||
|
UISSetActionId("Roll", 0, positiveRollInputActionIdUISProp, positiveRollInputActionDataSlotUISProp);
|
|||
|
UISSetActionId("PrimaryFire", 0, primaryFireInputActionIdUISProp, primaryFireInputActionDataSlotUISProp);
|
|||
|
UISSetActionId("SecondaryFire", 0, secondaryFireInputActionIdUISProp, secondaryFireInputActionDataSlotUISProp);
|
|||
|
}
|
|||
|
else { UISRefreshActions(); }
|
|||
|
#endregion
|
|||
|
serializedObject.ApplyModifiedProperties();
|
|||
|
GUIUtility.ExitGUI();
|
|||
|
}
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
// The array of actions can become null when all actions are manually deleted from the default map
|
|||
|
// using the UIS asset editor
|
|||
|
if (uisActionGUIContent == null) { UISRefreshActions(); }
|
|||
|
|
|||
|
int numActionIDs = uisActionIDs == null ? 0 : uisActionIDs.Length;
|
|||
|
|
|||
|
#region UIS On-screen controls
|
|||
|
DrawFoldoutWithLabel(onscreenControlsShowInEditorProp, uisOnScreenControlsContent);
|
|||
|
if (onscreenControlsShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(" Add Virtual Joysticks", GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
if (GUILayout.Button("Left Stick", GUILayout.MaxWidth(75f))) { UISAddOnScreenControls("LeftStick"); }
|
|||
|
if (GUILayout.Button("Right Stick", GUILayout.MaxWidth(75f))) { UISAddOnScreenControls("RightStick"); }
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(" Add Buttons", GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
if (GUILayout.Button("Left Btns", GUILayout.MaxWidth(75f))) { UISAddOnScreenControls("LeftButtons"); }
|
|||
|
if (GUILayout.Button("Right Btns", GUILayout.MaxWidth(75f))) { UISAddOnScreenControls("RightButtons"); }
|
|||
|
// We currently don't have a quit input action
|
|||
|
if (GUILayout.Button("Quit Btn", GUILayout.MaxWidth(70f))) { UISAddOnScreenQuit(); }
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Horizontal Input
|
|||
|
DrawFoldoutWithLabel(horizontalShowInEditorProp, horizontalHeaderContent);
|
|||
|
if (horizontalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawUnityInputSystem(horizontalInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
positiveHorizontalInputActionIdUISProp, positiveHorizontalInputActionDataSlotUISProp,
|
|||
|
uisHorizontalInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionIDs, true
|
|||
|
);
|
|||
|
EditorGUILayout.PropertyField(invertHorizontalInputAxisProp, invertInputAxisContent);
|
|||
|
DrawSensitivity(horizontalInputAxisModeProp,
|
|||
|
isSensitivityForHorizontalEnabledProp, sensitivityEnabledContent,
|
|||
|
horizontalAxisSensitivityProp, sensitivityContent,
|
|||
|
horizontalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isHorizontalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Vertical Input
|
|||
|
DrawFoldoutWithLabel(verticalShowInEditorProp, verticalHeaderContent);
|
|||
|
if (verticalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawUnityInputSystem(verticalInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
positiveVerticalInputActionIdUISProp, positiveVerticalInputActionDataSlotUISProp,
|
|||
|
uisVerticalInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionIDs, true
|
|||
|
);
|
|||
|
EditorGUILayout.PropertyField(invertVerticalInputAxisProp, invertInputAxisContent);
|
|||
|
DrawSensitivity(verticalInputAxisModeProp,
|
|||
|
isSensitivityForVerticalEnabledProp, sensitivityEnabledContent,
|
|||
|
verticalAxisSensitivityProp, sensitivityContent,
|
|||
|
verticalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isVerticalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Longitudinal input
|
|||
|
DrawFoldoutWithLabel(longitudinalShowInEditorProp, longitudinalHeaderContent);
|
|||
|
if (longitudinalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawUnityInputSystem(longitudinalInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
positiveLongitudinalInputActionIdUISProp, positiveLongitudinalInputActionDataSlotUISProp,
|
|||
|
uisLongitudinalInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionIDs, true
|
|||
|
);
|
|||
|
EditorGUILayout.PropertyField(invertLongitudinalInputAxisProp, invertInputAxisContent);
|
|||
|
DrawSensitivity(longitudinalInputAxisModeProp,
|
|||
|
isSensitivityForLongitudinalEnabledProp, sensitivityEnabledContent,
|
|||
|
longitudinalAxisSensitivityProp, sensitivityContent,
|
|||
|
longitudinalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isLongitudinalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Pitch input
|
|||
|
DrawFoldoutWithLabel(pitchShowInEditorProp, pitchHeaderContent);
|
|||
|
if (pitchShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isMouseForPitchEnabledUISProp, uisPitchInputMouseContent);
|
|||
|
if (isMouseForPitchEnabledUISProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(pitchSensitivityUISProp, uisPitchSensitivityContent);
|
|||
|
EditorGUILayout.PropertyField(pitchDeadzoneUISProp, uisPitchDeadzoneContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
DrawUnityInputSystem(pitchInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
positivePitchInputActionIdUISProp, positivePitchInputActionDataSlotUISProp,
|
|||
|
uisPitchInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionIDs, true
|
|||
|
);
|
|||
|
EditorGUILayout.PropertyField(invertPitchInputAxisProp, invertInputAxisContent);
|
|||
|
DrawSensitivity(pitchInputAxisModeProp,
|
|||
|
isSensitivityForPitchEnabledProp, sensitivityEnabledContent,
|
|||
|
pitchAxisSensitivityProp, sensitivityContent,
|
|||
|
pitchAxisGravityProp, gravityContent);
|
|||
|
}
|
|||
|
DrawDiscardData(isPitchDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Yaw input
|
|||
|
DrawFoldoutWithLabel(yawShowInEditorProp, yawHeaderContent);
|
|||
|
if (yawShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isMouseForYawEnabledUISProp, uisYawInputMouseContent);
|
|||
|
if (isMouseForYawEnabledUISProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(yawSensitivityUISProp, uisYawSensitivityContent);
|
|||
|
EditorGUILayout.PropertyField(yawDeadzoneUISProp, uisYawDeadzoneContent);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
DrawUnityInputSystem(yawInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
positiveYawInputActionIdUISProp, positiveYawInputActionDataSlotUISProp,
|
|||
|
uisYawInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionIDs, true
|
|||
|
);
|
|||
|
EditorGUILayout.PropertyField(invertYawInputAxisProp, invertInputAxisContent);
|
|||
|
DrawSensitivity(yawInputAxisModeProp,
|
|||
|
isSensitivityForYawEnabledProp, sensitivityEnabledContent,
|
|||
|
yawAxisSensitivityProp, sensitivityContent,
|
|||
|
yawAxisGravityProp, gravityContent);
|
|||
|
}
|
|||
|
DrawDiscardData(isYawDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Roll input
|
|||
|
DrawFoldoutWithLabel(rollShowInEditorProp, rollHeaderContent);
|
|||
|
if (rollShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawUnityInputSystem(rollInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
positiveRollInputActionIdUISProp, positiveRollInputActionDataSlotUISProp,
|
|||
|
uisRollInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionIDs, true
|
|||
|
);
|
|||
|
EditorGUILayout.PropertyField(invertRollInputAxisProp, invertInputAxisContent);
|
|||
|
DrawSensitivity(rollInputAxisModeProp,
|
|||
|
isSensitivityForRollEnabledProp, sensitivityEnabledContent,
|
|||
|
rollAxisSensitivityProp, sensitivityContent,
|
|||
|
rollAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isRollDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Primary Fire Input
|
|||
|
DrawFoldoutWithLabel(primaryFireShowInEditorProp, primaryFireHeaderContent);
|
|||
|
if (primaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawUnityInputSystemFire(primaryFireButtonEnabledProp, uisPrimaryFireEnabledContent,
|
|||
|
primaryFireInputActionIdUISProp, primaryFireInputActionDataSlotUISProp,
|
|||
|
primaryFireCanBeHeldProp, uisPrimaryFireInputAContent,
|
|||
|
uisInputATypeContent, uisInputCTypeContent, uisInputDataSlotContent,
|
|||
|
fireCanBeHeldContent, uisDataSlots2, uisDataSlots3, numActionIDs
|
|||
|
);
|
|||
|
DrawDiscardData(isPrimaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Secondary Fire Input
|
|||
|
DrawFoldoutWithLabel(secondaryFireShowInEditorProp, secondaryFireHeaderContent);
|
|||
|
if (secondaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawUnityInputSystemFire(secondaryFireButtonEnabledProp, uisSecondaryFireEnabledContent,
|
|||
|
secondaryFireInputActionIdUISProp, secondaryFireInputActionDataSlotUISProp,
|
|||
|
secondaryFireCanBeHeldProp, uisSecondaryFireInputAContent,
|
|||
|
uisInputATypeContent, uisInputCTypeContent, uisInputDataSlotContent,
|
|||
|
fireCanBeHeldContent, uisDataSlots2, uisDataSlots3, numActionIDs
|
|||
|
);
|
|||
|
DrawDiscardData(isSecondaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Docking Input
|
|||
|
DrawFoldoutWithLabel(dockingShowInEditorProp, dockingHeaderContent);
|
|||
|
if (dockingShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawUnityInputSystemFire(dockingButtonEnabledProp, uisDockingEnabledContent,
|
|||
|
dockingInputActionIdUISProp, dockingInputActionDataSlotUISProp,
|
|||
|
null, uisDockingInputAContent,
|
|||
|
uisInputATypeContent, uisInputCTypeContent, uisInputDataSlotContent,
|
|||
|
null, uisDataSlots2, uisDataSlots3, numActionIDs
|
|||
|
);
|
|||
|
DrawDiscardData(isDockDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Rumble Controller output
|
|||
|
DrawFoldoutWithLabel(rumbleShowInEditorProp, rumbleHeaderContent);
|
|||
|
if (rumbleShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(maxRumble1Prop, maxRumble1Content);
|
|||
|
EditorGUILayout.PropertyField(maxRumble2Prop, maxRumble2Content);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
}
|
|||
|
#else
|
|||
|
EditorGUILayout.HelpBox("Could not find the Unity Input System. Did you install Input System 1.0.0 or newer from the Package Manager?", MessageType.Warning, true);
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion Unity Input System
|
|||
|
|
|||
|
#region Oculus OVR API input
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.OculusAPI && !isRefreshing)
|
|||
|
{
|
|||
|
#if SSC_OVR
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(" Oculus Plugin version ", GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(ovrPluginVersion);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
//EditorGUILayout.HelpBox("This feature is in technical preview", MessageType.Warning);
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(isOVRInputUpdatedIfRequiredProp, ovrIsInputUpdateRequiredContent);
|
|||
|
|
|||
|
#region OVR Horizontal Input
|
|||
|
DrawFoldoutWithLabel(horizontalShowInEditorProp, horizontalHeaderContent);
|
|||
|
if (horizontalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(PIMCategory.Horizontal, horizontalInputAxisModeProp, ovrHorizontalInputTypeProp,
|
|||
|
positiveHorizontalInputOVRProp, negativeHorizontalInputOVRProp,
|
|||
|
ovrHorizontalInputTypeContent,
|
|||
|
ovrHorizontalPositiveInputContent,
|
|||
|
ovrHorizontalNegativeInputContent,
|
|||
|
ovrHorizontalInputContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(horizontalInputAxisModeProp,
|
|||
|
isSensitivityForHorizontalEnabledProp, sensitivityEnabledContent,
|
|||
|
horizontalAxisSensitivityProp, sensitivityContent,
|
|||
|
horizontalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isHorizontalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Horizontal Input
|
|||
|
|
|||
|
#region OVR Vertical Input
|
|||
|
DrawFoldoutWithLabel(verticalShowInEditorProp, verticalHeaderContent);
|
|||
|
if (verticalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(PIMCategory.Vertical, verticalInputAxisModeProp, ovrVerticalInputTypeProp,
|
|||
|
positiveVerticalInputOVRProp, negativeVerticalInputOVRProp,
|
|||
|
ovrVerticalInputTypeContent,
|
|||
|
ovrVerticalPositiveInputContent,
|
|||
|
ovrVerticalNegativeInputContent,
|
|||
|
ovrVerticalInputContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(verticalInputAxisModeProp,
|
|||
|
isSensitivityForVerticalEnabledProp, sensitivityEnabledContent,
|
|||
|
verticalAxisSensitivityProp, sensitivityContent,
|
|||
|
verticalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isVerticalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Vertical Input
|
|||
|
|
|||
|
#region OVR Longitudinal Input
|
|||
|
DrawFoldoutWithLabel(longitudinalShowInEditorProp, longitudinalHeaderContent);
|
|||
|
if (longitudinalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(PIMCategory.Longitidinal, longitudinalInputAxisModeProp, ovrLongitudinalInputTypeProp,
|
|||
|
positiveLongitudinalInputOVRProp, negativeLongitudinalInputOVRProp,
|
|||
|
ovrLongitudinalInputTypeContent,
|
|||
|
ovrLongitudinalPositiveInputContent,
|
|||
|
ovrLongitudinalNegativeInputContent,
|
|||
|
ovrLongitudinalInputContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(longitudinalInputAxisModeProp,
|
|||
|
isSensitivityForLongitudinalEnabledProp, sensitivityEnabledContent,
|
|||
|
longitudinalAxisSensitivityProp, sensitivityContent,
|
|||
|
longitudinalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isLongitudinalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Longitudinal Input
|
|||
|
|
|||
|
#region OVR Pitch Input
|
|||
|
DrawFoldoutWithLabel(pitchShowInEditorProp, pitchHeaderContent);
|
|||
|
if (pitchShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(PIMCategory.Pitch, pitchInputAxisModeProp, ovrPitchInputTypeProp,
|
|||
|
positivePitchInputOVRProp, negativePitchInputOVRProp,
|
|||
|
ovrPitchInputTypeContent,
|
|||
|
ovrPitchPositiveInputContent,
|
|||
|
ovrPitchNegativeInputContent,
|
|||
|
ovrPitchInputContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(pitchInputAxisModeProp,
|
|||
|
isSensitivityForPitchEnabledProp, sensitivityEnabledContent,
|
|||
|
pitchAxisSensitivityProp, sensitivityContent,
|
|||
|
pitchAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isPitchDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Pitch Input
|
|||
|
|
|||
|
#region OVR Yaw Input
|
|||
|
DrawFoldoutWithLabel(yawShowInEditorProp, yawHeaderContent);
|
|||
|
if (yawShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(PIMCategory.Yaw, yawInputAxisModeProp, ovrYawInputTypeProp,
|
|||
|
positiveYawInputOVRProp, negativeYawInputOVRProp,
|
|||
|
ovrYawInputTypeContent,
|
|||
|
ovrYawPositiveInputContent,
|
|||
|
ovrYawNegativeInputContent,
|
|||
|
ovrYawInputContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(yawInputAxisModeProp,
|
|||
|
isSensitivityForYawEnabledProp, sensitivityEnabledContent,
|
|||
|
yawAxisSensitivityProp, sensitivityContent,
|
|||
|
yawAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isYawDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Yaw Input
|
|||
|
|
|||
|
#region OVR Roll Input
|
|||
|
DrawFoldoutWithLabel(rollShowInEditorProp, rollHeaderContent);
|
|||
|
if (rollShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(PIMCategory.Roll, rollInputAxisModeProp, ovrRollInputTypeProp,
|
|||
|
positiveRollInputOVRProp, negativeRollInputOVRProp,
|
|||
|
ovrRollInputTypeContent,
|
|||
|
ovrRollPositiveInputContent,
|
|||
|
ovrRollNegativeInputContent,
|
|||
|
ovrRollInputContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(rollInputAxisModeProp,
|
|||
|
isSensitivityForRollEnabledProp, sensitivityEnabledContent,
|
|||
|
rollAxisSensitivityProp, sensitivityContent,
|
|||
|
rollAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isRollDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Roll Input
|
|||
|
|
|||
|
#region OVR Primary Fire Input
|
|||
|
DrawFoldoutWithLabel(primaryFireShowInEditorProp, primaryFireHeaderContent);
|
|||
|
if (primaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(primaryFireButtonEnabledProp, primaryFireInputOVRProp, primaryFireCanBeHeldProp, ovrPrimaryFireEnabledContent, ovrPrimaryFireInputContent, fireCanBeHeldContent);
|
|||
|
DrawDiscardData(isPrimaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Primary Fire Input
|
|||
|
|
|||
|
#region OVR Secondary Fire Input
|
|||
|
DrawFoldoutWithLabel(secondaryFireShowInEditorProp, secondaryFireHeaderContent);
|
|||
|
if (secondaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(secondaryFireButtonEnabledProp, secondaryFireInputOVRProp, secondaryFireCanBeHeldProp, ovrSecondaryFireEnabledContent, ovrSecondaryFireInputContent, fireCanBeHeldContent);
|
|||
|
DrawDiscardData(isSecondaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Secondary Fire Input
|
|||
|
|
|||
|
#region OVR Docking Input
|
|||
|
DrawFoldoutWithLabel(dockingShowInEditorProp, dockingHeaderContent);
|
|||
|
if (dockingShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(dockingButtonEnabledProp, dockingInputOVRProp, null, ovrDockingEnabledContent, ovrDockingInputContent, null);
|
|||
|
DrawDiscardData(isDockDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion OVR Docking Input
|
|||
|
|
|||
|
#else
|
|||
|
EditorGUILayout.HelpBox("Could not find Oculus OVR API. Did you install the Oculus Integration package 1.3.2 or newer?", MessageType.Warning, true);
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion Oculus API input
|
|||
|
|
|||
|
#region Rewired Input
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.Rewired && !isRefreshing)
|
|||
|
#if SSC_REWIRED
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("Set up Actions in the Rewired Input Manager and then configure them below.", MessageType.Info, true);
|
|||
|
|
|||
|
// NOTE: Cannot add an ActionCategory and any Action in code (it is not supported by Rewired)
|
|||
|
// The user must manually configure them in the Rewired Input Manager
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(rwVersionContent, GUILayout.Width(defaultEditorLabelWidth-3f));
|
|||
|
EditorGUILayout.LabelField(rwVersion);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
if (rewiredUserData != null)
|
|||
|
{
|
|||
|
int numActionCategories = actionCategoryIDs == null ? 0 : actionCategoryIDs.Length;
|
|||
|
|
|||
|
#region Rewired Player
|
|||
|
EditorGUILayout.PropertyField(rewiredPlayerNumberProp, rwPlayerNumberContent);
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Horizontal Input
|
|||
|
DrawFoldoutWithLabel(horizontalShowInEditorProp, horizontalHeaderContent);
|
|||
|
if (horizontalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(PIMCategory.Horizontal, horizontalInputAxisModeProp, positiveHorizontalInputActionIdProp, negativeHorizontalInputActionIdProp,
|
|||
|
rwHorizontalInputACPositiveContent, rwHorizontalInputACNegativeContent, rwHorizontalInputACContent,
|
|||
|
rwHorizontalInputAIPositiveContent, rwHorizontalInputAINegativeContent, rwHorizontalInputAIContent,
|
|||
|
ref actionIDsHorizPositive, ref actionIDsHorizNegative, ref ActionGUIContentHorizPositive, ref ActionGUIContentHorizNegative, numActionCategories);
|
|||
|
|
|||
|
DrawSensitivity(horizontalInputAxisModeProp,
|
|||
|
isSensitivityForHorizontalEnabledProp, sensitivityEnabledContent,
|
|||
|
horizontalAxisSensitivityProp, sensitivityContent,
|
|||
|
horizontalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isHorizontalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Vertical Input
|
|||
|
DrawFoldoutWithLabel(verticalShowInEditorProp, verticalHeaderContent);
|
|||
|
if (verticalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(PIMCategory.Vertical, verticalInputAxisModeProp, positiveVerticalInputActionIdProp, negativeVerticalInputActionIdProp,
|
|||
|
rwVerticalInputACPositiveContent, rwVerticalInputACNegativeContent, rwVerticalInputACContent,
|
|||
|
rwVerticalInputAIPositiveContent, rwVerticalInputAINegativeContent, rwVerticalInputAIContent,
|
|||
|
ref actionIDsVertPositive, ref actionIDsVertNegative, ref ActionGUIContentVertPositive, ref ActionGUIContentVertNegative, numActionCategories);
|
|||
|
|
|||
|
DrawSensitivity(verticalInputAxisModeProp,
|
|||
|
isSensitivityForVerticalEnabledProp, sensitivityEnabledContent,
|
|||
|
verticalAxisSensitivityProp, sensitivityContent,
|
|||
|
verticalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isVerticalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Longitudinal Input
|
|||
|
DrawFoldoutWithLabel(longitudinalShowInEditorProp, longitudinalHeaderContent);
|
|||
|
if (longitudinalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(PIMCategory.Longitidinal, longitudinalInputAxisModeProp, positiveLongitudinalInputActionIdProp, negativeLongitudinalInputActionIdProp,
|
|||
|
rwLongitudinalInputACPositiveContent, rwLongitudinalInputACNegativeContent, rwLongitudinalInputACContent,
|
|||
|
rwLongitudinalInputAIPositiveContent, rwLongitudinalInputAINegativeContent, rwLongitudinalInputAIContent,
|
|||
|
ref actionIDsLngtdlPositive, ref actionIDsLngtdlNegative, ref ActionGUIContentLngtdlPositive, ref ActionGUIContentLngtdlNegative, numActionCategories);
|
|||
|
|
|||
|
DrawSensitivity(longitudinalInputAxisModeProp,
|
|||
|
isSensitivityForLongitudinalEnabledProp, sensitivityEnabledContent,
|
|||
|
longitudinalAxisSensitivityProp, sensitivityContent,
|
|||
|
longitudinalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isLongitudinalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Pitch input
|
|||
|
DrawFoldoutWithLabel(pitchShowInEditorProp, pitchHeaderContent);
|
|||
|
if (pitchShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(PIMCategory.Pitch, pitchInputAxisModeProp, positivePitchInputActionIdProp, negativePitchInputActionIdProp,
|
|||
|
rwPitchInputACPositiveContent, rwPitchInputACNegativeContent, rwPitchInputACContent,
|
|||
|
rwPitchInputAIPositiveContent, rwPitchInputAINegativeContent, rwPitchInputAIContent,
|
|||
|
ref actionIDsPitchPositive, ref actionIDsPitchNegative, ref ActionGUIContentPitchPositive, ref ActionGUIContentPitchNegative, numActionCategories);
|
|||
|
|
|||
|
DrawSensitivity(pitchInputAxisModeProp,
|
|||
|
isSensitivityForPitchEnabledProp, sensitivityEnabledContent,
|
|||
|
pitchAxisSensitivityProp, sensitivityContent,
|
|||
|
pitchAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isPitchDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Yaw input
|
|||
|
DrawFoldoutWithLabel(yawShowInEditorProp, yawHeaderContent);
|
|||
|
if (yawShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(PIMCategory.Yaw, yawInputAxisModeProp, positiveYawInputActionIdProp, negativeYawInputActionIdProp,
|
|||
|
rwYawInputACPositiveContent, rwYawInputACNegativeContent, rwYawInputACContent,
|
|||
|
rwYawInputAIPositiveContent, rwYawInputAINegativeContent, rwYawInputAIContent,
|
|||
|
ref actionIDsYawPositive, ref actionIDsYawNegative, ref ActionGUIContentYawPositive, ref ActionGUIContentYawNegative, numActionCategories);
|
|||
|
|
|||
|
DrawSensitivity(yawInputAxisModeProp,
|
|||
|
isSensitivityForYawEnabledProp, sensitivityEnabledContent,
|
|||
|
yawAxisSensitivityProp, sensitivityContent,
|
|||
|
yawAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isYawDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Roll input
|
|||
|
DrawFoldoutWithLabel(rollShowInEditorProp, rollHeaderContent);
|
|||
|
if (rollShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(PIMCategory.Roll, rollInputAxisModeProp, positiveRollInputActionIdProp, negativeRollInputActionIdProp,
|
|||
|
rwRollInputACPositiveContent, rwRollInputACNegativeContent, rwRollInputACContent,
|
|||
|
rwRollInputAIPositiveContent, rwRollInputAINegativeContent, rwRollInputAIContent,
|
|||
|
ref actionIDsRollPositive, ref actionIDsRollNegative, ref ActionGUIContentRollPositive, ref ActionGUIContentRollNegative, numActionCategories);
|
|||
|
|
|||
|
DrawSensitivity(rollInputAxisModeProp,
|
|||
|
isSensitivityForRollEnabledProp, sensitivityEnabledContent,
|
|||
|
rollAxisSensitivityProp, sensitivityContent,
|
|||
|
rollAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isRollDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Rewired Primary Fire Input
|
|||
|
DrawFoldoutWithLabel(primaryFireShowInEditorProp, primaryFireHeaderContent);
|
|||
|
if (primaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(primaryFireButtonEnabledProp, primaryFireInputActionIdProp, primaryFireCanBeHeldProp, rwPrimaryFireEnabledContent, rwPrimaryFireInputACContent, rwPrimaryFireInputAIContent, fireCanBeHeldContent, ref actionIDsPrimaryFire, ref ActionGUIContentPrimaryFire, numActionCategories);
|
|||
|
DrawDiscardData(isPrimaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion Rewired Primary Fire Input
|
|||
|
|
|||
|
#region Rewired Secondary Fire Input
|
|||
|
DrawFoldoutWithLabel(secondaryFireShowInEditorProp, secondaryFireHeaderContent);
|
|||
|
if (secondaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(secondaryFireButtonEnabledProp, secondaryFireInputActionIdProp, secondaryFireCanBeHeldProp, rwSecondaryFireEnabledContent, rwSecondaryFireInputACContent, rwSecondaryFireInputAIContent, fireCanBeHeldContent, ref actionIDsSecondaryFire, ref ActionGUIContentSecondaryFire, numActionCategories);
|
|||
|
DrawDiscardData(isSecondaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion Rewired Secondary Fire Input
|
|||
|
|
|||
|
#region Rewired Docking Input
|
|||
|
DrawFoldoutWithLabel(dockingShowInEditorProp, dockingHeaderContent);
|
|||
|
if (dockingShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(dockingButtonEnabledProp, dockingInputActionIdProp, null, rwDockingEnabledContent, rwDockingInputACContent, rwDockingInputAIContent, null, ref actionIDsDocking, ref ActionGUIContentDocking, numActionCategories);
|
|||
|
DrawDiscardData(isDockDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion Rewired Docking Input
|
|||
|
|
|||
|
#region Rumble Controller output
|
|||
|
DrawFoldoutWithLabel(rumbleShowInEditorProp, rumbleHeaderContent);
|
|||
|
if (rumbleShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(maxRumble1Prop, maxRumble1Content);
|
|||
|
EditorGUILayout.PropertyField(maxRumble2Prop, maxRumble2Content);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("Could not find Rewired Input Manager in the scene", MessageType.Warning, true);
|
|||
|
}
|
|||
|
}
|
|||
|
#else
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("Rewired does not appear to be installed in the project.", MessageType.Warning, true);
|
|||
|
}
|
|||
|
#endif
|
|||
|
#endregion Rewired Input
|
|||
|
|
|||
|
#region VIVE
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.Vive && !isRefreshing)
|
|||
|
{
|
|||
|
// Vive has a hierarchy of Role, Controller, input type (ControllerButton, ControllerAxis)
|
|||
|
|
|||
|
#if VIU_PLUGIN
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField("Vive Input Utility version ", GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(viveVersion);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
#region VIVE Horizontal Input
|
|||
|
DrawFoldoutWithLabel(horizontalShowInEditorProp, horizontalHeaderContent);
|
|||
|
if (horizontalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(PIMCategory.Horizontal, horizontalInputAxisModeProp, viveHorizontalInputTypeProp,
|
|||
|
viveHorizontalRoleTypeProp,
|
|||
|
positiveHorizontalInputRoleIdProp, negativeHorizontalInputRoleIdProp,
|
|||
|
positiveHorizontalInputCtrlViveProp, negativeHorizontalInputCtrlViveProp,
|
|||
|
viveHorizontalInputTypeContent,
|
|||
|
viveHorizontalRoleTypeContent,
|
|||
|
viveHorizontalPositiveRoleIdContent,
|
|||
|
viveHorizontalNegativeRoleIdContent,
|
|||
|
viveHorizontalRoleIdContent,
|
|||
|
viveHorizontalPositiveInputCtrlContent,
|
|||
|
viveHorizontalNegativeInputCtrlContent,
|
|||
|
viveHorizontalInputCtrlContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(horizontalInputAxisModeProp,
|
|||
|
isSensitivityForHorizontalEnabledProp, sensitivityEnabledContent,
|
|||
|
horizontalAxisSensitivityProp, sensitivityContent,
|
|||
|
horizontalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isHorizontalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Horizontal Input
|
|||
|
|
|||
|
#region VIVE Vertical Input
|
|||
|
DrawFoldoutWithLabel(verticalShowInEditorProp, verticalHeaderContent);
|
|||
|
if (verticalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(PIMCategory.Vertical, verticalInputAxisModeProp, viveVerticalInputTypeProp,
|
|||
|
viveVerticalRoleTypeProp,
|
|||
|
positiveVerticalInputRoleIdProp, negativeVerticalInputRoleIdProp,
|
|||
|
positiveVerticalInputCtrlViveProp, negativeVerticalInputCtrlViveProp,
|
|||
|
viveVerticalInputTypeContent,
|
|||
|
viveVerticalRoleTypeContent,
|
|||
|
viveVerticalPositiveRoleIdContent,
|
|||
|
viveVerticalNegativeRoleIdContent,
|
|||
|
viveVerticalRoleIdContent,
|
|||
|
viveVerticalPositiveInputCtrlContent,
|
|||
|
viveVerticalNegativeInputCtrlContent,
|
|||
|
viveVerticalInputCtrlContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(verticalInputAxisModeProp,
|
|||
|
isSensitivityForVerticalEnabledProp, sensitivityEnabledContent,
|
|||
|
verticalAxisSensitivityProp, sensitivityContent,
|
|||
|
verticalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isVerticalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Vertical Input
|
|||
|
|
|||
|
#region VIVE Longitudinal Input
|
|||
|
DrawFoldoutWithLabel(longitudinalShowInEditorProp, longitudinalHeaderContent);
|
|||
|
if (longitudinalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(PIMCategory.Longitidinal, longitudinalInputAxisModeProp, viveLongitudinalInputTypeProp,
|
|||
|
viveLongitudinalRoleTypeProp,
|
|||
|
positiveLongitudinalInputRoleIdProp, negativeLongitudinalInputRoleIdProp,
|
|||
|
positiveLongitudinalInputCtrlViveProp, negativeLongitudinalInputCtrlViveProp,
|
|||
|
viveLongitudinalInputTypeContent,
|
|||
|
viveLongitudinalRoleTypeContent,
|
|||
|
viveLongitudinalPositiveRoleIdContent,
|
|||
|
viveLongitudinalNegativeRoleIdContent,
|
|||
|
viveLongitudinalRoleIdContent,
|
|||
|
viveLongitudinalPositiveInputCtrlContent,
|
|||
|
viveLongitudinalNegativeInputCtrlContent,
|
|||
|
viveLongitudinalInputCtrlContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(longitudinalInputAxisModeProp,
|
|||
|
isSensitivityForLongitudinalEnabledProp, sensitivityEnabledContent,
|
|||
|
longitudinalAxisSensitivityProp, sensitivityContent,
|
|||
|
longitudinalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isLongitudinalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Longitudinal Input
|
|||
|
|
|||
|
#region VIVE Pitch Input
|
|||
|
DrawFoldoutWithLabel(pitchShowInEditorProp, pitchHeaderContent);
|
|||
|
if (pitchShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(PIMCategory.Pitch, pitchInputAxisModeProp, vivePitchInputTypeProp,
|
|||
|
vivePitchRoleTypeProp,
|
|||
|
positivePitchInputRoleIdProp, negativePitchInputRoleIdProp,
|
|||
|
positivePitchInputCtrlViveProp, negativePitchInputCtrlViveProp,
|
|||
|
vivePitchInputTypeContent,
|
|||
|
vivePitchRoleTypeContent,
|
|||
|
vivePitchPositiveRoleIdContent,
|
|||
|
vivePitchNegativeRoleIdContent,
|
|||
|
vivePitchRoleIdContent,
|
|||
|
vivePitchPositiveInputCtrlContent,
|
|||
|
vivePitchNegativeInputCtrlContent,
|
|||
|
vivePitchInputCtrlContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(pitchInputAxisModeProp,
|
|||
|
isSensitivityForPitchEnabledProp, sensitivityEnabledContent,
|
|||
|
pitchAxisSensitivityProp, sensitivityContent,
|
|||
|
pitchAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isPitchDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Pitch Input
|
|||
|
|
|||
|
#region VIVE Yaw Input
|
|||
|
DrawFoldoutWithLabel(yawShowInEditorProp, yawHeaderContent);
|
|||
|
if (yawShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(PIMCategory.Yaw, yawInputAxisModeProp, viveYawInputTypeProp,
|
|||
|
viveYawRoleTypeProp,
|
|||
|
positiveYawInputRoleIdProp, negativeYawInputRoleIdProp,
|
|||
|
positiveYawInputCtrlViveProp, negativeYawInputCtrlViveProp,
|
|||
|
viveYawInputTypeContent,
|
|||
|
viveYawRoleTypeContent,
|
|||
|
viveYawPositiveRoleIdContent,
|
|||
|
viveYawNegativeRoleIdContent,
|
|||
|
viveYawRoleIdContent,
|
|||
|
viveYawPositiveInputCtrlContent,
|
|||
|
viveYawNegativeInputCtrlContent,
|
|||
|
viveYawInputCtrlContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(yawInputAxisModeProp,
|
|||
|
isSensitivityForYawEnabledProp, sensitivityEnabledContent,
|
|||
|
yawAxisSensitivityProp, sensitivityContent,
|
|||
|
yawAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isYawDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Yaw Input
|
|||
|
|
|||
|
#region VIVE Roll Input
|
|||
|
DrawFoldoutWithLabel(rollShowInEditorProp, rollHeaderContent);
|
|||
|
if (rollShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(PIMCategory.Roll, rollInputAxisModeProp, viveRollInputTypeProp,
|
|||
|
viveRollRoleTypeProp,
|
|||
|
positiveRollInputRoleIdProp, negativeRollInputRoleIdProp,
|
|||
|
positiveRollInputCtrlViveProp, negativeRollInputCtrlViveProp,
|
|||
|
viveRollInputTypeContent,
|
|||
|
viveRollRoleTypeContent,
|
|||
|
viveRollPositiveRoleIdContent,
|
|||
|
viveRollNegativeRoleIdContent,
|
|||
|
viveRollRoleIdContent,
|
|||
|
viveRollPositiveInputCtrlContent,
|
|||
|
viveRollNegativeInputCtrlContent,
|
|||
|
viveRollInputCtrlContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(rollInputAxisModeProp,
|
|||
|
isSensitivityForRollEnabledProp, sensitivityEnabledContent,
|
|||
|
rollAxisSensitivityProp, sensitivityContent,
|
|||
|
rollAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isRollDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Roll Input
|
|||
|
|
|||
|
#region VIVE Primary Fire Input
|
|||
|
DrawFoldoutWithLabel(primaryFireShowInEditorProp, primaryFireHeaderContent);
|
|||
|
if (primaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(
|
|||
|
primaryFireButtonEnabledProp,
|
|||
|
vivePrimaryFireRoleTypeProp,
|
|||
|
primaryFireInputRoleIdProp,
|
|||
|
primaryFireInputCtrlViveProp,
|
|||
|
primaryFireCanBeHeldProp,
|
|||
|
vivePrimaryFireEnabledContent,
|
|||
|
vivePrimaryFireRoleTypeContent,
|
|||
|
vivePrimaryFireRoleIdContent,
|
|||
|
vivePrimaryFireInputCtrlContent,
|
|||
|
fireCanBeHeldContent
|
|||
|
);
|
|||
|
DrawDiscardData(isPrimaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Primary Fire Input
|
|||
|
|
|||
|
#region VIVE Secondary Fire Input
|
|||
|
DrawFoldoutWithLabel(secondaryFireShowInEditorProp, secondaryFireHeaderContent);
|
|||
|
if (secondaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(
|
|||
|
secondaryFireButtonEnabledProp,
|
|||
|
viveSecondaryFireRoleTypeProp,
|
|||
|
secondaryFireInputRoleIdProp,
|
|||
|
secondaryFireInputCtrlViveProp,
|
|||
|
secondaryFireCanBeHeldProp,
|
|||
|
viveSecondaryFireEnabledContent,
|
|||
|
viveSecondaryFireRoleTypeContent,
|
|||
|
viveSecondaryFireRoleIdContent,
|
|||
|
viveSecondaryFireInputCtrlContent,
|
|||
|
fireCanBeHeldContent
|
|||
|
);
|
|||
|
DrawDiscardData(isSecondaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Secondary Fire Input
|
|||
|
|
|||
|
#region VIVE Docking Input
|
|||
|
DrawFoldoutWithLabel(dockingShowInEditorProp, dockingHeaderContent);
|
|||
|
if (dockingShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(
|
|||
|
dockingButtonEnabledProp,
|
|||
|
viveDockingRoleTypeProp,
|
|||
|
dockingInputRoleIdProp,
|
|||
|
dockingInputCtrlViveProp,
|
|||
|
null,
|
|||
|
viveDockingEnabledContent,
|
|||
|
viveDockingRoleTypeContent,
|
|||
|
viveDockingRoleIdContent,
|
|||
|
viveDockingInputCtrlContent,
|
|||
|
null
|
|||
|
);
|
|||
|
DrawDiscardData(isDockDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion VIVE Secondary Fire Input
|
|||
|
|
|||
|
#else
|
|||
|
EditorGUILayout.HelpBox("Could not find the VIVE plugin. Did you install the Vive Input Utility package 1.10.1 or newer?", MessageType.Warning, true);
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region UnityXR
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.UnityXR && !isRefreshing)
|
|||
|
{
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(xrPluginVersionContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(string.IsNullOrEmpty(xrVersion) ? xrPluginNotInstalled : xrVersion);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(xrOpenXRVersionContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(string.IsNullOrEmpty(xrVersion) ? xrPluginNotInstalled : openXRVersion);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(xrOculusXRVersionContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(string.IsNullOrEmpty(oculusXRVersion) ? xrPluginNotInstalled : oculusXRVersion);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
SSCEditorHelper.InTechPreview(false);
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(inputActionAssetXRProp, xrInputActionAssetContent);
|
|||
|
|
|||
|
if (inputActionAssetXRProp.objectReferenceValue == null)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("Unity XR uses the Unity Input System which requires a Input Action Asset.", MessageType.Error, true);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
#region Get Action Maps
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(" Available Actions", GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
if (GUILayout.Button("Refresh", GUILayout.MaxWidth(70f))) { XRRefreshActionMaps(); }
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
if (xrActionMapGUIContent == null) { XRRefreshActionMaps(); }
|
|||
|
|
|||
|
int numActionMapIDs = xrActionMapIDs == null ? 0 : xrActionMapIDs.Length;
|
|||
|
#endregion
|
|||
|
|
|||
|
#region XR Camera
|
|||
|
// XR First Person has a Camera and a tranform that can be rotated (they could be on the same gameobject)
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(firstPersonTransform1XRProp, xrFirstPersonTransform1Content);
|
|||
|
if (EditorGUI.EndChangeCheck() && firstPersonTransform1XRProp.objectReferenceValue != null)
|
|||
|
{
|
|||
|
if (!((Transform)firstPersonTransform1XRProp.objectReferenceValue).IsChildOf(playerInputModule.transform))
|
|||
|
{
|
|||
|
firstPersonTransform1XRProp.objectReferenceValue = null;
|
|||
|
Debug.LogWarning("For XR First Person, the transform must be a child of the parent Ship Control Module gameobject or part of the prefab.");
|
|||
|
}
|
|||
|
// If the camera hasn't been setup, assume it is a child of the look transform
|
|||
|
else if (firstPersonCamera1XRProp.objectReferenceValue == null)
|
|||
|
{
|
|||
|
// Find the first camera
|
|||
|
firstPersonCamera1XRProp.objectReferenceValue = ((Transform)firstPersonTransform1XRProp.objectReferenceValue).GetComponentInChildren<Camera>();
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
GUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(xrFirstPersonCamera1Content, GUILayout.Width(defaultEditorLabelWidth - 53f));
|
|||
|
|
|||
|
if (GUILayout.Button(xrFirstPersonNewCamera1Content, buttonCompact, GUILayout.MaxWidth(50f)) && firstPersonCamera1XRProp.objectReferenceValue == null)
|
|||
|
{
|
|||
|
serializedObject.ApplyModifiedProperties();
|
|||
|
|
|||
|
Undo.SetCurrentGroupName("New XR First Person Camera");
|
|||
|
int undoGroup = UnityEditor.Undo.GetCurrentGroup();
|
|||
|
|
|||
|
Undo.RecordObject(playerInputModule, string.Empty);
|
|||
|
|
|||
|
//GameObject camOffsetGameObject = new GameObject("XR Camera Offset");
|
|||
|
//GameObject camGameObject = new GameObject("XR Camera");
|
|||
|
|
|||
|
GameObject camOffsetGameObject = SSCEditorHelper.GetOrCreateChildGameObject(playerInputModule.gameObject, "XR Camera Offset", true);
|
|||
|
GameObject camGameObject = SSCEditorHelper.GetOrCreateChildGameObject(camOffsetGameObject, "XR Camera", false);
|
|||
|
|
|||
|
if (camOffsetGameObject != null && camGameObject != null)
|
|||
|
{
|
|||
|
Undo.RegisterCreatedObjectUndo(camOffsetGameObject, string.Empty);
|
|||
|
Undo.RegisterCreatedObjectUndo(camGameObject, string.Empty);
|
|||
|
|
|||
|
Camera _newCamera;
|
|||
|
|
|||
|
if (!camGameObject.TryGetComponent(out _newCamera))
|
|||
|
{
|
|||
|
_newCamera = Undo.AddComponent(camGameObject, typeof(Camera)) as Camera;
|
|||
|
}
|
|||
|
|
|||
|
_newCamera.tag = "MainCamera";
|
|||
|
|
|||
|
// When seated in cockpit with no visible body, we don't want to clip through the sides of the cockpit
|
|||
|
// or through say the canopy.
|
|||
|
_newCamera.nearClipPlane = 0.05f;
|
|||
|
//playerInputModule.lookFirstPersonCamera1 = _newCamera;
|
|||
|
|
|||
|
// Distinguish between the old XR TrackPoseDriver and the one with the new Unity Input System.
|
|||
|
var _tposeDriver = Undo.AddComponent(camGameObject, typeof(UnityEngine.InputSystem.XR.TrackedPoseDriver)) as UnityEngine.InputSystem.XR.TrackedPoseDriver;
|
|||
|
|
|||
|
if (_tposeDriver != null)
|
|||
|
{
|
|||
|
// Permit both rotation AND position for the head-mounted device (HMD). This will give a more natural
|
|||
|
// feel for the user and may help reduce motion sickness.
|
|||
|
_tposeDriver.trackingType = UnityEngine.InputSystem.XR.TrackedPoseDriver.TrackingType.RotationAndPosition;
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputAction _tposPosition = new UnityEngine.InputSystem.InputAction(null, UnityEngine.InputSystem.InputActionType.Value);
|
|||
|
if (_tposPosition != null)
|
|||
|
{
|
|||
|
_tposeDriver.positionAction = _tposPosition;
|
|||
|
}
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputAction _tposRotation = new UnityEngine.InputSystem.InputAction(null, UnityEngine.InputSystem.InputActionType.Value);
|
|||
|
if (_tposRotation != null)
|
|||
|
{
|
|||
|
_tposRotation.expectedControlType = "Quaternion";
|
|||
|
_tposeDriver.rotationAction = _tposRotation;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
//camOffsetGameObject.transform.SetParent(playerInputModule.transform, false);
|
|||
|
camGameObject.transform.SetParent(camOffsetGameObject.transform, false);
|
|||
|
playerInputModule.SetXRFirstPersonCamera1(_newCamera, camGameObject.transform, true);
|
|||
|
|
|||
|
// Look for an existing AudioListener
|
|||
|
AudioListener _audioListener = playerInputModule.GetComponentInChildren<AudioListener>();
|
|||
|
if (_audioListener == null)
|
|||
|
{
|
|||
|
// Didn't find one, so add an AudioListener now
|
|||
|
_audioListener = Undo.AddComponent(camGameObject, typeof(AudioListener)) as AudioListener;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
Undo.CollapseUndoOperations(undoGroup);
|
|||
|
|
|||
|
// Should be non-scene objects but is required to force being set as dirty
|
|||
|
EditorUtility.SetDirty(playerInputModule);
|
|||
|
|
|||
|
GUIUtility.ExitGUI();
|
|||
|
|
|||
|
//serializedObject.Update();
|
|||
|
}
|
|||
|
EditorGUILayout.PropertyField(firstPersonCamera1XRProp, GUIContent.none);
|
|||
|
|
|||
|
GUILayout.EndHorizontal();
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region XR Hands
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
GUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(xrLeftHandTransformContent, GUILayout.Width(defaultEditorLabelWidth - 53f));
|
|||
|
if (GUILayout.Button(xrNewHandContent, buttonCompact, GUILayout.MaxWidth(50f)) && leftHandTransformXRProp.objectReferenceValue == null)
|
|||
|
{
|
|||
|
XRCreateHand(leftHandTransformXRProp, true);
|
|||
|
}
|
|||
|
EditorGUILayout.PropertyField(leftHandTransformXRProp, GUIContent.none);
|
|||
|
|
|||
|
GUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
GUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(xrRightHandTransformContent, GUILayout.Width(defaultEditorLabelWidth - 53f));
|
|||
|
if (GUILayout.Button(xrNewHandContent, buttonCompact, GUILayout.MaxWidth(50f)) && rightHandTransformXRProp.objectReferenceValue == null)
|
|||
|
{
|
|||
|
XRCreateHand(rightHandTransformXRProp, false);
|
|||
|
}
|
|||
|
EditorGUILayout.PropertyField(rightHandTransformXRProp, GUIContent.none);
|
|||
|
|
|||
|
GUILayout.EndHorizontal();
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Horizontal Input
|
|||
|
DrawFoldoutWithLabel(horizontalShowInEditorProp, horizontalHeaderContent);
|
|||
|
if (horizontalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXR(horizontalInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
inputActionAssetXRProp, positiveHorizontalInputActionMapIdXRProp,
|
|||
|
positiveHorizontalInputActionIdUISProp, positiveHorizontalInputActionDataSlotUISProp,
|
|||
|
xrInputAMContent, uisHorizontalInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, true, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawSensitivity(horizontalInputAxisModeProp,
|
|||
|
isSensitivityForHorizontalEnabledProp, sensitivityEnabledContent,
|
|||
|
horizontalAxisSensitivityProp, sensitivityContent,
|
|||
|
horizontalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isHorizontalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Vertical Input
|
|||
|
DrawFoldoutWithLabel(verticalShowInEditorProp, verticalHeaderContent);
|
|||
|
if (verticalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXR(verticalInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
inputActionAssetXRProp, positiveVerticalInputActionMapIdXRProp,
|
|||
|
positiveVerticalInputActionIdUISProp, positiveVerticalInputActionDataSlotUISProp,
|
|||
|
xrInputAMContent, uisVerticalInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, true, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawSensitivity(verticalInputAxisModeProp,
|
|||
|
isSensitivityForVerticalEnabledProp, sensitivityEnabledContent,
|
|||
|
verticalAxisSensitivityProp, sensitivityContent,
|
|||
|
verticalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isVerticalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Longitudinal Input
|
|||
|
DrawFoldoutWithLabel(longitudinalShowInEditorProp, longitudinalHeaderContent);
|
|||
|
if (longitudinalShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXR(longitudinalInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
inputActionAssetXRProp, positiveLongitudinalInputActionMapIdXRProp,
|
|||
|
positiveLongitudinalInputActionIdUISProp, positiveLongitudinalInputActionDataSlotUISProp,
|
|||
|
xrInputAMContent, uisLongitudinalInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, true, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawSensitivity(longitudinalInputAxisModeProp,
|
|||
|
isSensitivityForLongitudinalEnabledProp, sensitivityEnabledContent,
|
|||
|
longitudinalAxisSensitivityProp, sensitivityContent,
|
|||
|
longitudinalAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isLongitudinalDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Pitch Input
|
|||
|
DrawFoldoutWithLabel(pitchShowInEditorProp, pitchHeaderContent);
|
|||
|
if (pitchShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXR(pitchInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
inputActionAssetXRProp, positivePitchInputActionMapIdXRProp,
|
|||
|
positivePitchInputActionIdUISProp, positivePitchInputActionDataSlotUISProp,
|
|||
|
xrInputAMContent, uisPitchInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, true, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawSensitivity(pitchInputAxisModeProp,
|
|||
|
isSensitivityForPitchEnabledProp, sensitivityEnabledContent,
|
|||
|
pitchAxisSensitivityProp, sensitivityContent,
|
|||
|
pitchAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isPitchDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Yaw Input
|
|||
|
DrawFoldoutWithLabel(yawShowInEditorProp, yawHeaderContent);
|
|||
|
if (yawShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXR(yawInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
inputActionAssetXRProp, positiveYawInputActionMapIdXRProp,
|
|||
|
positiveYawInputActionIdUISProp, positiveYawInputActionDataSlotUISProp,
|
|||
|
xrInputAMContent, uisYawInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, true, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawSensitivity(yawInputAxisModeProp,
|
|||
|
isSensitivityForYawEnabledProp, sensitivityEnabledContent,
|
|||
|
yawAxisSensitivityProp, sensitivityContent,
|
|||
|
yawAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isYawDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Roll Input
|
|||
|
DrawFoldoutWithLabel(rollShowInEditorProp, rollHeaderContent);
|
|||
|
if (rollShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXR(rollInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
inputActionAssetXRProp, positiveRollInputActionMapIdXRProp,
|
|||
|
positiveRollInputActionIdUISProp, positiveRollInputActionDataSlotUISProp,
|
|||
|
xrInputAMContent, uisRollInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, true, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawSensitivity(rollInputAxisModeProp,
|
|||
|
isSensitivityForRollEnabledProp, sensitivityEnabledContent,
|
|||
|
rollAxisSensitivityProp, sensitivityContent,
|
|||
|
rollAxisGravityProp, gravityContent);
|
|||
|
DrawDiscardData(isRollDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Primary Fire Input
|
|||
|
DrawFoldoutWithLabel(primaryFireShowInEditorProp, primaryFireHeaderContent);
|
|||
|
if (primaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXRButton(primaryFireButtonEnabledProp, uisPrimaryFireEnabledContent,
|
|||
|
inputActionAssetXRProp, primaryFireInputActionMapIdXRProp,
|
|||
|
primaryFireInputActionIdUISProp, primaryFireInputActionDataSlotUISProp,
|
|||
|
primaryFireCanBeHeldProp, xrInputAMContent, uisPrimaryFireInputAContent,
|
|||
|
uisInputATypeContent, uisInputCTypeContent, uisInputDataSlotContent,
|
|||
|
fireCanBeHeldContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawDiscardData(isPrimaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Secondary Fire Input
|
|||
|
DrawFoldoutWithLabel(secondaryFireShowInEditorProp, secondaryFireHeaderContent);
|
|||
|
if (secondaryFireShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXRButton(secondaryFireButtonEnabledProp, uisSecondaryFireEnabledContent,
|
|||
|
inputActionAssetXRProp, secondaryFireInputActionMapIdXRProp,
|
|||
|
secondaryFireInputActionIdUISProp, secondaryFireInputActionDataSlotUISProp,
|
|||
|
secondaryFireCanBeHeldProp, xrInputAMContent, uisSecondaryFireInputAContent,
|
|||
|
uisInputATypeContent, uisInputCTypeContent, uisInputDataSlotContent,
|
|||
|
fireCanBeHeldContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawDiscardData(isSecondaryFireDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Docking Input
|
|||
|
DrawFoldoutWithLabel(dockingShowInEditorProp, dockingHeaderContent);
|
|||
|
if (dockingShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
DrawXRButton(dockingButtonEnabledProp, uisDockingEnabledContent,
|
|||
|
inputActionAssetXRProp, dockingInputActionMapIdXRProp,
|
|||
|
dockingInputActionIdUISProp, dockingInputActionDataSlotUISProp,
|
|||
|
null, xrInputAMContent, uisDockingInputAContent,
|
|||
|
uisInputATypeContent, uisInputCTypeContent, uisInputDataSlotContent,
|
|||
|
null, uisDataSlots2, uisDataSlots3, numActionMapIDs, xrForceActionRefresh
|
|||
|
);
|
|||
|
DrawDiscardData(isDockDataDiscardedProp, discardDataContent);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Rumble Controller output
|
|||
|
DrawFoldoutWithLabel(rumbleShowInEditorProp, rumbleHeaderContent);
|
|||
|
if (rumbleShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(maxRumble1Prop, maxRumble1Content);
|
|||
|
EditorGUILayout.PropertyField(maxRumble2Prop, maxRumble2Content);
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
xrForceActionRefresh = false;
|
|||
|
}
|
|||
|
|
|||
|
#elif !UNITY_2020_3_OR_NEWER
|
|||
|
EditorGUILayout.HelpBox("In SSC, Unity XR is only supported on Unity 2020.3 or newer. You could use Oculus API or VIVE API instead.", MessageType.Warning, true);
|
|||
|
#else
|
|||
|
EditorGUILayout.HelpBox("Unity XR package or Unity Input System is not installed. Did you install the XR Management package?", MessageType.Warning, true);
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Custom Player Input
|
|||
|
DrawFoldoutWithLabel(cpiShowInEditorProp, cpiHeaderContent);
|
|||
|
if (cpiShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
cpiDeletePos = -1;
|
|||
|
|
|||
|
#region Check if list is null and get size
|
|||
|
|
|||
|
// Checking the property for being NULL doesn't check if the list is actually null.
|
|||
|
if (playerInputModule.customPlayerInputList == null)
|
|||
|
{
|
|||
|
// Apply property changes
|
|||
|
serializedObject.ApplyModifiedProperties();
|
|||
|
playerInputModule.customPlayerInputList = new List<CustomPlayerInput>(4);
|
|||
|
// Read in the properties
|
|||
|
serializedObject.Update();
|
|||
|
}
|
|||
|
|
|||
|
int numCustomPlayerInputs = cpiListProp.arraySize;
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Add or Remove items
|
|||
|
|
|||
|
GUILayout.BeginHorizontal();
|
|||
|
|
|||
|
EditorGUI.indentLevel += 1;
|
|||
|
EditorGUIUtility.fieldWidth = 15f;
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
cpiIsListExpandedProp.boolValue = EditorGUILayout.Foldout(cpiIsListExpandedProp.boolValue, GUIContent.none, foldoutStyleNoLabel);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
serializedObject.ApplyModifiedProperties();
|
|||
|
ExpandList(playerInputModule.customPlayerInputList, cpiIsListExpandedProp.boolValue);
|
|||
|
// Read in the properties
|
|||
|
serializedObject.Update();
|
|||
|
}
|
|||
|
EditorGUI.indentLevel -= 1;
|
|||
|
|
|||
|
EditorGUIUtility.fieldWidth = defaultEditorFieldWidth;
|
|||
|
EditorGUILayout.LabelField("Custom Player Inputs: " + numCustomPlayerInputs.ToString("00"), labelFieldRichText);
|
|||
|
|
|||
|
if (GUILayout.Button("+", GUILayout.MaxWidth(30f)))
|
|||
|
{
|
|||
|
// Apply property changes
|
|||
|
serializedObject.ApplyModifiedProperties();
|
|||
|
Undo.RecordObject(playerInputModule, "Add Custom Player Input");
|
|||
|
playerInputModule.customPlayerInputList.Add(new CustomPlayerInput());
|
|||
|
ExpandList(playerInputModule.customPlayerInputList, false);
|
|||
|
// Read in the properties
|
|||
|
serializedObject.Update();
|
|||
|
|
|||
|
numCustomPlayerInputs = cpiListProp.arraySize;
|
|||
|
if (numCustomPlayerInputs > 0)
|
|||
|
{
|
|||
|
// Force new custom input to be serialized in scene
|
|||
|
cpiItemProp = cpiListProp.GetArrayElementAtIndex(numCustomPlayerInputs - 1);
|
|||
|
cpiItemShowInEditorProp = cpiItemProp.FindPropertyRelative("showInEditor");
|
|||
|
cpiItemShowInEditorProp.boolValue = !cpiItemShowInEditorProp.boolValue;
|
|||
|
// Show the new custom player input
|
|||
|
cpiItemShowInEditorProp.boolValue = true;
|
|||
|
}
|
|||
|
}
|
|||
|
if (GUILayout.Button("-", GUILayout.MaxWidth(30f)))
|
|||
|
{
|
|||
|
if (numCustomPlayerInputs > 0) { cpiDeletePos = cpiListProp.arraySize - 1; }
|
|||
|
}
|
|||
|
|
|||
|
GUILayout.EndHorizontal();
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Custom Player Input List items
|
|||
|
|
|||
|
#if SSC_REWIRED
|
|||
|
int numActionCategories = actionCategoryIDs == null ? 0 : actionCategoryIDs.Length;
|
|||
|
#endif
|
|||
|
|
|||
|
#if SSC_UIS
|
|||
|
bool isUISAvailable = inputModeProp.intValue == (int)PlayerInputModule.InputMode.UnityInputSystem &&
|
|||
|
uisPlayerInput != null && uisPlayerInput.actions != null &&
|
|||
|
uisPlayerInput.notificationBehavior == UnityEngine.InputSystem.PlayerNotifications.InvokeUnityEvents &&
|
|||
|
!string.IsNullOrEmpty(uisPlayerInput.defaultActionMap);
|
|||
|
int numActionIDs = uisActionIDs == null ? 0 : uisActionIDs.Length;
|
|||
|
#endif
|
|||
|
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
bool isXRAvailable = inputModeProp.intValue == (int)PlayerInputModule.InputMode.UnityXR &&
|
|||
|
inputActionAssetXRProp != null && inputActionAssetXRProp.objectReferenceValue != null;
|
|||
|
int numActionMapIDs = xrActionMapIDs == null ? 0 : xrActionMapIDs.Length;
|
|||
|
#endif
|
|||
|
|
|||
|
for (int cpiIdx = 0; cpiIdx < numCustomPlayerInputs; cpiIdx++)
|
|||
|
{
|
|||
|
GUILayout.BeginVertical(EditorStyles.helpBox);
|
|||
|
cpiItemProp = cpiListProp.GetArrayElementAtIndex(cpiIdx);
|
|||
|
|
|||
|
cpiItemShowInEditorProp = cpiItemProp.FindPropertyRelative("showInEditor");
|
|||
|
cpiIsButtonProp = cpiItemProp.FindPropertyRelative("isButton");
|
|||
|
cpiCanBeHeldDownProp = cpiItemProp.FindPropertyRelative("canBeHeldDown");
|
|||
|
cpiInputAxisModeProp = cpiItemProp.FindPropertyRelative("inputAxisMode");
|
|||
|
cpiIsSensitivityEnabledProp = cpiItemProp.FindPropertyRelative("isSensitivityEnabled");
|
|||
|
cpiSensitivityProp = cpiItemProp.FindPropertyRelative("sensitivity");
|
|||
|
cpiGravityProp = cpiItemProp.FindPropertyRelative("gravity");
|
|||
|
|
|||
|
#region Custom input name and Delete button
|
|||
|
GUILayout.BeginHorizontal();
|
|||
|
EditorGUI.indentLevel += 1;
|
|||
|
cpiItemShowInEditorProp.boolValue = EditorGUILayout.Foldout(cpiItemShowInEditorProp.boolValue, "Custom Player Input " + (cpiIdx + 1).ToString("00"));
|
|||
|
EditorGUI.indentLevel -= 1;
|
|||
|
// Delete button
|
|||
|
if (GUILayout.Button("X", buttonCompact, GUILayout.MaxWidth(20f))) { cpiDeletePos = cpiIdx; }
|
|||
|
GUILayout.EndHorizontal();
|
|||
|
#endregion
|
|||
|
|
|||
|
if (cpiItemShowInEditorProp.boolValue)
|
|||
|
{
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER || SSC_OVR
|
|||
|
// If isButton is changes from false to true, we may need to reset some values below
|
|||
|
// to indicate only one input axis is possible.
|
|||
|
bool hasButtonChanged = false;
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(cpiIsButtonProp, cpiIsButtonContent);
|
|||
|
if (EditorGUI.EndChangeCheck()) { hasButtonChanged = true; }
|
|||
|
#else
|
|||
|
EditorGUILayout.PropertyField(cpiIsButtonProp, cpiIsButtonContent);
|
|||
|
#endif
|
|||
|
|
|||
|
if (inputModeProp.intValue != (int)PlayerInputModule.InputMode.Rewired &&
|
|||
|
inputModeProp.intValue != (int)PlayerInputModule.InputMode.Vive &&
|
|||
|
inputModeProp.intValue != (int)PlayerInputModule.InputMode.UnityInputSystem &&
|
|||
|
inputModeProp.intValue != (int)PlayerInputModule.InputMode.UnityXR)
|
|||
|
{
|
|||
|
if (cpiIsButtonProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(cpiCanBeHeldDownProp, cpiCanBeHeldDownContent);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#region Direct Keyboard Input
|
|||
|
if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.DirectKeyboard)
|
|||
|
{
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
cpidkmPositiveKeycodeProp = cpiItemProp.FindPropertyRelative("dkmPositiveKeycode");
|
|||
|
cpidkmNegativeKeycodeProp = cpiItemProp.FindPropertyRelative("dkmNegativeKeycode");
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(cpidkmPositiveKeycodeProp, positiveKeycodeContent);
|
|||
|
if (!cpiIsButtonProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(cpidkmNegativeKeycodeProp, negativeKeycodeContent);
|
|||
|
|
|||
|
if (cpidkmPositiveKeycodeProp.intValue == cpidkmNegativeKeycodeProp.intValue
|
|||
|
&& cpidkmPositiveKeycodeProp.intValue != 0)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalKeycodesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
else if (hasButtonChanged) { cpidkmNegativeKeycodeProp.intValue = 0; }
|
|||
|
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Legacy Unity Input System
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.LegacyUnity)
|
|||
|
{
|
|||
|
#if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
|
|||
|
|
|||
|
cpilisPositiveAxisNameProp = cpiItemProp.FindPropertyRelative("lisPositiveAxisName");
|
|||
|
cpilisNegativeAxisNameProp = cpiItemProp.FindPropertyRelative("lisNegativeAxisName");
|
|||
|
cpilisInvertAxisProp = cpiItemProp.FindPropertyRelative("lisInvertAxis");
|
|||
|
cpilisIsPositiveAxisValidProp = cpiItemProp.FindPropertyRelative("lisIsPositiveAxisValid");
|
|||
|
cpilisIsNegativeAxisValidProp = cpiItemProp.FindPropertyRelative("lisIsNegativeAxisValid");
|
|||
|
|
|||
|
if (cpiIsButtonProp.boolValue)
|
|||
|
{
|
|||
|
// If this is a button, there is only one input
|
|||
|
if (hasButtonChanged) { cpiInputAxisModeProp.intValue = (int)PlayerInputModule.InputAxisMode.SingleAxis; }
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(cpilisPositiveAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
cpilisIsPositiveAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(cpilisPositiveAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!cpilisIsPositiveAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
// Single or Combined Axis
|
|||
|
EditorGUILayout.PropertyField(cpiInputAxisModeProp, inputAxisModeContent);
|
|||
|
if (cpiInputAxisModeProp.intValue != (int)PlayerInputModule.InputAxisMode.NoInput)
|
|||
|
{
|
|||
|
if (cpiInputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.SingleAxis)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(cpilisPositiveAxisNameProp, singleAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
cpilisIsPositiveAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(cpilisPositiveAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!cpilisIsPositiveAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(cpilisPositiveAxisNameProp, positiveAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
cpilisIsPositiveAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(cpilisPositiveAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!cpilisIsPositiveAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(cpilisNegativeAxisNameProp, negativeAxisNameContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
cpilisIsNegativeAxisValidProp.boolValue = PlayerInputModule.IsLegacyAxisValid(cpilisNegativeAxisNameProp.stringValue, false);
|
|||
|
}
|
|||
|
if (!cpilisIsNegativeAxisValidProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(invalidLegacyAxisNameWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
if (cpilisPositiveAxisNameProp.stringValue == cpilisNegativeAxisNameProp.stringValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalAxisNamesWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(cpilisInvertAxisProp, invertInputAxisContent);
|
|||
|
DrawSensitivity(cpiInputAxisModeProp, cpiIsSensitivityEnabledProp, sensitivityEnabledContent,
|
|||
|
cpiSensitivityProp, sensitivityContent, cpiGravityProp, gravityContent);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Unity Input System (add with Unity package manager)
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.UnityInputSystem)
|
|||
|
{
|
|||
|
#if SSC_UIS
|
|||
|
if (isUISAvailable)
|
|||
|
{
|
|||
|
cpiIsButtonEnabledProp = cpiItemProp.FindPropertyRelative("isButtonEnabled");
|
|||
|
cpiuisPositiveInputActionIdProp = cpiItemProp.FindPropertyRelative("uisPositiveInputActionId");
|
|||
|
cpiuisPositiveInputActionDataSlotProp = cpiItemProp.FindPropertyRelative("uisPositiveInputActionDataSlot");
|
|||
|
|
|||
|
if (cpiIsButtonProp.boolValue)
|
|||
|
{
|
|||
|
DrawUnityInputSystemFire(cpiIsButtonEnabledProp, uisCustomEnabledContent,
|
|||
|
cpiuisPositiveInputActionIdProp, cpiuisPositiveInputActionDataSlotProp,
|
|||
|
cpiCanBeHeldDownProp, uisCustomInputAContent,
|
|||
|
uisInputATypeContent, uisInputCTypeContent, uisInputDataSlotContent,
|
|||
|
cpiCanBeHeldDownContent, uisDataSlots2, uisDataSlots3, numActionIDs
|
|||
|
);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
DrawUnityInputSystem(cpiInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
cpiuisPositiveInputActionIdProp, cpiuisPositiveInputActionDataSlotProp,
|
|||
|
uisCustomInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionIDs, false
|
|||
|
);
|
|||
|
DrawSensitivity(cpiInputAxisModeProp,
|
|||
|
cpiIsSensitivityEnabledProp, sensitivityEnabledContent,
|
|||
|
cpiSensitivityProp, sensitivityContent,
|
|||
|
cpiGravityProp, gravityContent);
|
|||
|
}
|
|||
|
}
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Oculus OVR API input
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.OculusAPI && !isRefreshing)
|
|||
|
{
|
|||
|
#if SSC_OVR
|
|||
|
|
|||
|
cpiovrInputTypeProp = cpiItemProp.FindPropertyRelative("ovrInputType");
|
|||
|
cpiovrPositiveInputProp = cpiItemProp.FindPropertyRelative("ovrPositiveInput");
|
|||
|
cpiovrNegativeInputProp = cpiItemProp.FindPropertyRelative("ovrNegativeInput");
|
|||
|
|
|||
|
if (cpiIsButtonProp.boolValue)
|
|||
|
{
|
|||
|
DrawOVRInput(cpiovrPositiveInputProp, null, ovrCustomButtonInputContent, null);
|
|||
|
if (hasButtonChanged) { cpiovrNegativeInputProp.intValue = 0; }
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
DrawOVRInput(PIMCategory.CustomPlayerInput, cpiInputAxisModeProp, cpiovrInputTypeProp,
|
|||
|
cpiovrPositiveInputProp, cpiovrNegativeInputProp,
|
|||
|
ovrCustomInputTypeContent,
|
|||
|
ovrCustomPositiveInputContent,
|
|||
|
ovrCustomNegativeInputContent,
|
|||
|
ovrCustomInputContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(cpiInputAxisModeProp, cpiIsSensitivityEnabledProp, sensitivityEnabledContent,
|
|||
|
cpiSensitivityProp, sensitivityContent, cpiGravityProp, gravityContent);
|
|||
|
}
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Rewired Input
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.Rewired && !isRefreshing)
|
|||
|
{
|
|||
|
#if SSC_REWIRED
|
|||
|
cpiIsButtonEnabledProp = cpiItemProp.FindPropertyRelative("isButtonEnabled");
|
|||
|
cpirwdPositiveInputActionIdProp = cpiItemProp.FindPropertyRelative("rwdPositiveInputActionId");
|
|||
|
cpirwdNegativeInputActionIdProp = cpiItemProp.FindPropertyRelative("rwdNegativeInputActionId");
|
|||
|
|
|||
|
CustomPlayerInput customPlayerInput = playerInputModule.customPlayerInputList[cpiIdx];
|
|||
|
|
|||
|
if (cpiIsButtonProp.boolValue)
|
|||
|
{
|
|||
|
DrawRewiredInput(cpiIsButtonEnabledProp, cpirwdPositiveInputActionIdProp, cpiCanBeHeldDownProp, rwCustomEnabledContent, rwCustomInputACContent, rwCustomInputAIContent,
|
|||
|
cpiCanBeHeldDownContent, ref customPlayerInput.actionIDsPositive, ref customPlayerInput.ActionGUIContentPositive, numActionCategories);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
DrawRewiredInput(PIMCategory.CustomPlayerInput, cpiInputAxisModeProp, cpirwdPositiveInputActionIdProp, cpirwdNegativeInputActionIdProp,
|
|||
|
rwCustomInputACPositiveContent, rwCustomInputACNegativeContent, rwCustomInputACContent,
|
|||
|
rwCustomInputAIPositiveContent, rwCustomInputAINegativeContent, rwCustomInputAIContent,
|
|||
|
ref customPlayerInput.actionIDsPositive, ref customPlayerInput.actionIDsNegative,
|
|||
|
ref customPlayerInput.ActionGUIContentPositive, ref customPlayerInput.ActionGUIContentNegative, numActionCategories);
|
|||
|
|
|||
|
DrawSensitivity(cpiInputAxisModeProp, cpiIsSensitivityEnabledProp, sensitivityEnabledContent,
|
|||
|
cpiSensitivityProp, sensitivityContent, cpiGravityProp, gravityContent);
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region VIVE
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.Vive && !isRefreshing)
|
|||
|
{
|
|||
|
#if VIU_PLUGIN
|
|||
|
cpiIsButtonEnabledProp = cpiItemProp.FindPropertyRelative("isButtonEnabled");
|
|||
|
cpiviveInputTypeProp = cpiItemProp.FindPropertyRelative("viveInputType");
|
|||
|
cpiviveRoleTypeProp = cpiItemProp.FindPropertyRelative("viveRoleType");
|
|||
|
cpivivePositiveInputRoleIdProp = cpiItemProp.FindPropertyRelative("vivePositiveInputRoleId");
|
|||
|
cpiviveNegativeInputRoleIdProp = cpiItemProp.FindPropertyRelative("viveNegativeInputRoleId");
|
|||
|
cpivivePositiveInputCtrlProp = cpiItemProp.FindPropertyRelative("vivePositiveInputCtrl");
|
|||
|
cpiviveNegativeInputCtrlProp = cpiItemProp.FindPropertyRelative("viveNegativeInputCtrl");
|
|||
|
|
|||
|
if (cpiIsButtonProp.boolValue)
|
|||
|
{
|
|||
|
DrawViveInput(
|
|||
|
cpiIsButtonEnabledProp,
|
|||
|
cpiviveRoleTypeProp,
|
|||
|
cpivivePositiveInputRoleIdProp,
|
|||
|
cpivivePositiveInputCtrlProp,
|
|||
|
cpiCanBeHeldDownProp,
|
|||
|
viveCustomEnabledContent,
|
|||
|
viveCustomRoleTypeContent,
|
|||
|
viveCustomRoleIdContent,
|
|||
|
viveCustomInputCtrlContent,
|
|||
|
cpiCanBeHeldDownContent
|
|||
|
);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
DrawViveInput(PIMCategory.CustomPlayerInput, cpiInputAxisModeProp, cpiviveInputTypeProp,
|
|||
|
cpiviveRoleTypeProp,
|
|||
|
cpivivePositiveInputRoleIdProp, cpiviveNegativeInputRoleIdProp,
|
|||
|
cpivivePositiveInputCtrlProp, cpiviveNegativeInputCtrlProp,
|
|||
|
viveCustomInputTypeContent,
|
|||
|
viveCustomRoleTypeContent,
|
|||
|
viveCustomPositiveRoleIdContent,
|
|||
|
viveCustomNegativeRoleIdContent,
|
|||
|
viveCustomRoleIdContent,
|
|||
|
viveCustomPositiveInputCtrlContent,
|
|||
|
viveCustomNegativeInputCtrlContent,
|
|||
|
viveCustomInputCtrlContent
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(cpiInputAxisModeProp, cpiIsSensitivityEnabledProp, sensitivityEnabledContent,
|
|||
|
cpiSensitivityProp, sensitivityContent, cpiGravityProp, gravityContent);
|
|||
|
}
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region UnityXR
|
|||
|
else if (inputModeProp.intValue == (int)PlayerInputModule.InputMode.UnityXR && !isRefreshing)
|
|||
|
{
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
if (isXRAvailable)
|
|||
|
{
|
|||
|
cpiIsButtonEnabledProp = cpiItemProp.FindPropertyRelative("isButtonEnabled");
|
|||
|
cpixrPositiveInputActionMapIdProp = cpiItemProp.FindPropertyRelative("xrPositiveInputActionMapId");
|
|||
|
cpiuisPositiveInputActionIdProp = cpiItemProp.FindPropertyRelative("uisPositiveInputActionId");
|
|||
|
cpiuisPositiveInputActionDataSlotProp = cpiItemProp.FindPropertyRelative("uisPositiveInputActionDataSlot");
|
|||
|
|
|||
|
if (cpiIsButtonProp.boolValue)
|
|||
|
{
|
|||
|
DrawXRButton(cpiIsButtonEnabledProp, uisCustomEnabledContent,
|
|||
|
inputActionAssetXRProp, cpixrPositiveInputActionMapIdProp,
|
|||
|
cpiuisPositiveInputActionIdProp, cpiuisPositiveInputActionDataSlotProp,
|
|||
|
cpiCanBeHeldDownProp, xrInputAMContent, uisCustomInputAContent,
|
|||
|
uisInputATypeContent, uisInputCTypeContent, uisInputDataSlotContent,
|
|||
|
cpiCanBeHeldDownContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, xrForceActionRefresh
|
|||
|
);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
DrawXR(cpiInputAxisModeProp, inputSystemAxisModeContent,
|
|||
|
inputActionAssetXRProp, cpixrPositiveInputActionMapIdProp,
|
|||
|
cpiuisPositiveInputActionIdProp, cpiuisPositiveInputActionDataSlotProp,
|
|||
|
xrInputAMContent, uisCustomInputAContent, uisInputATypeContent, uisInputCTypeContent,
|
|||
|
uisInputDataSlotContent, uisDataSlots2, uisDataSlots3, numActionMapIDs, false, xrForceActionRefresh
|
|||
|
);
|
|||
|
|
|||
|
DrawSensitivity(cpiInputAxisModeProp,
|
|||
|
cpiIsSensitivityEnabledProp, sensitivityEnabledContent,
|
|||
|
cpiSensitivityProp, sensitivityContent,
|
|||
|
cpiGravityProp, gravityContent);
|
|||
|
}
|
|||
|
}
|
|||
|
#endif
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
cpiEventProp = cpiItemProp.FindPropertyRelative("customPlayerInputEvt");
|
|||
|
EditorGUILayout.PropertyField(cpiEventProp, cpiEventContent);
|
|||
|
}
|
|||
|
|
|||
|
GUILayout.EndVertical();
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Delete Items
|
|||
|
if (cpiDeletePos >= 0)
|
|||
|
{
|
|||
|
// In U2019.4+ DisplayDialog seems to trigger another OnInspectorGUI() and cpiDeletePos is reset to -1.
|
|||
|
int _deleteIndex = cpiDeletePos;
|
|||
|
|
|||
|
if (EditorUtility.DisplayDialog("Delete Custom Player Input " + (cpiDeletePos + 1) + "?", "Custom Player Input " + (cpiDeletePos + 1).ToString("00") + " will be deleted\n\nThis action will remove the custom player input from the list and cannot be undone.", "Delete Now", "Cancel"))
|
|||
|
{
|
|||
|
cpiListProp.DeleteArrayElementAtIndex(_deleteIndex);
|
|||
|
cpiDeletePos = -1;
|
|||
|
serializedObject.ApplyModifiedProperties();
|
|||
|
GUIUtility.ExitGUI();
|
|||
|
}
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
EditorGUILayout.EndVertical();
|
|||
|
|
|||
|
#region Debug Mode
|
|||
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|||
|
isDebuggingEnabled = EditorGUILayout.Toggle(debugModeContent, isDebuggingEnabled);
|
|||
|
// Debug at runtime in the editor
|
|||
|
if (isDebuggingEnabled && shipInput != null && playerInputModule != null)
|
|||
|
{
|
|||
|
SSCEditorHelper.PerformanceImpact();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugIsInitialisedContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth - 3f));
|
|||
|
EditorGUILayout.LabelField(playerInputModule.IsInitialised ? "Yes" : "No", GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugIsInputEnabledContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth - 3f));
|
|||
|
EditorGUILayout.LabelField(playerInputModule.IsInputEnabled ? "Yes" : "No", GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugIsCustomPlayerInputOnlyEnabledContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth - 3f));
|
|||
|
EditorGUILayout.LabelField(playerInputModule.IsCustomPlayerInputOnlyEnabled ? "Yes" : "No", GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugIsShipAIModeEnabledContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth - 3f));
|
|||
|
EditorGUILayout.LabelField(playerInputModule.IsShipAIModeEnabled ? "Yes" : "No", GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugHorizontalContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isHorizontalDataDiscardedProp.boolValue ? "---" : shipInput.horizontal.ToString("0.000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugVerticalContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isVerticalDataDiscardedProp.boolValue ? "---" : shipInput.vertical.ToString("0.000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugLongitudinalContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isLongitudinalDataDiscardedProp.boolValue ? "---" : shipInput.longitudinal.ToString("0.000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugPitchContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isPitchDataDiscardedProp.boolValue ? "---" : shipInput.pitch.ToString("0.000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugYawContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isYawDataDiscardedProp.boolValue ? "---" : shipInput.yaw.ToString("0.000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugRollContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isRollDataDiscardedProp.boolValue ? "---" : shipInput.roll.ToString("0.000"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugPrimaryFireContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isPrimaryFireDataDiscardedProp.boolValue ? "---" : shipInput.primaryFire.ToString(), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugSecondaryFireContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isSecondaryFireDataDiscardedProp.boolValue ? "---" : shipInput.secondaryFire.ToString(), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugDockingContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(isDockDataDiscardedProp.boolValue ? "---" : shipInput.dock.ToString(), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(debugShipSpeedContent, labelFieldRichText, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
if (shipControlModule != null)
|
|||
|
{
|
|||
|
// z-axis of Local space velocity. Convert to km/h
|
|||
|
float shipVelocity = (shipControlModule.shipInstance.TransformInverseRotation * shipControlModule.ShipRigidbody.velocity).z * 3.6f;
|
|||
|
EditorGUILayout.LabelField(shipVelocity.ToString("0.0"), GUILayout.MaxWidth(defaultEditorFieldWidth));
|
|||
|
}
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
#if SSC_UIS
|
|||
|
if (GUILayout.Button(uisDebugApplyChangedContent, GUILayout.MaxWidth(120f)))
|
|||
|
{
|
|||
|
serializedObject.ApplyModifiedProperties();
|
|||
|
((PlayerInputModule)serializedObject.targetObject).UpdateUnityInputSystemActions(true);
|
|||
|
}
|
|||
|
#endif
|
|||
|
|
|||
|
}
|
|||
|
EditorGUILayout.EndVertical();
|
|||
|
#endregion Debug Mode
|
|||
|
|
|||
|
// Apply property changes
|
|||
|
serializedObject.ApplyModifiedProperties();
|
|||
|
|
|||
|
playerInputModule.allowRepaint = true;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Private methods - General
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Verify that the appropriate Thrusters are present in the ShipControlModule. If not, display a warning in the inspector.
|
|||
|
/// </summary>
|
|||
|
/// <param name="pimCategory"></param>
|
|||
|
private void VerifyThrusterPresent(PIMCategory pimCategory)
|
|||
|
{
|
|||
|
|
|||
|
if (shipControlModule != null && shipControlModule.shipInstance != null)
|
|||
|
{
|
|||
|
// Force use: 0 - none. 1 - forwards thrust. 2 - backwards thrust. 3 - upwards thrust. 4 - downwards thrust. 5 - rightwards thrust. 6 - leftwards thrust.
|
|||
|
|
|||
|
bool isThrusterMissing = false;
|
|||
|
string thrustInputText = string.Empty;
|
|||
|
|
|||
|
switch (pimCategory)
|
|||
|
{
|
|||
|
case PIMCategory.Horizontal:
|
|||
|
isThrusterMissing = !shipControlModule.shipInstance.thrusterList.Exists(th => th.forceUse == 5 || th.forceUse == 6);
|
|||
|
thrustInputText = "Leftward or Rightward";
|
|||
|
break;
|
|||
|
case PIMCategory.Vertical:
|
|||
|
isThrusterMissing = !shipControlModule.shipInstance.thrusterList.Exists(th => th.forceUse == 3 || th.forceUse == 4);
|
|||
|
thrustInputText = "Upward or Downward";
|
|||
|
break;
|
|||
|
case PIMCategory.Longitidinal:
|
|||
|
isThrusterMissing = !shipControlModule.shipInstance.thrusterList.Exists(th => th.forceUse == 1 || th.forceUse == 2);
|
|||
|
thrustInputText = "Forward or Backward";
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
if (isThrusterMissing)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("This input will have no effect because there is no Thruster in the ShipControlModule using it. To fix this add at least one Thruster configured with " + thrustInputText + " Thrust.", MessageType.Warning);
|
|||
|
}
|
|||
|
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Expand (show) or collapse (hide) all items in a list in the editor
|
|||
|
/// </summary>
|
|||
|
/// <typeparam name="T"></typeparam>
|
|||
|
/// <param name="componentList"></param>
|
|||
|
/// <param name="isExpanded"></param>
|
|||
|
private void ExpandList<T>(List<T> componentList, bool isExpanded)
|
|||
|
{
|
|||
|
int numComponents = componentList == null ? 0 : componentList.Count;
|
|||
|
|
|||
|
if (numComponents > 0)
|
|||
|
{
|
|||
|
System.Type compType = typeof(T);
|
|||
|
|
|||
|
if (compType == typeof(CustomPlayerInput))
|
|||
|
{
|
|||
|
for (int cpi = 0; cpi < numComponents; cpi++)
|
|||
|
{
|
|||
|
(componentList[cpi] as CustomPlayerInput).showInEditor = isExpanded;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Private Draw methods - General
|
|||
|
|
|||
|
private void DrawFoldoutWithLabel(SerializedProperty showInEditorProp, GUIContent headerLabel)
|
|||
|
{
|
|||
|
GUILayout.BeginHorizontal();
|
|||
|
EditorGUI.indentLevel += 1;
|
|||
|
EditorGUIUtility.fieldWidth = 15f;
|
|||
|
showInEditorProp.boolValue = EditorGUILayout.Foldout(showInEditorProp.boolValue, emptyString, foldoutStyleNoLabel);
|
|||
|
EditorGUIUtility.fieldWidth = defaultEditorFieldWidth;
|
|||
|
EditorGUI.indentLevel -= 1;
|
|||
|
EditorGUILayout.LabelField(headerLabel, headingFieldRichText);
|
|||
|
GUILayout.EndHorizontal();
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Draw sensitivity for Direct keyboard
|
|||
|
/// </summary>
|
|||
|
/// <param name="positiveIntProp"></param>
|
|||
|
/// <param name="negativeIntProp"></param>
|
|||
|
/// <param name="isSensitivityEnabledProp"></param>
|
|||
|
/// <param name="isSensitivityEnabledContent"></param>
|
|||
|
/// <param name="axisSensitivityProp"></param>
|
|||
|
/// <param name="axisSensitivityContent"></param>
|
|||
|
/// <param name="axisGravityProp"></param>
|
|||
|
/// <param name="axisGravityContent"></param>
|
|||
|
private void DrawSensitivity
|
|||
|
(
|
|||
|
SerializedProperty positiveIntProp,
|
|||
|
SerializedProperty negativeIntProp,
|
|||
|
SerializedProperty isSensitivityEnabledProp,
|
|||
|
GUIContent isSensitivityEnabledContent,
|
|||
|
SerializedProperty axisSensitivityProp,
|
|||
|
GUIContent axisSensitivityContent,
|
|||
|
SerializedProperty axisGravityProp,
|
|||
|
GUIContent axisGravityContent
|
|||
|
)
|
|||
|
{
|
|||
|
if (positiveIntProp.intValue != 0 || negativeIntProp.intValue != 0)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isSensitivityEnabledProp, isSensitivityEnabledContent);
|
|||
|
if (isSensitivityEnabledProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(axisSensitivityProp, axisSensitivityContent);
|
|||
|
EditorGUILayout.PropertyField(axisGravityProp, axisGravityContent);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Draw sensitivity for Legacy Unity, UIS, Rewired, Oculus, VIVE
|
|||
|
/// </summary>
|
|||
|
/// <param name="inputAxisModeProp"></param>
|
|||
|
/// <param name="isSensitivityEnabledProp"></param>
|
|||
|
/// <param name="isSensitivityEnabledContent"></param>
|
|||
|
/// <param name="axisSensitivityProp"></param>
|
|||
|
/// <param name="axisSensitivityContent"></param>
|
|||
|
/// <param name="axisGravityProp"></param>
|
|||
|
/// <param name="axisGravityContent"></param>
|
|||
|
private void DrawSensitivity
|
|||
|
(
|
|||
|
SerializedProperty inputAxisModeProp,
|
|||
|
SerializedProperty isSensitivityEnabledProp,
|
|||
|
GUIContent isSensitivityEnabledContent,
|
|||
|
SerializedProperty axisSensitivityProp,
|
|||
|
GUIContent axisSensitivityContent,
|
|||
|
SerializedProperty axisGravityProp,
|
|||
|
GUIContent axisGravityContent
|
|||
|
)
|
|||
|
{
|
|||
|
if (inputAxisModeProp.intValue != (int)PlayerInputModule.InputAxisMode.NoInput)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(isSensitivityEnabledProp, isSensitivityEnabledContent);
|
|||
|
if (isSensitivityEnabledProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(axisSensitivityProp, axisSensitivityContent);
|
|||
|
EditorGUILayout.PropertyField(axisGravityProp, axisGravityContent);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
private void DrawDiscardData(SerializedProperty sendDataProp, GUIContent sendDataContent)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(sendDataProp, sendDataContent);
|
|||
|
}
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Private Draw methods - Oculus API
|
|||
|
#if SSC_OVR
|
|||
|
|
|||
|
private void DrawOVRInput
|
|||
|
(
|
|||
|
PIMCategory pimCategory,
|
|||
|
SerializedProperty inputAxisModeProp,
|
|||
|
SerializedProperty inputTypeProp,
|
|||
|
SerializedProperty positiveInputOVRProp,
|
|||
|
SerializedProperty negativeInputOVRProp,
|
|||
|
GUIContent ovrInputTypeContent,
|
|||
|
GUIContent ovrPositiveInputContent,
|
|||
|
GUIContent ovrNegativeInputContent,
|
|||
|
GUIContent ovrInputContent
|
|||
|
)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputAxisModeProp, inputAxisModeContent);
|
|||
|
if (inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else
|
|||
|
{
|
|||
|
bool isCombined = inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.CombinedAxis;
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(inputTypeProp, ovrInputTypeContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
positiveInputOVRProp.intValue = 0;
|
|||
|
negativeInputOVRProp.intValue = 0;
|
|||
|
}
|
|||
|
|
|||
|
if (inputTypeProp.intValue == (int)PlayerInputModule.OculusInputType.Axis1D)
|
|||
|
{
|
|||
|
OVRInput.Axis1D ovrInputAxis1D = (OVRInput.Axis1D)positiveInputOVRProp.intValue;
|
|||
|
positiveInputOVRProp.intValue = (int)(OVRInput.Axis1D)EditorGUILayout.EnumPopup(isCombined ? ovrPositiveInputContent : ovrInputContent, ovrInputAxis1D);
|
|||
|
}
|
|||
|
else if (inputTypeProp.intValue == (int)PlayerInputModule.OculusInputType.Axis2D)
|
|||
|
{
|
|||
|
OVRInput.Axis2D ovrInputAxis2D = (OVRInput.Axis2D)positiveInputOVRProp.intValue;
|
|||
|
positiveInputOVRProp.intValue = (int)(OVRInput.Axis2D)EditorGUILayout.EnumPopup(isCombined ? ovrPositiveInputContent : ovrInputContent, ovrInputAxis2D);
|
|||
|
}
|
|||
|
else if (inputTypeProp.intValue == (int)PlayerInputModule.OculusInputType.Button)
|
|||
|
{
|
|||
|
OVRInput.Button ovrInputButton = (OVRInput.Button)positiveInputOVRProp.intValue;
|
|||
|
positiveInputOVRProp.intValue = (int)(OVRInput.Button)EditorGUILayout.EnumPopup(isCombined ? ovrPositiveInputContent : ovrInputContent, ovrInputButton);
|
|||
|
}
|
|||
|
else // Pose
|
|||
|
{
|
|||
|
PlayerInputModule.VRPoseRotation ovrInputRotation = (PlayerInputModule.VRPoseRotation)positiveInputOVRProp.intValue;
|
|||
|
positiveInputOVRProp.intValue = (int)(PlayerInputModule.VRPoseRotation)EditorGUILayout.EnumPopup(isCombined ? ovrPositiveInputContent : ovrInputContent, ovrInputRotation);
|
|||
|
}
|
|||
|
|
|||
|
if (isCombined)
|
|||
|
{
|
|||
|
if (inputTypeProp.intValue == (int)PlayerInputModule.OculusInputType.Axis1D)
|
|||
|
{
|
|||
|
OVRInput.Axis1D ovrInputAxis1D = (OVRInput.Axis1D)negativeInputOVRProp.intValue;
|
|||
|
negativeInputOVRProp.intValue = (int)(OVRInput.Axis1D)EditorGUILayout.EnumPopup(ovrNegativeInputContent, ovrInputAxis1D);
|
|||
|
}
|
|||
|
else if (inputTypeProp.intValue == (int)PlayerInputModule.OculusInputType.Axis2D)
|
|||
|
{
|
|||
|
OVRInput.Axis2D ovrInputAxis2D = (OVRInput.Axis2D)negativeInputOVRProp.intValue;
|
|||
|
negativeInputOVRProp.intValue = (int)(OVRInput.Axis2D)EditorGUILayout.EnumPopup(ovrNegativeInputContent, ovrInputAxis2D);
|
|||
|
}
|
|||
|
else if (inputTypeProp.intValue == (int)PlayerInputModule.OculusInputType.Button)
|
|||
|
{
|
|||
|
OVRInput.Button ovrInputButton = (OVRInput.Button)negativeInputOVRProp.intValue;
|
|||
|
negativeInputOVRProp.intValue = (int)(OVRInput.Button)EditorGUILayout.EnumPopup(ovrNegativeInputContent, ovrInputButton);
|
|||
|
}
|
|||
|
else // Pose
|
|||
|
{
|
|||
|
// Reset back to single axis as it currently only supports the Head Mounted Display which doesn't make sense with a Combined Axis.
|
|||
|
negativeInputOVRProp.intValue = 0;
|
|||
|
inputAxisModeProp.intValue = (int)PlayerInputModule.InputAxisMode.SingleAxis;
|
|||
|
}
|
|||
|
|
|||
|
if (positiveInputOVRProp.intValue == negativeInputOVRProp.intValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalOVRInputWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
VerifyThrusterPresent(pimCategory);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Oculus API Button-only input
|
|||
|
private void DrawOVRInput
|
|||
|
(
|
|||
|
SerializedProperty inputEnabledProp,
|
|||
|
SerializedProperty inputOVRProp,
|
|||
|
SerializedProperty inputCanBeHeldDownProp,
|
|||
|
GUIContent ovrInputEnabledContent,
|
|||
|
GUIContent ovrInputContent,
|
|||
|
GUIContent ovrInputCanBeHeldDownContent
|
|||
|
)
|
|||
|
{
|
|||
|
bool prevEnabled = inputEnabledProp.boolValue;
|
|||
|
EditorGUILayout.PropertyField(inputEnabledProp, ovrInputEnabledContent);
|
|||
|
// If enabled has been turned off, reset the xxxxInputOVR to 0 (None)
|
|||
|
if (prevEnabled != inputEnabledProp.boolValue && !inputEnabledProp.boolValue) { inputOVRProp.intValue = 0; }
|
|||
|
|
|||
|
if (inputEnabledProp.boolValue)
|
|||
|
{
|
|||
|
OVRInput.Button ovrInputButton = (OVRInput.Button)inputOVRProp.intValue;
|
|||
|
inputOVRProp.intValue = (int)(OVRInput.Button)EditorGUILayout.EnumPopup(ovrInputContent, ovrInputButton);
|
|||
|
|
|||
|
if (inputCanBeHeldDownProp != null)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputCanBeHeldDownProp, ovrInputCanBeHeldDownContent);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Oculus API Button-only input (without Is Enabled)
|
|||
|
private void DrawOVRInput
|
|||
|
(
|
|||
|
SerializedProperty inputOVRProp,
|
|||
|
SerializedProperty inputCanBeHeldDownProp,
|
|||
|
GUIContent ovrInputContent,
|
|||
|
GUIContent ovrInputCanBeHeldDownContent
|
|||
|
)
|
|||
|
{
|
|||
|
OVRInput.Button ovrInputButton = (OVRInput.Button)inputOVRProp.intValue;
|
|||
|
inputOVRProp.intValue = (int)(OVRInput.Button)EditorGUILayout.EnumPopup(ovrInputContent, ovrInputButton);
|
|||
|
|
|||
|
if (inputCanBeHeldDownProp != null)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputCanBeHeldDownProp, ovrInputCanBeHeldDownContent);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Private Draw methods - Unity Input System
|
|||
|
#if SSC_UIS
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Unity Input System draw method used for axis.
|
|||
|
/// showSlots should be false for CustomPlayerInputs as they will return
|
|||
|
/// all slot values at runtime.
|
|||
|
/// </summary>
|
|||
|
/// <param name="inputAxisModeProp"></param>
|
|||
|
/// <param name="inputAxisModeContent"></param>
|
|||
|
/// <param name="positiveInputActionIdProp"></param>
|
|||
|
/// <param name="positiveInputActionDataSlotProp"></param>
|
|||
|
/// <param name="uisInputACContent"></param>
|
|||
|
/// <param name="uisInputCTypeContent"></param>
|
|||
|
/// <param name="uisInputATypeContent"></param>
|
|||
|
/// <param name="uisInputADataSlotContent"></param>
|
|||
|
/// <param name="uisInputADataSlots2"></param>
|
|||
|
/// <param name="uisInputADataSlots3"></param>
|
|||
|
/// <param name="numActionIDs"></param>
|
|||
|
/// <param name="showSlots">set to false for CustomPlayerInputs</param>
|
|||
|
private void DrawUnityInputSystem
|
|||
|
(
|
|||
|
SerializedProperty inputAxisModeProp,
|
|||
|
GUIContent inputAxisModeContent,
|
|||
|
SerializedProperty positiveInputActionIdProp,
|
|||
|
SerializedProperty positiveInputActionDataSlotProp,
|
|||
|
GUIContent uisInputACContent,
|
|||
|
GUIContent uisInputCTypeContent,
|
|||
|
GUIContent uisInputATypeContent,
|
|||
|
GUIContent uisInputADataSlotContent,
|
|||
|
GUIContent[] uisInputADataSlots2,
|
|||
|
GUIContent[] uisInputADataSlots3,
|
|||
|
int numActionIDs, bool showSlots
|
|||
|
)
|
|||
|
{
|
|||
|
// NOTE: uisActionIDs[] and uisActionGUIContent have class-scope and are not passed in as parameters
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(inputAxisModeProp, inputAxisModeContent);
|
|||
|
if (inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { positiveInputActionIdProp.stringValue = string.Empty; }
|
|||
|
else if (inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.CombinedAxis)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("To create a combined axis input with Unity Input System, configure an Action with a Composite Binding.", MessageType.Error, true);
|
|||
|
positiveInputActionIdProp.stringValue = string.Empty;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
// Find the Action Category for this Action
|
|||
|
int actionIdx = UISGetActionIdx(positiveInputActionIdProp.stringValue);
|
|||
|
|
|||
|
int prevId = actionIdx;
|
|||
|
|
|||
|
actionIdx = EditorGUILayout.Popup(uisInputACContent, actionIdx, uisActionGUIContent);
|
|||
|
if (actionIdx != prevId)
|
|||
|
{
|
|||
|
if (actionIdx >= 0 && actionIdx < numActionIDs)
|
|||
|
{
|
|||
|
positiveInputActionIdProp.stringValue = uisActionIDs[actionIdx];
|
|||
|
|
|||
|
}
|
|||
|
else { positiveInputActionIdProp.stringValue = string.Empty; }
|
|||
|
}
|
|||
|
|
|||
|
if (actionIdx >= 0 && actionIdx < numActionIDs)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputAction inputAction = uisPlayerInput.actions.FindAction(positiveInputActionIdProp.stringValue);
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputCTypeContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(inputAction == null ? "unknown" : inputAction.type.ToString());
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputATypeContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(inputAction == null ? "unknown" : inputAction.expectedControlType);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
// expectedControlType can be null which may cause us some grief. Somewhere should make a note that this must be set
|
|||
|
// to work with SSC.
|
|||
|
|
|||
|
// For a list of control types see UnityEngine.InputSystem.Controls.
|
|||
|
// Library\PackageCache\com.unity.inputsystem@1.0.0-preview\InputSystem\Controls in current project
|
|||
|
// AnyKeyControl - if any action returns 1.0f, else 0.0f
|
|||
|
// AxisControl - float can be < -1 and > 1 unless normalize is set
|
|||
|
// ButtonControl - based on AxisControl with default pressPoint of -1.
|
|||
|
// DiscreteButtonControl - based on ButtonControl
|
|||
|
// DoubleControl
|
|||
|
// DpadControl - vector2
|
|||
|
// IntegerControl - int
|
|||
|
// KeyControl - based on ButtonControl
|
|||
|
// QuaternionControl - Quaternion
|
|||
|
// StickControl - vector2
|
|||
|
// TouchControl - can return various things like pressed, screen position, delta position, touchid, pressure etc
|
|||
|
|
|||
|
if (inputAction != null)
|
|||
|
{
|
|||
|
if (!showSlots)
|
|||
|
{
|
|||
|
// CustomPlayerInputs can use all slots so don't need to show them
|
|||
|
positiveInputActionDataSlotProp.intValue = 0;
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Button" || inputAction.expectedControlType == "Axis")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = 0;
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputADataSlotContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField("Slot1");
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Vector2" || inputAction.expectedControlType == "Dpad")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = EditorGUILayout.Popup(uisInputADataSlotContent, positiveInputActionDataSlotProp.intValue, uisInputADataSlots2) ;
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Vector3")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = EditorGUILayout.Popup(uisInputADataSlotContent, positiveInputActionDataSlotProp.intValue, uisInputADataSlots3);
|
|||
|
}
|
|||
|
else { positiveInputActionDataSlotProp.intValue = 0; }
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Unity Input System draw method used for fire and docking buttons
|
|||
|
/// </summary>
|
|||
|
/// <param name="inputEnabledProp"></param>
|
|||
|
/// <param name="inputEnabledContent"></param>
|
|||
|
/// <param name="positiveInputActionIdProp"></param>
|
|||
|
/// <param name="positiveInputActionDataSlotProp"></param>
|
|||
|
/// <param name="uisInputACContent"></param>
|
|||
|
/// <param name="uisInputCTypeContent"></param>
|
|||
|
/// <param name="uisInputATypeContent"></param>
|
|||
|
/// <param name="uisInputADataSlotContent"></param>
|
|||
|
/// <param name="uisInputADataSlots2"></param>
|
|||
|
/// <param name="uisInputADataSlots3"></param>
|
|||
|
/// <param name="numActionIDs"></param>
|
|||
|
private void DrawUnityInputSystemFire
|
|||
|
(
|
|||
|
SerializedProperty inputEnabledProp,
|
|||
|
GUIContent inputEnabledContent,
|
|||
|
SerializedProperty positiveInputActionIdProp,
|
|||
|
SerializedProperty positiveInputActionDataSlotProp,
|
|||
|
SerializedProperty inputCanBeHeldDownProp,
|
|||
|
GUIContent uisInputACContent,
|
|||
|
GUIContent uisInputCTypeContent,
|
|||
|
GUIContent uisInputATypeContent,
|
|||
|
GUIContent uisInputADataSlotContent,
|
|||
|
GUIContent uisInputCanBeHeldDownContent,
|
|||
|
GUIContent[] uisInputADataSlots2,
|
|||
|
GUIContent[] uisInputADataSlots3,
|
|||
|
int numActionIDs
|
|||
|
)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputEnabledProp, inputEnabledContent);
|
|||
|
if (!inputEnabledProp.boolValue) { positiveInputActionIdProp.stringValue = string.Empty; }
|
|||
|
else
|
|||
|
{
|
|||
|
// Find the Action Category for this Action
|
|||
|
int actionIdx = UISGetActionIdx(positiveInputActionIdProp.stringValue);
|
|||
|
|
|||
|
int prevId = actionIdx;
|
|||
|
actionIdx = EditorGUILayout.Popup(uisInputACContent, actionIdx, uisActionGUIContent);
|
|||
|
if (actionIdx != prevId)
|
|||
|
{
|
|||
|
if (actionIdx >= 0 && actionIdx < numActionIDs)
|
|||
|
{
|
|||
|
positiveInputActionIdProp.stringValue = uisActionIDs[actionIdx];
|
|||
|
|
|||
|
}
|
|||
|
else { positiveInputActionIdProp.stringValue = string.Empty; }
|
|||
|
}
|
|||
|
|
|||
|
if (actionIdx >= 0 && actionIdx < numActionIDs)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputAction inputAction = uisPlayerInput.actions.FindAction(positiveInputActionIdProp.stringValue);
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputCTypeContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(inputAction == null ? "unknown" : inputAction.type.ToString());
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputATypeContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(inputAction == null ? "unknown" : inputAction.expectedControlType);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
// expectedControlType can be null which may cause us some grief. Somewhere should make a note that this must be set
|
|||
|
// to work with SSC.
|
|||
|
|
|||
|
if (inputAction != null)
|
|||
|
{
|
|||
|
if (inputAction.expectedControlType == "Button" || inputAction.expectedControlType == "Axis")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = 0;
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputADataSlotContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField("Slot1");
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Vector2" || inputAction.expectedControlType == "Dpad")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = EditorGUILayout.Popup(uisInputADataSlotContent, positiveInputActionDataSlotProp.intValue, uisInputADataSlots2) ;
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Vector3")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = EditorGUILayout.Popup(uisInputADataSlotContent, positiveInputActionDataSlotProp.intValue, uisInputADataSlots3);
|
|||
|
}
|
|||
|
else { positiveInputActionDataSlotProp.intValue = 0; }
|
|||
|
|
|||
|
// Docking doesn't have can be held down option
|
|||
|
if (inputCanBeHeldDownProp != null)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputCanBeHeldDownProp, uisInputCanBeHeldDownContent);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Private Draw methods - Rewired
|
|||
|
#if SSC_REWIRED
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Rewired Draw method used for Axis
|
|||
|
/// </summary>
|
|||
|
/// <param name="inputAxisModeProp"></param>
|
|||
|
/// <param name="positiveInputActionIdProp"></param>
|
|||
|
/// <param name="negativeInputActionIdProp"></param>
|
|||
|
/// <param name="rwInputACPositiveContent"></param>
|
|||
|
/// <param name="rwInputACNegativeContent"></param>
|
|||
|
/// <param name="rwInputACContent"></param>
|
|||
|
/// <param name="rwInputAIPositiveContent"></param>
|
|||
|
/// <param name="rwInputAINegativeContent"></param>
|
|||
|
/// <param name="rwInputAIContent"></param>
|
|||
|
/// <param name="actionIDsPositive"></param>
|
|||
|
/// <param name="actionIDsNegative"></param>
|
|||
|
/// <param name="ActionGUIContentPositive"></param>
|
|||
|
/// <param name="ActionGUIContentNegative"></param>
|
|||
|
/// <param name="numActionCategories"></param>
|
|||
|
private void DrawRewiredInput
|
|||
|
(
|
|||
|
PIMCategory pimCategory,
|
|||
|
SerializedProperty inputAxisModeProp,
|
|||
|
SerializedProperty positiveInputActionIdProp,
|
|||
|
SerializedProperty negativeInputActionIdProp,
|
|||
|
GUIContent rwInputACPositiveContent,
|
|||
|
GUIContent rwInputACNegativeContent,
|
|||
|
GUIContent rwInputACContent,
|
|||
|
GUIContent rwInputAIPositiveContent,
|
|||
|
GUIContent rwInputAINegativeContent,
|
|||
|
GUIContent rwInputAIContent,
|
|||
|
ref int[] actionIDsPositive,
|
|||
|
ref int[] actionIDsNegative,
|
|||
|
ref GUIContent[] ActionGUIContentPositive,
|
|||
|
ref GUIContent[] ActionGUIContentNegative,
|
|||
|
int numActionCategories
|
|||
|
)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputAxisModeProp, inputAxisModeContent);
|
|||
|
if (inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else
|
|||
|
{
|
|||
|
bool isCombined = inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.CombinedAxis;
|
|||
|
|
|||
|
// Find the Action Category for this Action
|
|||
|
int actionCategoryID = RWGetActionCategoryID(positiveInputActionIdProp.intValue);
|
|||
|
|
|||
|
int prevId = actionCategoryID;
|
|||
|
actionCategoryID = EditorGUILayout.IntPopup(isCombined ? rwInputACPositiveContent : rwInputACContent, actionCategoryID, ActionCategoryGUIContent, actionCategoryIDs);
|
|||
|
if (prevId != actionCategoryID)
|
|||
|
{
|
|||
|
// Get the new list of actions if switching action categories
|
|||
|
RWRefreshActions(actionCategoryID, ref actionIDsPositive, ref ActionGUIContentPositive);
|
|||
|
// Default to first action in category
|
|||
|
if (actionIDsPositive != null && actionIDsPositive.Length > 0) { positiveInputActionIdProp.intValue = actionIDsPositive[0]; }
|
|||
|
}
|
|||
|
|
|||
|
int actionCategoryIndex = rewiredUserData.GetActionCategoryIndex(actionCategoryID);
|
|||
|
|
|||
|
// Show list of actions for this category
|
|||
|
if (actionCategoryIndex >= 0 && actionCategoryIndex < numActionCategories && actionCategories[actionCategoryIndex] != dropDownNone)
|
|||
|
{
|
|||
|
positiveInputActionIdProp.intValue = EditorGUILayout.IntPopup(isCombined ? rwInputAIPositiveContent : rwInputAIContent, positiveInputActionIdProp.intValue, ActionGUIContentPositive, actionIDsPositive);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.LabelField(isCombined ? rwInputAIPositiveContent : rwInputAIContent);
|
|||
|
}
|
|||
|
|
|||
|
if (inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.CombinedAxis)
|
|||
|
{
|
|||
|
actionCategoryID = RWGetActionCategoryID(negativeInputActionIdProp.intValue);
|
|||
|
|
|||
|
prevId = actionCategoryID;
|
|||
|
actionCategoryID = EditorGUILayout.IntPopup(rwInputACNegativeContent, actionCategoryID, ActionCategoryGUIContent, actionCategoryIDs);
|
|||
|
if (prevId != actionCategoryID)
|
|||
|
{
|
|||
|
// Get the new list of actions if switching action categories
|
|||
|
RWRefreshActions(actionCategoryID, ref actionIDsNegative, ref ActionGUIContentNegative);
|
|||
|
// Default to first action in category
|
|||
|
if (actionIDsNegative != null && actionIDsNegative.Length > 0) { negativeInputActionIdProp.intValue = actionIDsNegative[0]; }
|
|||
|
}
|
|||
|
|
|||
|
actionCategoryIndex = rewiredUserData.GetActionCategoryIndex(actionCategoryID);
|
|||
|
|
|||
|
// Show list of actions for this category
|
|||
|
if (actionCategoryIndex >= 0 && actionCategoryIndex < numActionCategories && actionCategories[actionCategoryIndex] != dropDownNone)
|
|||
|
{
|
|||
|
negativeInputActionIdProp.intValue = EditorGUILayout.IntPopup(rwInputAINegativeContent, negativeInputActionIdProp.intValue, ActionGUIContentNegative, actionIDsNegative);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.LabelField(rwInputAINegativeContent);
|
|||
|
}
|
|||
|
|
|||
|
if (positiveInputActionIdProp.intValue == negativeInputActionIdProp.intValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(rwidenticalAxisIdWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Check thrusters in shipcontrolmodule
|
|||
|
if (isCombined ? positiveInputActionIdProp.intValue >= 0 || negativeInputActionIdProp.intValue >= 0 : positiveInputActionIdProp.intValue >= 0) { VerifyThrusterPresent(pimCategory); }
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Rewired Draw method used for Input Buttons
|
|||
|
/// </summary>
|
|||
|
/// <param name="inputEnabledProp"></param>
|
|||
|
/// <param name="inputActionIdProp"></param>
|
|||
|
/// <param name="inputCanBeHeldDownProp"></param>
|
|||
|
/// <param name="rwInputEnabledContent"></param>
|
|||
|
/// <param name="rwInputACContent"></param>
|
|||
|
/// <param name="rwInputAIContent"></param>
|
|||
|
/// <param name="rwInputCanBeHeldDownContent"></param>
|
|||
|
/// <param name="actionIDs"></param>
|
|||
|
/// <param name="ActionGUIContent"></param>
|
|||
|
/// <param name="numActionCategories"></param>
|
|||
|
private void DrawRewiredInput
|
|||
|
(SerializedProperty inputEnabledProp,
|
|||
|
SerializedProperty inputActionIdProp,
|
|||
|
SerializedProperty inputCanBeHeldDownProp,
|
|||
|
GUIContent rwInputEnabledContent,
|
|||
|
GUIContent rwInputACContent,
|
|||
|
GUIContent rwInputAIContent,
|
|||
|
GUIContent rwInputCanBeHeldDownContent,
|
|||
|
ref int[] actionIDs,
|
|||
|
ref GUIContent[] ActionGUIContent,
|
|||
|
int numActionCategories
|
|||
|
)
|
|||
|
{
|
|||
|
bool prevEnabled = inputEnabledProp.boolValue;
|
|||
|
EditorGUILayout.PropertyField(inputEnabledProp, rwInputEnabledContent);
|
|||
|
// If enabled has been turned off, reset the ActionId
|
|||
|
if (prevEnabled != inputEnabledProp.boolValue && !inputEnabledProp.boolValue) { inputActionIdProp.intValue = -1; }
|
|||
|
|
|||
|
if (inputEnabledProp.boolValue)
|
|||
|
{
|
|||
|
// Find the Action Category for this Action
|
|||
|
int actionCategoryID = RWGetActionCategoryID(inputActionIdProp.intValue);
|
|||
|
|
|||
|
int prevId = actionCategoryID;
|
|||
|
actionCategoryID = EditorGUILayout.IntPopup(rwInputACContent, actionCategoryID, ActionCategoryGUIContent, actionCategoryIDs);
|
|||
|
if (prevId != actionCategoryID)
|
|||
|
{
|
|||
|
// Get the new list of actions if switching action categories
|
|||
|
RWRefreshActions(actionCategoryID, ref actionIDs, ref ActionGUIContent);
|
|||
|
// Default to first action in category
|
|||
|
if (actionIDs != null && actionIDs.Length > 0) { inputActionIdProp.intValue = actionIDs[0]; }
|
|||
|
}
|
|||
|
|
|||
|
int actionCategoryIndex = rewiredUserData.GetActionCategoryIndex(actionCategoryID);
|
|||
|
|
|||
|
// Show list of actions for this category
|
|||
|
if (actionCategoryIndex >= 0 && actionCategoryIndex < numActionCategories && actionCategories[actionCategoryIndex] != dropDownNone)
|
|||
|
{
|
|||
|
inputActionIdProp.intValue = EditorGUILayout.IntPopup(rwInputAIContent, inputActionIdProp.intValue, ActionGUIContent, actionIDs);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
EditorGUILayout.LabelField(rwInputAIContent);
|
|||
|
}
|
|||
|
|
|||
|
if (inputCanBeHeldDownProp != null)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputCanBeHeldDownProp, rwInputCanBeHeldDownContent);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Private Draw methods - Vive
|
|||
|
#if VIU_PLUGIN
|
|||
|
|
|||
|
private void DrawViveInput
|
|||
|
(
|
|||
|
PIMCategory pimCategory,
|
|||
|
SerializedProperty inputAxisModeProp,
|
|||
|
SerializedProperty inputTypeProp,
|
|||
|
SerializedProperty roleTypeProp,
|
|||
|
SerializedProperty positiveRoleIdProp,
|
|||
|
SerializedProperty negativeRoleIdProp,
|
|||
|
SerializedProperty positiveInputViveProp,
|
|||
|
SerializedProperty negativeInputViveProp,
|
|||
|
GUIContent viveInputTypeContent,
|
|||
|
GUIContent viveRoleTypeContent,
|
|||
|
GUIContent vivePositiveRoleIdContent,
|
|||
|
GUIContent viveNegativeRoleIdContent,
|
|||
|
GUIContent viveRoleIdContent,
|
|||
|
GUIContent vivePositiveInputContent,
|
|||
|
GUIContent viveNegativeInputContent,
|
|||
|
GUIContent viveInputContent
|
|||
|
)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputAxisModeProp, inputAxisModeContent);
|
|||
|
if (inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { }
|
|||
|
else
|
|||
|
{
|
|||
|
bool isCombined = inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.CombinedAxis;
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(inputTypeProp, viveInputTypeContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
// When switching between types (Axis, Button, Pose) reset the enumeration values (which are stored as integers)
|
|||
|
positiveInputViveProp.intValue = 0;
|
|||
|
negativeInputViveProp.intValue = 0;
|
|||
|
}
|
|||
|
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(roleTypeProp, viveRoleTypeContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
// When switching between role types (DeviceRole, HandRole etc) reset the enumeration values (which are stored as integers)
|
|||
|
positiveRoleIdProp.intValue = 0;
|
|||
|
negativeRoleIdProp.intValue = 0;
|
|||
|
}
|
|||
|
|
|||
|
// PlayerInputModule.ViveRoleType enum: BodyRole = 0, DeviceRole = 1, HandRole = 2,TrackerRole = 3
|
|||
|
// Display an enumeration list for the selected Vive Role Type
|
|||
|
switch (roleTypeProp.intValue)
|
|||
|
{
|
|||
|
case 0:
|
|||
|
BodyRole bodyRole = (BodyRole)positiveRoleIdProp.intValue;
|
|||
|
positiveRoleIdProp.intValue = (int)(BodyRole)EditorGUILayout.EnumPopup(isCombined ? vivePositiveRoleIdContent : viveRoleIdContent, bodyRole);
|
|||
|
break;
|
|||
|
case 1:
|
|||
|
DeviceRole deviceRole = (DeviceRole)positiveRoleIdProp.intValue;
|
|||
|
positiveRoleIdProp.intValue = (int)(DeviceRole)EditorGUILayout.EnumPopup(isCombined ? vivePositiveRoleIdContent : viveRoleIdContent, deviceRole);
|
|||
|
break;
|
|||
|
case 3:
|
|||
|
TrackerRole trackerRole = (TrackerRole)positiveRoleIdProp.intValue;
|
|||
|
positiveRoleIdProp.intValue = (int)(TrackerRole)EditorGUILayout.EnumPopup(isCombined ? vivePositiveRoleIdContent : viveRoleIdContent, trackerRole);
|
|||
|
break;
|
|||
|
default: // HandRole 2
|
|||
|
HandRole handRole = (HandRole)positiveRoleIdProp.intValue;
|
|||
|
positiveRoleIdProp.intValue = (int)(HandRole)EditorGUILayout.EnumPopup(isCombined ? vivePositiveRoleIdContent : viveRoleIdContent, handRole);
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
//string roleTypeName = System.Enum.GetName(typeof(PlayerInputModule.ViveRoleType), roleTypeProp.intValue);
|
|||
|
//System.Type roleType = System.Type.GetType("HTC.UnityPlugin.Vive." + roleTypeName + ", Assembly-CSharp, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
|
|||
|
//ViveRoleProperty viveRoleProp = ViveRoleProperty.New(roleType, positiveRoleIdProp.intValue);
|
|||
|
|
|||
|
if (inputTypeProp.intValue == (int)PlayerInputModule.ViveInputType.Axis)
|
|||
|
{
|
|||
|
ControllerAxis viveInputAxis = (ControllerAxis)positiveInputViveProp.intValue;
|
|||
|
positiveInputViveProp.intValue = (int)(ControllerAxis)EditorGUILayout.EnumPopup(isCombined ? vivePositiveInputContent : viveInputContent, viveInputAxis);
|
|||
|
}
|
|||
|
else if (inputTypeProp.intValue == (int)PlayerInputModule.ViveInputType.Button)
|
|||
|
{
|
|||
|
ControllerButton viveInputButton = (ControllerButton)positiveInputViveProp.intValue;
|
|||
|
positiveInputViveProp.intValue = (int)(ControllerButton)EditorGUILayout.EnumPopup(isCombined ? vivePositiveInputContent : viveInputContent, viveInputButton);
|
|||
|
}
|
|||
|
else // Assume Pose
|
|||
|
{
|
|||
|
PlayerInputModule.VRPoseRotation viveInputButton = (PlayerInputModule.VRPoseRotation)positiveInputViveProp.intValue;
|
|||
|
positiveInputViveProp.intValue = (int)(PlayerInputModule.VRPoseRotation)EditorGUILayout.EnumPopup(isCombined ? vivePositiveInputContent : viveInputContent, viveInputButton);
|
|||
|
}
|
|||
|
|
|||
|
if (isCombined)
|
|||
|
{
|
|||
|
// PlayerInputModule.ViveRoleType enum: BodyRole = 0, DeviceRole = 1, HandRole = 2,TrackerRole = 3
|
|||
|
// Display an enumeration list for the selected Vive Role Type
|
|||
|
switch (roleTypeProp.intValue)
|
|||
|
{
|
|||
|
case 0:
|
|||
|
BodyRole bodyRole = (BodyRole)negativeRoleIdProp.intValue;
|
|||
|
negativeRoleIdProp.intValue = (int)(BodyRole)EditorGUILayout.EnumPopup(viveNegativeRoleIdContent, bodyRole);
|
|||
|
break;
|
|||
|
case 1:
|
|||
|
DeviceRole deviceRole = (DeviceRole)negativeRoleIdProp.intValue;
|
|||
|
negativeRoleIdProp.intValue = (int)(DeviceRole)EditorGUILayout.EnumPopup(viveNegativeRoleIdContent, deviceRole);
|
|||
|
break;
|
|||
|
case 3:
|
|||
|
TrackerRole trackerRole = (TrackerRole)negativeRoleIdProp.intValue;
|
|||
|
negativeRoleIdProp.intValue = (int)(TrackerRole)EditorGUILayout.EnumPopup(viveNegativeRoleIdContent, trackerRole);
|
|||
|
break;
|
|||
|
default: // HandRole 2
|
|||
|
HandRole handRole = (HandRole)negativeRoleIdProp.intValue;
|
|||
|
negativeRoleIdProp.intValue = (int)(HandRole)EditorGUILayout.EnumPopup(viveNegativeRoleIdContent, handRole);
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
if (inputTypeProp.intValue == (int)PlayerInputModule.ViveInputType.Axis)
|
|||
|
{
|
|||
|
ControllerAxis viveInputAxis = (ControllerAxis)negativeInputViveProp.intValue;
|
|||
|
negativeInputViveProp.intValue = (int)(ControllerAxis)EditorGUILayout.EnumPopup(viveNegativeInputContent, viveInputAxis);
|
|||
|
}
|
|||
|
else if (inputTypeProp.intValue == (int)PlayerInputModule.ViveInputType.Button)
|
|||
|
{
|
|||
|
ControllerButton viveInputButton = (ControllerButton)negativeInputViveProp.intValue;
|
|||
|
negativeInputViveProp.intValue = (int)(ControllerButton)EditorGUILayout.EnumPopup(viveNegativeInputContent, viveInputButton);
|
|||
|
}
|
|||
|
else // assume Pose
|
|||
|
{
|
|||
|
PlayerInputModule.VRPoseRotation viveInputButton = (PlayerInputModule.VRPoseRotation)negativeInputViveProp.intValue;
|
|||
|
negativeInputViveProp.intValue = (int)(PlayerInputModule.VRPoseRotation)EditorGUILayout.EnumPopup(viveNegativeInputContent, viveInputButton);
|
|||
|
}
|
|||
|
|
|||
|
if (positiveRoleIdProp.intValue == negativeRoleIdProp.intValue && positiveInputViveProp.intValue == negativeInputViveProp.intValue)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox(identicalViveInputWarningContent, MessageType.Warning);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Check thrusters in shipcontrolmodule
|
|||
|
VerifyThrusterPresent(pimCategory);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Vive Button Input only
|
|||
|
// Currently used for primary and secondary fire and docking buttons
|
|||
|
private void DrawViveInput
|
|||
|
(
|
|||
|
SerializedProperty inputEnabledProp,
|
|||
|
SerializedProperty roleTypeProp,
|
|||
|
SerializedProperty inputRoleIdProp,
|
|||
|
SerializedProperty inputViveCtrlProp,
|
|||
|
SerializedProperty inputCanBeHeldDownProp,
|
|||
|
GUIContent viveInputEnabledContent,
|
|||
|
GUIContent viveRoleTypeContent,
|
|||
|
GUIContent viveRoleIdContent,
|
|||
|
GUIContent viveButtonInputContent,
|
|||
|
GUIContent viveInputCanBeHeldDownContent
|
|||
|
)
|
|||
|
{
|
|||
|
bool prevEnabled = inputEnabledProp.boolValue;
|
|||
|
EditorGUILayout.PropertyField(inputEnabledProp, viveInputEnabledContent);
|
|||
|
// If enabled has been turned off, reset the inputViveXXX to 0 (None)
|
|||
|
if (prevEnabled != inputEnabledProp.boolValue && !inputEnabledProp.boolValue) { inputViveCtrlProp.intValue = 0; }
|
|||
|
|
|||
|
if (inputEnabledProp.boolValue)
|
|||
|
{
|
|||
|
EditorGUI.BeginChangeCheck();
|
|||
|
EditorGUILayout.PropertyField(roleTypeProp, viveRoleTypeContent);
|
|||
|
if (EditorGUI.EndChangeCheck())
|
|||
|
{
|
|||
|
// When switching between role types (DeviceRole, HandRole etc) reset the enumeration values (which are stored as integers)
|
|||
|
inputRoleIdProp.intValue = 0;
|
|||
|
}
|
|||
|
|
|||
|
// PlayerInputModule.ViveRoleType enum: BodyRole = 0, DeviceRole = 1, HandRole = 2,TrackerRole = 3
|
|||
|
// Display an enumeration list for the selected Vive Role Type
|
|||
|
switch (roleTypeProp.intValue)
|
|||
|
{
|
|||
|
case 0:
|
|||
|
BodyRole bodyRole = (BodyRole)inputRoleIdProp.intValue;
|
|||
|
inputRoleIdProp.intValue = (int)(BodyRole)EditorGUILayout.EnumPopup(viveRoleIdContent, bodyRole);
|
|||
|
break;
|
|||
|
case 1:
|
|||
|
DeviceRole deviceRole = (DeviceRole)inputRoleIdProp.intValue;
|
|||
|
inputRoleIdProp.intValue = (int)(DeviceRole)EditorGUILayout.EnumPopup(viveRoleIdContent, deviceRole);
|
|||
|
break;
|
|||
|
case 3:
|
|||
|
TrackerRole trackerRole = (TrackerRole)inputRoleIdProp.intValue;
|
|||
|
inputRoleIdProp.intValue = (int)(TrackerRole)EditorGUILayout.EnumPopup(viveRoleIdContent, trackerRole);
|
|||
|
break;
|
|||
|
default: // HandRole 2
|
|||
|
HandRole handRole = (HandRole)inputRoleIdProp.intValue;
|
|||
|
inputRoleIdProp.intValue = (int)(HandRole)EditorGUILayout.EnumPopup(viveRoleIdContent, handRole);
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
ControllerButton viveInputButton = (ControllerButton)inputViveCtrlProp.intValue;
|
|||
|
inputViveCtrlProp.intValue = (int)(ControllerButton)EditorGUILayout.EnumPopup(viveButtonInputContent, viveInputButton);
|
|||
|
|
|||
|
// Docking does not have the Can Be Held Down option
|
|||
|
if (inputCanBeHeldDownProp != null)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputCanBeHeldDownProp, viveInputCanBeHeldDownContent);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Private Draw methods - XR
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// XR draw method used for axis. Gets data from the Unity Input System
|
|||
|
/// showSlots should be false for CustomPlayerInputs as they will return
|
|||
|
/// all slot values at runtime.
|
|||
|
/// </summary>
|
|||
|
/// <param name="inputAxisModeProp"></param>
|
|||
|
/// <param name="inputAxisModeContent"></param>
|
|||
|
/// <param name="inputActionAssetProp"></param>
|
|||
|
/// <param name="positiveInputActionMapIdProp"></param>
|
|||
|
/// <param name="positiveInputActionIdProp"></param>
|
|||
|
/// <param name="positiveInputActionDataSlotProp"></param>
|
|||
|
/// <param name="uisInputAMContent"></param>
|
|||
|
/// <param name="uisInputACContent"></param>
|
|||
|
/// <param name="uisInputCTypeContent"></param>
|
|||
|
/// <param name="uisInputATypeContent"></param>
|
|||
|
/// <param name="uisInputADataSlotContent"></param>
|
|||
|
/// <param name="uisInputADataSlots2"></param>
|
|||
|
/// <param name="uisInputADataSlots3"></param>
|
|||
|
/// <param name="numActionMapIDs"></param>
|
|||
|
/// <param name="showSlots">Set to false for CustomPlayerInputs</param>
|
|||
|
/// <param name="forceRefresh"></param>
|
|||
|
private void DrawXR
|
|||
|
(
|
|||
|
SerializedProperty inputAxisModeProp,
|
|||
|
GUIContent inputAxisModeContent,
|
|||
|
SerializedProperty inputActionAssetProp,
|
|||
|
SerializedProperty positiveInputActionMapIdProp,
|
|||
|
SerializedProperty positiveInputActionIdProp,
|
|||
|
SerializedProperty positiveInputActionDataSlotProp,
|
|||
|
GUIContent uisInputAMContent,
|
|||
|
GUIContent uisInputACContent,
|
|||
|
GUIContent uisInputCTypeContent,
|
|||
|
GUIContent uisInputATypeContent,
|
|||
|
GUIContent uisInputADataSlotContent,
|
|||
|
GUIContent[] uisInputADataSlots2,
|
|||
|
GUIContent[] uisInputADataSlots3,
|
|||
|
int numActionMapIDs,
|
|||
|
bool showSlots,
|
|||
|
bool forceRefresh
|
|||
|
)
|
|||
|
{
|
|||
|
// NOTE: uisActionIDs[] and uisActionGUIContent have class-scope and are not passed in as parameters
|
|||
|
|
|||
|
int actionMapIdx = XRGetActionMapIdx(positiveInputActionMapIdProp.stringValue);
|
|||
|
|
|||
|
int prevActionMapId = actionMapIdx;
|
|||
|
|
|||
|
// Get the actionMap and refresh the available actions
|
|||
|
actionMapIdx = EditorGUILayout.Popup(uisInputAMContent, actionMapIdx, xrActionMapGUIContent);
|
|||
|
|
|||
|
if (actionMapIdx != prevActionMapId)
|
|||
|
{
|
|||
|
if (actionMapIdx >= 0 && actionMapIdx < numActionMapIDs)
|
|||
|
{
|
|||
|
positiveInputActionMapIdProp.stringValue = xrActionMapIDs[actionMapIdx];
|
|||
|
|
|||
|
}
|
|||
|
else { positiveInputActionMapIdProp.stringValue = string.Empty; }
|
|||
|
}
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(inputAxisModeProp, inputAxisModeContent);
|
|||
|
if (inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.NoInput) { positiveInputActionIdProp.stringValue = string.Empty; }
|
|||
|
else if (inputAxisModeProp.intValue == (int)PlayerInputModule.InputAxisMode.CombinedAxis)
|
|||
|
{
|
|||
|
EditorGUILayout.HelpBox("To create a combined axis input with Unity Input System for XR, configure an Action with a Composite Binding.", MessageType.Error, true);
|
|||
|
positiveInputActionIdProp.stringValue = string.Empty;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
XRRefreshActions(positiveInputActionMapIdProp.stringValue, forceRefresh);
|
|||
|
|
|||
|
int numActionIDs = uisActionIDs == null ? 0 : uisActionIDs.Length;
|
|||
|
|
|||
|
// Find the Action Category for this Action
|
|||
|
int actionIdx = UISGetActionIdx(positiveInputActionIdProp.stringValue);
|
|||
|
|
|||
|
int prevActionId = actionIdx;
|
|||
|
|
|||
|
actionIdx = EditorGUILayout.Popup(uisInputACContent, actionIdx, uisActionGUIContent);
|
|||
|
if (actionIdx != prevActionId)
|
|||
|
{
|
|||
|
if (actionIdx >= 0 && actionIdx < numActionIDs)
|
|||
|
{
|
|||
|
positiveInputActionIdProp.stringValue = uisActionIDs[actionIdx];
|
|||
|
|
|||
|
}
|
|||
|
else { positiveInputActionIdProp.stringValue = string.Empty; }
|
|||
|
}
|
|||
|
|
|||
|
if (actionIdx >= 0 && actionIdx < numActionIDs && inputActionAssetProp.objectReferenceValue != null)
|
|||
|
{
|
|||
|
// Get the action map for this axis
|
|||
|
UnityEngine.InputSystem.InputActionMap actionMap = ((UnityEngine.InputSystem.InputActionAsset)inputActionAssetProp.objectReferenceValue).FindActionMap(positiveInputActionMapIdProp.stringValue);
|
|||
|
|
|||
|
if (actionMap != null)
|
|||
|
{
|
|||
|
// Find the action within the Unity Input System action map
|
|||
|
UnityEngine.InputSystem.InputAction inputAction = actionMap.FindAction(positiveInputActionIdProp.stringValue);
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputCTypeContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(inputAction == null ? "unknown" : inputAction.type.ToString());
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputATypeContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(inputAction == null ? "unknown" : inputAction.expectedControlType);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
// expectedControlType can be null which may cause us some grief. Somewhere should make a note that this must be set
|
|||
|
// to work with SSC.
|
|||
|
|
|||
|
// For a list of control types see UnityEngine.InputSystem.Controls.
|
|||
|
// Library\PackageCache\com.unity.inputsystem@1.0.0-preview\InputSystem\Controls in current project
|
|||
|
// AnyKeyControl - if any action returns 1.0f, else 0.0f
|
|||
|
// AxisControl - float can be < -1 and > 1 unless normalize is set
|
|||
|
// ButtonControl - based on AxisControl with default pressPoint of -1.
|
|||
|
// DiscreteButtonControl - based on ButtonControl
|
|||
|
// DoubleControl
|
|||
|
// DpadControl - vector2
|
|||
|
// IntegerControl - int
|
|||
|
// KeyControl - based on ButtonControl
|
|||
|
// QuaternionControl - Quaternion
|
|||
|
// StickControl - vector2
|
|||
|
// TouchControl - can return various things like pressed, screen position, delta position, touchid, pressure etc
|
|||
|
|
|||
|
if (inputAction != null)
|
|||
|
{
|
|||
|
if (!showSlots)
|
|||
|
{
|
|||
|
// CustomPlayerInputs can use all slots so don't need to show them
|
|||
|
positiveInputActionDataSlotProp.intValue = 0;
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Button" || inputAction.expectedControlType == "Axis")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = 0;
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputADataSlotContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField("Slot1");
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Vector2" || inputAction.expectedControlType == "Dpad")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = EditorGUILayout.Popup(uisInputADataSlotContent, positiveInputActionDataSlotProp.intValue, uisInputADataSlots2);
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Vector3")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = EditorGUILayout.Popup(uisInputADataSlotContent, positiveInputActionDataSlotProp.intValue, uisInputADataSlots3);
|
|||
|
}
|
|||
|
else { positiveInputActionDataSlotProp.intValue = 0; }
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
positiveInputActionIdProp.stringValue = string.Empty;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// XR draw method used for button response.
|
|||
|
/// </summary>
|
|||
|
/// <param name="inputEnabledProp"></param>
|
|||
|
/// <param name="inputEnabledContent"></param>
|
|||
|
/// <param name="inputActionAssetProp"></param>
|
|||
|
/// <param name="positiveInputActionMapIdProp"></param>
|
|||
|
/// <param name="positiveInputActionIdProp"></param>
|
|||
|
/// <param name="positiveInputActionDataSlotProp"></param>
|
|||
|
/// <param name="inputCanBeHeldDownProp"></param>
|
|||
|
/// <param name="uisInputAMContent"></param>
|
|||
|
/// <param name="uisInputACContent"></param>
|
|||
|
/// <param name="uisInputCTypeContent"></param>
|
|||
|
/// <param name="uisInputATypeContent"></param>
|
|||
|
/// <param name="uisInputADataSlotContent"></param>
|
|||
|
/// <param name="uisInputCanBeHeldDownContent"></param>
|
|||
|
/// <param name="uisInputADataSlots2"></param>
|
|||
|
/// <param name="uisInputADataSlots3"></param>
|
|||
|
/// <param name="numActionMapIDs"></param>
|
|||
|
/// <param name="forceRefresh"></param>
|
|||
|
private void DrawXRButton
|
|||
|
(
|
|||
|
SerializedProperty inputEnabledProp,
|
|||
|
GUIContent inputEnabledContent,
|
|||
|
SerializedProperty inputActionAssetProp,
|
|||
|
SerializedProperty positiveInputActionMapIdProp,
|
|||
|
SerializedProperty positiveInputActionIdProp,
|
|||
|
SerializedProperty positiveInputActionDataSlotProp,
|
|||
|
SerializedProperty inputCanBeHeldDownProp,
|
|||
|
GUIContent uisInputAMContent,
|
|||
|
GUIContent uisInputACContent,
|
|||
|
GUIContent uisInputCTypeContent,
|
|||
|
GUIContent uisInputATypeContent,
|
|||
|
GUIContent uisInputADataSlotContent,
|
|||
|
GUIContent uisInputCanBeHeldDownContent,
|
|||
|
GUIContent[] uisInputADataSlots2,
|
|||
|
GUIContent[] uisInputADataSlots3,
|
|||
|
int numActionMapIDs,
|
|||
|
bool forceRefresh
|
|||
|
)
|
|||
|
{
|
|||
|
int actionMapIdx = XRGetActionMapIdx(positiveInputActionMapIdProp.stringValue);
|
|||
|
|
|||
|
int prevActionMapId = actionMapIdx;
|
|||
|
|
|||
|
// Get the actionMap and refresh the available actions
|
|||
|
actionMapIdx = EditorGUILayout.Popup(uisInputAMContent, actionMapIdx, xrActionMapGUIContent);
|
|||
|
|
|||
|
if (actionMapIdx != prevActionMapId)
|
|||
|
{
|
|||
|
if (actionMapIdx >= 0 && actionMapIdx < numActionMapIDs)
|
|||
|
{
|
|||
|
positiveInputActionMapIdProp.stringValue = xrActionMapIDs[actionMapIdx];
|
|||
|
|
|||
|
}
|
|||
|
else { positiveInputActionMapIdProp.stringValue = string.Empty; }
|
|||
|
}
|
|||
|
|
|||
|
EditorGUILayout.PropertyField(inputEnabledProp, inputEnabledContent);
|
|||
|
if (!inputEnabledProp.boolValue) { positiveInputActionIdProp.stringValue = string.Empty; }
|
|||
|
else
|
|||
|
{
|
|||
|
XRRefreshActions(positiveInputActionMapIdProp.stringValue, forceRefresh);
|
|||
|
|
|||
|
int numActionIDs = uisActionIDs == null ? 0 : uisActionIDs.Length;
|
|||
|
|
|||
|
// Find the Action Category for this Action
|
|||
|
int actionIdx = UISGetActionIdx(positiveInputActionIdProp.stringValue);
|
|||
|
|
|||
|
int prevId = actionIdx;
|
|||
|
actionIdx = EditorGUILayout.Popup(uisInputACContent, actionIdx, uisActionGUIContent);
|
|||
|
if (actionIdx != prevId)
|
|||
|
{
|
|||
|
if (actionIdx >= 0 && actionIdx < numActionIDs)
|
|||
|
{
|
|||
|
positiveInputActionIdProp.stringValue = uisActionIDs[actionIdx];
|
|||
|
|
|||
|
}
|
|||
|
else { positiveInputActionIdProp.stringValue = string.Empty; }
|
|||
|
}
|
|||
|
|
|||
|
if (actionIdx >= 0 && actionIdx < numActionIDs && inputActionAssetProp.objectReferenceValue != null)
|
|||
|
{
|
|||
|
// Get the action map for this axis
|
|||
|
UnityEngine.InputSystem.InputActionMap actionMap = ((UnityEngine.InputSystem.InputActionAsset)inputActionAssetProp.objectReferenceValue).FindActionMap(positiveInputActionMapIdProp.stringValue);
|
|||
|
|
|||
|
if (actionMap != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputAction inputAction = actionMap.FindAction(positiveInputActionIdProp.stringValue);
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputCTypeContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(inputAction == null ? "unknown" : inputAction.type.ToString());
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputATypeContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField(inputAction == null ? "unknown" : inputAction.expectedControlType);
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
|
|||
|
// expectedControlType can be null which may cause us some grief. Somewhere should make a note that this must be set
|
|||
|
// to work with SSC.
|
|||
|
|
|||
|
if (inputAction != null)
|
|||
|
{
|
|||
|
if (inputAction.expectedControlType == "Button" || inputAction.expectedControlType == "Axis")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = 0;
|
|||
|
EditorGUILayout.BeginHorizontal();
|
|||
|
EditorGUILayout.LabelField(uisInputADataSlotContent, GUILayout.Width(defaultEditorLabelWidth));
|
|||
|
EditorGUILayout.LabelField("Slot1");
|
|||
|
EditorGUILayout.EndHorizontal();
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Vector2" || inputAction.expectedControlType == "Dpad")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = EditorGUILayout.Popup(uisInputADataSlotContent, positiveInputActionDataSlotProp.intValue, uisInputADataSlots2);
|
|||
|
}
|
|||
|
else if (inputAction.expectedControlType == "Vector3")
|
|||
|
{
|
|||
|
positiveInputActionDataSlotProp.intValue = EditorGUILayout.Popup(uisInputADataSlotContent, positiveInputActionDataSlotProp.intValue, uisInputADataSlots3);
|
|||
|
}
|
|||
|
else { positiveInputActionDataSlotProp.intValue = 0; }
|
|||
|
|
|||
|
// Docking doesn't have can be held down option
|
|||
|
if (inputCanBeHeldDownProp != null)
|
|||
|
{
|
|||
|
EditorGUILayout.PropertyField(inputCanBeHeldDownProp, uisInputCanBeHeldDownContent);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
positiveInputActionIdProp.stringValue = string.Empty;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Unity Input System Methods
|
|||
|
#if SSC_UIS
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Add events to the default map selected in Unity's PlayerInput script.
|
|||
|
/// </summary>
|
|||
|
public bool UISAddDefaultEvents()
|
|||
|
{
|
|||
|
bool isSuccess = false;
|
|||
|
|
|||
|
if (uisPlayerInput != null && uisPlayerInput.actions != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionMap actionMap = uisPlayerInput.actions.FindActionMap(uisPlayerInput.defaultActionMap);
|
|||
|
|
|||
|
if (EditorUtility.DisplayDialog("Add Actions", "Add Actions to Default Map: " + actionMap.name + "?", "Yes", "CANCEL!"))
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputAction action = null;
|
|||
|
|
|||
|
// Composites can be 1DAxis (or Axis), 2DVector (or Dpad), ButtonWithOneModifier, or ButtonWithTwoModifiers.
|
|||
|
// When adding bindings AddCompositeBinding(action, "1DAxis(normalize=true)"), normalize=true seems to be on by default.
|
|||
|
|
|||
|
// For composite bindings e.g. 2DVector/Dpad, the value is returned according to the axis - not the order it is added with AddCompositeBinding().
|
|||
|
// Left/Right = x-axis = vector2.x = SSC DataSlot1, Up/Down = y-axis = vector2.y = SSC DataSlot2.
|
|||
|
|
|||
|
// EXAMPLE of adding a Vector2/Dpad in a single line
|
|||
|
// UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Gamepad>/leftStick", null, null, "Gamepad").WithName("LeftStick");
|
|||
|
|
|||
|
// EXAMPLE Vector2 composite binding
|
|||
|
//action = actionMap.FindAction("Vertical_Roll");
|
|||
|
//if (action == null)
|
|||
|
//{
|
|||
|
// action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
// actionMap, "Vertical_Roll", UnityEngine.InputSystem.InputActionType.Value, null, null, null, null, "Dpad");
|
|||
|
// if (action != null)
|
|||
|
// {
|
|||
|
// UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "2DVector") // Or "Dpad"
|
|||
|
// .With("Up", "<Gamepad>/rightStick/up", "Gamepad")
|
|||
|
// .With("Down", "<Gamepad>/rightStick/down", "Gamepad")
|
|||
|
// .With("Left", "<Gamepad>/rightStick/left", "Gamepad")
|
|||
|
// .With("Right", "<Gamepad>/rightStick/right", "Gamepad");
|
|||
|
|
|||
|
// UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "Dpad") // Or "2DVector"
|
|||
|
// .With("Up", "<Keyboard>/e", "Keyboard&Mouse")
|
|||
|
// .With("Down", "<Keyboard>/q", "Keyboard&Mouse")
|
|||
|
// .With("Left", "<Keyboard>/leftArrow", "Keyboard&Mouse")
|
|||
|
// .With("Right", "<Keyboard>/rightArrow", "Keyboard&Mouse");
|
|||
|
// }
|
|||
|
//}
|
|||
|
|
|||
|
#region Horizontal (currently not used in sample events
|
|||
|
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Vertical
|
|||
|
action = actionMap.FindAction("Vertical");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "Vertical", UnityEngine.InputSystem.InputActionType.Value, null, null, null, null, "Axis");
|
|||
|
if (action != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "Axis") // Or "1DAxis"
|
|||
|
.With("Positive", "<Gamepad>/rightStick/up", "Gamepad")
|
|||
|
.With("Negative", "<Gamepad>/rightStick/down", "Gamepad");
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis") // Or "Axis"
|
|||
|
.With("Positive", "<Keyboard>/e", "Keyboard&Mouse")
|
|||
|
.With("Negative", "<Keyboard>/q", "Keyboard&Mouse");
|
|||
|
}
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Longitudinal
|
|||
|
action = actionMap.FindAction("Longitudinal");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "Longitudinal", UnityEngine.InputSystem.InputActionType.Value, null, null, null, null, "Axis");
|
|||
|
if (action != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis")
|
|||
|
.With("Positive", "<Gamepad>/rightTrigger", "Gamepad")
|
|||
|
.With("Negative", "<Gamepad>/leftTrigger", "Gamepad");
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis")
|
|||
|
.With("Positive", "<Keyboard>/upArrow", "Keyboard&Mouse")
|
|||
|
.With("Negative", "<Keyboard>/downArrow", "Keyboard&Mouse");
|
|||
|
}
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Pitch
|
|||
|
action = actionMap.FindAction("Pitch");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "Pitch", UnityEngine.InputSystem.InputActionType.Value, null, null, null, null, "Axis");
|
|||
|
if (action != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis")
|
|||
|
.With("Positive", "<Keyboard>/w", "Keyboard&Mouse")
|
|||
|
.With("Negative", "<Keyboard>/s", "Keyboard&Mouse");
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis")
|
|||
|
.With("Positive", "<Gamepad>/leftStick/up", "Gamepad")
|
|||
|
.With("Negative", "<Gamepad>/leftStick/down", "Gamepad");
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis")
|
|||
|
.With("Positive", "<Joystick>/stick/up", "Joystick")
|
|||
|
.With("Negative", "<Joystick>/stick/down", "Joystick");
|
|||
|
}
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Yaw
|
|||
|
action = actionMap.FindAction("Yaw");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "Yaw", UnityEngine.InputSystem.InputActionType.Value, null, null, null, null, "Axis");
|
|||
|
if (action != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis")
|
|||
|
.With("Positive", "<Keyboard>/d", "Keyboard&Mouse")
|
|||
|
.With("Negative", "<Keyboard>/a", "Keyboard&Mouse");
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis")
|
|||
|
.With("Positive", "<Gamepad>/leftStick/right", "Gamepad")
|
|||
|
.With("Negative", "<Gamepad>/leftStick/left", "Gamepad");
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis")
|
|||
|
.With("Positive", "<Joystick>/stick/right", "Joystick")
|
|||
|
.With("Negative", "<Joystick>/stick/left", "Joystick");
|
|||
|
}
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Roll
|
|||
|
action = actionMap.FindAction("Roll");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "Roll", UnityEngine.InputSystem.InputActionType.Value, null, null, null, null, "Axis");
|
|||
|
if (action != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis") // Or "Axis"
|
|||
|
.With("Positive", "<Gamepad>/rightStick/right", "Gamepad")
|
|||
|
.With("Negative", "<Gamepad>/rightStick/left", "Gamepad");
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddCompositeBinding(action, "1DAxis") // Or "Axis"
|
|||
|
.With("Positive", "<Keyboard>/rightArrow", "Keyboard&Mouse")
|
|||
|
.With("Negative", "<Keyboard>/leftArrow", "Keyboard&Mouse");
|
|||
|
}
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Primary Fire
|
|||
|
action = actionMap.FindAction("PrimaryFire");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "PrimaryFire", UnityEngine.InputSystem.InputActionType.Button, null, null, null, null, "Button");
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Keyboard>/space", null, null, "Keyboard&Mouse").WithName("SpaceBar");
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Gamepad>/buttonSouth", null, null, "Gamepad").WithName("AorCrossButton");
|
|||
|
// Instead of using Touch here, use OnScreen controls.
|
|||
|
//UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Touchscreen>/primaryTouch/tap", null, null, "Touch").WithName("TouchTap");
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Joystick>/trigger", null, null, "Joystick").WithName("JoyTrigger");
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Secondary Fire
|
|||
|
action = actionMap.FindAction("SecondaryFire");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "SecondaryFire", UnityEngine.InputSystem.InputActionType.Button, null, null, null, null, "Button");
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Mouse>/leftButton", null, null, "Keyboard&Mouse").WithName("LeftMouseButton");
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Gamepad>/buttonNorth", null, null, "Gamepad").WithName("YorTriangleButton");
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Dock
|
|||
|
action = actionMap.FindAction("Dock");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "Dock", UnityEngine.InputSystem.InputActionType.Button, null, null, null, null, "Button");
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Keyboard>/u", null, null, "Keyboard&Mouse").WithName("KeyU");
|
|||
|
}
|
|||
|
#endregion
|
|||
|
|
|||
|
UISSaveInputAsset();
|
|||
|
|
|||
|
isSuccess = true;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return isSuccess;
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Attempt to save the Input Sytem asset to disk
|
|||
|
/// </summary>
|
|||
|
private void UISSaveInputAsset()
|
|||
|
{
|
|||
|
if (uisPlayerInput != null && uisPlayerInput.actions != null)
|
|||
|
{
|
|||
|
try
|
|||
|
{
|
|||
|
string playerInputPath = AssetDatabase.GetAssetPath(uisPlayerInput.actions);
|
|||
|
string jsonActions = uisPlayerInput.actions.ToJson();
|
|||
|
//Debug.Log("asset path: " + playerInputPath + " name: " + uisPlayerInput.actions.name);
|
|||
|
|
|||
|
if (!string.IsNullOrEmpty(jsonActions) && !string.IsNullOrEmpty(playerInputPath))
|
|||
|
{
|
|||
|
System.IO.File.WriteAllText(playerInputPath, jsonActions);
|
|||
|
|
|||
|
// This was required for 1.0.0 preview 3 and earlier but causes issues
|
|||
|
// and isn't required for 1.0.0 preview 4+
|
|||
|
//AssetDatabase.ImportAsset(playerInputPath);
|
|||
|
}
|
|||
|
}
|
|||
|
catch (System.Exception ex)
|
|||
|
{
|
|||
|
Debug.LogWarning("ERROR: PlayerInputModule - could not save asset: " + uisPlayerInput.actions.name + " PLEASE REPORT - " + ex.Message);
|
|||
|
}
|
|||
|
|
|||
|
//EditorUtility.SetDirty(uisPlayerInput.actions);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
private void UISGetorCreateCanvas(out GameObject controlsCanvasGO, out Canvas controlCanvas, out Vector2 canvasSize)
|
|||
|
{
|
|||
|
controlsCanvasGO = null;
|
|||
|
canvasSize = Vector2.zero;
|
|||
|
Canvas[] canvasArray = FindObjectsOfType<Canvas>();
|
|||
|
controlCanvas = ArrayUtility.Find(canvasArray, cv => cv.name == "ControlsCanvas");
|
|||
|
|
|||
|
// If ControlsCanvas doesn't exist, create it
|
|||
|
if (controlCanvas == null)
|
|||
|
{
|
|||
|
controlsCanvasGO = new GameObject("ControlsCanvas");
|
|||
|
controlsCanvasGO.layer = 5;
|
|||
|
controlsCanvasGO.AddComponent<Canvas>();
|
|||
|
|
|||
|
controlCanvas = controlsCanvasGO.GetComponent<Canvas>();
|
|||
|
controlCanvas.renderMode = RenderMode.ScreenSpaceOverlay;
|
|||
|
controlsCanvasGO.AddComponent<UnityEngine.UI.CanvasScaler>();
|
|||
|
controlsCanvasGO.AddComponent<UnityEngine.UI.GraphicRaycaster>();
|
|||
|
}
|
|||
|
|
|||
|
// Add an Event System if it doesn't already exist.
|
|||
|
// NOTE: If it is disabled in scene, a new one isn't added.
|
|||
|
EditorApplication.ExecuteMenuItem("GameObject/UI/Event System");
|
|||
|
|
|||
|
if (controlCanvas != null)
|
|||
|
{
|
|||
|
controlsCanvasGO = controlCanvas.gameObject;
|
|||
|
canvasSize = controlsCanvasGO.GetComponent<RectTransform>().sizeDelta;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
private void UISAddOnScreenControls(string controlToAdd)
|
|||
|
{
|
|||
|
GameObject controlsCanvasGO;
|
|||
|
Canvas controlCanvas;
|
|||
|
Vector2 canvasSize;
|
|||
|
|
|||
|
UISGetorCreateCanvas(out controlsCanvasGO, out controlCanvas, out canvasSize);
|
|||
|
|
|||
|
if (controlCanvas != null)
|
|||
|
{
|
|||
|
// Get a list of onscreen joysticks on the control canvas
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenStick[] stickArray = controlsCanvasGO.GetComponentsInChildren<UnityEngine.InputSystem.OnScreen.OnScreenStick>();
|
|||
|
|
|||
|
if (controlToAdd == "LeftStick")
|
|||
|
{
|
|||
|
// Offset from bottom-left of canvas
|
|||
|
UISAddOnScreenStickIfMissing(stickArray, "LeftStick", "/<GamePad>/LeftStick", 100f, 150f, 0f, 0f, 0f, 0f, controlsCanvasGO.transform);
|
|||
|
}
|
|||
|
if (controlToAdd == "RightStick")
|
|||
|
{
|
|||
|
// Offset from bottom-right of canvas
|
|||
|
UISAddOnScreenStickIfMissing(stickArray, "RightStick", "/<GamePad>/RightStick", canvasSize.x - 100f, 150f, 1f, 0f, 1f, 0f, controlsCanvasGO.transform);
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
// Get a list of onscreen buttons on the control canvas
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenButton[] buttonsArray = controlsCanvasGO.GetComponentsInChildren<UnityEngine.InputSystem.OnScreen.OnScreenButton>();
|
|||
|
|
|||
|
if (controlToAdd == "LeftButtons")
|
|||
|
{
|
|||
|
// Offset from bottom-left of canvas
|
|||
|
UISAddOnScreenButtonIfMissing(buttonsArray, "LButtonUp", "<Keyboard>/w", 210f, 205f, 0f, 0f, 0f, 0f, controlsCanvasGO.transform);
|
|||
|
UISAddOnScreenButtonIfMissing(buttonsArray, "LButtonDown", "<Keyboard>/s", 210f, 100f, 0f, 0f, 0f, 0f, controlsCanvasGO.transform);
|
|||
|
UISAddOnScreenButtonIfMissing(buttonsArray, "LButtonLeft", "<Keyboard>/a", 105f, 100f, 0f, 0f, 0f, 0f, controlsCanvasGO.transform);
|
|||
|
UISAddOnScreenButtonIfMissing(buttonsArray, "LButtonRight", "<Keyboard>/d", 315f, 100f, 0f, 0f, 0f, 0f, controlsCanvasGO.transform);
|
|||
|
}
|
|||
|
else if (controlToAdd == "RightButtons")
|
|||
|
{
|
|||
|
// Offset from bottom-right of canvas
|
|||
|
|
|||
|
UISAddOnScreenButtonIfMissing(buttonsArray, "ButtonUp", "<GamePad>/rightTrigger", canvasSize.x - 210f, 205f, 1f, 0f, 1f, 0f, controlsCanvasGO.transform);
|
|||
|
UISAddOnScreenButtonIfMissing(buttonsArray, "ButtonDown", "<GamePad>/leftTrigger", canvasSize.x - 210f, 100f, 1f, 0f, 1f, 0f, controlsCanvasGO.transform);
|
|||
|
UISAddOnScreenButtonIfMissing(buttonsArray, "ButtonRollRight", "<Keyboard>/rightArrow", canvasSize.x - 105f, 100f, 1f, 0f, 1f, 0f, controlsCanvasGO.transform);
|
|||
|
UISAddOnScreenButtonIfMissing(buttonsArray, "ButtonRollLeft", "<Keyboard>/leftArrow", canvasSize.x - 315f, 100f, 1f, 0f, 1f, 0f, controlsCanvasGO.transform);
|
|||
|
|
|||
|
UISAddOnScreenTxtButtonIfMissing(buttonsArray, "ButtonFB1", "FB1", "<Gamepad>/buttonSouth", canvasSize.x / 2f - 315f, 205f + (canvasSize.y / 2f), 1f, 0f, 1f, 0f, controlsCanvasGO.transform);
|
|||
|
UISAddOnScreenTxtButtonIfMissing(buttonsArray, "ButtonFB2", "FB2", "<Gamepad>/buttonNorth", canvasSize.x / 2f - 105f, 205f + (canvasSize.y / 2f), 1f, 0f, 1f, 0f, controlsCanvasGO.transform);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
private void UISAddOnScreenQuit()
|
|||
|
{
|
|||
|
GameObject controlsCanvasGO;
|
|||
|
Canvas controlCanvas;
|
|||
|
Vector2 canvasSize;
|
|||
|
|
|||
|
UISGetorCreateCanvas(out controlsCanvasGO, out controlCanvas, out canvasSize);
|
|||
|
|
|||
|
if (controlCanvas != null)
|
|||
|
{
|
|||
|
// Get a list of onscreen buttons on the control canvas
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenButton[] buttonsArray = controlsCanvasGO.GetComponentsInChildren<UnityEngine.InputSystem.OnScreen.OnScreenButton>();
|
|||
|
|
|||
|
// Place in top-right corner
|
|||
|
UISAddOnScreenTxtButtonIfMissing(buttonsArray, "ButtonQuit", "Quit", "<Gamepad>/start", canvasSize.x / 2f - 50f, canvasSize.y * 1.5f - 50f, 1f, 0f, 1f, 0f, controlsCanvasGO.transform);
|
|||
|
|
|||
|
// Add the action to go with the button
|
|||
|
if (uisPlayerInput != null && uisPlayerInput.actions != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionMap actionMap = uisPlayerInput.actions.FindActionMap(uisPlayerInput.defaultActionMap);
|
|||
|
if (EditorUtility.DisplayDialog("Add Action", "Add Quit Action to Default Map: " + actionMap.name + "?", "Yes", "CANCEL!"))
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputAction action = actionMap.FindAction("QuitApp");
|
|||
|
if (action == null)
|
|||
|
{
|
|||
|
action = UnityEngine.InputSystem.InputActionSetupExtensions.AddAction(
|
|||
|
actionMap, "QuitApp", UnityEngine.InputSystem.InputActionType.Button, null, null, null, null, "Button");
|
|||
|
UnityEngine.InputSystem.InputActionSetupExtensions.AddBinding(action, "<Gamepad>/start", null, null, "Gamepad").WithName("StartQuitButton");
|
|||
|
UISSaveInputAsset();
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// If an OnScreen button is missing from the canvas, add it.
|
|||
|
/// </summary>
|
|||
|
/// <param name="buttonsArray"></param>
|
|||
|
/// <param name="buttonName"></param>
|
|||
|
/// <param name="controlPath"></param>
|
|||
|
/// <param name="buttonOffsetX"></param>
|
|||
|
/// <param name="buttonOffsetY"></param>
|
|||
|
/// <param name="parentTrfm"></param>
|
|||
|
private void UISAddOnScreenButtonIfMissing
|
|||
|
(
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenButton[] buttonsArray,
|
|||
|
string buttonName,
|
|||
|
string controlPath,
|
|||
|
float buttonOffsetX, float buttonOffsetY,
|
|||
|
float anchorMinX, float anchorMinY,
|
|||
|
float anchorMaxX, float anchorMaxY,
|
|||
|
Transform parentTrfm
|
|||
|
)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenButton button = ArrayUtility.Find(buttonsArray, btn => btn.name == buttonName);
|
|||
|
if (button == null)
|
|||
|
{
|
|||
|
GameObject buttonGO = new GameObject(buttonName);
|
|||
|
buttonGO.layer = 5;
|
|||
|
buttonGO.transform.SetParent(parentTrfm);
|
|||
|
RectTransform rectTrfm = buttonGO.AddComponent<RectTransform>();
|
|||
|
rectTrfm.anchorMin = new Vector2(anchorMinX, anchorMinY);
|
|||
|
rectTrfm.anchorMax = new Vector2(anchorMaxX, anchorMaxY);
|
|||
|
buttonGO.transform.position = new Vector3(buttonOffsetX, buttonOffsetY, 0f);
|
|||
|
buttonGO.AddComponent<CanvasRenderer>();
|
|||
|
UnityEngine.UI.Image buttomImg = buttonGO.AddComponent<UnityEngine.UI.Image>();
|
|||
|
UnityEngine.UI.Button buttonBtn = buttonGO.AddComponent<UnityEngine.UI.Button>();
|
|||
|
buttomImg.color = new Color(1f,1f,1f, 50f / 255f);
|
|||
|
buttomImg.sprite = AssetDatabase.GetBuiltinExtraResource<Sprite>("UI/Skin/UISprite.psd");
|
|||
|
buttomImg.type = UnityEngine.UI.Image.Type.Sliced;
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenButton newButton = buttonGO.AddComponent<UnityEngine.InputSystem.OnScreen.OnScreenButton>();
|
|||
|
newButton.controlPath = controlPath;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// If an OnScreen fire button is missing from the canvas, add it.
|
|||
|
/// </summary>
|
|||
|
/// <param name="buttonsArray"></param>
|
|||
|
/// <param name="buttonName"></param>
|
|||
|
/// <param name="controlPath"></param>
|
|||
|
/// <param name="buttonOffsetX"></param>
|
|||
|
/// <param name="buttonOffsetY"></param>
|
|||
|
/// <param name="anchorMinX"></param>
|
|||
|
/// <param name="anchorMinY"></param>
|
|||
|
/// <param name="anchorMaxX"></param>
|
|||
|
/// <param name="anchorMaxY"></param>
|
|||
|
/// <param name="parentTrfm"></param>
|
|||
|
private void UISAddOnScreenTxtButtonIfMissing
|
|||
|
(
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenButton[] buttonsArray,
|
|||
|
string buttonName,
|
|||
|
string buttonText,
|
|||
|
string controlPath,
|
|||
|
float buttonOffsetX, float buttonOffsetY,
|
|||
|
float anchorMinX, float anchorMinY,
|
|||
|
float anchorMaxX, float anchorMaxY,
|
|||
|
Transform parentTrfm
|
|||
|
)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenButton button = ArrayUtility.Find(buttonsArray, btn => btn.name == buttonName);
|
|||
|
if (button == null)
|
|||
|
{
|
|||
|
GameObject buttonGO = new GameObject(buttonName);
|
|||
|
buttonGO.layer = 5;
|
|||
|
buttonGO.transform.position = new Vector3(buttonOffsetX, buttonOffsetY, 0f);
|
|||
|
buttonGO.transform.SetParent(parentTrfm);
|
|||
|
RectTransform rectTrfm = buttonGO.AddComponent<RectTransform>();
|
|||
|
rectTrfm.anchorMin = new Vector2(anchorMinX, anchorMinY);
|
|||
|
rectTrfm.anchorMax = new Vector2(anchorMaxX, anchorMaxY);
|
|||
|
buttonGO.AddComponent<CanvasRenderer>();
|
|||
|
UnityEngine.UI.Image buttomImg = buttonGO.AddComponent<UnityEngine.UI.Image>();
|
|||
|
UnityEngine.UI.Button buttonBtn = buttonGO.AddComponent<UnityEngine.UI.Button>();
|
|||
|
buttomImg.color = new Color(1f,1f,1f, 50f / 255f);
|
|||
|
Sprite sprite = AssetDatabase.GetBuiltinExtraResource<Sprite>("UI/Skin/Knob.psd");
|
|||
|
if (sprite != null) { buttomImg.sprite = sprite; }
|
|||
|
buttomImg.type = UnityEngine.UI.Image.Type.Simple;
|
|||
|
// Add text
|
|||
|
GameObject buttonTxtGO = new GameObject("Text");
|
|||
|
buttonTxtGO.layer = 5;
|
|||
|
rectTrfm = buttonTxtGO.AddComponent<RectTransform>();
|
|||
|
// Centre the text in the button
|
|||
|
rectTrfm.anchorMin = new Vector2(0f, 0f);
|
|||
|
rectTrfm.anchorMax = new Vector2(1f, 1f);
|
|||
|
buttonTxtGO.AddComponent<CanvasRenderer>();
|
|||
|
UnityEngine.UI.Text buttonTxt = buttonTxtGO.AddComponent<UnityEngine.UI.Text>();
|
|||
|
buttonTxt.text = buttonText;
|
|||
|
buttonTxt.alignment = TextAnchor.MiddleCenter;
|
|||
|
buttonTxtGO.transform.SetParent(buttonGO.transform);
|
|||
|
buttonTxt.transform.localPosition = new Vector3(0f, 0f, 0f);
|
|||
|
// Add onscreen button
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenButton newButton = buttonGO.AddComponent<UnityEngine.InputSystem.OnScreen.OnScreenButton>();
|
|||
|
newButton.controlPath = controlPath;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// If an OnScreenStick is missing from the canvas, add it
|
|||
|
/// </summary>
|
|||
|
/// <param name="stickArray"></param>
|
|||
|
/// <param name="stickName"></param>
|
|||
|
/// <param name="controlPath"></param>
|
|||
|
/// <param name="buttonOffsetX"></param>
|
|||
|
/// <param name="buttonOffsetY"></param>
|
|||
|
/// <param name="anchorMinX"></param>
|
|||
|
/// <param name="anchorMinY"></param>
|
|||
|
/// <param name="anchorMaxX"></param>
|
|||
|
/// <param name="anchorMaxY"></param>
|
|||
|
/// <param name="parentTrfm"></param>
|
|||
|
private void UISAddOnScreenStickIfMissing
|
|||
|
(
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenStick[] stickArray,
|
|||
|
string stickName,
|
|||
|
string controlPath,
|
|||
|
float buttonOffsetX, float buttonOffsetY,
|
|||
|
float anchorMinX, float anchorMinY,
|
|||
|
float anchorMaxX, float anchorMaxY,
|
|||
|
Transform parentTrfm
|
|||
|
)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenStick stick = ArrayUtility.Find(stickArray, btn => btn.name == stickName);
|
|||
|
if (stick == null)
|
|||
|
{
|
|||
|
GameObject stickGO = new GameObject(stickName);
|
|||
|
stickGO.layer = 5;
|
|||
|
stickGO.transform.SetParent(parentTrfm);
|
|||
|
RectTransform rectTrfm = stickGO.AddComponent<RectTransform>();
|
|||
|
rectTrfm.anchorMin = new Vector2(anchorMinX, anchorMinY);
|
|||
|
rectTrfm.anchorMax = new Vector2(anchorMaxX, anchorMaxY);
|
|||
|
stickGO.transform.position = new Vector3(buttonOffsetX, buttonOffsetY, 0f);
|
|||
|
stickGO.AddComponent<CanvasRenderer>();
|
|||
|
UnityEngine.UI.Image stickImg = stickGO.AddComponent<UnityEngine.UI.Image>();
|
|||
|
UnityEngine.UI.Button stickBtn = stickGO.AddComponent<UnityEngine.UI.Button>();
|
|||
|
stickImg.color = new Color(1f,1f,1f, 80f / 255f);
|
|||
|
Sprite sprite = AssetDatabase.GetBuiltinExtraResource<Sprite>("UI/Skin/Knob.psd");
|
|||
|
if (sprite != null) { stickImg.sprite = sprite; }
|
|||
|
stickImg.type = UnityEngine.UI.Image.Type.Simple;
|
|||
|
UnityEngine.InputSystem.OnScreen.OnScreenStick newStick = stickGO.AddComponent<UnityEngine.InputSystem.OnScreen.OnScreenStick>();
|
|||
|
newStick.controlPath = controlPath;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Refresh the list of Actions available for the Default Map
|
|||
|
/// </summary>
|
|||
|
private void UISRefreshActions()
|
|||
|
{
|
|||
|
List<string> uisActionNameList = new List<string>(10);
|
|||
|
List<string> uisActionIDList = new List<string>(10);
|
|||
|
List<GUIContent> uisActionGUIContentList = new List<GUIContent>(10);
|
|||
|
|
|||
|
if (uisPlayerInput != null && uisPlayerInput.actions != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionMap actionMap = uisPlayerInput.actions.FindActionMap(uisPlayerInput.defaultActionMap);
|
|||
|
|
|||
|
// This readonly array can not be null but the map can be.
|
|||
|
// The map can be null when it was previously set in PlayerInput but was deleted in the UIS PlayerInput Editor.
|
|||
|
int numActions = actionMap == null ? 0 : actionMap.actions.Count;
|
|||
|
|
|||
|
for (int actIdx = 0; actIdx < numActions; actIdx++)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputAction action = actionMap.actions[actIdx];
|
|||
|
uisActionNameList.Add(action.name);
|
|||
|
uisActionIDList.Add(action.id.ToString());
|
|||
|
uisActionGUIContentList.Add(new GUIContent(action.name));
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Populate the lookup arrays and the GUIContent used in the dropdown list
|
|||
|
if (uisActionGUIContentList.Count > 0)
|
|||
|
{
|
|||
|
uisActionGUIContent = uisActionGUIContentList.ToArray();
|
|||
|
uisActionIDs = uisActionIDList.ToArray();
|
|||
|
uisActionNames = uisActionNameList.ToArray();
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
uisActionGUIContent = new GUIContent[] { new GUIContent(uisDropDownNone) };
|
|||
|
uisActionNames = new string[] { uisDropDownNone };
|
|||
|
uisActionIDs = new string[] { "" };
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Get the index of the action in the list of uisActionIDs.
|
|||
|
/// </summary>
|
|||
|
/// <param name="actionId"></param>
|
|||
|
/// <returns></returns>
|
|||
|
private int UISGetActionIdx(string actionId)
|
|||
|
{
|
|||
|
if (uisActionIDs != null)
|
|||
|
{
|
|||
|
return ArrayUtility.FindIndex<string>(uisActionIDs, s => s == actionId);
|
|||
|
}
|
|||
|
else { return -1; }
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Set the action Id (which is a string) for the action name supplied. Set the zero-based dataSlot
|
|||
|
/// (without validation) to the one supplied (set to 0 if no matching action name).
|
|||
|
/// </summary>
|
|||
|
/// <param name="actionName"></param>
|
|||
|
/// <param name="dataSlot"></param>
|
|||
|
/// <param name="positiveInputActionIdProp"></param>
|
|||
|
/// <param name="positiveInputActionDataSlotProp"></param>
|
|||
|
private void UISSetActionId(string actionName, int dataSlot, SerializedProperty positiveInputActionIdProp, SerializedProperty positiveInputActionDataSlotProp)
|
|||
|
{
|
|||
|
int acNameIdx = ArrayUtility.FindIndex(uisActionNames, an => an == actionName && !string.IsNullOrEmpty(actionName));
|
|||
|
if (acNameIdx >= 0 && acNameIdx < uisActionNames.Length)
|
|||
|
{
|
|||
|
positiveInputActionIdProp.stringValue = uisActionIDs[acNameIdx];
|
|||
|
positiveInputActionDataSlotProp.intValue = dataSlot;
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
positiveInputActionIdProp.stringValue = string.Empty;
|
|||
|
positiveInputActionDataSlotProp.intValue = 0;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region Rewired Methods
|
|||
|
#if SSC_REWIRED
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Find the rewired Input Manager in the scene (if there is one).
|
|||
|
/// If found, get a reference to the userdata.
|
|||
|
/// </summary>
|
|||
|
private void FindRewiredInputManager()
|
|||
|
{
|
|||
|
rewiredInputManager = Object.FindObjectOfType<Rewired.InputManager>();
|
|||
|
if (rewiredInputManager != null)
|
|||
|
{
|
|||
|
rewiredUserData = rewiredInputManager.userData;
|
|||
|
rwVersion = ReInput.programVersion;
|
|||
|
}
|
|||
|
else { rwVersion = string.Empty; }
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Get the Rewired Action Category an Action belongs to
|
|||
|
/// </summary>
|
|||
|
/// <param name="actionId"></param>
|
|||
|
/// <returns></returns>
|
|||
|
private int RWGetActionCategoryID(int actionId)
|
|||
|
{
|
|||
|
if (rewiredUserData != null)
|
|||
|
{
|
|||
|
InputAction inputAction = rewiredUserData.GetActionById(actionId);
|
|||
|
if (inputAction == null) { return -1; }
|
|||
|
else { return inputAction.categoryId; }
|
|||
|
}
|
|||
|
else { return -1; }
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Refresh the Rewired action arrays supplied for a given Action Category
|
|||
|
/// </summary>
|
|||
|
/// <param name="actionCategoryId"></param>
|
|||
|
/// <param name="actionIDs"></param>
|
|||
|
/// <param name="actionGUIContents"></param>
|
|||
|
private void RWRefreshActions(int actionCategoryId, ref int[] actionIDs, ref GUIContent[] actionGUIContents)
|
|||
|
{
|
|||
|
if (actionIDList == null || ActionGUIContentList == null) { return; }
|
|||
|
|
|||
|
// Empty the re-usable lists
|
|||
|
actionIDList.Clear();
|
|||
|
ActionGUIContentList.Clear();
|
|||
|
|
|||
|
// Basic validation
|
|||
|
if (rewiredUserData != null && actionCategoryId >= 0 && actionIDs != null && actionGUIContents != null)
|
|||
|
{
|
|||
|
int[] actionIds = rewiredUserData.GetSortedActionIdsInCategory(actionCategoryId);
|
|||
|
int numActions = actionIds == null ? 0 : actionIds.Length;
|
|||
|
|
|||
|
for (int actionIdx = 0; actionIdx < numActions; actionIdx++)
|
|||
|
{
|
|||
|
InputAction inputAction = rewiredUserData.GetActionById(actionIds[actionIdx]);
|
|||
|
|
|||
|
if (inputAction != null && inputAction.userAssignable)
|
|||
|
{
|
|||
|
actionIDList.Add(inputAction.id);
|
|||
|
ActionGUIContentList.Add(new GUIContent(inputAction.name, inputAction.descriptiveName));
|
|||
|
|
|||
|
//Debug.Log("Adding " + inputAction.name);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (actionIDList.Count > 0)
|
|||
|
{
|
|||
|
actionIDs = actionIDList.ToArray();
|
|||
|
actionGUIContents = ActionGUIContentList.ToArray();
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
actionIDs = new int[] { 0 };
|
|||
|
actionGUIContents = new GUIContent[] { new GUIContent(dropDownNone) };
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Update the arrays for all the user-defined Rewired Actions. These populate the dropdown
|
|||
|
/// lists in the editor.
|
|||
|
/// </summary>
|
|||
|
private void RWRefreshActionsAll()
|
|||
|
{
|
|||
|
if (rewiredUserData != null)
|
|||
|
{
|
|||
|
// To build the lists, the Action Category is required for each list
|
|||
|
|
|||
|
actionIDsHorizPositive = new int[1];
|
|||
|
ActionGUIContentHorizPositive = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.positiveHorizontalInputActionId), ref actionIDsHorizPositive, ref ActionGUIContentHorizPositive);
|
|||
|
|
|||
|
actionIDsHorizNegative = new int[1];
|
|||
|
ActionGUIContentHorizNegative = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.negativeHorizontalInputActionId), ref actionIDsHorizNegative, ref ActionGUIContentHorizNegative);
|
|||
|
|
|||
|
actionIDsVertPositive = new int[1];
|
|||
|
ActionGUIContentVertPositive = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.positiveVerticalInputActionId), ref actionIDsVertPositive, ref ActionGUIContentVertPositive);
|
|||
|
|
|||
|
actionIDsVertNegative = new int[1];
|
|||
|
ActionGUIContentVertNegative = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.negativeVerticalInputActionId), ref actionIDsVertNegative, ref ActionGUIContentVertNegative);
|
|||
|
|
|||
|
actionIDsLngtdlPositive = new int[1];
|
|||
|
ActionGUIContentLngtdlPositive = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.positiveLongitudinalInputActionId), ref actionIDsLngtdlPositive, ref ActionGUIContentLngtdlPositive);
|
|||
|
|
|||
|
actionIDsLngtdlNegative = new int[1];
|
|||
|
ActionGUIContentLngtdlNegative = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.negativeLongitudinalInputActionId), ref actionIDsLngtdlNegative, ref ActionGUIContentLngtdlNegative);
|
|||
|
|
|||
|
actionIDsPitchPositive = new int[1];
|
|||
|
ActionGUIContentPitchPositive = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.positivePitchInputActionId), ref actionIDsPitchPositive, ref ActionGUIContentPitchPositive);
|
|||
|
|
|||
|
actionIDsPitchNegative = new int[1];
|
|||
|
ActionGUIContentPitchNegative = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.negativePitchInputActionId), ref actionIDsPitchNegative, ref ActionGUIContentPitchNegative);
|
|||
|
|
|||
|
actionIDsYawPositive = new int[1];
|
|||
|
ActionGUIContentYawPositive = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.positiveYawInputActionId), ref actionIDsYawPositive, ref ActionGUIContentYawPositive);
|
|||
|
|
|||
|
actionIDsYawNegative = new int[1];
|
|||
|
ActionGUIContentYawNegative = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.negativeYawInputActionId), ref actionIDsYawNegative, ref ActionGUIContentYawNegative);
|
|||
|
|
|||
|
actionIDsRollPositive = new int[1];
|
|||
|
ActionGUIContentRollPositive = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.positiveRollInputActionId), ref actionIDsRollPositive, ref ActionGUIContentRollPositive);
|
|||
|
|
|||
|
actionIDsRollNegative = new int[1];
|
|||
|
ActionGUIContentRollNegative = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.negativeRollInputActionId), ref actionIDsRollNegative, ref ActionGUIContentRollNegative);
|
|||
|
|
|||
|
actionIDsPrimaryFire = new int[1];
|
|||
|
ActionGUIContentPrimaryFire = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.primaryFireInputActionId), ref actionIDsPrimaryFire, ref ActionGUIContentPrimaryFire);
|
|||
|
|
|||
|
actionIDsSecondaryFire = new int[1];
|
|||
|
ActionGUIContentSecondaryFire = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.secondaryFireInputActionId), ref actionIDsSecondaryFire, ref ActionGUIContentSecondaryFire);
|
|||
|
|
|||
|
actionIDsDocking = new int[1];
|
|||
|
ActionGUIContentDocking = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(playerInputModule.dockingInputActionId), ref actionIDsDocking, ref ActionGUIContentDocking);
|
|||
|
|
|||
|
int numCPI = playerInputModule.customPlayerInputList == null ? 0 : playerInputModule.customPlayerInputList.Count;
|
|||
|
|
|||
|
for (int cpiIdx = 0; cpiIdx < numCPI; cpiIdx++)
|
|||
|
{
|
|||
|
CustomPlayerInput customPlayerInput = playerInputModule.customPlayerInputList[cpiIdx];
|
|||
|
|
|||
|
if (customPlayerInput != null)
|
|||
|
{
|
|||
|
customPlayerInput.actionIDsPositive = new int[1];
|
|||
|
customPlayerInput.ActionGUIContentPositive = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(customPlayerInput.rwdPositiveInputActionId), ref customPlayerInput.actionIDsPositive, ref customPlayerInput.ActionGUIContentPositive);
|
|||
|
|
|||
|
customPlayerInput.actionIDsNegative = new int[1];
|
|||
|
customPlayerInput.ActionGUIContentNegative = new GUIContent[1];
|
|||
|
RWRefreshActions(RWGetActionCategoryID(customPlayerInput.rwdNegativeInputActionId), ref customPlayerInput.actionIDsNegative, ref customPlayerInput.ActionGUIContentNegative);
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
actionIDsHorizPositive = null;
|
|||
|
ActionGUIContentHorizPositive = null;
|
|||
|
actionIDsHorizNegative = null;
|
|||
|
ActionGUIContentHorizNegative = null;
|
|||
|
|
|||
|
actionIDsVertPositive = null;
|
|||
|
ActionGUIContentVertPositive = null;
|
|||
|
actionIDsVertNegative = null;
|
|||
|
ActionGUIContentVertNegative = null;
|
|||
|
|
|||
|
actionIDsLngtdlPositive = null;
|
|||
|
ActionGUIContentLngtdlPositive = null;
|
|||
|
actionIDsLngtdlNegative = null;
|
|||
|
ActionGUIContentLngtdlNegative = null;
|
|||
|
|
|||
|
actionIDsPitchPositive = null;
|
|||
|
ActionGUIContentPitchPositive = null;
|
|||
|
actionIDsPitchNegative = null;
|
|||
|
ActionGUIContentPitchNegative = null;
|
|||
|
|
|||
|
actionIDsYawPositive = null;
|
|||
|
ActionGUIContentYawPositive = null;
|
|||
|
actionIDsYawNegative = null;
|
|||
|
ActionGUIContentYawNegative = null;
|
|||
|
|
|||
|
actionIDsRollPositive = null;
|
|||
|
ActionGUIContentRollPositive = null;
|
|||
|
actionIDsRollNegative = null;
|
|||
|
ActionGUIContentRollNegative = null;
|
|||
|
|
|||
|
actionIDsPrimaryFire = null;
|
|||
|
ActionGUIContentPrimaryFire = null;
|
|||
|
|
|||
|
actionIDsSecondaryFire = null;
|
|||
|
ActionGUIContentSecondaryFire = null;
|
|||
|
|
|||
|
actionIDsDocking = null;
|
|||
|
ActionGUIContentDocking = null;
|
|||
|
|
|||
|
int numCPI = playerInputModule.customPlayerInputList == null ? 0 : playerInputModule.customPlayerInputList.Count;
|
|||
|
|
|||
|
for (int cpiIdx = 0; cpiIdx < numCPI; cpiIdx++)
|
|||
|
{
|
|||
|
CustomPlayerInput customPlayerInput = playerInputModule.customPlayerInputList[cpiIdx];
|
|||
|
|
|||
|
if (customPlayerInput != null)
|
|||
|
{
|
|||
|
customPlayerInput.actionIDsPositive = null;
|
|||
|
customPlayerInput.actionIDsNegative = null;
|
|||
|
customPlayerInput.ActionGUIContentPositive = null;
|
|||
|
customPlayerInput.ActionGUIContentNegative = null;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Populate arrays for the list of Action Categories
|
|||
|
/// </summary>
|
|||
|
private void RWRefreshActionCategories()
|
|||
|
{
|
|||
|
List<string> actionCategoriesList = new List<string>(5);
|
|||
|
List<int> actionCategoryIDList = new List<int>(5);
|
|||
|
List<GUIContent> ActionCategoryGUIContentList = new List<GUIContent>(5);
|
|||
|
|
|||
|
if (rewiredUserData != null)
|
|||
|
{
|
|||
|
int[] actionCategoryIds = rewiredUserData.GetActionCategoryIds();
|
|||
|
|
|||
|
int numCategories = actionCategoryIds == null ? 0 : actionCategoryIds.Length;
|
|||
|
|
|||
|
for (int catIdx = 0; catIdx < numCategories; catIdx++)
|
|||
|
{
|
|||
|
InputCategory inputCategory = rewiredUserData.GetActionCategoryById(actionCategoryIds[catIdx]);
|
|||
|
|
|||
|
if (inputCategory != null && inputCategory.userAssignable)
|
|||
|
{
|
|||
|
actionCategoriesList.Add(inputCategory.name);
|
|||
|
actionCategoryIDList.Add(inputCategory.id);
|
|||
|
ActionCategoryGUIContentList.Add(new GUIContent(inputCategory.name, inputCategory.descriptiveName));
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (actionCategoriesList.Count > 0)
|
|||
|
{
|
|||
|
actionCategories = actionCategoriesList.ToArray();
|
|||
|
actionCategoryIDs = actionCategoryIDList.ToArray();
|
|||
|
ActionCategoryGUIContent = ActionCategoryGUIContentList.ToArray();
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
actionCategories = new string[] { dropDownNone };
|
|||
|
actionCategoryIDs = new int[] { 0 };
|
|||
|
ActionCategoryGUIContent = new GUIContent[] { new GUIContent(dropDownNone) };
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
#else
|
|||
|
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
|
|||
|
#region XR Methods
|
|||
|
#if SCSM_XR && SSC_UIS
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Create a hand transform under "XR Hands Offset"
|
|||
|
/// </summary>
|
|||
|
/// <param name="handProperty"></param>
|
|||
|
/// <param name="isLefthand"></param>
|
|||
|
private void XRCreateHand(SerializedProperty handProperty, bool isLefthand)
|
|||
|
{
|
|||
|
// Check if it already exists to help with Undo.
|
|||
|
Transform xrHandsTrfm = playerInputModule.transform.Find(xrHandsOffsetName);
|
|||
|
|
|||
|
if (xrHandsTrfm == null)
|
|||
|
{
|
|||
|
xrHandsTrfm = SSCUtils.GetOrCreateChildTransform(playerInputModule.transform, xrHandsOffsetName);
|
|||
|
|
|||
|
if (xrHandsTrfm != null)
|
|||
|
{
|
|||
|
Undo.RegisterCreatedObjectUndo(xrHandsTrfm.gameObject, string.Empty);
|
|||
|
xrHandsTrfm.localPosition = Vector3.zero;
|
|||
|
xrHandsTrfm.localRotation = Quaternion.identity;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (xrHandsTrfm != null)
|
|||
|
{
|
|||
|
// Check if it already exists to help with Undo.
|
|||
|
Transform xrHandTrfm = xrHandsTrfm.Find(isLefthand ? xrLeftHandName : xrRightHandName);
|
|||
|
|
|||
|
if (xrHandTrfm == null)
|
|||
|
{
|
|||
|
xrHandTrfm = SSCUtils.GetOrCreateChildTransform(xrHandsTrfm, isLefthand ? xrLeftHandName : xrRightHandName);
|
|||
|
Undo.RegisterCreatedObjectUndo(xrHandTrfm.gameObject, string.Empty);
|
|||
|
|
|||
|
xrHandTrfm.localPosition = Vector3.zero;
|
|||
|
xrHandTrfm.localRotation = Quaternion.identity;
|
|||
|
|
|||
|
// Distinguish between the old XR TrackPoseDriver and the one with the new Unity Input System.
|
|||
|
var _tposeDriver = Undo.AddComponent(xrHandTrfm.gameObject, typeof(UnityEngine.InputSystem.XR.TrackedPoseDriver)) as UnityEngine.InputSystem.XR.TrackedPoseDriver;
|
|||
|
|
|||
|
if (_tposeDriver != null)
|
|||
|
{
|
|||
|
_tposeDriver.trackingType = UnityEngine.InputSystem.XR.TrackedPoseDriver.TrackingType.RotationAndPosition;
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputAction _tposPosition = new UnityEngine.InputSystem.InputAction(null, UnityEngine.InputSystem.InputActionType.Value);
|
|||
|
if (_tposPosition != null)
|
|||
|
{
|
|||
|
//_tposPosition.expectedControlType = "Quaternion";
|
|||
|
_tposeDriver.positionAction = _tposPosition;
|
|||
|
}
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputAction _tposRotation = new UnityEngine.InputSystem.InputAction(null, UnityEngine.InputSystem.InputActionType.Value);
|
|||
|
if (_tposRotation != null)
|
|||
|
{
|
|||
|
_tposRotation.expectedControlType = "Quaternion";
|
|||
|
_tposeDriver.rotationAction = _tposRotation;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (xrHandTrfm != null)
|
|||
|
{
|
|||
|
handProperty.objectReferenceValue = xrHandTrfm;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Get the index of the action map in the list of xrActionMapIDs.
|
|||
|
/// </summary>
|
|||
|
/// <param name="actionId"></param>
|
|||
|
/// <returns></returns>
|
|||
|
private int XRGetActionMapIdx(string actionMapId)
|
|||
|
{
|
|||
|
if (xrActionMapIDs != null)
|
|||
|
{
|
|||
|
return ArrayUtility.FindIndex<string>(xrActionMapIDs, s => s == actionMapId);
|
|||
|
}
|
|||
|
else { return -1; }
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Refresh the list of Actions available for selected Action Map
|
|||
|
/// </summary>
|
|||
|
private void XRRefreshActions(string actionMapId, bool forceRefresh)
|
|||
|
{
|
|||
|
bool hasChanged = string.Compare(actionMapId, xrCurrentActionMapId, false) != 0;
|
|||
|
|
|||
|
if (hasChanged || forceRefresh)
|
|||
|
{
|
|||
|
xrCurrentActionMapId = string.Copy(actionMapId);
|
|||
|
|
|||
|
// cache the lists to reduce GC in the editor at runtime
|
|||
|
if (xrActionNameList == null) { xrActionNameList = new List<string>(10); }
|
|||
|
else { xrActionNameList.Clear(); }
|
|||
|
if (xrActionIDList == null) { xrActionIDList = new List<string>(10); }
|
|||
|
else { xrActionIDList.Clear(); }
|
|||
|
if (xrActionGUIContentList == null) { xrActionGUIContentList = new List<GUIContent>(10); }
|
|||
|
else { xrActionGUIContentList.Clear(); }
|
|||
|
|
|||
|
UnityEngine.InputSystem.InputActionAsset inputActionAsset = playerInputModule.GetXRInputActionAsset();
|
|||
|
UnityEngine.InputSystem.InputActionMap actionMap = inputActionAsset == null ? null : inputActionAsset.FindActionMap(actionMapId);
|
|||
|
|
|||
|
if (actionMap != null)
|
|||
|
{
|
|||
|
// This readonly array can not be null but the map can be.
|
|||
|
// The map can be null when it was previously set in PlayerInput but was deleted in the UIS PlayerInput Editor.
|
|||
|
int numActions = actionMap == null ? 0 : actionMap.actions.Count;
|
|||
|
|
|||
|
for (int actIdx = 0; actIdx < numActions; actIdx++)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputAction action = actionMap.actions[actIdx];
|
|||
|
xrActionNameList.Add(action.name);
|
|||
|
xrActionIDList.Add(action.id.ToString());
|
|||
|
xrActionGUIContentList.Add(new GUIContent(action.name));
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
// Populate the lookup arrays and the GUIContent used in the dropdown list
|
|||
|
if (xrActionGUIContentList.Count > 0)
|
|||
|
{
|
|||
|
uisActionGUIContent = xrActionGUIContentList.ToArray();
|
|||
|
uisActionIDs = xrActionIDList.ToArray();
|
|||
|
uisActionNames = xrActionNameList.ToArray();
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
uisActionGUIContent = new GUIContent[] { new GUIContent(uisDropDownNone) };
|
|||
|
uisActionNames = new string[] { uisDropDownNone };
|
|||
|
uisActionIDs = new string[] { "" };
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
/// <summary>
|
|||
|
/// Refresh the list of action maps available in the InputActionAsset assigned to the XR inputmode
|
|||
|
/// </summary>
|
|||
|
private void XRRefreshActionMaps()
|
|||
|
{
|
|||
|
if (inputActionAssetXRProp != null && inputActionAssetXRProp.objectReferenceValue != null)
|
|||
|
{
|
|||
|
UnityEngine.InputSystem.InputActionAsset inputActions = (UnityEngine.InputSystem.InputActionAsset)inputActionAssetXRProp.objectReferenceValue;
|
|||
|
|
|||
|
var actionMaps = inputActions.actionMaps;
|
|||
|
|
|||
|
xrActionMapGUIContent = new GUIContent[actionMaps.Count + 1];
|
|||
|
xrActionMapIDs = new string[actionMaps.Count + 1];
|
|||
|
xrActionMapGUIContent[0] = new GUIContent(EditorGUIUtility.TrTextContent(uisDropDownNone));
|
|||
|
xrActionMapIDs[0] = string.Empty;
|
|||
|
|
|||
|
for (int i = 0; i < actionMaps.Count; ++i)
|
|||
|
{
|
|||
|
var actionMap = actionMaps[i];
|
|||
|
xrActionMapGUIContent[i + 1] = new GUIContent(actionMap.name);
|
|||
|
xrActionMapIDs[i + 1] = actionMap.id.ToString();
|
|||
|
}
|
|||
|
}
|
|||
|
else
|
|||
|
{
|
|||
|
xrActionMapGUIContent = new GUIContent[1];
|
|||
|
xrActionMapGUIContent[0] = new GUIContent(EditorGUIUtility.TrTextContent(uisDropDownNone));
|
|||
|
}
|
|||
|
}
|
|||
|
#endif
|
|||
|
#endregion
|
|||
|
}
|
|||
|
}
|