```csharp ///

/// Applies an axis group from the source device to this virtual device. /// Populates the relevant axis mappings as well. ///

public void SetAxisGroup(IAxisDevice sourceDevice, int sourceGroupIndex, int targetGroupIndex); ///

/// Applies the specified axis from the source device to this virtual device ///

public void SetAxis(IAxisDevice sourceDevice, int sourceAxisIndex, int targetAxisIndex); ///

/// Clears the specified axis from this virtual device. Basicaly, [axisIndex] = null ///

public void ClearAxis(int axisIndex); ///

/// Clears the specified axis group from this virtual device. Basically, [groupIndex] = null /// Will also clear the individual axis mappings for the axes in the group if clearAxes is true ///

/// The index of the axis group /// Whether the axis mappings for the axes in the group should also be cleared public void ClearAxisGroup(int groupIndex, bool clearAxes); public bool HasAxis(int axisIndex) => AxisMappings[axisIndex] != null; ///

/// Returns true if the device is fully mapped, with all required axes defined ///

public virtual bool IsFullyMapped => AxisMappings.All(mapping => mapping != null); ///

/// True if they are, false if 1 or more underlying devices have disconnected ///

public bool AllPhysicalDevicesConnected { get; } ///

/// True if the axis is mapped and the underlying device is connected ///

public bool IsAxisAvailable(int axisIndex); ///

/// Of course it is a virtual device ///

bool IAxisDevice.IsVirtual => true; ///

/// If true, calling will set the desired axis, and if the input axis is already mapped to /// another virtual axis, that other virtual axis must be cleared. /// In other words, forces a 1:1 mapping of input axes to virtual axes. ///

public bool ForceUniqueInputAxes { get; set; } ///

/// Replaces all the used axes of the specified device with the matching axes of the new device ///

/// InvalidOperationException if the devices are not the same type and no valid axis mappings are provided /// to reconcile this. This compatibility is implementation-specific public abstract void ReplaceDevice(T oldDevice, T newDevice, IReadOnlyList<(int, int)>? axisMappings = null) where T : IAxisDevice; } ```

how things go, inputly

Similar Threads