Use system-native cursor for custom cursor (#3343)

* Use system-specific cursor for custom cursor

Currently, the game draws the cursor as it's own sprite. This is fine in most cases, however, this will cause input lag when the user moves their cursor. This is because the sprite cursor is drawn on every flip, which may lag behind.

The OS (which SDL interfaces) has it's own cursor api, and therefore is preferred, since that sets the display systems physical cursor instead of rendering our own.

* Error handling

* Reset custom cursor when disabled

* Disable by default

Author: swagtoy

src/gui/mousecursor.cpp

@@ -17,12 +17,18 @@
 #include "gui/mousecursor.hpp"
 
 #include <SDL.h>
+#include <SDL_error.h>
+#include <SDL_events.h>
+#include <SDL_mouse.h>
+#include <memory>
 
 #include "supertux/gameconfig.hpp"
 #include "supertux/globals.hpp"
 #include "sprite/sprite.hpp"
+#include "util/log.hpp"
 #include "video/drawing_context.hpp"
 #include "video/renderer.hpp"
+#include "video/sdl_surface.hpp"
 #include "video/surface.hpp"
 #include "video/video_system.hpp"
 #include "video/viewport.hpp"
@@ -33,13 +39,49 @@ MouseCursor::MouseCursor(SpritePtr sprite) :
   m_state(MouseCursorState::NORMAL),
   m_applied_state(MouseCursorState::HIDE),
   m_sprite(std::move(sprite)),
+  m_custom_cursor_last(false),
+  m_cursors(),
   m_x(),
   m_y(),
   m_mobile_mode(false),
   m_icon()
 {
 }
 
+void
+MouseCursor::set_cursor_action(const std::string& action)
+{
+  if (!g_config->custom_system_cursor)
+  {
+    m_sprite->set_action(action);
+    return;
+  }
+
+  if (m_cursors.find(action) == m_cursors.end())
+  {
+    auto surfaces = m_sprite->get_action_surfaces(action);
+    if (surfaces->empty())
+      return;
+    std::string filename = (*surfaces)[0]->get_filename();
+    SDLSurfacePtr surface = SDLSurface::from_file(filename);
+    m_cursors[action] = 
+      std::move(std::shared_ptr<SDL_Cursor>(SDL_CreateColorCursor(surface.get(), 0, 0), &SDL_FreeCursor));
+    if (m_cursors[action])
+    {
+      SDL_SetCursor(m_cursors[action].get());
+    }
+    else
+    {
+      log_warning << "Couldn't load cursor: " << SDL_GetError() << "\nRendering cursor instead.\n";
+      g_config->custom_system_cursor = false;
+    }
+  }
+  else
+  {
+    SDL_SetCursor(m_cursors[action].get());
+  }
+}
+
 void
 MouseCursor::apply_state(MouseCursorState state)
 {
@@ -50,18 +92,20 @@ MouseCursor::apply_state(MouseCursorState state)
     switch(state)
     {
       case MouseCursorState::NORMAL:
-        m_sprite->set_action("default");
+        set_cursor_action("default");
         break;
 
       case MouseCursorState::CLICK:
-        m_sprite->set_action("click");
+        set_cursor_action("click");
         break;
 
       case MouseCursorState::LINK:
-        m_sprite->set_action("link");
+        set_cursor_action("link");
         break;
 
       case MouseCursorState::HIDE:
+        if (g_config->custom_system_cursor)
+          SDL_ShowCursor(SDL_DISABLE);
         break;
     }
   }
@@ -70,11 +114,28 @@ MouseCursor::apply_state(MouseCursorState state)
 void
 MouseCursor::draw(DrawingContext& context)
 {
-  if (!g_config->custom_mouse_cursor) return;
+  if (!g_config->custom_mouse_cursor)
+  {
+    if (m_custom_cursor_last)
+    {
+      SDL_Cursor* default_cursor = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
+      if (default_cursor)
+        SDL_SetCursor(default_cursor);
+      SDL_FreeCursor(default_cursor);
+      m_custom_cursor_last = false;
+    }
+    return;
+  }
+  
   if (m_state != MouseCursorState::HIDE)
   {
     int x, y;
     Uint32 ispressed = SDL_GetMouseState(&x, &y);
+    
+    if (g_config->custom_system_cursor && SDL_ShowCursor(SDL_QUERY) == SDL_DISABLE)
+    {
+      SDL_ShowCursor(SDL_ENABLE);
+    }
 
     if (m_mobile_mode)
     {
@@ -93,7 +154,8 @@ MouseCursor::draw(DrawingContext& context)
 
     Vector mouse_pos = VideoSystem::current()->get_viewport().to_logical(x, y);
 
-    m_sprite->draw(context.color(), mouse_pos, LAYER_GUI + 100);
+    if (!g_config->custom_system_cursor)
+      m_sprite->draw(context.color(), mouse_pos, LAYER_GUI + 100);
 
     if (m_icon) {
       context.color().draw_surface(m_icon,
@@ -102,4 +164,6 @@ MouseCursor::draw(DrawingContext& context)
                                    LAYER_GUI + 100);
     }
   }
+  
+  m_custom_cursor_last = g_config->custom_mouse_cursor;
 }

src/gui/mousecursor.hpp

@@ -16,7 +16,9 @@
 
 #pragma once
 
+#include <SDL_mouse.h>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "config.h"
@@ -60,6 +62,7 @@ class MouseCursor final : public Currenton<MouseCursor>
 
 private:
   void apply_state(MouseCursorState state);
+  void set_cursor_action(const std::string& action);
 
 private:
   MouseCursorState m_state;
@@ -68,6 +71,9 @@ class MouseCursor final : public Currenton<MouseCursor>
   int m_x, m_y;
   bool m_mobile_mode;
   SurfacePtr m_icon;
+  bool m_custom_cursor_last;
+  
+  std::unordered_map<std::string, std::shared_ptr<SDL_Cursor>> m_cursors;
 
 private:
   MouseCursor(const MouseCursor&) = delete;

src/supertux/gameconfig.cpp

@@ -79,6 +79,7 @@ Config::Config() :
   confirmation_dialog(false),
   pause_on_focusloss(true),
   custom_mouse_cursor(true),
+  custom_system_cursor(false),
   do_release_check(false),
   disable_network(true),
   custom_title_levels(true),
@@ -152,6 +153,7 @@ Config::load()
   config_mapping.get("confirmation_dialog", confirmation_dialog);
   config_mapping.get("pause_on_focusloss", pause_on_focusloss);
   config_mapping.get("custom_mouse_cursor", custom_mouse_cursor);
+  config_mapping.get("custom_system_cursor", custom_system_cursor);
   config_mapping.get("do_release_check", do_release_check);
   config_mapping.get("disable_network", disable_network);
   config_mapping.get("custom_title_levels", custom_title_levels);
@@ -373,6 +375,7 @@ Config::save()
   writer.write("confirmation_dialog", confirmation_dialog);
   writer.write("pause_on_focusloss", pause_on_focusloss);
   writer.write("custom_mouse_cursor", custom_mouse_cursor);
+  writer.write("custom_system_cursor", custom_system_cursor);
   writer.write("do_release_check", do_release_check);
   writer.write("disable_network", disable_network);
   writer.write("custom_title_levels", custom_title_levels);

src/supertux/gameconfig.hpp

@@ -111,6 +111,7 @@ class Config final
   bool confirmation_dialog;
   bool pause_on_focusloss;
   bool custom_mouse_cursor;
+  bool custom_system_cursor;
   bool do_release_check;
   bool disable_network;
   bool custom_title_levels;

src/supertux/main.cpp

@@ -465,7 +465,8 @@ Main::init_video()
   SDLSurfacePtr icon = SDLSurface::from_file(icon_fname);
   VideoSystem::current()->set_icon(*icon);
 
-  SDL_ShowCursor(g_config->custom_mouse_cursor ? 0 : 1);
+  SDL_ShowCursor(
+    (g_config->custom_mouse_cursor && !g_config->custom_system_cursor) ? SDL_DISABLE : SDL_ENABLE);
 
   log_info << (g_config->use_fullscreen?"fullscreen ":"window ")
            << " Window: "     << g_config->window_size

src/supertux/menu/options_menu.cpp

@@ -227,6 +227,8 @@ OptionsMenu::refresh()
         .set_help(_("Automatically pause the game when the window loses focus"));
 
       add_toggle(MNID_CUSTOM_CURSOR, _("Use custom mouse cursor"), &g_config->custom_mouse_cursor).set_help(_("Whether the game renders its own cursor or uses the system's cursor"));
+      
+      add_toggle(MNID_CUSTOM_CURSOR, _("Use native custom cursor"), &g_config->custom_system_cursor).set_help(_("Whether the game uses a native custom cursor or renders it in the game"));
 
 #ifndef __EMSCRIPTEN__
       if (!g_config->disable_network)