input.h

#pragma once
 
#include "pixelbullet/input/key_codes.h"
#include "pixelbullet/input/mouse_codes.h"
 
#include <bitset>
#include <cstddef>
#include <glm/glm.hpp>
 
namespace pixelbullet::input_internal
{
struct InputStateAccess;
} // namespace pixelbullet::input_internal
 
namespace pixelbullet
{
namespace input
{
class InputState
{
public:
    [[nodiscard]] bool IsKeyDown(KeyCode key) const;
    [[nodiscard]] bool IsKeyPressed(KeyCode key) const;
    [[nodiscard]] bool IsKeyReleased(KeyCode key) const;
    [[nodiscard]] bool IsMouseButtonDown(MouseCode button) const;
    [[nodiscard]] bool IsMouseButtonPressed(MouseCode button) const;
    [[nodiscard]] bool IsMouseButtonReleased(MouseCode button) const;
    [[nodiscard]] glm::vec2 GetMousePosition() const noexcept
    {
        return mouse_position_;
    }
    [[nodiscard]] float GetMouseX() const noexcept
    {
        return mouse_position_.x;
    }
    [[nodiscard]] float GetMouseY() const noexcept
    {
        return mouse_position_.y;
    }
    [[nodiscard]] glm::vec2 GetMouseDelta() const noexcept
    {
        return mouse_delta_;
    }
    [[nodiscard]] float GetMouseDeltaX() const noexcept
    {
        return mouse_delta_.x;
    }
    [[nodiscard]] float GetMouseDeltaY() const noexcept
    {
        return mouse_delta_.y;
    }
    [[nodiscard]] glm::vec2 GetMouseScrollDelta() const noexcept
    {
        return mouse_scroll_delta_;
    }
    [[nodiscard]] float GetMouseScrollDeltaX() const noexcept
    {
        return mouse_scroll_delta_.x;
    }
    [[nodiscard]] float GetMouseScrollDeltaY() const noexcept
    {
        return mouse_scroll_delta_.y;
    }
 
private:
    static constexpr std::size_t kMaxTrackedKeys = 512;
    static constexpr std::size_t kMaxTrackedMouseButtons = 8;
 
    void SetKeyDown(KeyCode key, bool is_down);
    void SetMouseButtonDown(MouseCode button, bool is_down);
    void SetMousePosition(glm::vec2 mouse_position) noexcept
    {
        mouse_delta_ += mouse_position - mouse_position_;
        mouse_position_ = mouse_position;
    }
    void SyncMousePosition(glm::vec2 mouse_position) noexcept
    {
        mouse_position_ = mouse_position;
    }
    void ResetMouseDelta() noexcept
    {
        mouse_delta_ = glm::vec2(0.0f);
    }
    void ResetTransientInputs() noexcept
    {
        key_pressed_.reset();
        key_released_.reset();
        mouse_button_pressed_.reset();
        mouse_button_released_.reset();
        mouse_delta_ = glm::vec2(0.0f);
        mouse_scroll_delta_ = glm::vec2(0.0f);
    }
    void ClearInputState() noexcept
    {
        key_down_.reset();
        mouse_button_down_.reset();
        ResetTransientInputs();
    }
 
    friend struct pixelbullet::input_internal::InputStateAccess;
 
    std::bitset<kMaxTrackedKeys> key_down_;
    std::bitset<kMaxTrackedKeys> key_pressed_;
    std::bitset<kMaxTrackedKeys> key_released_;
    std::bitset<kMaxTrackedMouseButtons> mouse_button_down_;
    std::bitset<kMaxTrackedMouseButtons> mouse_button_pressed_;
    std::bitset<kMaxTrackedMouseButtons> mouse_button_released_;
    glm::vec2 mouse_position_ = glm::vec2(0.0f);
    glm::vec2 mouse_delta_ = glm::vec2(0.0f);
    glm::vec2 mouse_scroll_delta_ = glm::vec2(0.0f);
};
} // namespace input
} // namespace pixelbullet