public VirtualError DisableFeeding(uint userIndex)
        {
            bool success;

            if (userIndex < 1 || userIndex > 4)
            {
                return(VirtualError.Index);
            }
            if (!ViGEmClient.isVBusExists(false))
            {
                return(VirtualError.Missing);
            }
            if (!ViGEmClient.Current.isControllerExists(userIndex))
            {
                return(VirtualError.None);
            }
            if (!ViGEmClient.Current.IsControllerConnected(userIndex))
            {
                return(VirtualError.None);
            }
            success = ViGEmClient.Current.UnPlug(userIndex);
            return(success
                ? VirtualError.None
                : VirtualError.Other);
        }
        public VirtualError DisableFeeding(uint userIndex)
        {
            bool success;

            if (userIndex < 1 || userIndex > 4)
            {
                return(VirtualError.Index);
            }
            if (!ViGEmClient.isVBusExists())
            {
                return(VirtualError.Missing);
            }
            if (!ViGEmClient.isControllerExists(userIndex))
            {
                return(VirtualError.None);
            }
            if (ViGEmClient.isControllerOwned(userIndex))
            {
                success = ViGEmClient.UnPlug(userIndex);
                if (success)
                {
                    return(VirtualError.None);
                }
            }
            else
            {
                success = ViGEmClient.UnPlugForce(userIndex);
                if (success)
                {
                    return(VirtualError.None);
                }
            }
            return(VirtualError.Other);
        }
 public VirtualError CheckUnInstallVirtualDriver()
 {
     // If driver is installed already then return.
     if (ViGEmClient.isVBusExists())
     {
         return(VirtualError.None);
     }
     JocysCom.ClassLibrary.Win32.NativeMethods.RunElevated(Application.ExecutablePath, Program.UnInstallVirtualDriverParam, System.Diagnostics.ProcessWindowStyle.Hidden);
     return(VirtualError.None);
 }
 public static VirtualError CheckUnInstallVirtualDriver()
 {
     // If driver is installed already then return.
     if (!ViGEmClient.isVBusExists(false))
     {
         return(VirtualError.None);
     }
     Program.RunElevated(AdminCommand.UninstallViGEmBus);
     return(VirtualError.None);
 }
        public VirtualError EnableFeeding(uint userIndex)
        {
            if (userIndex < 1 || userIndex > 4)
            {
                return(VirtualError.Index);
            }
            if (!ViGEmClient.isVBusExists(true))
            {
                return(VirtualError.Missing);
            }
            if (!ViGEmClient.Current.isControllerExists(userIndex))
            {
                return(VirtualError.Other);
            }
            if (ViGEmClient.Current.IsControllerConnected(userIndex))
            {
                return(VirtualError.None);
            }
            var success = ViGEmClient.Current.PlugIn(userIndex);

            return(success
                ? VirtualError.None
                : VirtualError.Other);
        }
        void UpdateVirtualDevices()
        {
            // Allow if not testing or testing with option enabled.
            var o     = SettingsManager.Options;
            var allow = !o.TestEnabled || o.TestSetXInputStates;

            if (!allow)
            {
                return;
            }
            var game = MainForm.Current.CurrentGame;

            // If game does not support emulation type.
            if (!((EmulationType)game.EmulationType).HasFlag(EmulationType.Virtual))
            {
                return;
            }
            // If virtual driver is missing then return.
            if (!ViGEmClient.isVBusExists())
            {
                return;
            }
            if (ViGEmClient.Targets == null)
            {
                ViGEmClient.Targets    = new Nefarius.ViGEm.Client.Targets.Xbox360Controller[4];
                ViGEmClient.Targets[0] = new Nefarius.ViGEm.Client.Targets.Xbox360Controller(ViGEmClient.Client);
                ViGEmClient.Targets[1] = new Nefarius.ViGEm.Client.Targets.Xbox360Controller(ViGEmClient.Client);
                ViGEmClient.Targets[2] = new Nefarius.ViGEm.Client.Targets.Xbox360Controller(ViGEmClient.Client);
                ViGEmClient.Targets[3] = new Nefarius.ViGEm.Client.Targets.Xbox360Controller(ViGEmClient.Client);
            }
            for (uint i = 1; i <= 4; i++)
            {
                var mapTo          = (MapTo)i;
                var flag           = AppHelper.GetMapFlag(mapTo);
                var value          = (MapToMask)game.EnableMask;
                var virtualEnabled = value.HasFlag(flag);
                var feedingState   = FeedingState[i - 1];
                if (virtualEnabled)
                {
                    // If feeding status unknonw or not enabled then...
                    if (!feedingState.HasValue || !feedingState.Value)
                    {
                        var success = EnableFeeding(i) == VirtualError.None;
                        if (!success)
                        {
                            return;
                        }
                        FeedingState[i - 1] = true;
                    }
                    FeedDevice(i);
                }
                else
                {
                    // If feeding status unknonw or enabled then...
                    if (!feedingState.HasValue || feedingState.Value)
                    {
                        var success = DisableFeeding(i) == VirtualError.None;
                        if (!success)
                        {
                            return;
                        }
                        FeedingState[i - 1] = false;
                    }
                }
            }
        }
        /// <summary>
        /// Enable or disable virtual controllers depending on game settings.
        /// </summary>
        /// <param name="game"></param>
        void UpdateVirtualDevices(UserGame game)
        {
            // Allow if not testing or testing with option enabled.
            var o     = SettingsManager.Options;
            var allow = !o.TestEnabled || o.TestSetXInputStates;

            if (!allow)
            {
                return;
            }
            // If virtual driver is missing then return.
            if (!ViGEmClient.isVBusExists(true))
            {
                return;
            }
            var isVirtual = ((EmulationType)game.EmulationType).HasFlag(EmulationType.Virtual);

            // If game does not use virtual emulation then...
            if (!isVirtual)
            {
                ViGEmClient.DisposeCurrent();
                return;
            }
            var client = ViGEmClient.Current;

            if (client.Targets == null)
            {
                client.Targets = new Xbox360Controller[4];
                for (int i = 0; i < 4; i++)
                {
                    var controller = new Xbox360Controller(client);
                    client.Targets[i]            = controller;
                    controller.FeedbackReceived += Controller_FeedbackReceived;
                }
            }
            for (uint i = 1; i <= 4; i++)
            {
                var mapTo          = (MapTo)i;
                var flag           = AppHelper.GetMapFlag(mapTo);
                var value          = (MapToMask)game.EnableMask;
                var virtualEnabled = value.HasFlag(flag);
                var feedingState   = FeedingState[i - 1];
                if (virtualEnabled)
                {
                    // If feeding status unknown or not enabled then...
                    if (!feedingState.HasValue || !feedingState.Value || !client.IsControllerConnected(i))
                    {
                        var success = EnableFeeding(i) == VirtualError.None;
                        if (!success)
                        {
                            return;
                        }
                        FeedingState[i - 1] = true;
                    }
                    FeedDevice(i);
                }
                else
                {
                    // If feeding status unknown or enabled then...
                    if (!feedingState.HasValue || feedingState.Value || client.IsControllerConnected(i))
                    {
                        var success = DisableFeeding(i) == VirtualError.None;
                        if (!success)
                        {
                            return;
                        }
                        FeedingState[i - 1] = false;
                    }
                }
            }
        }