InputEvent.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Platform/Forward.hpp"
 
#include "Input.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/Variant.hpp"
 
#include "CeresEngine/Math/Vector.hpp"
 
namespace CeresEngine {
 
    enum class InputEventType {
        Key,
 
        Mouse,
 
        Text
    };
 
    struct InputEvent {
        double timestamp = 0.0;
 
        PlatformWindow* window = nullptr;
    };
 
    enum class KeyEventType {
        Down,
 
        Up
    };
 
    struct KeyEvent final : public InputEvent {
        static constexpr inline InputEventType structType = InputEventType::Key;
 
        KeyEventType type;
 
        Button button = Button::None;
 
        ModifierButton modifiers;
 
        bool isRepeat = false;
 
        UInt32 repeatCount = 0;
 
        UInt32 scanCode = 0;
    };
 
    enum class MouseEventType {
        Down,
 
        Up,
 
        Move,
 
        Drag,
 
        Scroll
    };
 
    struct MouseEvent final : public InputEvent {
        static constexpr inline InputEventType structType = InputEventType::Mouse;
 
        MouseEventType type;
 
        Button button = Button::None;
 
        ModifierButton modifiers = ModifierButton::None;
 
        Vector2 position;
 
        Vector2 delta;
 
        Vector2 scrollAmount;
    };
 
    struct TextEvent final : public InputEvent {
        static constexpr inline InputEventType structType = InputEventType::Text;
 
        String characters;
    };
 
    class AnyInputEvent {
    private:
        using Variant = Variant<std::monostate, KeyEvent, MouseEvent, TextEvent>;
 
        Variant mData;
 
    public:
        AnyInputEvent() noexcept = default;
 
        CE_EXPLICIT(false) AnyInputEvent(const KeyEvent& event) noexcept : mData(event) {}
 
        CE_EXPLICIT(false) AnyInputEvent(const MouseEvent& event) noexcept : mData(event) {}
 
        CE_EXPLICIT(false) AnyInputEvent(const TextEvent& event) noexcept : mData(event) {}
 
        AnyInputEvent(const AnyInputEvent&) = default;
        AnyInputEvent& operator=(const AnyInputEvent&) = default;
 
        AnyInputEvent(AnyInputEvent&&) noexcept = default;
        AnyInputEvent& operator=(AnyInputEvent&&) noexcept = default;
 
        ~AnyInputEvent() noexcept = default;
 
    public: // Common Data
        [[nodiscard]] PlatformWindow* getWindow() const noexcept;
 
    public: // Casting
        [[nodiscard]] bool isValid() const noexcept;
 
        [[nodiscard]] explicit operator bool() const noexcept { return isValid(); }
 
        [[nodiscard]] InputEventType getEventType() const noexcept;
 
        template<typename T> [[nodiscard]] bool is() const noexcept { return getEventType() == T::structType; }
 
        template<typename T> [[nodiscard]] const T& as() const noexcept {
            assert(getEventType() == T::structType);
            return mData.as<T>();
        }
 
        template<typename T> [[nodiscard]] T& as() noexcept {
            assert(getEventType() == T::structType);
            return mData.as<T>();
        }
 
    public: // KeyEvent
        [[nodiscard]] bool isKeyEvent() const noexcept { return is<KeyEvent>(); }
 
        [[nodiscard]] const KeyEvent& asKeyEvent() const noexcept { return as<KeyEvent>(); }
 
        [[nodiscard]] KeyEvent& asKeyEvent() noexcept { return as<KeyEvent>(); };
 
    public: // MouseEvent
        [[nodiscard]] bool isMouseEvent() const noexcept { return is<MouseEvent>(); }
 
        [[nodiscard]] const MouseEvent& asMouseEvent() const noexcept { return as<MouseEvent>(); }
 
        [[nodiscard]] MouseEvent& asMouseEvent() noexcept { return as<MouseEvent>(); };
 
    public: // TextEvent
        [[nodiscard]] bool isTextEvent() const noexcept { return is<TextEvent>(); }
 
        [[nodiscard]] const TextEvent& asTextEvent() const noexcept { return as<TextEvent>(); }
 
        [[nodiscard]] TextEvent& asTextEvent() noexcept { return as<TextEvent>(); };
    };
 
} // namespace CeresEngine