Edgaru089/SFML
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reviewed the sensor API

Browse Source
This commit is contained in:
Laurent Gomila 2014-04-07 23:00:41 +02:00 committed by Jonathan De Wachter
parent ffd4b71722
commit 80431deef4
22 changed files with 637 additions and 992 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/SFML/Window/Event.hpp
View File

@ -154,13 +154,15 @@ public :
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Sensor events parameters (SensorEnabled, SensorData, SensorDisabled) /// \brief Sensor event parameters (SensorChanged)
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
struct SensorEvent struct SensorEvent
{ {
Sensor::Type type; Sensor::Type type; ///< Type of the sensor
Sensor::Data data; float x; ///< Current value of the sensor on X axis
float y; ///< Current value of the sensor on Y axis
float z; ///< Current value of the sensor on Z axis
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -190,9 +192,7 @@ public :
TouchBegan, ///< A touch event began (data in event.touch) TouchBegan, ///< A touch event began (data in event.touch)
TouchMoved, ///< A touch moved (data in event.touch) TouchMoved, ///< A touch moved (data in event.touch)
TouchEnded, ///< A touch event ended (data in event.touch) TouchEnded, ///< A touch event ended (data in event.touch)
SensorEnabled, ///< A sensor was enabled (data in event.sensor) SensorChanged, ///< A sensor value changed (data in event.sensor)
SensorData, ///< A new sensor data arrived (data in event.sensor)
SensorDisabled, ///< A sensor was disabled (data in event.sensor)
Count ///< Keep last -- the total number of event types Count ///< Keep last -- the total number of event types
}; };
@ -214,7 +214,7 @@ public :
JoystickButtonEvent joystickButton; ///< Joystick button event parameters (Event::JoystickButtonPressed, Event::JoystickButtonReleased) JoystickButtonEvent joystickButton; ///< Joystick button event parameters (Event::JoystickButtonPressed, Event::JoystickButtonReleased)
JoystickConnectEvent joystickConnect; ///< Joystick (dis)connect event parameters (Event::JoystickConnected, Event::JoystickDisconnected) JoystickConnectEvent joystickConnect; ///< Joystick (dis)connect event parameters (Event::JoystickConnected, Event::JoystickDisconnected)
TouchEvent touch; ///< Touch events parameters (Event::TouchBegan, Event::TouchMoved, Event::TouchEnded) TouchEvent touch; ///< Touch events parameters (Event::TouchBegan, Event::TouchMoved, Event::TouchEnded)
SensorEvent sensor; ///< Sensor events parameters (Event::SensorEnabled, Event::SensorData, Event::SensorDisabled) SensorEvent sensor; ///< Sensor event parameters (Event::SensorChanged)
}; };
}; };

184
include/SFML/Window/Sensor.hpp
View File

