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 SensorBase;
 
// Forward decl
struct Sensor;

using SensorRaw = SDL_Sensor*;

using SensorRef = ResourceRefT<SensorBase>;

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)

struct SensorBase : ResourceBaseT<SensorRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Close();

  PropertiesRef GetProperties();

  const char* GetName();

  SensorType GetType();

  int GetNonPortableType();

  SensorID GetID();

  void GetData(float* data, int num_values);
};

struct Sensor : SensorBase
{
  using SensorBase::SensorBase;

  constexpr explicit Sensor(SensorRaw resource) noexcept
    : SensorBase(resource)
  {
  }

  constexpr Sensor(Sensor&& other) noexcept
    : Sensor(other.release())
  {
  }

  Sensor(SensorID instance_id);

  ~Sensor() { SDL_CloseSensor(get()); }

  constexpr Sensor& operator=(Sensor&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

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 Sensor::Sensor(SensorID instance_id)
  : Sensor(SDL_OpenSensor(instance_id))
{
}

inline SensorRef GetSensorFromID(SensorID instance_id)
{
  return {SDL_GetSensorFromID(instance_id)};
}

inline PropertiesRef GetSensorProperties(SensorRef sensor)
{
  return {CheckError(SDL_GetSensorProperties(sensor))};
}
 
inline PropertiesRef SensorBase::GetProperties()
{
  return SDL::GetSensorProperties(get());
}

inline const char* GetSensorName(SensorRef sensor)
{
  return SDL_GetSensorName(sensor);
}
 
inline const char* SensorBase::GetName() { return SDL::GetSensorName(get()); }

inline SensorType GetSensorType(SensorRef sensor)
{
  return SDL_GetSensorType(sensor);
}
 
inline SensorType SensorBase::GetType() { return SDL::GetSensorType(get()); }

inline int GetSensorNonPortableType(SensorRef sensor)
{
  return SDL_GetSensorNonPortableType(sensor);
}
 
inline int SensorBase::GetNonPortableType()
{
  return SDL::GetSensorNonPortableType(get());
}

inline SensorID GetSensorID(SensorRef sensor)
{
  return CheckError(SDL_GetSensorID(sensor));
}
 
inline SensorID SensorBase::GetID() { return SDL::GetSensorID(get()); }

inline void GetSensorData(SensorRef sensor, float* data, int num_values)
{
  CheckError(SDL_GetSensorData(sensor, data, num_values));
}
 
inline void SensorBase::GetData(float* data, int num_values)
{
  SDL::GetSensorData(get(), data, num_values);
}

inline void CloseSensor(SensorRaw sensor) { SDL_CloseSensor(sensor); }
 
inline void SensorBase::Close() { CloseSensor(release()); }

inline void UpdateSensors() { SDL_UpdateSensors(); }

 
} // namespace SDL
 
#endif /* SDL3PP_SENSOR_H_ */