SDL3pp_sensor.h

#ifndef SDL3PP_SENSOR_H_
#define SDL3PP_SENSOR_H_
 
#include <SDL3/SDL_sensor.h>
#include "SDL3pp_error.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_stdinc.h"
#include "SDL3pp_version.h"
 
namespace SDL {
 
// Forward decl
struct Sensor;
 
using SensorRaw = SDL_Sensor*;
 
// Forward decl
struct SensorRef;
 
struct SensorParam
{
  SensorRaw value; 
 
  constexpr SensorParam(SensorRaw value)
    : value(value)
  {
  }
 
  constexpr SensorParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const SensorParam& other) const = default;
 
  constexpr operator SensorRaw() const { return value; }
};
 
using SensorID = Uint32;
 
using SensorType = SDL_SensorType;
 
constexpr SensorType SENSOR_INVALID =
  SDL_SENSOR_INVALID; 
 
constexpr SensorType SENSOR_UNKNOWN =
  SDL_SENSOR_UNKNOWN; 
 
constexpr SensorType SENSOR_ACCEL = SDL_SENSOR_ACCEL; 
 
constexpr SensorType SENSOR_GYRO = SDL_SENSOR_GYRO; 
 
constexpr SensorType SENSOR_ACCEL_L = SDL_SENSOR_ACCEL_L;
 
constexpr SensorType SENSOR_GYRO_L =
  SDL_SENSOR_GYRO_L; 
 
constexpr SensorType SENSOR_ACCEL_R =
  SDL_SENSOR_ACCEL_R; 
 
constexpr SensorType SENSOR_GYRO_R =
  SDL_SENSOR_GYRO_R; 
 
#if SDL_VERSION_ATLEAST(3, 2, 22)
 
constexpr SensorType SENSOR_COUNT = SDL_SENSOR_COUNT; 
 
#endif // SDL_VERSION_ATLEAST(3, 2, 22)
 
class Sensor
{
  SensorRaw m_resource = nullptr;
 
public:
  constexpr Sensor(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Sensor(const SensorRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr Sensor(const Sensor& other) noexcept = default;
 
public:
  constexpr Sensor(Sensor&& other) noexcept
    : Sensor(other.release())
  {
  }
 
  constexpr Sensor(const SensorRef& other) = delete;
 
  constexpr Sensor(SensorRef&& other) = delete;
 
  Sensor(SensorID instance_id)
    : m_resource(SDL_OpenSensor(instance_id))
  {
  }
 
  ~Sensor() { SDL_CloseSensor(m_resource); }
 
  constexpr Sensor& operator=(Sensor&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Sensor& operator=(const Sensor& other) noexcept = default;
 
public:
  constexpr SensorRaw get() const noexcept { return m_resource; }
 
  constexpr SensorRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Sensor& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator SensorParam() const noexcept { return {m_resource}; }
 
  void Close();
 
  PropertiesRef GetProperties();
 
  const char* GetName();
 
  SensorType GetType();
 
  int GetNonPortableType();
 
  SensorID GetID();
 
  void GetData(float* data, int num_values);
};
 
struct SensorRef : Sensor
{
  using Sensor::Sensor;
 
  SensorRef(SensorParam resource) noexcept
    : Sensor(resource.value)
  {
  }
 
  SensorRef(SensorRaw resource) noexcept
    : Sensor(resource)
  {
  }
 
  constexpr SensorRef(const SensorRef& other) noexcept = default;
 
  ~SensorRef() { release(); }
};
 
constexpr float STANDARD_GRAVITY = SDL_STANDARD_GRAVITY;
 
inline OwnArray<SensorID> GetSensors()
{
  int count = 0;
  auto data = SDL_GetSensors(&count);
  return OwnArray<SensorID>(data, size_t(count));
}
 
inline const char* GetSensorNameForID(SensorID instance_id)
{
  return SDL_GetSensorNameForID(instance_id);
}
 
inline SensorType GetSensorTypeForID(SensorID instance_id)
{
  return SDL_GetSensorTypeForID(instance_id);
}
 
inline int GetSensorNonPortableTypeForID(SensorID instance_id)
{
  return SDL_GetSensorNonPortableTypeForID(instance_id);
}
 
inline Sensor OpenSensor(SensorID instance_id) { return Sensor(instance_id); }
 
inline SensorRef GetSensorFromID(SensorID instance_id)
{
  return {SDL_GetSensorFromID(instance_id)};
}
 
inline PropertiesRef GetSensorProperties(SensorParam sensor)
{
  return {CheckError(SDL_GetSensorProperties(sensor))};
}
 
inline PropertiesRef Sensor::GetProperties()
{
  return SDL::GetSensorProperties(m_resource);
}
 
inline const char* GetSensorName(SensorParam sensor)
{
  return SDL_GetSensorName(sensor);
}
 
inline const char* Sensor::GetName() { return SDL::GetSensorName(m_resource); }
 
inline SensorType GetSensorType(SensorParam sensor)
{
  return SDL_GetSensorType(sensor);
}
 
inline SensorType Sensor::GetType() { return SDL::GetSensorType(m_resource); }
 
inline int GetSensorNonPortableType(SensorParam sensor)
{
  return SDL_GetSensorNonPortableType(sensor);
}
 
inline int Sensor::GetNonPortableType()
{
  return SDL::GetSensorNonPortableType(m_resource);
}
 
inline SensorID GetSensorID(SensorParam sensor)
{
  return SDL_GetSensorID(sensor);
}
 
inline SensorID Sensor::GetID() { return SDL::GetSensorID(m_resource); }
 
inline void GetSensorData(SensorParam sensor, float* data, int num_values)
{
  CheckError(SDL_GetSensorData(sensor, data, num_values));
}
 
inline void Sensor::GetData(float* data, int num_values)
{
  SDL::GetSensorData(m_resource, data, num_values);
}
 
inline void CloseSensor(SensorRaw sensor) { SDL_CloseSensor(sensor); }
 
inline void Sensor::Close() { CloseSensor(release()); }
 
inline void UpdateSensors() { SDL_UpdateSensors(); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_SENSOR_H_ */