private async Task mapNewAxisToPoles(int axisId)
        {
            var poles = await _repo.Pole.GetPoles();

            foreach (var pole in poles)
            {
                var axisPole = new AxisPole()
                {
                    AxisId = axisId,
                    PoleId = pole.Id,
                    Weight = 0
                };
                _repo.AxisPole.AddAxisPole(axisPole);
            }

            await _repo.AxisPole.SaveAllAsync();
        }
Esempio n. 2
0
        public void Process(int raw)
        {
            if (Core == null)
                return;

            double value = raw / (double)UInt16.MaxValue * 2 - 1;

            if (EnableDeadzone) {
                double deadzone = Deadzone;

                if (deadzone < 0)
                    deadzone = Core.GlobalDeadzone;

                if (value >= -deadzone && value <= deadzone) {
                    value = 0;
                }
            }

            AxisPole pole = AxisPole.None;
            double intensity = -1;
            double poleSize = -1;

            if (poleSize < 0)
                poleSize = Core.AxisPoleSize;

            if (value >= 1.0 - poleSize) {
                pole = AxisPole.Positive;
                intensity = (value - 1.0 + poleSize) / poleSize;
            } else if (value <= -1.0 + poleSize) {
                pole = AxisPole.Negative;
                intensity = (Math.Abs(value) - 1.0 + poleSize) / poleSize;
            }

            if (Analog != null && Analog.AcceptAnalog) {
                Analog.Analog(value);
            }

            int posValue = 0, negValue = 0;

            if (pole != LastPole) {
                if (LastPole != AxisPole.None) {
                    if (LastPole == AxisPole.Positive) {
                        posValue = 0;
                        if (PositiveRelease != null)
                            PositiveRelease(this, EventArgs.Empty);
                    } else if (LastPole == AxisPole.Negative) {
                        negValue = 0;
                        if (NegativeRelease != null)
                            NegativeRelease(this, EventArgs.Empty);
                    }
                }

                if (pole == AxisPole.Positive) {
                    posValue = 1;
                    if (PositivePress != null)
                        PositivePress(this, EventArgs.Empty);
                } else if (pole == AxisPole.Negative) {
                    negValue = 1;
                    if (NegativePress != null)
                        NegativePress(this, EventArgs.Empty);
                }

                LastPole = pole;
            } else if (pole == AxisPole.Positive) {
                Positive.Intensity = intensity;
                posValue = 1;
            } else if (pole == AxisPole.Negative) {
                Negative.Intensity = intensity;
                negValue = 1;
            }

            if (Positive != null) Positive.Process(posValue);
            if (Negative != null) Negative.Process(negValue);
        }
Esempio n. 3
0
 public ButtonActions GetPole(AxisPole pole)
 {
     return(GetPole(pole == AxisPole.Positive ? Gestures.Positive : Gestures.Negative));
 }
Esempio n. 4
0
 public ButtonActions GetPole(AxisPole pole)
 {
     return GetPole(pole == AxisPole.Positive ? Gestures.Positive : Gestures.Negative);
 }
Esempio n. 5
0
        public void Process(int raw)
        {
            if (Core == null)
            {
                return;
            }

            double value = raw / (double)UInt16.MaxValue * 2 - 1;

            if (EnableDeadzone)
            {
                double deadzone = Deadzone;

                if (deadzone < 0)
                {
                    deadzone = Core.GlobalDeadzone;
                }

                if (value >= -deadzone && value <= deadzone)
                {
                    value = 0;
                }
            }

            AxisPole pole      = AxisPole.None;
            double   intensity = -1;
            double   poleSize  = -1;

            if (poleSize < 0)
            {
                poleSize = Core.AxisPoleSize;
            }

            if (value >= 1.0 - poleSize)
            {
                pole      = AxisPole.Positive;
                intensity = (value - 1.0 + poleSize) / poleSize;
            }
            else if (value <= -1.0 + poleSize)
            {
                pole      = AxisPole.Negative;
                intensity = (Math.Abs(value) - 1.0 + poleSize) / poleSize;
            }

            if (Analog != null && Analog.AcceptAnalog)
            {
                Analog.Analog(value);
            }

            int posValue = 0, negValue = 0;

            if (pole != LastPole)
            {
                if (LastPole != AxisPole.None)
                {
                    if (LastPole == AxisPole.Positive)
                    {
                        posValue = 0;
                        if (PositiveRelease != null)
                        {
                            PositiveRelease(this, EventArgs.Empty);
                        }
                    }
                    else if (LastPole == AxisPole.Negative)
                    {
                        negValue = 0;
                        if (NegativeRelease != null)
                        {
                            NegativeRelease(this, EventArgs.Empty);
                        }
                    }
                }

                if (pole == AxisPole.Positive)
                {
                    posValue = 1;
                    if (PositivePress != null)
                    {
                        PositivePress(this, EventArgs.Empty);
                    }
                }
                else if (pole == AxisPole.Negative)
                {
                    negValue = 1;
                    if (NegativePress != null)
                    {
                        NegativePress(this, EventArgs.Empty);
                    }
                }

                LastPole = pole;
            }
            else if (pole == AxisPole.Positive)
            {
                Positive.Intensity = intensity;
                posValue           = 1;
            }
            else if (pole == AxisPole.Negative)
            {
                Negative.Intensity = intensity;
                negValue           = 1;
            }

            if (Positive != null)
            {
                Positive.Process(posValue);
            }
            if (Negative != null)
            {
                Negative.Process(negValue);
            }
        }