Ejemplo n.º 1
0
        public virtual void sixaxisMoved(SixAxisEventArgs arg)
        {
            float deltaX = 0, deltaY = 0;

            deltaX = Global.getGyroMouseHorizontalAxis(deviceNumber) == 0 ? arg.sixAxis.gyroYaw : arg.sixAxis.gyroRoll;
            deltaY = -arg.sixAxis.gyroPitch;

            if (arg.sixAxis.previous == null)
            {
                tempDouble = (double)(arg.sixAxis.timestampUs) / 200; // Base default speed on 5 ms
            }
            else
            {
                tempDouble = (double)(arg.sixAxis.timestampUs - arg.sixAxis.previous.timestampUs) / 200; // Base default speed on 5 ms
            }
            gyroSmooth = Global.getGyroSmoothing(deviceNumber);
            double gyroSmoothWeight = 0.0;

            coefficient = (Global.getGyroSensitivity(deviceNumber) * 0.01) * GYRO_MOUSE_COEFFICIENT;
            double offset = GYRO_MOUSE_OFFSET;

            if (gyroSmooth)
            {
                gyroSmoothWeight = Global.getGyroSmoothingWeight(deviceNumber);
                if (gyroSmoothWeight > 0.0)
                {
                    offset = GYRO_SMOOTH_MOUSE_OFFSET;
                }
            }

            double tempAngle = System.Math.Atan2(-deltaY, deltaX);
            double normX     = System.Math.Abs(System.Math.Cos(tempAngle));
            double normY     = System.Math.Abs(System.Math.Sin(tempAngle));
            int    signX     = System.Math.Sign(deltaX);
            int    signY     = System.Math.Sign(deltaY);

            if (deltaX == 0 || (hRemainder > 0 != deltaX > 0))
            {
                hRemainder = 0.0;
            }

            if (deltaY == 0 || (vRemainder > 0 != deltaY > 0))
            {
                vRemainder = 0.0;
            }

            int deadzoneX = (int)System.Math.Abs(normX * GYRO_MOUSE_DEADZONE);
            int deadzoneY = (int)System.Math.Abs(normY * GYRO_MOUSE_DEADZONE);

            if (System.Math.Abs(deltaX) > deadzoneX)
            {
                deltaX -= signX * deadzoneX;
            }
            else
            {
                deltaX = 0;
            }

            if (System.Math.Abs(deltaY) > deadzoneY)
            {
                deltaY -= signY * deadzoneY;
            }
            else
            {
                deltaY = 0;
            }

            double xMotion = deltaX != 0 ? coefficient * (deltaX * tempDouble)
                             + (normX * (offset * signX)) : 0;

            int xAction = 0;

            if (xMotion != 0.0)
            {
                xMotion += hRemainder;
            }
            else
            {
                hRemainder = 0.0;
            }

            verticalScale = Global.getGyroSensVerticalScale(deviceNumber) * 0.01;
            double yMotion = deltaY != 0 ? (coefficient * verticalScale) * (deltaY * tempDouble)
                             + (normY * (offset * signY)) : 0;

            int yAction = 0;

            if (yMotion != 0.0)
            {
                yMotion += vRemainder;
            }
            else
            {
                vRemainder = 0.0;
            }

            if (gyroSmooth)
            {
                int iIndex = smoothBufferTail % SMOOTH_BUFFER_LEN;
                xSmoothBuffer[iIndex] = xMotion;
                ySmoothBuffer[iIndex] = yMotion;
                smoothBufferTail      = iIndex + 1;

                double currentWeight = 1.0;
                double finalWeight = 0.0;
                double x_out = 0.0, y_out = 0.0;
                int    idx = 0;
                for (int i = 0; i < SMOOTH_BUFFER_LEN; i++)
                {
                    idx            = System.Math.Abs(smoothBufferTail - i - 1) % SMOOTH_BUFFER_LEN;
                    x_out         += xSmoothBuffer[idx] * currentWeight;
                    y_out         += ySmoothBuffer[idx] * currentWeight;
                    finalWeight   += currentWeight;
                    currentWeight *= gyroSmoothWeight;
                }

                x_out  /= finalWeight;
                xMotion = x_out;
                y_out  /= finalWeight;
                yMotion = y_out;
            }

            hRemainder = vRemainder = 0.0;
            if (xMotion != 0.0)
            {
                xAction    = (int)xMotion;
                hRemainder = xMotion - xAction;
            }

            if (yMotion != 0.0)
            {
                yAction    = (int)yMotion;
                vRemainder = yMotion - yAction;
            }

            int gyroInvert = Global.getGyroInvert(deviceNumber);

            if ((gyroInvert & 0x02) == 2)
            {
                xAction *= -1;
            }

            if ((gyroInvert & 0x01) == 1)
            {
                yAction *= -1;
            }

            if (yAction != 0 || xAction != 0)
            {
                InputMethods.MoveCursorBy(xAction, yAction);
            }

            hDirection = xMotion > 0.0 ? Direction.Positive : xMotion < 0.0 ? Direction.Negative : Direction.Neutral;
            vDirection = yMotion > 0.0 ? Direction.Positive : yMotion < 0.0 ? Direction.Negative : Direction.Neutral;
        }