handle events

Author: jube

include/gf2/core/Event.h

@@ -5,7 +5,6 @@
 
 #include <cstdint>
 
-#include <array>
 #include <string_view>
 #include <variant>
 
@@ -174,24 +173,24 @@ namespace gf {
   struct GF_CORE_API MouseMovedEvent {
     WindowId window_id;
     MouseId mouse_id;
-    Vec2I position;
-    Vec2I motion;
+    Vec2F position;
+    Vec2F motion;
   };
 
   struct GF_CORE_API MouseButtonPressedEvent {
     WindowId window_id;
     MouseId mouse_id;
     MouseButton button;
-    Vec2F position;
     uint8_t clicks;
+    Vec2F position;
   };
 
   struct GF_CORE_API MouseButtonReleasedEvent {
     WindowId window_id;
     MouseId mouse_id;
     MouseButton button;
-    Vec2F position;
     uint8_t clicks;
+    Vec2F position;
   };
 
   struct GF_CORE_API MouseWheelScrolledEvent {

include/gf2/core/MouseTypes.h

@@ -5,9 +5,12 @@
 
 #include <cstdint>
 
+#include <limits>
+#include <type_traits>
+
 namespace gf {
 
-  enum class MouseButton : uint32_t { // NOLINT(performance-enum-size)
+  enum class MouseButton : uint8_t {
     None,
     Left,
     Middle,
@@ -18,13 +21,13 @@ namespace gf {
     Touch2,
   };
 
-  constexpr MouseButton AnyMouseButton = static_cast<MouseButton>(0xFFFFFFFF);
+  constexpr MouseButton AnyMouseButton = MouseButton{ std::numeric_limits<std::underlying_type_t<MouseButton>>::max() };
 
   enum class MouseId : uint32_t;
 
-  constexpr MouseId TouchMouseId = static_cast<MouseId>(0xFFFFFFFF);
+  constexpr MouseId TouchMouseId = MouseId{ std::numeric_limits<std::underlying_type_t<MouseId>>::max() };
 
-  enum class MouseWheelDirection : uint32_t { // NOLINT(performance-enum-size)
+  enum class MouseWheelDirection { // NOLINT(performance-enum-size)
     Normal,
     Flipped,
   };

include/gf2/core/TouchTypes.h

@@ -14,6 +14,13 @@ namespace gf {
 
   constexpr TouchId MouseTouchId = TouchId{ std::numeric_limits<std::underlying_type_t<TouchId>>::max() };
 
+  enum class TouchDeviceType { // NOLINT(performance-enum-size)
+    Invalid = -1,
+    Direct,
+    IndirectAbsolute,
+    IndirectRelative,
+  };
+
   enum class FingerId : uint64_t;
 
 } // namespace gf

include/gf2/graphics/Cursor.h

@@ -44,6 +44,8 @@ namespace gf {
     SDL_Cursor* m_cursor = nullptr;
   };
 
+  void capture_mouse(bool captured = true);
+
 }
 
 #endif // GF_CURSOR_H

include/gf2/graphics/Gamepad.h

@@ -47,13 +47,12 @@ namespace gf {
     void close();
 
   private:
-    friend class Gamepad;
+    friend struct Gamepad;
     GamepadDevice(SDL_Gamepad* gamepad);
     SDL_Gamepad* m_gamepad = nullptr;
   };
 
-  class GF_GRAPHICS_API Gamepad {
-  public:
+  struct GF_GRAPHICS_API Gamepad {
     static GamepadDevice open(GamepadId id);
     static GamepadDevice from_id(GamepadId id);
 

include/gf2/graphics/Keyboard.h

@@ -3,6 +3,9 @@
 #ifndef GF_KEYBOARD_H
 #define GF_KEYBOARD_H
 
+#include <tuple>
+
+#include <gf2/core/Flags.h>
 #include <gf2/core/Keycode.h>
 #include <gf2/core/Modifier.h>
 #include <gf2/core/Scancode.h>
@@ -18,8 +21,8 @@ namespace gf {
     static const char* keycode_name(Keycode keycode);
     static Keycode keycode_from_name(const char* name);
 
-    static Keycode localize(Scancode scancode);
-    static Scancode unlocalize(Keycode keycode);
+    static Keycode localize(Scancode scancode, Flags<Modifier> modifiers);
+    static std::tuple<Scancode, Flags<Modifier>> unlocalize(Keycode keycode);
   };
 
 } // namespace gf

library/graphics/Cursor.cc

@@ -79,7 +79,15 @@ namespace gf {
       return;
     }
 
+    // TODO: [SDL3] check return
     SDL_SetCursor(cursor->m_cursor);
   }
 
+  void capture_mouse(bool captured)
+  {
+    if (!SDL_CaptureMouse(captured)) {
+      Log::error("Failed to capture the mouse: {}", SDL_GetError());
+    }
+  }
+
 }

library/graphics/Keyboard.cc

@@ -3,12 +3,17 @@
 
 #include <gf2/graphics/Keyboard.h>
 
+#include <type_traits>
+
 #include <SDL3/SDL.h>
+#include "gf2/core/Modifier.h"
 
 namespace gf {
 
   namespace {
 
+    static_assert(std::is_same_v<std::underlying_type_t<Modifier>, SDL_Keymod>);
+
     template<Modifier Mod, SDL_Keymod Value>
     constexpr void modifier_check()
     {
@@ -493,14 +498,16 @@ namespace gf {
     return static_cast<Keycode>(SDL_GetKeyFromName(name));
   }
 
-  Keycode Keyboard::localize(Scancode scancode)
+  Keycode Keyboard::localize(Scancode scancode, Flags<Modifier> modifiers)
   {
-    return static_cast<Keycode>(SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(scancode), SDL_KMOD_NONE, true));
+    return static_cast<Keycode>(SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(scancode), modifiers.value(), true));
   }
 
-  Scancode Keyboard::unlocalize(Keycode keycode)
+  std::tuple<Scancode, Flags<Modifier>> Keyboard::unlocalize(Keycode keycode)
   {
-    return static_cast<Scancode>(SDL_GetScancodeFromKey(static_cast<SDL_Keycode>(keycode), nullptr));
+    SDL_Keymod modifiers = 0;
+    SDL_Scancode scancode = SDL_GetScancodeFromKey(static_cast<SDL_Keycode>(keycode), &modifiers);
+    return { static_cast<Scancode>(scancode), static_cast<Modifier>(modifiers) };
   }
 
 } // namespace gf

library/graphics/Mouse.cc

@@ -11,10 +11,14 @@ namespace gf {
 
   namespace {
 
-    template<MouseButton Button, uint32_t Value>
+    static_assert(std::is_same_v<std::underlying_type_t<MouseId>, SDL_MouseID>);
+    static_assert(std::is_same_v<std::underlying_type_t<MouseWheelDirection>, std::make_signed_t<SDL_MouseWheelDirection>>);
+    static_assert(TouchMouseId == static_cast<MouseId>(SDL_TOUCH_MOUSEID));
+
+    template<MouseButton Button, uint8_t Value>
     constexpr void mouse_button_check()
     {
-      static_assert(static_cast<uint32_t>(Button) == Value, "Check gf::Mouse");
+      static_assert(static_cast<uint8_t>(Button) == Value);
     }
 
     [[maybe_unused]] constexpr void mouse_check()
@@ -24,9 +28,6 @@ namespace gf {
       mouse_button_check<MouseButton::Right, SDL_BUTTON_RIGHT>();
       mouse_button_check<MouseButton::XButton1, SDL_BUTTON_X1>();
       mouse_button_check<MouseButton::XButton2, SDL_BUTTON_X2>();
-
-      static_assert(std::is_same_v<std::underlying_type_t<MouseId>, decltype(SDL_TOUCH_MOUSEID)>, "Check gf::Mouse");
-      static_assert(TouchMouseId == static_cast<MouseId>(SDL_TOUCH_MOUSEID), "Check gf::Mouse");
     }
 
   } // namespace

library/graphics/Touch.cc

@@ -2,7 +2,6 @@
 // Copyright (c) 2023-2025 Julien Bernard
 
 #include <type_traits>
-#include <utility>
 
 #include <SDL3/SDL.h>
 
@@ -11,13 +10,24 @@
 namespace gf {
 
   namespace {
+    static_assert(std::is_same_v<std::underlying_type_t<TouchId>, SDL_TouchID>);
+    static_assert(MouseTouchId == static_cast<TouchId>(SDL_MOUSE_TOUCHID));
+    static_assert(std::is_same_v<std::underlying_type_t<TouchDeviceType>, std::underlying_type_t<SDL_TouchDeviceType>>);
 
-    [[maybe_unused]] constexpr void touch_check()
+    static_assert(std::is_same_v<std::underlying_type_t<FingerId>, SDL_FingerID>);
+
+    template<TouchDeviceType Type, SDL_TouchDeviceType Value>
+    constexpr void touch_device_type_check()
     {
-      static_assert(std::is_same_v<std::underlying_type_t<TouchId>, decltype(SDL_MOUSE_TOUCHID)>);
-      static_assert(MouseTouchId == static_cast<TouchId>(SDL_MOUSE_TOUCHID));
+      static_assert(static_cast<SDL_TouchDeviceType>(Type) == Value);
+    }
 
-      static_assert(std::is_same_v<std::underlying_type_t<FingerId>, decltype(std::declval<SDL_Finger>().id)>);
+    [[maybe_unused]] constexpr void touch_check()
+    {
+      touch_device_type_check<TouchDeviceType::Invalid, SDL_TOUCH_DEVICE_INVALID>();
+      touch_device_type_check<TouchDeviceType::Direct, SDL_TOUCH_DEVICE_DIRECT>();
+      touch_device_type_check<TouchDeviceType::IndirectAbsolute, SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE>();
+      touch_device_type_check<TouchDeviceType::IndirectRelative, SDL_TOUCH_DEVICE_INDIRECT_RELATIVE>();
     }
 
   } // namespace