action.cpp

Go to the documentation of this file.

#include "./asw/modules/action.h"
 
#include <algorithm>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace {
 
struct ActionData {
    std::vector<asw::input::ActionBinding> bindings;
 
    bool pressed { false };
    bool released { false };
    bool down { false };
    float strength { 0.0F };
 
    bool prev_down { false };
};
 
// Looked up by string_view without building a std::string
struct NameHash {
    using is_transparent = void;
 
    std::size_t operator()(std::string_view name) const
    {
        return std::hash<std::string_view> { }(name);
    }
};
 
std::unordered_map<std::string, ActionData, NameHash, std::equal_to<>> action_map;
 
// ---------------------------------------------------------------------------
// Per-binding query helpers
// ---------------------------------------------------------------------------
 
bool binding_is_down(const asw::input::ActionBinding& binding, float& out_strength)
{
    return std::visit(
        [&out_strength](const auto& b) -> bool {
            using T = std::decay_t<decltype(b)>;
 
            if constexpr (std::is_same_v<T, asw::input::KeyBinding>) {
                if (asw::input::get_key(b.key)) {
                    out_strength = std::max(out_strength, 1.0F);
                    return true;
                }
                return false;
 
            } else if constexpr (std::is_same_v<T, asw::input::MouseButtonBinding>) {
                if (asw::input::get_mouse_button(b.button)) {
                    out_strength = std::max(out_strength, 1.0F);
                    return true;
                }
                return false;
 
            } else if constexpr (std::is_same_v<T, asw::input::ControllerButtonBinding>) {
                if (asw::input::get_controller_button(b.controller_index, b.button)) {
                    out_strength = std::max(out_strength, 1.0F);
                    return true;
                }
                return false;
 
            } else if constexpr (std::is_same_v<T, asw::input::ControllerAxisBinding>) {
                // Check each pad on its own, so one pad pushing the other way
                // does not hide this direction on another pad
                const auto check = [&](uint32_t index) {
                    const float val = asw::input::get_controller_axis(index, b.axis);
                    const float effective = b.positive_direction ? val : -val;
                    if (effective >= b.threshold) {
                        out_strength = std::max(out_strength, effective);
                        return true;
                    }
                    return false;
                };
 
                if (b.controller_index != asw::input::ANY_CONTROLLER) {
                    return check(b.controller_index);
                }
 
                bool any = false;
                const auto count = static_cast<uint32_t>(asw::input::get_controller_count());
                for (uint32_t i = 0; i < count; ++i) {
                    any |= check(i);
                }
                return any;
            }
 
            return false;
        },
        binding);
}
 
bool binding_is_pressed(const asw::input::ActionBinding& binding)
{
    return std::visit(
        [](const auto& b) -> bool {
            using T = std::decay_t<decltype(b)>;
 
            if constexpr (std::is_same_v<T, asw::input::KeyBinding>) {
                return asw::input::get_key_down(b.key);
 
            } else if constexpr (std::is_same_v<T, asw::input::MouseButtonBinding>) {
                return asw::input::get_mouse_button_down(b.button);
 
            } else if constexpr (std::is_same_v<T, asw::input::ControllerButtonBinding>) {
                return asw::input::get_controller_button_down(b.controller_index, b.button);
 
            } else {
                // ControllerAxisBinding: transition handled by prev_down in update_actions.
                return false;
            }
        },
        binding);
}
 
bool binding_is_released(const asw::input::ActionBinding& binding)
{
    return std::visit(
        [](const auto& b) -> bool {
            using T = std::decay_t<decltype(b)>;
 
            if constexpr (std::is_same_v<T, asw::input::KeyBinding>) {
                return asw::input::get_key_up(b.key);
 
            } else if constexpr (std::is_same_v<T, asw::input::MouseButtonBinding>) {
                return asw::input::get_mouse_button_up(b.button);
 
            } else if constexpr (std::is_same_v<T, asw::input::ControllerButtonBinding>) {
                return asw::input::get_controller_button_up(b.controller_index, b.button);
 
            } else {
                // ControllerAxisBinding: transition handled by prev_down in update_actions.
                return false;
            }
        },
        binding);
}
 
} // namespace
 
// ---------------------------------------------------------------------------
// Public API
// ---------------------------------------------------------------------------
 
void asw::input::bind_action(std::string_view name, asw::input::ActionBinding binding)
{
    action_map[std::string(name)].bindings.push_back(binding);
}
 
void asw::input::unbind_action(std::string_view name)
{
    if (auto it = action_map.find(name); it != action_map.end()) {
        action_map.erase(it);
    }
}
 
void asw::input::clear_actions()
{
    action_map.clear();
}
 
bool asw::input::get_action_down(std::string_view name)
{
    auto it = action_map.find(name);
    return it != action_map.end() && it->second.pressed;
}
 
bool asw::input::get_action_up(std::string_view name)
{
    auto it = action_map.find(name);
    return it != action_map.end() && it->second.released;
}
 
bool asw::input::get_action(std::string_view name)
{
    auto it = action_map.find(name);
    return it != action_map.end() && it->second.down;
}
 
float asw::input::get_action_strength(std::string_view name)
{
    auto it = action_map.find(name);
    return it != action_map.end() ? it->second.strength : 0.0F;
}
 
void asw::input::update_actions()
{
    for (auto& [name, action] : action_map) {
        bool any_down = false;
        bool any_pressed = false;
        bool any_released = false;
        float max_strength = 0.0F;
 
        for (const auto& binding : action.bindings) {
            any_down |= binding_is_down(binding, max_strength);
            any_pressed |= binding_is_pressed(binding);
            any_released |= binding_is_released(binding);
        }
 
        // The action is pressed when it goes from up to down, and released
        // when it goes from down to up. A binding's own edge still counts, so
        // a tap within one frame is seen, but not while another binding holds
        // the action down, e.g. pressing a second jump key does not jump again.
        action.pressed = !action.prev_down && (any_down || any_pressed);
        action.released = !any_down && (action.prev_down || any_released);
        action.down = any_down;
        action.strength = max_strength;
        action.prev_down = any_down;
    }
}