foray_event.hpp

Go to the documentation of this file.

#pragma once
#include "../foray_basics.hpp"
#include "../foray_vulkan.hpp"
#include "foray_helpers.hpp"
#include "foray_input.hpp"
#include "foray_osi_declares.hpp"
#include <memory>
#include <sdl2/SDL.h>
 
namespace foray::osi {
    class Event : public Polymorphic
    {
      public:
        enum class EType : int16_t
        {
            Undefined = -1,
            InputAnalogue,
            InputBinary,
            InputDirectional,
            InputMouseMoved,
            WindowResized,
            WindowFocusChanged,
            WindowCloseRequested,
            WindowItemDropped,
            InputDeviceAvailability,
            Custom,
            ENUM_MAX
        };
 
        inline Event() = default;
        inline Event(Window* const source, const uint32_t timestamp, const EType type) : Source(source), Timestamp(timestamp), Type(type), CustomType(0) {}
        inline Event(Window* const source, const uint32_t timestamp, const int8_t customtype) : Source(source), Timestamp(timestamp), Type(EType::Custom), CustomType(customtype) {}
        inline virtual ~Event() {}
 
        Window* Source = nullptr;
        uint32_t Timestamp = 0;
        EType Type = EType::Undefined;
        int16_t CustomType = 0;
        SDL_Event RawSdlEventData = {};
    };
 
    class EventInput : public Event
    {
      public:
        inline EventInput() = default;
        inline EventInput(Window* const source, const uint32_t timestamp, const EType type, InputDevice* const device) : Event(source, timestamp, type), SourceDevice(device) {}
 
        InputDevice* SourceDevice = nullptr;
    };
 
    class EventInputDeviceAvailability : public EventInput
    {
      public:
        inline EventInputDeviceAvailability(const uint32_t timestamp, InputDevice* const device, const bool added)
            : EventInput(nullptr, timestamp, Event::EType::InputDeviceAvailability, device), Added(added)
        {
        }
 
        bool Added = false;
    };
 
    class EventInputAnalogue : public EventInput
    {
      public:
        inline EventInputAnalogue() = default;
        inline EventInputAnalogue(Window* const source, const uint32_t timestamp, InputDevice* device, const InputAnalogue* axis, int16_t current)
            : EventInput(source, timestamp, EType::InputAnalogue, device), SourceInput(axis), State(current)
        {
        }
 
        const InputAnalogue* SourceInput = nullptr;
        int16_t State = 0;
    };
 
    class EventInputBinary : public EventInput
    {
      public:
        inline EventInputBinary() = default;
        inline EventInputBinary(Window* const source, const uint32_t timestamp, InputDevice* device, const InputBinary* button, bool pressed)
            : EventInput(source, timestamp, EType::InputBinary, device), SourceInput(button), State(pressed)
        {
        }
 
        const InputBinary* SourceInput = nullptr;
        bool State = 0;
    };
 
    class EventInputDirectional : public EventInput
    {
      public:
        inline EventInputDirectional() = default;
        inline EventInputDirectional(Window* const source, const uint32_t timestamp, InputDevice* device, const InputDirectional* inputsource, int32_t offsetX, int32_t offsetY)
            : EventInput(source, timestamp, EType::InputBinary, device), SourceInput(inputsource), OffsetX(offsetX), OffsetY(offsetY)
        {
        }
 
        const InputDirectional* SourceInput = nullptr;
        int32_t OffsetX = 0;
        int32_t OffsetY = 0;
    };
 
    class EventInputMouseMoved : public EventInput
    {
      public:
        inline EventInputMouseMoved() = default;
        inline EventInputMouseMoved(Window* const source, const uint32_t timestamp, InputDevice* const device, fp32_t currentx, fp32_t currenty, fp32_t relativeX, fp32_t relativeY)
            : EventInput(source, timestamp, EType::InputMouseMoved, device), CurrentX(currentx), CurrentY(currenty), RelativeX(relativeX), RelativeY(relativeY)
        {
        }
 
        fp32_t CurrentX = 0.f;
        fp32_t CurrentY = 0.f;
        fp32_t RelativeX = 0.f;
        fp32_t RelativeY = 0.f;
    };
 
    class EventWindowResized : public Event
    {
      public:
        inline EventWindowResized() = default;
        inline EventWindowResized(Window* const source, const uint32_t timestamp, VkExtent2D current) : Event(source, timestamp, EType::WindowResized), Current(current) {}
 
        VkExtent2D Current = {};
    };
 
    class EventWindowFocusChanged : public Event
    {
      public:
        inline EventWindowFocusChanged() = default;
        inline EventWindowFocusChanged(Window* source, const uint32_t timestamp, bool mouseFocus, bool inputFocus)
            : Event(source, timestamp, EType::WindowFocusChanged), MouseFocus(mouseFocus), InputFocus(inputFocus)
        {
        }
 
        bool MouseFocus = false;
        bool InputFocus = false;
    };
 
    class EventWindowCloseRequested : public Event
    {
      public:
        inline EventWindowCloseRequested() = default;
        inline EventWindowCloseRequested(Window* const source, const uint32_t timestamp) : Event(source, timestamp, EType::WindowCloseRequested) {}
    };
}  // namespace foray