@ -29,17 +29,14 @@
// Headers // Headers
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
#include <SFML/Window/Export.hpp> #include <SFML/Window/Export.hpp>
#include <SFML/System/Vector2.hpp>
#include <SFML/System/Vector3.hpp> #include <SFML/System/Vector3.hpp>
#include <SFML/System/Time.hpp> #include <SFML/System/Time.hpp>
namespace sf namespace sf
{ {
class Window;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Give access to the real-time state of the sensor /// \brief Give access to the real-time state of the sensors
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
class SFML_WINDOW_API Sensor class SFML_WINDOW_API Sensor
@ -52,42 +49,14 @@ public :
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
enum Type enum Type
{ {
Accelerometer, ///< The acceleration sensor measures the acceleration force Accelerometer, ///< Measures the raw acceleration (m/s²)
Gyroscope, ///< The gyroscope sensor measures the rate of rotation Gyroscope, ///< Measures the raw rotation rates (degrees/s)
Magnetometer, ///< The magnetic sensor measures the ambient magnetic field Magnetometer, ///< Measures the ambient magnetic field (micro-teslas)
Temperature, ///< The temperature sensor measures the ambient room temperature Gravity, ///< Measures the direction and intensity of gravity, independent of device acceleration (m/s²)
Proximity, ///< The proximity sensor measures how close an object is UserAcceleration, ///< Measures the direction and intensity of device acceleration, independent of the gravity (m/s²)
Gravity, ///< The gravity sensor measures the force of gravity Orientation, ///< Measures the absolute 3D orientation (degrees)
Light, ///< The light sensor measures the amount of ambient light or illumination
LinearAcceleration, ///< The linear acceleration sensor that measures acceleration
Orientation, ///< The orientation sensor that measures the degrees of orientation
Pressure, ///< The pressure sensor give air pressure readings
Altimeter, ///< The altimeter measures the altitude by using air pressure measurements
Compass, ///< The compass sensor give compass heading readings
Count ///< Keep last -- the total number of sensor type Count ///< Keep last -- the total number of sensor types
};
////////////////////////////////////////////////////////////
/// \brief Sensor data
///
////////////////////////////////////////////////////////////
union Data
{
struct
{
float x; ///< X-axis data
float y; ///< Y-axis data
float z; ///< Z-axis data
}
acceleration, ///< Acceleration in m/s^2 (Sensor::Accelerometer, Sensor::Gravity, Sensor::LinearAcceleration)
magnetic, ///< Magnetic in uT (Sensor::Magnetometer)
vector, ///< Vector representing angle in degrees (Sensor::Orientation, Sensor::Compass)
gyroscope; ///< Gyroscope data in rad/s (Sensor::Gyroscope)
float temperature; ///< Temperature in degrees Celsius (Sensor::Temperature)
float distance; ///< Distance in meter (Sensor::Proximity, Sensor::Altimeter)
float light; ///< Illumination in lx (Sensor::Light)
float pressure; ///< Pressure in hPa (Sensor::Pressure)
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -100,97 +69,82 @@ public :
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
static bool isAvailable(Type sensor); static bool isAvailable(Type sensor);
////////////////////////////////////////////////////////////
/// \brief Get the resolution of a sensor
///
/// The resolution represents the sensitivity of a sensor. The
/// resolution of a sensor is the smallest change it can detect in
/// the quantity that it is measuring
///
/// \param sensor Sensor to check
///
/// \return The sensor's resolution in the sensor's unit.
///
////////////////////////////////////////////////////////////
static float getResolution(Type sensor);
////////////////////////////////////////////////////////////
/// \brief Get the maximum range of a sensor
///
/// The resolution represents the sensitivity of a sensor. The
/// value returned is in the sensor's unit.
///
/// \param sensor Sensor to check
///
/// \return The sensor's resolution in the sensor's unit.
///
////////////////////////////////////////////////////////////
static Vector2f getMaximumRange(Type sensor);
////////////////////////////////////////////////////////////
/// \brief Get the minimum delay allowed between two events
///
/// When setting the refresh rate of a sensor, you'll need to
/// make sure the value is a superior to the minimum delay
/// allowable
///
/// \param sensor Sensor to check
///
/// \return The minimum delay allowed between two events
///
////////////////////////////////////////////////////////////
Time getMinimumDelay(Type sensor);
////////////////////////////////////////////////////////////
/// \brief Check if a sensor is enabled
///
/// \param sensor Sensor to check
///
/// \return True if the sensor is enabled, false otherwise
///
////////////////////////////////////////////////////////////
static bool isEnable(Type sensor);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Enable or disable a sensor /// \brief Enable or disable a sensor
/// ///
/// A sensor is disabled by default otherwise it would consume too /// All sensors are disabled by default, to avoid consuming too
/// much battery power. Once a sensor enabled, it will start sending /// much battery power. Once a sensor is enabled, it starts
/// sensor events of that type (if available). /// sending events of the corresponding type.
/// ///
/// \param sensor Sensor to enable /// This function does nothing if the sensor is unavailable.
/// \param enable True to enable, false to disable ///
/// \param sensor Sensor to enable
/// \param enabled True to enable, false to disable
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
static void setEnable(Type sensor, bool enable = true); static void setEnabled(Type sensor, bool enabled);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Set the refresh rate of a sensor /// \brief Get the current sensor value
/// ///
/// This is the delay you want between each measure report /// \param sensor Sensor to read
/// ///
/// \param sensor Sensor to modify /// \return The current sensor value
/// \param rate Delay between each event
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
static void setRefreshRate(Type sensor, const Time& rate); static Vector3f getValue(Type sensor);
////////////////////////////////////////////////////////////
/// \brief Get the current sensor data
///
/// If the sensor support real-time retrieval, you'll get
/// the current sensor data otherwise this is likely the
/// latest data of this sensor type.
///
/// \param sensor Sensor to check
///
/// \return The current sensor data
///
////////////////////////////////////////////////////////////
static Data getData(Type sensor);
}; };
} // namespace sf } // namespace sf
#endif // SFML_SENSOR_HPP #endif // SFML_SENSOR_HPP
////////////////////////////////////////////////////////////
/// \class sf::Sensor
/// \ingroup window
///
/// sf::Sensor provides an interface to the state of the
/// various sensors that a device provides. It only contains static
/// functions, so it's not meant to be instanciated.
///
/// This class allows users to query the sensors values at any
/// time and directly, without having to deal with a window and
/// its events. Compared to the SensorChanged event, sf::Sensor
/// can retrieve the state of a sensor at any time (you don't need to
/// store and update its current value on your side).
///
/// Depending on the OS and hardware of the device (phone, tablet, ...),
/// some sensor types may not be available. You should always check
/// the availability of a sensor before trying to read it, with the
/// sf::Sensor::isAvailable function.
///
/// You may wonder why some sensor types look so similar, for example
/// Accelerometer and Gravity / UserAcceleration. The first one
/// is the raw measurement of the acceleration, and takes in account
/// both the earth gravity and the user movement. The others are
/// more precise: they provide these components separately, which is
/// usually more useful. In fact they are not direct sensors, they
/// are computed internally based on the raw acceleration and other sensors.
/// This is exactly the same for Gyroscope vs Orientation.
///
/// Because sensors consume a non-negligible amount of current, they are
/// all disabled by default. You must call sf::Sensor::setEnabled for each
/// sensor in which you are interested.
///
/// Usage example:
/// \code
/// if (sf::Sensor::isAvailable(sf::Sensor::Gravity))
/// {
/// // gravity sensor is available
/// }
///
/// // enable the gravity sensor
/// sf::Sensor::setEnabled(sf::Sensor::Gravity, true);
///
/// // get the current value of gravity
/// sf::Vector3f gravity = sf::Sensor::getValue(sf::Sensor::Gravity);
/// \endcode
///
////////////////////////////////////////////////////////////

4
src/SFML/Network/Ftp.cpp
View File

@ -28,9 +28,7 @@
#include <SFML/Network/Ftp.hpp> #include <SFML/Network/Ftp.hpp>
#include <SFML/Network/IpAddress.hpp> #include <SFML/Network/IpAddress.hpp>
#include <algorithm> #include <algorithm>
#ifdef SFML_SYSTEM_ANDROID #include <cctype>
#include <cctype>
#endif
#include <fstream> #include <fstream>
#include <iterator> #include <iterator>
#include <sstream> #include <sstream>

189
src/SFML/Window/Android/SensorImpl.cpp
View File

@ -1,7 +1,7 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// //
// SFML - Simple and Fast Multimedia Library // SFML - Simple and Fast Multimedia Library
// Copyright (C) 2013 Jonathan De Wachter (dewachter.jonathan@gmail.com) // Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
// //
// This software is provided 'as-is', without any express or implied warranty. // This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software. // In no event will the authors be held liable for any damages arising from the use of this software.
@ -26,21 +26,8 @@
// Headers // Headers
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
#include <SFML/Window/SensorImpl.hpp> #include <SFML/Window/SensorImpl.hpp>
#include <SFML/System/Lock.hpp>
#include <SFML/System/Time.hpp>
#include <SFML/System/Android/Activity.hpp>
#include <android/looper.h>
namespace
{
ALooper* looper;
ASensorManager* sensorManager;
ASensorEventQueue* sensorEventQueue;
std::queue<sf::Sensor::Data> sensorData[sf::Sensor::Count];
}
namespace sf namespace sf
{ {
namespace priv namespace priv
@ -48,182 +35,52 @@ namespace priv
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::initialize() void SensorImpl::initialize()
{ {
// Get the looper associated with this thread // To be implemented
looper = ALooper_forThread();
// Get the unique sensor manager
sensorManager = ASensorManager_getInstance();
// Create the sensor events queue and attach it to the looper
sensorEventQueue = ASensorManager_createEventQueue(sensorManager, looper,
1, &processSensorEvents, NULL);
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::cleanup() void SensorImpl::cleanup()
{ {
// Detach the sensor events queue from the looper and destroy it // To be implemented
ASensorManager_destroyEventQueue(sensorManager, sensorEventQueue);
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorCaps& SensorImpl::initialize(unsigned int type) bool SensorImpl::isAvailable(Sensor::Type /*sensor*/)
{ {
// Get the default sensor matching the type // To be implemented
m_sensor = getDefaultSensor(type); return false;
static SensorCaps capabilities;
if (!m_sensor)
{
// Sensor not available, stop here
capabilities.available = false;
return capabilities;
}
else
capabilities.available = true;
// Get the sensor resolution
capabilities.resolution = ASensor_getResolution(m_sensor);
// Get the minimum delay allowed between events
capabilities.minimumDelay = microseconds(ASensor_getMinDelay(m_sensor));
// To get the maximum range we'll need to use JNI since it's not available from C (todo)
capabilities.maximumRange = Vector2f();
// Initialize SensorState attributes
setRefreshRate(capabilities.minimumDelay); // Set the event rate (not to consume too much battery)
setEnable(false); // Disable the sensor by default (initialize SensorState on the fly)
m_state.pendingData = &sensorData[type];
return capabilities;
}
////////////////////////////////////////////////////////////
void SensorImpl::terminate()
{
// Nothing to do
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorState& SensorImpl::update() bool SensorImpl::open(Sensor::Type /*sensor*/)
{ {
// Update our pending sensor data lists // To be implemented
ALooper_pollAll(0, NULL, NULL, NULL); return false;
return m_state;
}
////////////////////////////////////////////////////////////
bool SensorImpl::isEnable()
{
return m_state.enabled;
}
////////////////////////////////////////////////////////////
void SensorImpl::setEnable(bool enable)
{
if (enable)
ASensorEventQueue_enableSensor(sensorEventQueue, m_sensor);
else
ASensorEventQueue_disableSensor(sensorEventQueue, m_sensor);
m_state.enabled = enable;
}
////////////////////////////////////////////////////////////
void SensorImpl::setRefreshRate(const Time& rate)
{
ASensorEventQueue_setEventRate(sensorEventQueue, m_sensor, rate.asMicroseconds());
m_state.refreshRate = rate;
}
////////////////////////////////////////////////////////////
ASensor const* SensorImpl::getDefaultSensor(unsigned int type)
{
int sensorType = 0;
switch(type)
{
case Sensor::Accelerometer:
sensorType = ASENSOR_TYPE_ACCELEROMETER;
break;
case Sensor::Magnetometer:
sensorType = ASENSOR_TYPE_MAGNETIC_FIELD;
break;
case Sensor::Gyroscope:
sensorType = ASENSOR_TYPE_GYROSCOPE;
break;
case Sensor::Light:
sensorType = ASENSOR_TYPE_LIGHT;
break;
case Sensor::Proximity:
sensorType = ASENSOR_TYPE_PROXIMITY;
break;
default:
// The other sensors are unavailable on Android from the android C API
return NULL;
}
return ASensorManager_getDefaultSensor(sensorManager, sensorType);
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
int SensorImpl::processSensorEvents(int fd, int events, void* data) void SensorImpl::close()
{ {
ASensorEvent event; // To be implemented
}
while (ASensorEventQueue_getEvents(sensorEventQueue, &event, 1) > 0)
{
Sensor::Data data;
Sensor::Type type;
switch (event.sensor) ////////////////////////////////////////////////////////////
{ Vector3f SensorImpl::update()
case ASENSOR_TYPE_ACCELEROMETER: {
type = Sensor::Accelerometer; // To be implemented
data.acceleration.x = event.acceleration.x; return Vector3f(0, 0, 0);
data.acceleration.y = event.acceleration.y; }
data.acceleration.z = event.acceleration.z;
break;
case ASENSOR_TYPE_GYROSCOPE:
type = Sensor::Gyroscope;
data.vector.x = event.vector.x;
data.vector.y = event.vector.y;
data.vector.z = event.vector.z;
break;
case ASENSOR_TYPE_MAGNETIC_FIELD: ////////////////////////////////////////////////////////////
type = Sensor::Magnetometer; void SensorImpl::setEnabled(bool /*enabled*/)
data.magnetic.x = event.magnetic.x; {
data.magnetic.y = event.magnetic.y; // To be implemented
data.magnetic.z = event.magnetic.z;
break;
case ASENSOR_TYPE_LIGHT:
type = Sensor::Light;
data.light = event.light;
break;
case ASENSOR_TYPE_PROXIMITY:
type = Sensor::Proximity;
break;
}
sensorData[type].push(data);
}
return 1;
} }
} // namespace priv } // namespace priv

82
src/SFML/Window/Android/SensorImpl.hpp
View File

@ -1,7 +1,7 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// //
// SFML - Simple and Fast Multimedia Library // SFML - Simple and Fast Multimedia Library
// Copyright (C) 2013 Jonathan De Wachter (dewachter.jonathan@gmail.com) // Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
// //
// This software is provided 'as-is', without any express or implied warranty. // This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software. // In no event will the authors be held liable for any damages arising from the use of this software.
@ -25,10 +25,6 @@
#ifndef SFML_SENSORIMPLANDROID_HPP #ifndef SFML_SENSORIMPLANDROID_HPP
#define SFML_SENSORIMPLANDROID_HPP #define SFML_SENSORIMPLANDROID_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <android/sensor.h>
namespace sf namespace sf
{ {
@ -55,82 +51,46 @@ public :
static void cleanup(); static void cleanup();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Initialize the sensor /// \brief Check if a sensor is available
/// ///
/// \param type Index assigned to the sensor /// \param sensor Sensor to check
/// ///
/// \return The sensor capabilities /// \return True if the sensor is available, false otherwise
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorCaps& initialize(unsigned int type); static bool isAvailable(Sensor::Type sensor);
////////////////////////////////////////////////////////////
/// \brief Open the sensor
///
/// \param sensor Type of the sensor
///
/// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
bool open(Sensor::Type sensor);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Close the sensor /// \brief Close the sensor
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void terminate(); void close();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Update the sensor and get its new state /// \brief Update the sensor and get its new value
/// ///
/// \return Sensor state /// \return Sensor value
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorState& update(); Vector3f update();
////////////////////////////////////////////////////////////
/// \brief Check if the sensor is enabled
///
/// \return True if the sensor is enabled, false otherwise
///
////////////////////////////////////////////////////////////
bool isEnable();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Enable or disable the sensor /// \brief Enable or disable the sensor
/// ///
/// \param enable True to enable, false to disable /// \param enabled True to enable, false to disable
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void setEnable(bool enable); void setEnabled(bool enabled);
////////////////////////////////////////////////////////////
/// \brief Set the refresh rate of the sensor
///
/// \param rate Delay between each refresh
///
////////////////////////////////////////////////////////////
void setRefreshRate(const Time& rate);
private:
////////////////////////////////////////////////////////////
/// \brief Get the default Android sensor matching the sensor type
///
/// \param type Type of the sensor
///
/// \return The default Android sensor, NULL otherwise
///
////////////////////////////////////////////////////////////
ASensor const* getDefaultSensor(unsigned int type);
////////////////////////////////////////////////////////////
/// \brief Process the pending sensor data available and add them to our lists
///
/// \param fd File descriptor
/// \param events Bitmask of the poll events that were triggered
/// \param data Data pointer supplied
///
/// \return Whether it should continue (1) or unregister the callback (0)
///
////////////////////////////////////////////////////////////
static int processSensorEvents(int fd, int events, void* data);
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
const ASensor* m_sensor; ///< Android sensor structure
unsigned int m_index; ///< Index of the sensor
SensorState m_state; ///< Sensor state
}; };
} // namespace priv } // namespace priv

5
src/SFML/Window/CMakeLists.txt
View File

@ -57,6 +57,8 @@ if(SFML_OS_WINDOWS)
${SRCROOT}/Win32/InputImpl.hpp ${SRCROOT}/Win32/InputImpl.hpp
${SRCROOT}/Win32/JoystickImpl.cpp ${SRCROOT}/Win32/JoystickImpl.cpp
${SRCROOT}/Win32/JoystickImpl.hpp ${SRCROOT}/Win32/JoystickImpl.hpp
${SRCROOT}/Win32/SensorImpl.hpp
${SRCROOT}/Win32/SensorImpl.cpp
${SRCROOT}/Win32/VideoModeImpl.cpp ${SRCROOT}/Win32/VideoModeImpl.cpp
${SRCROOT}/Win32/WindowImplWin32.cpp ${SRCROOT}/Win32/WindowImplWin32.cpp
${SRCROOT}/Win32/WindowImplWin32.hpp ${SRCROOT}/Win32/WindowImplWin32.hpp
@ -172,7 +174,8 @@ elseif(SFML_OS_ANDROID)
${SRCROOT}/Android/JoystickImpl.hpp ${SRCROOT}/Android/JoystickImpl.hpp
${SRCROOT}/Android/JoystickImpl.cpp ${SRCROOT}/Android/JoystickImpl.cpp
${SRCROOT}/Android/SensorImpl.hpp ${SRCROOT}/Android/SensorImpl.hpp
${SRCROOT}/Android/SensorImpl.cpp) ${SRCROOT}/Android/SensorImpl.cpp
)
source_group("android" FILES ${PLATFORM_SRC}) source_group("android" FILES ${PLATFORM_SRC})
endif() endif()

12
src/SFML/Window/JoystickImpl.hpp
View File

@ -79,17 +79,29 @@ struct JoystickState
#if defined(SFML_SYSTEM_WINDOWS) #if defined(SFML_SYSTEM_WINDOWS)
#include <SFML/Window/Win32/JoystickImpl.hpp> #include <SFML/Window/Win32/JoystickImpl.hpp>
#elif defined(SFML_SYSTEM_LINUX) #elif defined(SFML_SYSTEM_LINUX)
#include <SFML/Window/Unix/JoystickImpl.hpp> #include <SFML/Window/Unix/JoystickImpl.hpp>
#elif defined(SFML_SYSTEM_FREEBSD) #elif defined(SFML_SYSTEM_FREEBSD)
#include <SFML/Window/FreeBSD/JoystickImpl.hpp> #include <SFML/Window/FreeBSD/JoystickImpl.hpp>
#elif defined(SFML_SYSTEM_MACOS) #elif defined(SFML_SYSTEM_MACOS)
#include <SFML/Window/OSX/JoystickImpl.hpp> #include <SFML/Window/OSX/JoystickImpl.hpp>
#elif defined(SFML_SYSTEM_IOS) #elif defined(SFML_SYSTEM_IOS)
#include <SFML/Window/iOS/JoystickImpl.hpp> #include <SFML/Window/iOS/JoystickImpl.hpp>
#elif defined(SFML_SYSTEM_ANDROID) #elif defined(SFML_SYSTEM_ANDROID)
#include <SFML/Window/Android/JoystickImpl.hpp> #include <SFML/Window/Android/JoystickImpl.hpp>
#endif #endif

67
src/SFML/Window/OSX/SensorImpl.mm → src/SFML/Window/OSX/SensorImpl.cpp
View File

@ -1,8 +1,7 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// //
// SFML - Simple and Fast Multimedia Library // SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2013 Marco Antognini (antognini.marco@gmail.com), // Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
// Laurent Gomila (laurent.gom@gmail.com),
// //
// This software is provided 'as-is', without any express or implied warranty. // This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software. // In no event will the authors be held liable for any damages arising from the use of this software.
@ -36,56 +35,52 @@ namespace priv
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::initialize() void SensorImpl::initialize()
{ {
// Not applicable // To be implemented
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::cleanup() void SensorImpl::cleanup()
{ {
// Not applicable // To be implemented
} }
////////////////////////////////////////////////////////////
SensorCaps& SensorImpl::initialize(unsigned int type)
{
// Not applicable
SensorCaps capabilities;
capabilities.available = false;
return capabilities;
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::terminate() bool SensorImpl::isAvailable(Sensor::Type /*sensor*/)
{ {
// Not applicable // To be implemented
}
////////////////////////////////////////////////////////////
SensorState& SensorImpl::update()
{
// Not applicable
static SensorState state;
return state;
}
////////////////////////////////////////////////////////////
bool SensorImpl::isEnable()
{
// Not applicable
return false; return false;
} }
////////////////////////////////////////////////////////////
void SensorImpl::setEnable(bool enable)
{
// Not applicable
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::setRefreshRate(const Time& rate) bool SensorImpl::open(Sensor::Type /*sensor*/)
{ {
// Not applicable // To be implemented
return false;
}
////////////////////////////////////////////////////////////
void SensorImpl::close()
{
// To be implemented
}
////////////////////////////////////////////////////////////
Vector3f SensorImpl::update()
{
// To be implemented
return Vector3f(0, 0, 0);
}
////////////////////////////////////////////////////////////
void SensorImpl::setEnabled(bool /*enabled*/)
{
// To be implemented
} }
} // namespace priv } // namespace priv

50
src/SFML/Window/OSX/SensorImpl.hpp
View File

@ -1,8 +1,7 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// //
// SFML - Simple and Fast Multimedia Library // SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2013 Marco Antognini (antognini.marco@gmail.com), // Copyright (C) 2007-2013 Laurent Gomila (laurent.gom@gmail.com)
// Laurent Gomila (laurent.gom@gmail.com),
// //
// This software is provided 'as-is', without any express or implied warranty. // This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software. // In no event will the authors be held liable for any damages arising from the use of this software.
@ -52,53 +51,46 @@ public :
static void cleanup(); static void cleanup();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Initialize the sensor /// \brief Check if a sensor is available
/// ///
/// \param type Index assigned to the sensor /// \param sensor Sensor to check
/// ///
/// \return The sensor capabilities /// \return True if the sensor is available, false otherwise
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorCaps& initialize(unsigned int type); static bool isAvailable(Sensor::Type sensor);
////////////////////////////////////////////////////////////
/// \brief Open the sensor
///
/// \param sensor Type of the sensor
///
/// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
bool open(Sensor::Type sensor);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Close the sensor /// \brief Close the sensor
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void terminate(); void close();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Update the sensor and get its new state /// \brief Update the sensor and get its new value
/// ///
/// \return Sensor state /// \return Sensor value
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorState& update(); Vector3f update();
////////////////////////////////////////////////////////////
/// \brief Check if the sensor is enabled
///
/// \return True if the sensor is enabled, false otherwise
///
////////////////////////////////////////////////////////////
bool isEnable();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Enable or disable the sensor /// \brief Enable or disable the sensor
/// ///
/// \param enable True to enable, false to disable /// \param enabled True to enable, false to disable
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void setEnable(bool enable); void setEnabled(bool enabled);
////////////////////////////////////////////////////////////
/// \brief Set the refresh rate of the sensor
///
/// \param rate Delay between each refresh
///
////////////////////////////////////////////////////////////
void setRefreshRate(const Time& rate);
}; };
} // namespace priv } // namespace priv

40
src/SFML/Window/Sensor.cpp
View File

@ -35,49 +35,19 @@ namespace sf
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
bool Sensor::isAvailable(Type sensor) bool Sensor::isAvailable(Type sensor)
{ {
return priv::SensorManager::getInstance().getCapabilities(sensor).available; return priv::SensorManager::getInstance().isAvailable(sensor);
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
float Sensor::getResolution(Type sensor) void Sensor::setEnabled(Type sensor, bool enabled)
{ {
return priv::SensorManager::getInstance().getCapabilities(sensor).resolution; return priv::SensorManager::getInstance().setEnabled(sensor, enabled);
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
Vector2f Sensor::getMaximumRange(Type sensor) Vector3f Sensor::getValue(Type sensor)
{ {
return priv::SensorManager::getInstance().getCapabilities(sensor).maximumRange; return priv::SensorManager::getInstance().getValue(sensor);
}
////////////////////////////////////////////////////////////
Time Sensor::getMinimumDelay(Type sensor)
{
return priv::SensorManager::getInstance().getCapabilities(sensor).minimumDelay;
}
////////////////////////////////////////////////////////////
bool Sensor::isEnable(Type sensor)
{
return priv::SensorManager::getInstance().isEnable(sensor);
}
////////////////////////////////////////////////////////////
void Sensor::setEnable(Type sensor, bool enable)
{
return priv::SensorManager::getInstance().setEnable(sensor, enable);
}
////////////////////////////////////////////////////////////
void Sensor::setRefreshRate(Type sensor, const Time& rate)
{
priv::SensorManager::getInstance().setRefreshRate(sensor, rate);
}
////////////////////////////////////////////////////////////
Sensor::Data Sensor::getData(Type sensor)
{
return priv::SensorManager::getInstance().getState(sensor).pendingData->back();
} }
} // namespace sf } // namespace sf

63
src/SFML/Window/SensorImpl.hpp
View File

@ -30,70 +30,27 @@
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
#include <SFML/Config.hpp> #include <SFML/Config.hpp>
#include <SFML/Window/Sensor.hpp> #include <SFML/Window/Sensor.hpp>
#include <SFML/System/Time.hpp>
#include <SFML/System/Vector2.hpp>
#include <queue>
#include <cstddef>
namespace sf
{
namespace priv
{
////////////////////////////////////////////////////////////
/// \brief Structure holding a sensor's capabilities
///
////////////////////////////////////////////////////////////
struct SensorCaps
{
SensorCaps()
{
available = false;
resolution = 0;
maximumRange = Vector2f(0, 0);
minimumDelay = Time::Zero;
}
bool available; ///< Is the sensor available on the underlying platform
float resolution; ///< How sensible the sensor is in the sensor's unit
Vector2f maximumRange; ///< Maximum range of the sensor in the sensor's unit
Time minimumDelay; ///< Minimum delay allowed between two events
};
////////////////////////////////////////////////////////////
/// \brief Structure holding a sensor's state
///
////////////////////////////////////////////////////////////
struct SensorState
{
SensorState()
{
pendingData = NULL;
enabled = false;
refreshRate = Time::Zero;
}
std::queue<Sensor::Data>* pendingData; ///< Pending sensor data
bool enabled; ///< Is the sensor currently enabled?
Time refreshRate; ///< Delay between two events
};
} // namespace priv
} // namespace sf
#if defined(SFML_SYSTEM_WINDOWS) #if defined(SFML_SYSTEM_WINDOWS)
#include <SFML/Window/Win32/SensorImpl.hpp> #include <SFML/Window/Win32/SensorImpl.hpp>
#elif defined(SFML_SYSTEM_LINUX) #elif defined(SFML_SYSTEM_LINUX)
#include <SFML/Window/Unix/SensorImpl.hpp> #include <SFML/Window/Unix/SensorImpl.hpp>
#elif defined(SFML_SYSTEM_MACOS) #elif defined(SFML_SYSTEM_MACOS)
#include <SFML/Window/OSX/SensorImpl.hpp> #include <SFML/Window/OSX/SensorImpl.hpp>
#elif defined(SFML_SYSTEM_IOS) #elif defined(SFML_SYSTEM_IOS)
#include <SFML/Window/iOS/SensorImpl.hpp> #include <SFML/Window/iOS/SensorImpl.hpp>
#elif defined(SFML_SYSTEM_ANDROID) #elif defined(SFML_SYSTEM_ANDROID)
#include <SFML/Window/Android/SensorImpl.hpp> #include <SFML/Window/Android/SensorImpl.hpp>
#endif #endif

99
src/SFML/Window/SensorManager.cpp
View File

@ -42,16 +42,38 @@ SensorManager& SensorManager::getInstance()
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const SensorCaps& SensorManager::getCapabilities(unsigned int sensor) const bool SensorManager::isAvailable(Sensor::Type sensor)
{ {
return m_sensors[sensor].capabilities; return m_sensors[sensor].available;
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const SensorState& SensorManager::getState(unsigned int sensor) const void SensorManager::setEnabled(Sensor::Type sensor, bool enabled)
{ {
return m_sensors[sensor].state; if (m_sensors[sensor].available)
{
m_sensors[sensor].enabled = enabled;
m_sensors[sensor].sensor.setEnabled(enabled);
}
else
{
err() << "Warning: trying to enable a sensor that is not available (call Sensor::isAvailable to check it)" << std::endl;
}
}
////////////////////////////////////////////////////////////
bool SensorManager::isEnabled(Sensor::Type sensor) const
{
return m_sensors[sensor].enabled;
}
////////////////////////////////////////////////////////////
Vector3f SensorManager::getValue(Sensor::Type sensor) const
{
return m_sensors[sensor].value;
} }
@ -60,52 +82,12 @@ void SensorManager::update()
{ {
for (int i = 0; i < Sensor::Count; ++i) for (int i = 0; i < Sensor::Count; ++i)
{ {
Item& item = m_sensors[i]; // Only process available sensors
if (m_sensors[i].available)
// Skip unavailable sensors m_sensors[i].value = m_sensors[i].sensor.update();
if (!item.capabilities.available)
continue;
// Get the current state of the sensor
item.state = item.sensor.update();
} }
} }
////////////////////////////////////////////////////////////
bool SensorManager::isEnable(unsigned int sensor)
{
if (!m_sensors[sensor].capabilities.available)
{
err() << "This sensor isn't available on your system (call Sensor::isAvailable to check it)" << std::endl;
return false;
}
return m_sensors[sensor].sensor.isEnable();
}
////////////////////////////////////////////////////////////
void SensorManager::setEnable(unsigned int sensor, bool enable)
{
if (!m_sensors[sensor].capabilities.available)
{
err() << "This sensor isn't available on your system (call Sensor::isAvailable to check it)" << std::endl;
return;
}
m_sensors[sensor].sensor.setEnable(enable);
}
////////////////////////////////////////////////////////////
void SensorManager::setRefreshRate(unsigned int sensor, const Time& rate)
{
if (!m_sensors[sensor].capabilities.available)
{
err() << "This sensor isn't available on your system (call Sensor::isAvailable to check it)" << std::endl;
return;
}
m_sensors[sensor].sensor.setRefreshRate(rate);
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorManager::SensorManager() SensorManager::SensorManager()
@ -116,12 +98,15 @@ SensorManager::SensorManager()
// Per sensor initialization // Per sensor initialization
for (int i = 0; i < Sensor::Count; ++i) for (int i = 0; i < Sensor::Count; ++i)
{ {
// Initialize the sensor and get its capabilities // Check which sensors are available
m_sensors[i].capabilities = m_sensors[i].sensor.initialize(i); m_sensors[i].available = SensorImpl::isAvailable(static_cast<Sensor::Type>(i));
// Available sensors are disabled by default // Open the available sensors
if (m_sensors[i].capabilities.available) if (m_sensors[i].available)
m_sensors[i].sensor.setEnable(false); {
m_sensors[i].sensor.open(static_cast<Sensor::Type>(i));
m_sensors[i].sensor.setEnabled(false);
}
} }
} }
@ -131,14 +116,8 @@ SensorManager::~SensorManager()
// Per sensor cleanup // Per sensor cleanup
for (int i = 0; i < Sensor::Count; ++i) for (int i = 0; i < Sensor::Count; ++i)
{ {
if (m_sensors[i].capabilities.available) if (m_sensors[i].available)
{ m_sensors[i].sensor.close();
// Disable the sensor
m_sensors[i].sensor.setEnable(false);
// Terminate the sensor
m_sensors[i].sensor.terminate();
}
} }
// Global sensor cleanup // Global sensor cleanup

72
src/SFML/Window/SensorManager.hpp
View File

@ -54,24 +54,43 @@ public :
static SensorManager& getInstance(); static SensorManager& getInstance();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Get the capabilities of a sensor /// \brief Check if a sensor is available on the underlying platform
/// ///
/// \param sensor Index of the sensor /// \param sensor Sensor to check
/// ///
/// \return Capabilities of the sensor /// \return True if the sensor is available, false otherwise
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const SensorCaps& getCapabilities(unsigned int sensor) const; bool isAvailable(Sensor::Type sensor);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Get the current state of a sensor /// \brief Enable or disable a sensor
/// ///
/// \param sensor Index of the sensor /// \param sensor Sensor to modify
/// /// \param enabled Whether it should be enabled or not
/// \return Current state of the sensor
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
const SensorState& getState(unsigned int sensor) const; void setEnabled(Sensor::Type sensor, bool enabled);
////////////////////////////////////////////////////////////
/// \brief Check if a sensor is enabled
///
/// \param sensor Sensor to check
///
/// \return True if the sensor is enabled, false otherwise
///
////////////////////////////////////////////////////////////
bool isEnabled(Sensor::Type sensor) const;
////////////////////////////////////////////////////////////
/// \brief Get the current value of a sensor
///
/// \param sensor Sensor to read
///
/// \return Current value of the sensor
///
////////////////////////////////////////////////////////////
Vector3f getValue(Sensor::Type sensor) const;
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Update the state of all the sensors /// \brief Update the state of all the sensors
@ -79,34 +98,6 @@ public :
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void update(); void update();
////////////////////////////////////////////////////////////
/// \brief Get the current status of a sensor
///
/// \param sensor Index of the sensor
///
/// \return True if the sensor is enabled, false otherwise
///
////////////////////////////////////////////////////////////
bool isEnable(unsigned int sensor);
////////////////////////////////////////////////////////////
/// \brief Enable or disable a sensor
///
/// \param sensor Index of the sensor
/// \param enable Whether it should be enabled or not
///
////////////////////////////////////////////////////////////
void setEnable(unsigned int sensor, bool enable);
////////////////////////////////////////////////////////////
/// \brief Set the refresh rate of a sensor
///
/// \param sensor Index of the sensor
/// \param rate Delay between each event
///
////////////////////////////////////////////////////////////
void setRefreshRate(unsigned int sensor, const Time& rate);
private: private:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
@ -127,9 +118,10 @@ private:
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
struct Item struct Item
{ {
SensorImpl sensor; ///< Sensor implementation bool available; ///< Is the sensor available on this device?
SensorState state; ///< The current sensor state bool enabled; ///< Current enable state of the sensor
SensorCaps capabilities; ///< The sensor capabilities SensorImpl sensor; ///< Sensor implementation
Vector3f value; ///< The current sensor value
}; };
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////

64
src/SFML/Window/Unix/SensorImpl.cpp
View File

@ -35,56 +35,52 @@ namespace priv
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::initialize() void SensorImpl::initialize()
{ {
// Not applicable // To be implemented
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::cleanup() void SensorImpl::cleanup()
{ {
// Not applicable // To be implemented
} }
////////////////////////////////////////////////////////////
SensorCaps& SensorImpl::initialize(unsigned int type)
{
// Not applicable
SensorCaps capabilities;
capabilities.available = false;
return capabilities;
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::terminate() bool SensorImpl::isAvailable(Sensor::Type /*sensor*/)
{ {
// Not applicable // To be implemented
}
////////////////////////////////////////////////////////////
SensorState& SensorImpl::update()
{
// Not applicable
static SensorState state;
return state;
}
////////////////////////////////////////////////////////////
bool SensorImpl::isEnable()
{
// Not applicable
return false; return false;
} }
////////////////////////////////////////////////////////////
void SensorImpl::setEnable(bool enable)
{
// Not applicable
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::setRefreshRate(const Time& rate) bool SensorImpl::open(Sensor::Type /*sensor*/)
{ {
// Not applicable // To be implemented
return false;
}
////////////////////////////////////////////////////////////
void SensorImpl::close()
{
// To be implemented
}
////////////////////////////////////////////////////////////
Vector3f SensorImpl::update()
{
// To be implemented
return Vector3f(0, 0, 0);
}
////////////////////////////////////////////////////////////
void SensorImpl::setEnabled(bool /*enabled*/)
{
// To be implemented
} }
} // namespace priv } // namespace priv

55
src/SFML/Window/Unix/SensorImpl.hpp
View File

@ -22,8 +22,8 @@
// //
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
#ifndef SFML_SENSORIMPLLINUX_HPP #ifndef SFML_SENSORIMPLUNIX_HPP
#define SFML_SENSORIMPLLINUX_HPP #define SFML_SENSORIMPLUNIX_HPP
namespace sf namespace sf
@ -31,7 +31,7 @@ namespace sf
namespace priv namespace priv
{ {
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Linux implementation of sensors /// \brief Unix implementation of sensors
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
class SensorImpl class SensorImpl
@ -51,53 +51,46 @@ public :
static void cleanup(); static void cleanup();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Initialize the sensor /// \brief Check if a sensor is available
/// ///
/// \param type Index assigned to the sensor /// \param sensor Sensor to check
/// ///
/// \return The sensor capabilities /// \return True if the sensor is available, false otherwise
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorCaps& initialize(unsigned int type); static bool isAvailable(Sensor::Type sensor);
////////////////////////////////////////////////////////////
/// \brief Open the sensor
///
/// \param sensor Type of the sensor
///
/// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
bool open(Sensor::Type sensor);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Close the sensor /// \brief Close the sensor
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void terminate(); void close();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Update the sensor and get its new state /// \brief Update the sensor and get its new value
/// ///
/// \return Sensor state /// \return Sensor value
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorState& update(); Vector3f update();
////////////////////////////////////////////////////////////
/// \brief Check if the sensor is enabled
///
/// \return True if the sensor is enabled, false otherwise
///
////////////////////////////////////////////////////////////
bool isEnable();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Enable or disable the sensor /// \brief Enable or disable the sensor
/// ///
/// \param enable True to enable, false to disable /// \param enabled True to enable, false to disable
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void setEnable(bool enable); void setEnabled(bool enabled);
////////////////////////////////////////////////////////////
/// \brief Set the refresh rate of the sensor
///
/// \param rate Delay between each refresh
///
////////////////////////////////////////////////////////////
void setRefreshRate(const Time& rate);
}; };
} // namespace priv } // namespace priv
@ -105,4 +98,4 @@ public :
} // namespace sf } // namespace sf
#endif // SFML_SENSORIMPLLINUX_HPP #endif // SFML_SENSORIMPLUNIX_HPP

64
src/SFML/Window/Win32/SensorImpl.cpp
View File

@ -35,56 +35,52 @@ namespace priv
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::initialize() void SensorImpl::initialize()
{ {
// Not applicable // To be implemented
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::cleanup() void SensorImpl::cleanup()
{ {
// Not applicable // To be implemented
} }
////////////////////////////////////////////////////////////
SensorCaps& SensorImpl::initialize(unsigned int type)
{
// Not applicable
SensorCaps capabilities;
capabilities.available = false;
return capabilities;
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::terminate() bool SensorImpl::isAvailable(Sensor::Type /*sensor*/)
{ {
// Not applicable // To be implemented
}
////////////////////////////////////////////////////////////
SensorState& SensorImpl::update()
{
// Not applicable
static SensorState state;
return state;
}
////////////////////////////////////////////////////////////
bool SensorImpl::isEnable()
{
// Not applicable
return false; return false;
} }
////////////////////////////////////////////////////////////
void SensorImpl::setEnable(bool enable)
{
// Not applicable
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::setRefreshRate(const Time& rate) bool SensorImpl::open(Sensor::Type /*sensor*/)
{ {
// Not applicable // To be implemented
return false;
}
////////////////////////////////////////////////////////////
void SensorImpl::close()
{
// To be implemented
}
////////////////////////////////////////////////////////////
Vector3f SensorImpl::update()
{
// To be implemented
return Vector3f(0, 0, 0);
}
////////////////////////////////////////////////////////////
void SensorImpl::setEnabled(bool /*enabled*/)
{
// To be implemented
} }
} // namespace priv } // namespace priv

47
src/SFML/Window/Win32/SensorImpl.hpp
View File

@ -51,53 +51,46 @@ public :
static void cleanup(); static void cleanup();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Initialize the sensor /// \brief Check if a sensor is available
/// ///
/// \param type Index assigned to the sensor /// \param sensor Sensor to check
/// ///
/// \return The sensor capabilities /// \return True if the sensor is available, false otherwise
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorCaps& initialize(unsigned int type); static bool isAvailable(Sensor::Type sensor);
////////////////////////////////////////////////////////////
/// \brief Open the sensor
///
/// \param sensor Type of the sensor
///
/// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
bool open(Sensor::Type sensor);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Close the sensor /// \brief Close the sensor
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void terminate(); void close();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Update the sensor and get its new state /// \brief Update the sensor and get its new value
/// ///
/// \return Sensor state /// \return Sensor value
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorState& update(); Vector3f update();
////////////////////////////////////////////////////////////
/// \brief Check if the sensor is enabled
///
/// \return True if the sensor is enabled, false otherwise
///
////////////////////////////////////////////////////////////
bool isEnable();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Enable or disable the sensor /// \brief Enable or disable the sensor
/// ///
/// \param enable True to enable, false to disable /// \param enabled True to enable, false to disable
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void setEnable(bool enable); void setEnabled(bool enabled);
////////////////////////////////////////////////////////////
/// \brief Set the refresh rate of the sensor
///
/// \param rate Delay between each refresh
///
////////////////////////////////////////////////////////////
void setRefreshRate(const Time& rate);
}; };
} // namespace priv } // namespace priv

63
src/SFML/Window/WindowImpl.cpp
View File

@ -81,17 +81,16 @@ WindowImpl* WindowImpl::create(WindowHandle handle)
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
WindowImpl::WindowImpl() : WindowImpl::WindowImpl() :
m_joyThreshold(0.1f) m_joystickThreshold(0.1f)
{ {
// Get the initial joystick states // Get the initial joystick states
JoystickManager::getInstance().update(); JoystickManager::getInstance().update();
for (unsigned int i = 0; i < Joystick::Count; ++i) for (unsigned int i = 0; i < Joystick::Count; ++i)
m_joyStates[i] = JoystickManager::getInstance().getState(i); m_joystickStates[i] = JoystickManager::getInstance().getState(i);
// Get the initial sensor states // Get the initial sensor states
SensorManager::getInstance().update();
for (unsigned int i = 0; i < Sensor::Count; ++i) for (unsigned int i = 0; i < Sensor::Count; ++i)
m_senStates[i] = SensorManager::getInstance().getState(i); m_sensorValue[i] = Vector3f(0, 0, 0);
} }
@ -105,7 +104,7 @@ WindowImpl::~WindowImpl()
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void WindowImpl::setJoystickThreshold(float threshold) void WindowImpl::setJoystickThreshold(float threshold)
{ {
m_joyThreshold = threshold; m_joystickThreshold = threshold;
} }
@ -165,12 +164,12 @@ void WindowImpl::processJoystickEvents()
for (unsigned int i = 0; i < Joystick::Count; ++i) for (unsigned int i = 0; i < Joystick::Count; ++i)
{ {
// Copy the previous state of the joystick and get the new one // Copy the previous state of the joystick and get the new one
JoystickState previousState = m_joyStates[i]; JoystickState previousState = m_joystickStates[i];
m_joyStates[i] = JoystickManager::getInstance().getState(i); m_joystickStates[i] = JoystickManager::getInstance().getState(i);
JoystickCaps caps = JoystickManager::getInstance().getCapabilities(i); JoystickCaps caps = JoystickManager::getInstance().getCapabilities(i);
// Connection state // Connection state
bool connected = m_joyStates[i].connected; bool connected = m_joystickStates[i].connected;
if (previousState.connected ^ connected) if (previousState.connected ^ connected)
{ {
Event event; Event event;
@ -188,8 +187,8 @@ void WindowImpl::processJoystickEvents()
{ {
Joystick::Axis axis = static_cast<Joystick::Axis>(j); Joystick::Axis axis = static_cast<Joystick::Axis>(j);
float prevPos = previousState.axes[axis]; float prevPos = previousState.axes[axis];
float currPos = m_joyStates[i].axes[axis]; float currPos = m_joystickStates[i].axes[axis];
if (fabs(currPos - prevPos) >= m_joyThreshold) if (fabs(currPos - prevPos) >= m_joystickThreshold)
{ {
Event event; Event event;
event.type = Event::JoystickMoved; event.type = Event::JoystickMoved;
@ -205,7 +204,7 @@ void WindowImpl::processJoystickEvents()
for (unsigned int j = 0; j < caps.buttonCount; ++j) for (unsigned int j = 0; j < caps.buttonCount; ++j)
{ {
bool prevPressed = previousState.buttons[j]; bool prevPressed = previousState.buttons[j];
bool currPressed = m_joyStates[i].buttons[j]; bool currPressed = m_joystickStates[i].buttons[j];
if (prevPressed ^ currPressed) if (prevPressed ^ currPressed)
{ {
@ -224,44 +223,30 @@ void WindowImpl::processJoystickEvents()
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void WindowImpl::processSensorEvents() void WindowImpl::processSensorEvents()
{ {
// First update sensor states // First update the sensor states
SensorManager::getInstance().update(); SensorManager::getInstance().update();
for (unsigned int i = 0; i < Sensor::Count; ++i) for (unsigned int i = 0; i < Sensor::Count; ++i)
{ {
// Copy the previous state of the sensor and get the new one Sensor::Type sensor = static_cast<Sensor::Type>(i);
SensorState previousState = m_senStates[i];
m_senStates[i] = SensorManager::getInstance().getState(i);
// Check whether it's still enabled // Only process enabled sensors
bool enabled = m_senStates[i].enabled; if (SensorManager::getInstance().isEnabled(sensor))
if (previousState.enabled ^ enabled)
{ {
Event event; // Copy the previous value of the sensor and get the new one
event.type = enabled ? Event::SensorEnabled : Event::SensorDisabled; Vector3f previousValue = m_sensorValue[i];
event.sensor.type = static_cast<Sensor::Type>(i); m_sensorValue[i] = SensorManager::getInstance().getValue(sensor);
pushEvent(event);
// This sensor has been disabled, we don't want these pending data // If the value has changed, trigger an event
if (!enabled) if (m_sensorValue[i] != previousValue) // @todo use a threshold?
{
while (!m_senStates[i].pendingData->empty())
m_senStates[i].pendingData->pop();
}
}
if (enabled)
{
// Send pending sensor data events
while (!m_senStates[i].pendingData->empty())
{ {
Event event; Event event;
event.type = Event::SensorData; event.type = Event::SensorChanged;
event.sensor.type = static_cast<Sensor::Type>(i); event.sensor.type = sensor;
event.sensor.data = m_senStates[i].pendingData->front(); event.sensor.x = m_sensorValue[i].x;
event.sensor.y = m_sensorValue[i].y;
event.sensor.z = m_sensorValue[i].z;
pushEvent(event); pushEvent(event);
m_senStates[i].pendingData->pop();
} }
} }
} }

8
src/SFML/Window/WindowImpl.hpp
View File

@ -237,10 +237,10 @@ private :
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// Member data // Member data
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
std::queue<Event> m_events; ///< Queue of available events std::queue<Event> m_events; ///< Queue of available events
JoystickState m_joyStates[Joystick::Count]; ///< Previous state of the joysticks JoystickState m_joystickStates[Joystick::Count]; ///< Previous state of the joysticks
SensorState m_senStates[Sensor::Count]; ///< Previous state of the sensors Vector3f m_sensorValue[Sensor::Count]; ///< Previous value of the sensors
float m_joyThreshold; ///< Joystick threshold (minimum motion for MOVE event to be generated) float m_joystickThreshold; ///< Joystick threshold (minimum motion for "move" event to be generated)
}; };
} // namespace priv } // namespace priv

164
src/SFML/Window/iOS/JoystickImpl.mm
View File

@ -26,21 +26,8 @@
// Headers // Headers
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
#include <SFML/Window/JoystickImpl.hpp> #include <SFML/Window/JoystickImpl.hpp>
#include <SFML/Window/iOS/SFAppDelegate.hpp>
namespace
{
enum
{
Accelerometer,
Gyroscope,
Magnetometer,
UserAcceleration,
AbsoluteOrientation
};
}
namespace sf namespace sf
{ {
namespace priv namespace priv
@ -48,182 +35,53 @@ namespace priv
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void JoystickImpl::initialize() void JoystickImpl::initialize()
{ {
// Nothing to do // Not implemented
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void JoystickImpl::cleanup() void JoystickImpl::cleanup()
{ {
// Nothing to do // Not implemented
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
bool JoystickImpl::isConnected(unsigned int index) bool JoystickImpl::isConnected(unsigned int index)
{ {
switch (index) // Not implemented
{ return false;
case Accelerometer:
return [SFAppDelegate getInstance].motionManager.accelerometerAvailable;
case Gyroscope:
return [SFAppDelegate getInstance].motionManager.gyroAvailable;
case Magnetometer:
return [SFAppDelegate getInstance].motionManager.magnetometerAvailable;
case UserAcceleration:
case AbsoluteOrientation:
return [SFAppDelegate getInstance].motionManager.deviceMotionAvailable;
default:
return false;
}
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
bool JoystickImpl::open(unsigned int index) bool JoystickImpl::open(unsigned int index)
{ {
// Enable the corresponding sensor // Not implemented
static const NSTimeInterval updateInterval = 1. / 60.; return false;
switch (index)
{
case Accelerometer:
[SFAppDelegate getInstance].motionManager.accelerometerUpdateInterval = updateInterval;
[[SFAppDelegate getInstance].motionManager startAccelerometerUpdates];
break;
case Gyroscope:
[SFAppDelegate getInstance].motionManager.gyroUpdateInterval = updateInterval;
[[SFAppDelegate getInstance].motionManager startGyroUpdates];
break;
case Magnetometer:
[SFAppDelegate getInstance].motionManager.magnetometerUpdateInterval = updateInterval;
[[SFAppDelegate getInstance].motionManager startMagnetometerUpdates];
break;
case UserAcceleration:
case AbsoluteOrientation:
if (![SFAppDelegate getInstance].motionManager.deviceMotionActive)
{
[SFAppDelegate getInstance].motionManager.deviceMotionUpdateInterval = updateInterval;
[[SFAppDelegate getInstance].motionManager startDeviceMotionUpdates];
}
break;
default:
break;
}
// Save the index
m_index = index;
return true;
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void JoystickImpl::close() void JoystickImpl::close()
{ {
// Disable the corresponding sensor // Not implemented
switch (m_index)
{
case Accelerometer:
if ([SFAppDelegate getInstance].motionManager.accelerometerActive)
[[SFAppDelegate getInstance].motionManager stopAccelerometerUpdates];
break;
case Gyroscope:
if ([SFAppDelegate getInstance].motionManager.gyroActive)
[[SFAppDelegate getInstance].motionManager stopGyroUpdates];
break;
case Magnetometer:
if ([SFAppDelegate getInstance].motionManager.magnetometerActive)
[[SFAppDelegate getInstance].motionManager stopMagnetometerUpdates];
break;
case UserAcceleration:
case AbsoluteOrientation:
if ([SFAppDelegate getInstance].motionManager.deviceMotionActive)
[[SFAppDelegate getInstance].motionManager stopDeviceMotionUpdates];
break;
default:
break;
}
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
JoystickCaps JoystickImpl::getCapabilities() const JoystickCaps JoystickImpl::getCapabilities() const
{ {
JoystickCaps caps; // Not implemented
return JoystickCaps();
// All the connected joysticks have (X, Y, Z) axes
caps.axes[Joystick::X] = true;
caps.axes[Joystick::Y] = true;
caps.axes[Joystick::Z] = true;
return caps;
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
JoystickState JoystickImpl::update() JoystickState JoystickImpl::update()
{ {
JoystickState state; // Not implemented
return JoystickState();
// Always connected
state.connected = true;
CMMotionManager* manager = [SFAppDelegate getInstance].motionManager;
switch (m_index)
{
case Accelerometer:
// Acceleration is given in G (reminder: 1G is regular earth gravity, 9.81 m/s^2), in range [-2, 2] (could be more on newer devices?)
state.axes[Joystick::X] = manager.accelerometerData.acceleration.x;
state.axes[Joystick::Y] = manager.accelerometerData.acceleration.y;
state.axes[Joystick::Z] = manager.accelerometerData.acceleration.z;
break;
case Gyroscope:
// Rotation rates are given in rad/s, in range [?, ?]
state.axes[Joystick::X] = manager.gyroData.rotationRate.x;
state.axes[Joystick::Y] = manager.gyroData.rotationRate.y;
state.axes[Joystick::Z] = manager.gyroData.rotationRate.z;
break;
case Magnetometer:
// Magnetic field is given in microteslas, in range [?, ?]
state.axes[Joystick::X] = manager.magnetometerData.magneticField.x;
state.axes[Joystick::Y] = manager.magnetometerData.magneticField.y;
state.axes[Joystick::Z] = manager.magnetometerData.magneticField.z;
break;
case UserAcceleration:
// User acceleration (gravity removed), same unit and range as raw accelerometer values
state.axes[Joystick::X] = manager.deviceMotion.userAcceleration.x;
state.axes[Joystick::Y] = manager.deviceMotion.userAcceleration.y;
state.axes[Joystick::Z] = manager.deviceMotion.userAcceleration.z;
break;
case AbsoluteOrientation:
// Absolute rotation (Euler) angles are given in radians, in range [-PI, PI]
state.axes[Joystick::X] = manager.deviceMotion.attitude.yaw;
state.axes[Joystick::Y] = manager.deviceMotion.attitude.pitch;
state.axes[Joystick::Z] = manager.deviceMotion.attitude.roll;
break;
default:
break;
}
return state;
} }
} // namespace priv } // namespace priv

54
src/SFML/Window/iOS/SensorImpl.hpp
View File

@ -25,6 +25,11 @@
#ifndef SFML_SENSORIMPLIOS_HPP #ifndef SFML_SENSORIMPLIOS_HPP
#define SFML_SENSORIMPLIOS_HPP #define SFML_SENSORIMPLIOS_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Window/Sensor.hpp>
namespace sf namespace sf
{ {
@ -51,53 +56,54 @@ public :
static void cleanup(); static void cleanup();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Initialize the sensor /// \brief Check if a sensor is available
/// ///
/// \param type Index assigned to the sensor /// \param sensor Sensor to check
/// ///
/// \return The sensor capabilities /// \return True if the sensor is available, false otherwise
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorCaps& initialize(unsigned int type); static bool isAvailable(Sensor::Type sensor);
////////////////////////////////////////////////////////////
/// \brief Open the sensor
///
/// \param sensor Type of the sensor
///
/// \return True on success, false on failure
///
////////////////////////////////////////////////////////////
bool open(Sensor::Type sensor);
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Close the sensor /// \brief Close the sensor
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void terminate(); void close();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Update the sensor and get its new state /// \brief Update the sensor and get its new value
/// ///
/// \return Sensor state /// \return Sensor value
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorState& update(); Vector3f update();
////////////////////////////////////////////////////////////
/// \brief Check if the sensor is enabled
///
/// \return True if the sensor is enabled, false otherwise
///
////////////////////////////////////////////////////////////
bool isEnable();
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Enable or disable the sensor /// \brief Enable or disable the sensor
/// ///
/// \param enable True to enable, false to disable /// \param enabled True to enable, false to disable
/// ///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void setEnable(bool enable); void setEnabled(bool enabled);
private :
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
/// \brief Set the refresh rate of the sensor // Member data
///
/// \param rate Delay between each refresh
///
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void setRefreshRate(const Time& rate); Sensor::Type m_sensor; ///< Type of the sensor
bool m_enabled; ///< Enable state of the sensor
}; };
} // namespace priv } // namespace priv

205
src/SFML/Window/iOS/SensorImpl.mm
View File

@ -28,6 +28,17 @@
#include <SFML/Window/SensorImpl.hpp> #include <SFML/Window/SensorImpl.hpp>
namespace
{
unsigned int deviceMotionEnabledCount = 0;
float toDegrees(float radians)
{
return radians * 180.f / 3.141592654f;
}
}
namespace sf namespace sf
{ {
namespace priv namespace priv
@ -35,56 +46,194 @@ namespace priv
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::initialize() void SensorImpl::initialize()
{ {
// To implement // Nothing to do
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::cleanup() void SensorImpl::cleanup()
{ {
// To implement // Nothing to do
} }
////////////////////////////////////////////////////////////
SensorCaps& SensorImpl::initialize(unsigned int type)
{
// To implement
SensorCaps capabilities;
capabilities.available = false;
return capabilities; ////////////////////////////////////////////////////////////
bool SensorImpl::isAvailable(Sensor::Type sensor)
{
switch (sensor)
{
case Sensor::Accelerometer:
return [SFAppDelegate getInstance].motionManager.accelerometerAvailable;
case Sensor::Gyroscope:
return [SFAppDelegate getInstance].motionManager.gyroAvailable;
case Sensor::Magnetometer:
return [SFAppDelegate getInstance].motionManager.magnetometerAvailable;
case Sensor::Gravity:
case Sensor::UserAcceleration:
case Sensor::Orientation:
return [SFAppDelegate getInstance].motionManager.deviceMotionAvailable;
default:
return false;
}
} }
////////////////////////////////////////////////////////////
void SensorImpl::terminate()
{
// To implement
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
SensorState& SensorImpl::update() bool SensorImpl::open(Sensor::Type sensor)
{ {
// To implement // Store the sensor type
static SensorState state; m_sensor = sensor;
return state;
// The sensor is disabled by default
m_enabled = false;
// Set the refresh rate (use the maximum allowed)
static const NSTimeInterval updateInterval = 1. / 60.;
switch (sensor)
{
case Sensor::Accelerometer:
[SFAppDelegate getInstance].motionManager.accelerometerUpdateInterval = updateInterval;
break;
case Sensor::Gyroscope:
[SFAppDelegate getInstance].motionManager.gyroUpdateInterval = updateInterval;
break;
case Sensor::Magnetometer:
[SFAppDelegate getInstance].motionManager.magnetometerUpdateInterval = updateInterval;
break;
case Sensor::Gravity:
case Sensor::UserAcceleration:
case Sensor::Orientation:
[SFAppDelegate getInstance].motionManager.deviceMotionUpdateInterval = updateInterval;
break;
default:
break;
}
return true;
} }
////////////////////////////////////////////////////////////
bool SensorImpl::isEnable()
{
// To implement
return false;
}
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::setEnable(bool enable) void SensorImpl::close()
{ {
// To implement // Nothing to do
} }
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
void SensorImpl::setRefreshRate(const Time& rate) Vector3f SensorImpl::update()
{ {
// To implement Vector3f value;
CMMotionManager* manager = [SFAppDelegate getInstance].motionManager;
switch (m_sensor)
{
case Sensor::Accelerometer:
// Acceleration is given in G, convert to m/s²
value.x = manager.accelerometerData.acceleration.x * 9.81f;
value.y = manager.accelerometerData.acceleration.y * 9.81f;
value.z = manager.accelerometerData.acceleration.z * 9.81f;
break;
case Sensor::Gyroscope:
// Rotation rates are given in rad/s, convert to deg/s
value.x = toDegrees(manager.gyroData.rotationRate.x);
value.y = toDegrees(manager.gyroData.rotationRate.y);
value.z = toDegrees(manager.gyroData.rotationRate.z);
break;
case Sensor::Magnetometer:
// Magnetic field is given in microteslas
value.x = manager.magnetometerData.magneticField.x;
value.y = manager.magnetometerData.magneticField.y;
value.z = manager.magnetometerData.magneticField.z;
break;
case Sensor::UserAcceleration:
// User acceleration is given in G, convert to m/s²
value.x = manager.deviceMotion.userAcceleration.x * 9.81f;
value.y = manager.deviceMotion.userAcceleration.y * 9.81f;
value.z = manager.deviceMotion.userAcceleration.z * 9.81f;
break;
case Sensor::Orientation:
// Absolute rotation (Euler) angles are given in radians, convert to degrees
value.x = toDegrees(manager.deviceMotion.attitude.yaw);
value.y = toDegrees(manager.deviceMotion.attitude.pitch);
value.z = toDegrees(manager.deviceMotion.attitude.roll);
break;
default:
break;
}
return value;
}
////////////////////////////////////////////////////////////
void SensorImpl::setEnabled(bool enabled)
{
// Don't do anything if the state is the same
if (enabled == m_enabled)
return;
switch (index)
{
case Sensor::Accelerometer:
if (enabled)
[[SFAppDelegate getInstance].motionManager startAccelerometerUpdates];
else
[[SFAppDelegate getInstance].motionManager stopAccelerometerUpdates];
break;
case Sensor::Gyroscope:
if (enabled)
[[SFAppDelegate getInstance].motionManager startGyroUpdates];
else
[[SFAppDelegate getInstance].motionManager stopGyroUpdates];
break;
case Sensor::Magnetometer:
if (enabled)
[[SFAppDelegate getInstance].motionManager startMagnetometerUpdates];
else
[[SFAppDelegate getInstance].motionManager stopMagnetometerUpdates];
break;
case Sensor::Gravity:
case Sensor::UserAcceleration:
case Sensor::Orientation:
// these 3 sensors all share the same implementation, so we must disable
// it only if the three sensors are disabled
if (enabled)
{
if (deviceMotionEnabledCount == 0)
[[SFAppDelegate getInstance].motionManager startDeviceMotionUpdates];
deviceMotionEnabledCount++;
}
else
{
deviceMotionEnabledCount--;
if (deviceMotionEnabledCount == 0)
[[SFAppDelegate getInstance].motionManager stopDeviceMotionUpdates];
}
break;
default:
break;
}
// Update the enable state
m_enabled = enabled;
} }
} // namespace priv } // namespace priv