Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

iOS > accelerometer.cs not implemented; default MG implementation laggy #25

Open
gomski opened this issue Jun 30, 2014 · 3 comments
Open

Comments

@gomski
Copy link

gomski commented Jun 30, 2014

The current implementation of the acceleroment.cs is only working on windows phones. I have used the default way of implementing accelerometer but doing it this way the accelero data becomes very laggy after a minute or so. I switched to th Xamarin implementation of the accelerometer and it was working fine on my iPad. Maybe it would be useful to implement the accelero abstraction for iOS in MG according to http://developer.xamarin.com/recipes/ios/input/accelerometer/use_coremotion_with_accelerometer/

@gomski
Copy link
Author

gomski commented Jul 1, 2014

#region File Description
//-----------------------------------------------------------------------------
// Accelerometer.cs
//
// Microsoft XNA Community Game Platform
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#endregion

#region Using Statements
using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using MonoTouch.CoreMotion;
using MonoTouch.Foundation;

#endregion

namespace Platformer2D
{
///

/// A static encapsulation of accelerometer input to provide games with a polling-based
/// accelerometer system.
/// </summary>


public static class Accelerometer
{

#if IPHONE
private static CMMotionManager accelerometer = new CMMotionManager();
#endif

#if WINDOWS_PHONE
// the accelerometer sensor on the device
private static Microsoft.Devices.Sensors.Accelerometer accelerometer = new Microsoft.Devices.Sensors.Accelerometer();
#endif
// we need an object for locking because the ReadingChanged event is fired
// on a different thread than our game
private static object threadLock = new object();

    // we use this to keep the last known value from the accelerometer callback
    private static Vector3 nextValue = new Vector3();


    // we want to prevent the Accelerometer from being initialized twice.
    private static bool isInitialized = false;

    // whether or not the accelerometer is active
    private static bool isActive = false;

    /// <summary>
    /// Initializes the Accelerometer for the current game. This method can only be called once per game.
    /// </summary>
    public static void Initialize()
    {
        // make sure we don't initialize the Accelerometer twice
        if (isInitialized)
        {
            throw new InvalidOperationException("Initialize can only be called once");
        }

#if IPHONE
if (accelerometer.AccelerometerAvailable)
{
accelerometer.AccelerometerUpdateInterval = 1f/60;
accelerometer.StartAccelerometerUpdates(NSOperationQueue.CurrentQueue, (data, error) =>
{
nextValue = new Vector3((float)data.Acceleration.X, (float)data.Acceleration.Y, (float)data.Acceleration.Z);
});
isActive = accelerometer.AccelerometerActive;
}
#endif
#if WINDOWS_PHONE
// try to start the sensor only on devices, catching the exception if it fails
if (Microsoft.Devices.Environment.DeviceType == Microsoft.Devices.DeviceType.Device)
{
try
{
accelerometer.ReadingChanged += new EventHandler<Microsoft.Devices.Sensors.AccelerometerReadingEventArgs>(sensor_ReadingChanged);
accelerometer.Start();
isActive = true;
}
catch (Microsoft.Devices.Sensors.AccelerometerFailedException)
{
isActive = false;
}
}
else
{
// we always return isActive on emulator because we use the arrow
// keys for simulation which is always available.
isActive = true;
}
#endif

        // remember that we are initialized
        isInitialized = true;
    }

#if WINDOWS_PHONE
private static void sensor_ReadingChanged(object sender, Microsoft.Devices.Sensors.AccelerometerReadingEventArgs e)
{
// store the accelerometer value in our variable to be used on the next Update
lock (threadLock)
{
nextValue = new Vector3((float)e.X, (float)e.Y, (float)e.Z);
}
}
#endif

    /// <summary>
    /// Gets the current state of the accelerometer.
    /// </summary>
    /// <returns>A new AccelerometerState with the current state of the accelerometer.</returns>
    public static AccelerometerState GetState()
    {
        // make sure we've initialized the Accelerometer before we try to get the state
        if (!isInitialized)
        {
            throw new InvalidOperationException("You must Initialize before you can call GetState");
        }

        // create a new value for our state
        Vector3 stateValue = new Vector3();

#if IPHONE
stateValue = nextValue;
#endif

#if WINDOWS_PHONE
// if the accelerometer is active
if (isActive)
{
if (Microsoft.Devices.Environment.DeviceType == Microsoft.Devices.DeviceType.Device)
{
// if we're on device, we'll just grab our latest reading from the accelerometer
lock (threadLock)
{
stateValue = nextValue;
}
}
else
{
// if we're in the emulator, we'll generate a fake acceleration value using the arrow keys
// press the pause/break key to toggle keyboard input for the emulator
KeyboardState keyboardState = Keyboard.GetState();

                stateValue.Z = -1;

                if (keyboardState.IsKeyDown(Keys.Left))
                    stateValue.X--;
                if (keyboardState.IsKeyDown(Keys.Right))
                    stateValue.X++;
                if (keyboardState.IsKeyDown(Keys.Up))
                    stateValue.Y++;
                if (keyboardState.IsKeyDown(Keys.Down))
                    stateValue.Y--;

                stateValue.Normalize();
            }
        }

#endif

        return new AccelerometerState(stateValue, isActive);
    }
}

/// <summary>
/// An encapsulation of the accelerometer's current state.
/// </summary>
public struct AccelerometerState
{
    /// <summary>
    /// Gets the accelerometer's current value in G-force.
    /// </summary>
    public Vector3 Acceleration { get; private set; }

    /// <summary>
    /// Gets whether or not the accelerometer is active and running.
    /// </summary>
    public bool IsActive { get; private set; }

    /// <summary>
    /// Initializes a new AccelerometerState.
    /// </summary>
    /// <param name="acceleration">The current acceleration (in G-force) of the accelerometer.</param>
    /// <param name="isActive">Whether or not the accelerometer is active.</param>
    public AccelerometerState(Vector3 acceleration, bool isActive)
        : this()
    {
        Acceleration = acceleration;
        IsActive = isActive;
    }

    /// <summary>
    /// Returns a string containing the values of the Acceleration and IsActive properties.
    /// </summary>
    /// <returns>A new string describing the state.</returns>
    public override string ToString()
    {
        return string.Format("Acceleration: {0}, IsActive: {1}", Acceleration, IsActive);
    }
}

}

@SimonDarksideJ
Copy link
Contributor

This issue needs raising against the main MonoGame project, it's not a sample specific issue.

Can you please close this issue and re raise it on the MonoGame project GitHub

@SimonDarksideJ
Copy link
Contributor

Any update @gomski did you create an issue in the main MG repo? if so can we close this issue?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

2 participants