-
Notifications
You must be signed in to change notification settings - Fork 0
/
Accelerometer.cs
183 lines (158 loc) · 6.44 KB
/
Accelerometer.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
#region File Description
//-----------------------------------------------------------------------------
// Accelerometer.cs
//
// Microsoft XNA Community Game Platform
// Copyright (C) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#endregion File Description
#region Using Statements
using System;
using Microsoft.Xna.Framework;
#endregion Using Statements
namespace BaconGameJam6
{
/// <summary>
/// A static encapsulation of accelerometer input to provide games with a polling-based
/// accelerometer system.
/// </summary>
public static class Accelerometer
{
#if WINDOWS_PHONE
// the accelerometer sensor on the device
private static Microsoft.Devices.Sensors.Accelerometer accelerometer = new Microsoft.Devices.Sensors.Accelerometer();
// 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();
#endif
// 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 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 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);
}
}
}