273 lines
12 KiB
C#
273 lines
12 KiB
C#
using Ryujinx.Ava.UI.Models.Input;
|
|
using Ryujinx.Common.Configuration.Hid;
|
|
using Ryujinx.Common.Configuration.Hid.Controller;
|
|
using Ryujinx.Common.Configuration.Hid.Controller.Motion;
|
|
using Ryujinx.Common.Logging;
|
|
using Ryujinx.Input;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using StickInputId = Ryujinx.Common.Configuration.Hid.Controller.StickInputId;
|
|
|
|
namespace Ryujinx.Ava.Input
|
|
{
|
|
public static class ControllerAssignmentManager
|
|
{
|
|
private static readonly uint[] _playerColors =
|
|
[
|
|
0xFFFF0000, // Player 1 - Red
|
|
0xFF0000FF, // Player 2 - Blue
|
|
0xFF00FF00, // Player 3 - Green
|
|
0xFFFFFF00, // Player 4 - Yellow
|
|
0xFFFF00FF, // Player 5 - Magenta
|
|
0xFFFFA500, // Player 6 - Orange
|
|
0xFF00FFFF, // Player 7 - Cyan
|
|
0xFF800080 // Player 8 - Purple
|
|
];
|
|
|
|
private const int MaxControllers = 9;
|
|
|
|
public static List<InputConfig> ReorderControllers(List<InputConfig> newConfig, List<InputConfig> oldConfig)
|
|
{
|
|
List<InputConfig> reorderedConfig = oldConfig.Select(config => new GamepadInputConfig(config).GetConfig()).ToList();
|
|
|
|
foreach (var config in newConfig)
|
|
{
|
|
InputConfig substitute = reorderedConfig.FirstOrDefault(x => x.Id == config.Id);
|
|
InputConfig toBeReplaced = reorderedConfig.FirstOrDefault(x => x.PlayerIndex == config.PlayerIndex);
|
|
|
|
if (substitute == null || toBeReplaced == null || substitute.PlayerIndex == toBeReplaced.PlayerIndex) continue;
|
|
|
|
(substitute.PlayerIndex, toBeReplaced.PlayerIndex) = (toBeReplaced.PlayerIndex, substitute.PlayerIndex);
|
|
}
|
|
|
|
return reorderedConfig;
|
|
}
|
|
|
|
public static List<InputConfig> GetConfiguredControllers(
|
|
List<IGamepad> controllers,
|
|
List<InputConfig> oldConfig,
|
|
out bool hasNewControllersConnected)
|
|
{
|
|
if(controllers == null || controllers.Count == 0)
|
|
{
|
|
hasNewControllersConnected = false;
|
|
return [];
|
|
}
|
|
|
|
Dictionary<string, InputConfig> oldConfigMap = oldConfig
|
|
.Where(c => c?.Id != null)
|
|
.ToDictionary(x => x.Id);
|
|
|
|
Dictionary<int, InputConfig> playerIndexMap = new();
|
|
HashSet<int> usedIndices = [];
|
|
int recognizedControllersCount = 0;
|
|
|
|
List<IGamepad> remainingControllers = controllers.Where(c => c?.Id != null).ToList();
|
|
|
|
// Add controllers with existing configurations
|
|
AddExistingControllers(remainingControllers, oldConfigMap, playerIndexMap, usedIndices, ref recognizedControllersCount);
|
|
|
|
// Add new controllers
|
|
AddNewControllers(remainingControllers, playerIndexMap, usedIndices);
|
|
|
|
List<InputConfig> orderedConfigs = playerIndexMap
|
|
.OrderBy(x => x.Key)
|
|
.Select(x => x.Value)
|
|
.ToList();
|
|
|
|
// Update player indices and LED colors
|
|
UpdatePlayerIndicesAndLEDs(orderedConfigs);
|
|
|
|
hasNewControllersConnected = controllers.Count > recognizedControllersCount;
|
|
return orderedConfigs;
|
|
}
|
|
|
|
private static void AddExistingControllers(
|
|
List<IGamepad> controllers,
|
|
Dictionary<string, InputConfig> oldConfigMap,
|
|
Dictionary<int, InputConfig> playerIndexMap,
|
|
HashSet<int> usedIndices,
|
|
ref int recognizedControllersCount)
|
|
{
|
|
foreach (var controller in controllers.ToList())
|
|
{
|
|
if (!oldConfigMap.TryGetValue(controller.Id, out InputConfig existingConfig))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
int desiredIndex = (int)existingConfig.PlayerIndex;
|
|
|
|
// Ensure the index is valid and available
|
|
if (desiredIndex < 0 || desiredIndex >= MaxControllers || usedIndices.Contains(desiredIndex))
|
|
{
|
|
desiredIndex = GetFirstAvailableIndex(usedIndices);
|
|
}
|
|
|
|
if(desiredIndex == -1) continue;
|
|
|
|
InputConfig config = new GamepadInputConfig(existingConfig).GetConfig();
|
|
config.PlayerIndex = (PlayerIndex)desiredIndex;
|
|
usedIndices.Add(desiredIndex);
|
|
playerIndexMap[desiredIndex] = config;
|
|
recognizedControllersCount++;
|
|
|
|
controllers.Remove(controller);
|
|
}
|
|
}
|
|
|
|
private static void AddNewControllers(
|
|
List<IGamepad> controllers,
|
|
Dictionary<int, InputConfig> playerIndexMap,
|
|
HashSet<int> usedIndices)
|
|
{
|
|
foreach (var controller in controllers)
|
|
{
|
|
InputConfig config = CreateConfigFromController(controller);
|
|
int freeIndex = GetFirstAvailableIndex(usedIndices);
|
|
config.PlayerIndex = (PlayerIndex)freeIndex;
|
|
usedIndices.Add(freeIndex);
|
|
playerIndexMap[freeIndex] = config;
|
|
}
|
|
}
|
|
|
|
private static int GetFirstAvailableIndex(HashSet<int> usedIndices)
|
|
{
|
|
for (int i = 0; i < MaxControllers; i++)
|
|
{
|
|
if (!usedIndices.Contains(i)) return i;
|
|
}
|
|
return -1; // Should not happen unless MaxControllers is exceeded
|
|
}
|
|
|
|
private static void UpdatePlayerIndicesAndLEDs(List<InputConfig> orderedConfigs)
|
|
{
|
|
for (int index = 0; index < orderedConfigs.Count; index++)
|
|
{
|
|
orderedConfigs[index].PlayerIndex = (PlayerIndex)index;
|
|
|
|
if (orderedConfigs[index] is not StandardControllerInputConfig standardConfig ||
|
|
standardConfig.Led.UseRainbow)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Logger.Warning?.Print(LogClass.Application, $"Setting color for Player{index + 1}");
|
|
standardConfig.Led = new LedConfigController
|
|
{
|
|
EnableLed = true,
|
|
LedColor = _playerColors[index]
|
|
};
|
|
}
|
|
}
|
|
|
|
private static InputConfig CreateConfigFromController(IGamepad controller)
|
|
{
|
|
if (controller == null) return null;
|
|
|
|
Logger.Warning?.Print(LogClass.Application, $"Creating config for controller: {controller.Id}");
|
|
|
|
string id = controller.Id.Split(" ")[0];
|
|
bool isNintendoStyle = controller.Name.Contains("Nintendo");
|
|
ControllerType controllerType;
|
|
|
|
if (isNintendoStyle && !controller.Name.Contains("(L/R)"))
|
|
{
|
|
if (controller.Name.Contains("(L)"))
|
|
{
|
|
controllerType = ControllerType.JoyconLeft;
|
|
}
|
|
else if (controller.Name.Contains("(R)"))
|
|
{
|
|
controllerType = ControllerType.JoyconRight;
|
|
}
|
|
else
|
|
{
|
|
controllerType = ControllerType.ProController;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if it's not a nintendo controller, we assume it's a pro controller or a joy-con pair
|
|
controllerType = ControllerType.ProController;
|
|
}
|
|
|
|
InputConfig config = new StandardControllerInputConfig
|
|
{
|
|
Version = InputConfig.CurrentVersion,
|
|
Backend = InputBackendType.GamepadSDL2,
|
|
Id = id,
|
|
ControllerType = controllerType,
|
|
DeadzoneLeft = 0.1f,
|
|
DeadzoneRight = 0.1f,
|
|
RangeLeft = 1.0f,
|
|
RangeRight = 1.0f,
|
|
TriggerThreshold = 0.5f,
|
|
LeftJoycon = new LeftJoyconCommonConfig<GamepadInputId>
|
|
{
|
|
DpadUp = (controllerType == ControllerType.JoyconLeft) ? GamepadInputId.Y : GamepadInputId.DpadUp,
|
|
DpadDown = (controllerType == ControllerType.JoyconLeft) ? GamepadInputId.A : GamepadInputId.DpadDown,
|
|
DpadLeft = (controllerType == ControllerType.JoyconLeft) ? GamepadInputId.B : GamepadInputId.DpadLeft,
|
|
DpadRight = (controllerType == ControllerType.JoyconLeft) ? GamepadInputId.X : GamepadInputId.DpadRight,
|
|
ButtonMinus = (controllerType == ControllerType.JoyconLeft) ? GamepadInputId.Plus : GamepadInputId.Minus,
|
|
ButtonL = GamepadInputId.LeftShoulder,
|
|
ButtonZl = GamepadInputId.LeftTrigger,
|
|
ButtonSl = (controllerType == ControllerType.JoyconLeft) ? GamepadInputId.LeftShoulder : GamepadInputId.Unbound,
|
|
ButtonSr = (controllerType == ControllerType.JoyconLeft) ? GamepadInputId.RightShoulder : GamepadInputId.Unbound,
|
|
},
|
|
LeftJoyconStick = new JoyconConfigControllerStick<GamepadInputId, StickInputId>
|
|
{
|
|
Joystick = StickInputId.Left,
|
|
StickButton = GamepadInputId.LeftStick,
|
|
InvertStickX = false,
|
|
InvertStickY = false,
|
|
Rotate90CW = (controllerType == ControllerType.JoyconLeft),
|
|
},
|
|
RightJoycon = new RightJoyconCommonConfig<GamepadInputId>
|
|
{
|
|
ButtonA = GamepadInputId.B,
|
|
ButtonB = (controllerType == ControllerType.JoyconRight) ? GamepadInputId.Y : GamepadInputId.A,
|
|
ButtonX = (controllerType == ControllerType.JoyconRight) ? GamepadInputId.A : GamepadInputId.Y,
|
|
ButtonY = GamepadInputId.X,
|
|
ButtonPlus = GamepadInputId.Plus,
|
|
ButtonR = GamepadInputId.RightShoulder,
|
|
ButtonZr = GamepadInputId.RightTrigger,
|
|
ButtonSl = (controllerType == ControllerType.JoyconRight) ? GamepadInputId.LeftShoulder : GamepadInputId.Unbound,
|
|
ButtonSr = (controllerType == ControllerType.JoyconRight) ? GamepadInputId.RightShoulder : GamepadInputId.Unbound,
|
|
},
|
|
RightJoyconStick = new JoyconConfigControllerStick<GamepadInputId, StickInputId>
|
|
{
|
|
Joystick = (controllerType == ControllerType.JoyconRight) ? StickInputId.Left : StickInputId.Right,
|
|
StickButton = GamepadInputId.RightStick,
|
|
InvertStickX = (controllerType == ControllerType.JoyconRight),
|
|
InvertStickY = (controllerType == ControllerType.JoyconRight),
|
|
Rotate90CW = (controllerType == ControllerType.JoyconRight),
|
|
},
|
|
Motion = new StandardMotionConfigController
|
|
{
|
|
MotionBackend = MotionInputBackendType.GamepadDriver,
|
|
EnableMotion = true,
|
|
Sensitivity = 100,
|
|
GyroDeadzone = 1,
|
|
},
|
|
Rumble = new RumbleConfigController
|
|
{
|
|
StrongRumble = 1f,
|
|
WeakRumble = 1f,
|
|
EnableRumble = false,
|
|
},
|
|
Led = new LedConfigController
|
|
{
|
|
EnableLed = true,
|
|
TurnOffLed = false,
|
|
UseRainbow = false,
|
|
LedColor = 0,
|
|
},
|
|
};
|
|
|
|
return config;
|
|
}
|
|
}
|
|
|
|
}
|