Пример #1
0
        public static RLocalButtonState FromPacket(byte[] packet)
        {
            RLocalButtonState buttonState = new RLocalButtonState();

            buttonState.button = BitConverter.ToInt32(packet, 8);
            buttonState.value  = BitConverter.ToInt32(packet, 12);

            return(buttonState);
        }
        public override List <RLocalButtonState> PollInputs(bool raw = false)
        {
            List <RLocalButtonState> buttonStates = new List <RLocalButtonState>();

            JoystickUpdate[] data = gamepad.GetBufferedData();
            foreach (JoystickUpdate update in data)
            {
                RLocalButtonState buttonState = KeyStateToStructure(update, raw);
                buttonStates.Add(buttonState);
            }
            return(buttonStates);
        }
        public RLocalButtonState KeyStateToStructure(JoystickUpdate update, bool raw)
        {
            var buttonState = new RLocalButtonState();

            buttonState.value    = update.Value;
            buttonState.rawInput = update.Offset.ToString();

            buttonState.button = RLocalInput.MapButtonToId[buttonState.rawInput];

            //if (!map.TryGetValue(buttonName, out buttonState.button)) return null;

            return(buttonState);
        }
Пример #4
0
        private void PacketHandler(object sender, RunWorkerCompletedEventArgs eargs)
        {
            if (eargs.Result == null)
            {
                return;
            }
            RLocalIncomingMessage message = (RLocalIncomingMessage)eargs.Result;

            switch (message.type)
            {
            case 3:     // Frame
                if (renderer == null)
                {
                    break;
                }
                DecodeFrame(message.bytes, renderer.RenderBuffer);
                break;

            case 9:     // Button
                RLocalButtonState buttonState = RLocalButtonState.FromPacket(message.bytes);
                vjoy.SetButtonState((uint)message.playerId, RLocalInput.MapIdToButton[buttonState.button], buttonState.value);
                break;

            case 20:     // Audio Format
                var waveFormat = RLocalAudioCapture.WaveFormatFromPacket(message.bytes);
                audioPlayback = new RLocalAudioPlayback(waveFormat);
                break;

            case 21:     // Audio Data
                if (audioPlayback == null)
                {
                    break;
                }
                audioPlayback.Write(message.bytes, 8, message.bytes.Length - 8);
                break;

            case 45:     // Video Format
                options.outWidth  = BitConverter.ToInt32(message.bytes, 8);
                options.outHeight = BitConverter.ToInt32(message.bytes, 12);

                renderer = new RLocalRenderer(options.outWidth, options.outHeight);
                ThreadPool.QueueUserWorkItem((a) =>
                {
                    StartRender();
                });
                break;
            }
            ;
        }
        public List <RLocalButtonState> GenerateNeutralAxisInputs()
        {
            var buttonStates = new List <RLocalButtonState>();

            var buttons = new string[] { "X", "Y", "RotationX", "RotationY" };

            for (int i = 0; i < buttons.Length; ++i)
            {
                var buttonState = new RLocalButtonState();
                buttonState.button = RLocalInput.MapButtonToId[buttons[i]];
                buttonState.value  = ushort.MaxValue / 2;
                buttonStates.Add(buttonState);
            }

            return(buttonStates);
        }
        public override List <RLocalButtonState> PollInputs(bool raw = false)
        {
            List <RLocalButtonState> buttonStates = new List <RLocalButtonState>();

            if (!hasBeenPolled)
            {
                hasBeenPolled = true;
                buttonStates.AddRange(GenerateNeutralAxisInputs());
            }

            KeyboardUpdate[] data = keyboard.GetBufferedData();
            foreach (KeyboardUpdate update in data)
            {
                RLocalButtonState buttonState = KeyStateToStructure(update, raw);
                if (buttonState != null)
                {
                    buttonStates.Add(buttonState);
                }
            }
            return(buttonStates);
        }
        public RLocalButtonState KeyStateToStructure(KeyboardUpdate update, bool raw)
        {
            int button;

            if (!map.TryGetValue(update.Key.ToString(), out button))
            {
                return(null);
            }

            var buttonState = new RLocalButtonState();

            buttonState.button   = button;
            buttonState.rawInput = update.Key.ToString();

            if (button == 1300)
            {
                buttonState.button = RLocalInput.MapButtonToId["Z"];
                buttonState.value  = update.IsPressed ? ushort.MaxValue : 0;
                return(buttonState);
            }
            else if (button == 1301)
            {
                buttonState.button = RLocalInput.MapButtonToId["RotationZ"];
                buttonState.value  = update.IsPressed ? ushort.MaxValue : 0;
                return(buttonState);
            }
            else
            {
                buttonState.value = update.IsPressed ? 128 : 0;
            }

            if (button >= 1000)
            {
                int angle = -1;
                switch (button)
                {
                case 1000:
                    up = update.IsPressed; break;

                case 1002:
                    right = update.IsPressed; break;

                case 1004:
                    down = update.IsPressed; break;

                case 1006:
                    left = update.IsPressed; break;
                }

                bool isPressed = (up || right || down || left);

                if (isPressed)
                {
                    if (up && right)
                    {
                        button = 1001;
                    }
                    else if (right && down)
                    {
                        button = 1003;
                    }
                    else if (down && left)
                    {
                        button = 1005;
                    }
                    else if (left && up)
                    {
                        button = 1007;
                    }
                    else
                    {
                        button = up ? 1000 : right ? 1002 : down ? 1004 : left ? 1006 : button;
                    }

                    if (isPressed)
                    {
                        switch (button)
                        {
                        case 1000: angle = 0; break;

                        case 1001: angle = 4500; break;

                        case 1002: angle = 9000; break;

                        case 1003: angle = 13500; break;

                        case 1004: angle = 18000; break;

                        case 1005: angle = 22500; break;

                        case 1006: angle = 27000; break;

                        case 1007: angle = 31500; break;
                        }
                    }
                }

                buttonState.button = 1100;
                buttonState.value  = angle;
            }

            return(buttonState);
        }