Event.h

Go to the documentation of this file.

#pragma once

 
#include <quasar/core/Base.h>
 
#include <cstdint>
#include <string>
#include <type_traits>
 
namespace Quasar
{
    enum class EventType : std::uint8_t
    {
        WindowClose,         
        WindowResize,        
        WindowFocus,         
        WindowMinimize,      
        KeyPressed,          
        KeyReleased,         
        KeyTyped,            
        MouseButtonPressed,  
        MouseButtonReleased, 
        MouseMoved,          
        MouseScrolled        
    };

    enum class EventCategory : std::uint8_t
    {
        None = 0,          
        Window = Bit(0),   
        Input = Bit(1),    
        Keyboard = Bit(2), 
        Mouse = Bit(3)     
    };

    constexpr EventCategory operator|(EventCategory left, EventCategory right)
    {
        using Underlying = std::underlying_type_t<EventCategory>;
        return static_cast<EventCategory>(static_cast<Underlying>(left) | static_cast<Underlying>(right));
    }

    constexpr EventCategory operator&(EventCategory left, EventCategory right)
    {
        using Underlying = std::underlying_type_t<EventCategory>;
        return static_cast<EventCategory>(static_cast<Underlying>(left) & static_cast<Underlying>(right));
    }

    constexpr const char* GetEventTypeName(EventType type)
    {
        switch (type)
        {
            case EventType::WindowClose:
                return "WindowClose";
            case EventType::WindowResize:
                return "WindowResize";
            case EventType::WindowFocus:
                return "WindowFocus";
            case EventType::WindowMinimize:
                return "WindowMinimize";
            case EventType::KeyPressed:
                return "KeyPressed";
            case EventType::KeyReleased:
                return "KeyReleased";
            case EventType::KeyTyped:
                return "KeyTyped";
            case EventType::MouseButtonPressed:
                return "MouseButtonPressed";
            case EventType::MouseButtonReleased:
                return "MouseButtonReleased";
            case EventType::MouseMoved:
                return "MouseMoved";
            case EventType::MouseScrolled:
                return "MouseScrolled";
        }
        return "Unknown";
    }

    class Event
    {
    public:
        virtual ~Event() = default;

        virtual EventType GetType() const = 0;

        virtual EventCategory GetCategories() const = 0;

        virtual std::string ToString() const { return GetName(); }

        const char* GetName() const { return GetEventTypeName(GetType()); }

        bool IsInCategory(EventCategory category) const { return (GetCategories() & category) != EventCategory::None; }

        bool IsHandled() const { return m_Handled; }

        void SetHandled(bool handled) { m_Handled = handled; }
 
    protected:
        Event() = default;

        Event(const Event&) = default;
        Event& operator=(const Event&) = default;
        Event(Event&&) = default;
        Event& operator=(Event&&) = default;
 
    private:
        bool m_Handled = false;
    };

    template <EventType Type, EventCategory Categories>
    class EventOf : public Event
    {
    public:
        static constexpr EventType GetStaticType() { return Type; }

        EventType GetType() const override { return Type; }

        EventCategory GetCategories() const override { return Categories; }
    };

    inline std::string format_as(const Event& event)
    {
        return event.ToString();
    }
}