haptic.hpp

Go to the documentation of this file.

#pragma once

#include <SDL_haptic.h>
#include <algorithm>

namespace sdl
{
class Haptic
{
    SDL_Haptic* haptic_ = nullptr;

    using effect_sdlid = int;

    using effect_list = std::vector<effect_sdlid>;

    effect_list my_effects{};

public:
    SDL_Haptic* ptr() const { return haptic_; }

    class InstalledEffect
    {
        static constexpr effect_list::size_type invalid_index =
            std::numeric_limits<effect_list::size_type>::max();
        effect_list::size_type index_ = invalid_index;
        Haptic*                owner_ = nullptr;
        friend class Haptic;

        void move_from(InstalledEffect& other) {}

    public:
        InstalledEffect(effect_list::size_type index, Haptic* owner) : index_{index}, owner_{owner}
        {
        }

        InstalledEffect() = default;
        InstalledEffect(InstalledEffect const&);
        InstalledEffect& operator=(InstalledEffect const&);

        InstalledEffect(InstalledEffect&& other) noexcept { *this = std::move(other); }

        InstalledEffect& operator=(InstalledEffect&& other) noexcept
        {
            if (index_ != other.index_)
            {
                index_ = other.index_;
                owner_ = other.owner_;

                other.index_ = invalid_index;
                other.owner_ = nullptr;
            }
            return *this;
        }

        ~InstalledEffect()
        {
            if (owner_ && index_ != invalid_index)
            {
                const effect_sdlid my_real_id = owner_->get_effect_sdlid(*this);
                SDL_HapticDestroyEffect(owner_->ptr(), my_real_id);

                owner_->remove_effect(my_real_id);
            }
        }

        void run(uint32_t iterations = 1) { owner_->run_effect(*this, iterations); }
    };

#if _MSC_VER >= 1910
#pragma warning(push)
#pragma warning(disable : 26495)
#endif

    union Effect
    {
        // This is analog to how we handle sdl events: this
        // definition is copied from SDL_haptic.h
        // note : It has been planned by SDL developers to change the `type`
        // type in 2.1.0.
        Uint16              type;      
        SDL_HapticConstant  constant;  
        SDL_HapticPeriodic  periodic;  
        SDL_HapticCondition condition; 
        SDL_HapticRamp      ramp;      
        SDL_HapticLeftRight leftright; 
        SDL_HapticCustom    custom;    

        operator SDL_HapticEffect*() const
        {
            // "I solemnly swear that I am up to no good."
            return (SDL_HapticEffect*)(this);
        }

        Effect()
        {
            // Hopefully this will prevent the library to work when SDL will
            // decide to "fix" the "oops, the 'type' variable doesn't have
            // enough bits" problem they encouterd with 2.0 (this fix is
            // scheduled to be in 2.1 since it's an API/ABI breakage)
            static_assert(
                sizeof(Effect::type) == sizeof(SDL_HapticEffect::type),
                "please compare the layout between SDL_HapticEffect and "
                "sdl::Haptic::Effect");
            static_assert(
                sizeof(Effect) == sizeof(SDL_HapticEffect),
                "please compare the layout between SDL_HapticEffect and "
                "sdl::Haptic::Effect");

            // be sure to fully zero initialize the enclosed effect
            SDL_memset(this, 0, sizeof(Effect));
        }
    };

#if _MSC_VER >= 1910
#pragma warning(pop)
#endif

    Haptic() {}

    Haptic(int haptic_index) : haptic_{SDL_HapticOpen(haptic_index)}
    {
        if (!haptic_)
        {
            throw Exception("SDL_HapticOpen");
        }
    }

    Haptic(SDL_Joystick* joystick) : haptic_{SDL_HapticOpenFromJoystick(joystick)}
    {
        if (!haptic_)
        {
            throw Exception("SDL_HapticOpenFromJoystick");
        }
    }

    ~Haptic()
    {
        if (haptic_)
        {
            SDL_HapticClose(haptic_);
        }
    }

    // not copyable
    Haptic(Haptic const&) = delete;
    Haptic& operator=(Haptic const&) = delete;

    Haptic(Haptic&& other) noexcept { *this = std::move(other); }

    Haptic& operator=(Haptic&& other) noexcept
    {
        if (haptic_ != other.haptic_)
        {
            haptic_       = other.haptic_;
            my_effects    = std::move(other.my_effects);
            other.haptic_ = nullptr;
        }
        return *this;
    }

    bool valid() const { return haptic_ != nullptr; }

    unsigned int get_capabilities() const
    {
        if (!valid()) // we're not an opened device... So we should decide what
                      // to do here...
            return 0U;

        const auto capabilities = SDL_HapticQuery(haptic_);

        if (!capabilities)
        {
            // couldn't get the capabilities of this haptic device.
            throw Exception("SDL_HapticQuery");
        }

        return capabilities;
    }

    bool is_capable_of(int haptic_flag) const
    {
        const auto caps = get_capabilities();
        return (haptic_flag & caps) != 0;
    }

    InstalledEffect new_effect(Effect const& e)
    {
        // We need to be able to play the haptic effect
        if (!is_capable_of(e.type)) return {};

        // maybe we should have another RAII wrapper around the registered
        // haptic effects
        const effect_sdlid raw_sdl_id = SDL_HapticNewEffect(haptic_, e);

        if (raw_sdl_id < 0) throw Exception("SDL_HapticNewEffect");

        my_effects.push_back(raw_sdl_id);
        return {my_effects.size() - 1, this};
    }

    effect_list::size_type registered_effect_count() const { return my_effects.size(); }

    effect_sdlid get_effect_sdlid(InstalledEffect const& h) const
    {
        return my_effects.at(h.index_);
    }

    void remove_effect(effect_sdlid e)
    {
        for (size_t i = 0, nb_effects = my_effects.size(); i < nb_effects; ++i)
        {
            if (my_effects[i] == e) my_effects[i] = -1;
        }
    }

    void run_effect(InstalledEffect const& h, uint32_t iterations = 1) const
    {
        const effect_sdlid e = get_effect_sdlid(h);
        if (e >= 0 && SDL_HapticRunEffect(haptic_, get_effect_sdlid(h), iterations) < 0)
        {
            throw Exception("SDL_HapticRunEffect");
        }
    }

    bool is_effect_compatible(Effect const& e) const { return is_capable_of(e.type); }
};
} // namespace sdl