gosu 1.1.1.1 → 1.4.1

data/src/Window.cpp

@@ -2,16 +2,15 @@
 #if !defined(GOSU_IS_IPHONE)
 
 #if defined(GOSU_IS_WIN)
+#define NOMINMAX
 #include <windows.h>
 #endif
 
 #include <Gosu/Gosu.hpp>
 #include "GraphicsImpl.hpp"
 #include <SDL.h>
-#include <cstdlib>
 #include <algorithm>
 #include <stdexcept>
-using namespace std;
 
 namespace Gosu
 {
@@ -20,14 +19,15 @@ namespace Gosu
         void register_frame();
     }
 
-    static void throw_sdl_error(const string& operation)
+    [[noreturn]] static void throw_sdl_error(const std::string& operation)
     {
         const char* error = SDL_GetError();
-        throw runtime_error(operation + ": " + (error ? error : "(unknown error)"));
+        throw std::runtime_error{operation + ": " + (error ? error : "(unknown error)")};
     }
 
     SDL_Window* shared_window()
     {
+        // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
         static SDL_Window* window = nullptr;
         if (window == nullptr) {
             if (SDL_Init(SDL_INIT_VIDEO) < 0) {
@@ -36,8 +36,8 @@ namespace Gosu
 
             Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN | SDL_WINDOW_ALLOW_HIGHDPI;
 
-            window =
-                SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 64, 64, flags);
+            window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 64, 64,
+                                      flags);
             if (window == nullptr) {
                 throw_sdl_error("Could not create window");
             }
@@ -50,10 +50,10 @@ namespace Gosu
     {
         static SDL_GLContext context = nullptr;
         if (context == nullptr) {
-        #ifdef GOSU_IS_OPENGLES
+#ifdef GOSU_IS_OPENGLES
             SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
             SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
-        #endif
+#endif
 
             context = SDL_GL_CreateContext(shared_window());
 
@@ -64,36 +64,41 @@ namespace Gosu
         return context;
     }
 
-    void ensure_current_context()
+    void ensure_current_context() //
     {
         SDL_GL_MakeCurrent(shared_window(), shared_gl_context());
     }
 }
 
-struct Gosu::Window::Impl
+struct Gosu::Window::Impl : Gosu::Noncopyable
 {
-    bool fullscreen;
-    double update_interval;
-    bool resizable;
+    bool fullscreen = false;
+    double update_interval = 0;
+    bool resizable = false;
     bool resizing = false;
 
     // A single `bool open` is not good enough to support the tick() method: When close() is called
     // from outside the window's call graph, the next call to tick() must return false (transition
-    // from CLOSING to CLOSED), but the call after that must return show the window again
-    // (transition from CLOSED to OPEN).
-    enum { CLOSED, OPEN, CLOSING } state = CLOSED;
+    // from CLOSING to CLOSED), but the call after that must show the window again (transition from
+    // CLOSED to OPEN).
+    enum
+    {
+        CLOSED,
+        OPEN,
+        CLOSING
+    } state = CLOSED;
 
-    unique_ptr<Graphics> graphics;
-    unique_ptr<Input> input;
+    std::unique_ptr<Graphics> graphics;
+    std::unique_ptr<Input> input;
 };
 
 Gosu::Window::Window(int width, int height, unsigned window_flags, double update_interval)
-: pimpl(new Impl)
+: m_impl(new Impl)
 {
     set_borderless(window_flags & WF_BORDERLESS);
     set_resizable(window_flags & WF_RESIZABLE);
 
-    // Even in fullscreen mode, temporarily show the window in windowed mode to centre it.
+    // Even in fullscreen mode, temporarily show the window in windowed mode to center it.
     // This ensures that the window will be centered correctly when exiting fullscreen mode.
     // Fixes https://github.com/gosu/gosu/issues/369
     // (This will implicitly create graphics() and input(), and make the OpenGL context current.)
@@ -105,11 +110,11 @@ Gosu::Window::Window(int width, int height, unsigned window_flags, double update
 
     SDL_GL_SetSwapInterval(1);
 
-    pimpl->update_interval = update_interval;
+    m_impl->update_interval = update_interval;
 
     input().on_button_down = [this](Button button) { button_down(button); };
-    input().on_button_up   = [this](Button button) { button_up(button); };
-    input().on_gamepad_connected    = [this](int index) { gamepad_connected(index); };
+    input().on_button_up = [this](Button button) { button_up(button); };
+    input().on_gamepad_connected = [this](int index) { gamepad_connected(index); };
     input().on_gamepad_disconnected = [this](int index) { gamepad_disconnected(index); };
 }
 
@@ -130,12 +135,12 @@ int Gosu::Window::height() const
 
 bool Gosu::Window::fullscreen() const
 {
-    return pimpl->fullscreen;
+    return m_impl->fullscreen;
 }
 
 void Gosu::Window::resize(int width, int height, bool fullscreen)
 {
-    pimpl->fullscreen = fullscreen;
+    m_impl->fullscreen = fullscreen;
 
     int actual_width = width;
     int actual_height = height;
@@ -144,19 +149,19 @@ void Gosu::Window::resize(int width, int height, bool fullscreen)
     double black_bar_height = 0;
 
     if (fullscreen) {
-        actual_width  = Gosu::screen_width(this);
+        actual_width = Gosu::screen_width(this);
         actual_height = Gosu::screen_height(this);
 
         if (resizable()) {
             // Resizable fullscreen windows stubbornly follow the desktop resolution.
-            width  = actual_width;
+            width = actual_width;
             height = actual_height;
         }
         else {
             // Scale the window to fill the desktop resolution.
             double scale_x = 1.0 * actual_width / width;
             double scale_y = 1.0 * actual_height / height;
-            scale_factor = min(scale_x, scale_y);
+            scale_factor = std::min(scale_x, scale_y);
             // Add black bars to preserve the aspect ratio, if necessary.
             if (scale_x < scale_y) {
                 black_bar_height = (actual_height / scale_x - height) / 2;
@@ -167,24 +172,24 @@ void Gosu::Window::resize(int width, int height, bool fullscreen)
         }
     }
     else {
-        int max_width  = Gosu::available_width(this);
+        int max_width = Gosu::available_width(this);
         int max_height = Gosu::available_height(this);
 
         if (resizable()) {
             // If the window is resizable, limit its size, without preserving the aspect ratio.
-            width  = actual_width  = min(width,  max_width);
-            height = actual_height = min(height, max_height);
+            width = actual_width = std::min(width, max_width);
+            height = actual_height = std::min(height, max_height);
         }
         else if (width > max_width || height > max_height) {
             // If the window cannot fit on the screen, shrink its contents.
-            scale_factor = min(1.0 * max_width / width, 1.0 * max_height / height);
-            actual_width  = width  * scale_factor;
-            actual_height = height * scale_factor;
+            scale_factor = std::min(1.0 * max_width / width, 1.0 * max_height / height);
+            actual_width = static_cast<int>(width * scale_factor);
+            actual_height = static_cast<int>(height * scale_factor);
         }
     }
 
     SDL_SetWindowFullscreen(shared_window(), fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
-    if (!pimpl->resizing) {
+    if (!m_impl->resizing) {
         SDL_SetWindowSize(shared_window(), actual_width, actual_height);
     }
 
@@ -192,37 +197,39 @@ void Gosu::Window::resize(int width, int height, bool fullscreen)
 
     ensure_current_context();
 
-    if (!pimpl->graphics) {
-        pimpl->graphics.reset(new Graphics(actual_width, actual_height));
+    if (!m_impl->graphics) {
+        m_impl->graphics.reset(new Graphics(actual_width, actual_height));
     }
     else {
-        pimpl->graphics->set_physical_resolution(actual_width, actual_height);
+        m_impl->graphics->set_physical_resolution(actual_width, actual_height);
     }
-    pimpl->graphics->set_resolution(width, height, black_bar_width, black_bar_height);
+    m_impl->graphics->set_resolution(width, height, black_bar_width, black_bar_height);
 
-    if (!pimpl->input) {
-        pimpl->input.reset(new Input(shared_window()));
+    if (!m_impl->input) {
+        m_impl->input.reset(new Input(shared_window()));
     }
-    pimpl->input->set_mouse_factors(1 / scale_factor, 1 / scale_factor,
-                                    black_bar_width, black_bar_height);
+    m_impl->input->set_mouse_factors(1 / scale_factor, 1 / scale_factor, black_bar_width,
+                                     black_bar_height);
 }
 
 bool Gosu::Window::resizable() const
 {
-    return pimpl->resizable;
+    return m_impl->resizable;
 }
 
 void Gosu::Window::set_resizable(bool resizable)
 {
-    pimpl->resizable = resizable;
+    m_impl->resizable = resizable;
     SDL_SetWindowResizable(shared_window(), resizable ? SDL_TRUE : SDL_FALSE);
 }
 
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
 bool Gosu::Window::borderless() const
 {
     return SDL_GetWindowFlags(shared_window()) & SDL_WINDOW_BORDERLESS;
 }
 
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
 void Gosu::Window::set_borderless(bool borderless)
 {
     SDL_SetWindowBordered(shared_window(), borderless ? SDL_FALSE : SDL_TRUE);
@@ -230,21 +237,23 @@ void Gosu::Window::set_borderless(bool borderless)
 
 double Gosu::Window::update_interval() const
 {
-    return pimpl->update_interval;
+    return m_impl->update_interval;
 }
 
 void Gosu::Window::set_update_interval(double update_interval)
 {
-    pimpl->update_interval = update_interval;
+    m_impl->update_interval = update_interval;
 }
 
-string Gosu::Window::caption() const
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
+std::string Gosu::Window::caption() const
 {
     const char* title = SDL_GetWindowTitle(shared_window());
     return title ? title : "";
 }
 
-void Gosu::Window::set_caption(const string& caption)
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
+void Gosu::Window::set_caption(const std::string& caption)
 {
     SDL_SetWindowTitle(shared_window(), caption.c_str());
 }
@@ -264,16 +273,17 @@ void Gosu::Window::show()
         while (tick()) {
             // Sleep to keep this loop from eating 100% CPU.
             unsigned long tick_time = milliseconds() - time_before_tick;
-            if (tick_time < update_interval()) {
-                sleep(update_interval() - tick_time);
+            double sleep_time = update_interval() - tick_time;
+            if (sleep_time >= 1) {
+                sleep(static_cast<unsigned long>(sleep_time));
             }
 
             time_before_tick = milliseconds();
         }
     } catch (...) {
-    #ifdef GOSU_IS_WIN
+#ifdef GOSU_IS_WIN
         if (previous_affinity) SetThreadAffinityMask(GetCurrentThread(), previous_affinity);
-    #endif
+#endif
         throw;
     }
 
@@ -281,19 +291,19 @@ void Gosu::Window::show()
     if (previous_affinity) SetThreadAffinityMask(GetCurrentThread(), previous_affinity);
 #endif
 
-    pimpl->state = Impl::CLOSED;
+    m_impl->state = Impl::CLOSED;
 }
 
 bool Gosu::Window::tick()
 {
-    if (pimpl->state == Impl::CLOSING) {
-        pimpl->state = Impl::CLOSED;
+    if (m_impl->state == Impl::CLOSING) {
+        m_impl->state = Impl::CLOSED;
         return false;
     }
 
-    if (pimpl->state == Impl::CLOSED) {
+    if (m_impl->state == Impl::CLOSED) {
         SDL_ShowWindow(shared_window());
-        pimpl->state = Impl::OPEN;
+        m_impl->state = Impl::OPEN;
 
         // SDL_GL_GetDrawableSize returns different values before and after showing the window.
         // -> When first showing the window, update the physical size of Graphics (=glViewport).
@@ -305,18 +315,26 @@ bool Gosu::Window::tick()
 
     SDL_Event e;
     while (SDL_PollEvent(&e)) {
-
         switch (e.type) {
             case SDL_WINDOWEVENT: {
                 switch (e.window.event) {
                     case SDL_WINDOWEVENT_SIZE_CHANGED: {
-                        if (pimpl->resizable && (width() != e.window.data1 || height() != e.window.data2)) {
-                            pimpl->resizing = true;
+                        if (m_impl->resizable &&
+                            (width() != e.window.data1 || height() != e.window.data2)) {
+                            m_impl->resizing = true;
                             resize(e.window.data1, e.window.data2, fullscreen());
-                            pimpl->resizing = false;
+                            m_impl->resizing = false;
                         }
                         break;
                     }
+                    case SDL_WINDOWEVENT_FOCUS_GAINED: {
+                        gain_focus();
+                        break;
+                    }
+                    case SDL_WINDOWEVENT_FOCUS_LOST: {
+                        lose_focus();
+                        break;
+                    }
                     default: {
                         break;
                     }
@@ -328,10 +346,9 @@ bool Gosu::Window::tick()
                 break;
             }
             case SDL_DROPFILE: {
-                char* dropped_filedir = e.drop.file;
-                if (dropped_filedir == nullptr) break;
-                drop(string(dropped_filedir));
-                SDL_free(dropped_filedir);
+                std::shared_ptr<char> dropped_file{e.drop.file, SDL_free};
+                if (dropped_file == nullptr) break;
+                drop(dropped_file.get());
                 break;
             }
             default: {
@@ -359,16 +376,16 @@ bool Gosu::Window::tick()
         SDL_GL_SwapWindow(shared_window());
     }
 
-    if (pimpl->state == Impl::CLOSING) {
-        pimpl->state = Impl::CLOSED;
+    if (m_impl->state == Impl::CLOSING) {
+        m_impl->state = Impl::CLOSED;
     }
 
-    return pimpl->state == Impl::OPEN;
+    return m_impl->state == Impl::OPEN;
 }
 
 void Gosu::Window::close()
 {
-    pimpl->state = Impl::CLOSING;
+    m_impl->state = Impl::CLOSING;
     SDL_HideWindow(shared_window());
 }
 
@@ -381,23 +398,23 @@ void Gosu::Window::button_down(Button button)
 #ifdef GOSU_IS_MAC
     // cmd+F and cmd+ctrl+F are both common shortcuts for toggling fullscreen mode on macOS.
     toggle_fullscreen = button == KB_F &&
-        (Input::down(KB_LEFT_META) || Input::down(KB_RIGHT_META)) &&
-        !Input::down(KB_LEFT_SHIFT) && !Input::down(KB_RIGHT_SHIFT) &&
-        !Input::down(KB_LEFT_ALT) && !Input::down(KB_RIGHT_ALT);
+                        (Input::down(KB_LEFT_META) || Input::down(KB_RIGHT_META)) &&
+                        !Input::down(KB_LEFT_SHIFT) && !Input::down(KB_RIGHT_SHIFT) &&
+                        !Input::down(KB_LEFT_ALT) && !Input::down(KB_RIGHT_ALT);
 #else
     // Alt+Enter and Alt+Return toggle fullscreen mode on all other platforms.
     toggle_fullscreen = (button == KB_RETURN || button == KB_ENTER) &&
-        (Input::down(KB_LEFT_ALT)     || Input::down(KB_RIGHT_ALT)) &&
-        !Input::down(KB_LEFT_CONTROL) && !Input::down(KB_RIGHT_CONTROL) &&
-        !Input::down(KB_LEFT_META)    && !Input::down(KB_RIGHT_META) &&
-        !Input::down(KB_LEFT_SHIFT)   && !Input::down(KB_RIGHT_SHIFT);
+                        (Input::down(KB_LEFT_ALT) || Input::down(KB_RIGHT_ALT)) &&
+                        !Input::down(KB_LEFT_CONTROL) && !Input::down(KB_RIGHT_CONTROL) &&
+                        !Input::down(KB_LEFT_META) && !Input::down(KB_RIGHT_META) &&
+                        !Input::down(KB_LEFT_SHIFT) && !Input::down(KB_RIGHT_SHIFT);
 #endif
     // F11 is supported as a shortcut for fullscreen mode on all platforms.
-    if (!toggle_fullscreen && button == KB_F11 &&
-        !Input::down(KB_LEFT_ALT)     && !Input::down(KB_RIGHT_ALT) &&
-        !Input::down(KB_LEFT_CONTROL) && !Input::down(KB_RIGHT_CONTROL) &&
-        !Input::down(KB_LEFT_META)    && !Input::down(KB_RIGHT_META) &&
-        !Input::down(KB_LEFT_SHIFT)   && !Input::down(KB_RIGHT_SHIFT)) {
+    if (!toggle_fullscreen && button == KB_F11 && !Input::down(KB_LEFT_ALT) &&
+        !Input::down(KB_RIGHT_ALT) && !Input::down(KB_LEFT_CONTROL) &&
+        !Input::down(KB_RIGHT_CONTROL) && !Input::down(KB_LEFT_META) &&
+        !Input::down(KB_RIGHT_META) && !Input::down(KB_LEFT_SHIFT) &&
+        !Input::down(KB_RIGHT_SHIFT)) {
         toggle_fullscreen = true;
     }
 
@@ -408,22 +425,22 @@ void Gosu::Window::button_down(Button button)
 
 const Gosu::Graphics& Gosu::Window::graphics() const
 {
-    return *pimpl->graphics;
+    return *m_impl->graphics;
 }
 
 Gosu::Graphics& Gosu::Window::graphics()
 {
-    return *pimpl->graphics;
+    return *m_impl->graphics;
 }
 
 const Gosu::Input& Gosu::Window::input() const
 {
-    return *pimpl->input;
+    return *m_impl->input;
 }
 
 Gosu::Input& Gosu::Window::input()
 {
-    return *pimpl->input;
+    return *m_impl->input;
 }
 
 #endif

data/src/WindowUIKit.cpp

@@ -4,51 +4,48 @@
 #include "GosuViewController.hpp"
 #include <Gosu/Gosu.hpp>
 
-using namespace std;
-
-struct Gosu::Window::Impl
+struct Gosu::Window::Impl : Gosu::Noncopyable
 {
     UIWindow* window;
     GosuViewController* controller;
-    unique_ptr<Graphics> graphics;
-    unique_ptr<Input> input;
-    
+    std::unique_ptr<Graphics> graphics;
+    std::unique_ptr<Input> input;
+
     double update_interval;
-    string caption;
+    std::string caption;
 };
 
 Gosu::Window::Window(int width, int height, unsigned window_flags, double update_interval)
-: pimpl(new Impl)
-{
-    pimpl->window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
-    pimpl->controller = [GosuViewController new];
-    pimpl->controller.gosuWindow = this;
-    pimpl->window.rootViewController = pimpl->controller;
-    
-    // It is important to load the view before creating the Graphics instance.
-    [pimpl->controller loadView];
-    
-    pimpl->graphics.reset(new Graphics(screen_width(), screen_height()));
-    pimpl->graphics->set_resolution(width, height);
-    
-    pimpl->input.reset(new Input((__bridge void*) pimpl->controller.view, update_interval));
-    pimpl->input->set_mouse_factors(1.0 * width / available_width(), 1.0 * height / available_height());
-    
-    pimpl->input->on_touch_began = [this](Gosu::Touch touch) { touch_began(touch); };
-    pimpl->input->on_touch_moved = [this](Gosu::Touch touch) { touch_moved(touch); };
-    pimpl->input->on_touch_ended = [this](Gosu::Touch touch) { touch_ended(touch); };
-    pimpl->input->on_touch_cancelled = [this](Gosu::Touch touch) { touch_cancelled(touch); };
-    
+: m_impl{new Impl}
+{
+    m_impl->window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
+    m_impl->controller = [GosuViewController new];
+    m_impl->controller.gosuWindow = this;
+    m_impl->window.rootViewController = m_impl->controller;
+
+    // It is important to (implicitly) load the view before creating the Graphics instance.
+    [m_impl->controller view];
+
+    m_impl->graphics.reset(new Graphics(screen_width(), screen_height()));
+    m_impl->graphics->set_resolution(width, height);
+
+    m_impl->input.reset(new Input((__bridge void*) m_impl->controller.view, update_interval));
+    m_impl->input->set_mouse_factors(1.0 * width / available_width(),
+                                     1.0 * height / available_height());
+
+    m_impl->input->on_touch_began = [this](Gosu::Touch touch) { touch_began(touch); };
+    m_impl->input->on_touch_moved = [this](Gosu::Touch touch) { touch_moved(touch); };
+    m_impl->input->on_touch_ended = [this](Gosu::Touch touch) { touch_ended(touch); };
+    m_impl->input->on_touch_cancelled = [this](Gosu::Touch touch) { touch_cancelled(touch); };
+
     // Now let the controller know about our Input instance.
-    [pimpl->controller trackTextInput:*pimpl->input];
-    
-    pimpl->update_interval = update_interval;
-}
+    [m_impl->controller trackTextInput:*m_impl->input];
 
-Gosu::Window::~Window()
-{
+    m_impl->update_interval = update_interval;
 }
 
+Gosu::Window::~Window() = default;
+
 int Gosu::Window::width() const
 {
     return graphics().width();
@@ -69,7 +66,7 @@ bool Gosu::Window::resizable() const
     return false;
 }
 
-void Gosu::Window::set_resizable(bool resizable)
+void Gosu::Window::set_resizable(bool)
 {
 }
 
@@ -78,53 +75,53 @@ bool Gosu::Window::borderless() const
     return true;
 }
 
-void Gosu::Window::set_borderless(bool borderless)
+void Gosu::Window::set_borderless(bool)
 {
 }
 
-void Gosu::Window::resize(int width, int height, bool fullscreen)
+void Gosu::Window::resize(int, int, bool)
 {
-    throw logic_error("Cannot resize windows on iOS");
+    throw std::logic_error{"Cannot resize windows on iOS"};
 }
 
 double Gosu::Window::update_interval() const
 {
-    return pimpl->update_interval;
+    return m_impl->update_interval;
 }
 
-void Gosu::Window::set_update_interval(double update_interval)
+void Gosu::Window::set_update_interval(double)
 {
-    throw logic_error("Cannot change the update interval on iOS");
+    throw std::logic_error{"Cannot change the update interval on iOS"};
 }
 
-string Gosu::Window::caption() const
+std::string Gosu::Window::caption() const
 {
-    return pimpl->caption;
+    return m_impl->caption;
 }
 
-void Gosu::Window::set_caption(const string& caption)
+void Gosu::Window::set_caption(const std::string& caption)
 {
-    pimpl->caption = caption;
+    m_impl->caption = caption;
 }
 
 const Gosu::Graphics& Gosu::Window::graphics() const
 {
-    return *pimpl->graphics;
+    return *m_impl->graphics;
 }
 
 Gosu::Graphics& Gosu::Window::graphics()
 {
-    return *pimpl->graphics;
+    return *m_impl->graphics;
 }
 
 const Gosu::Input& Gosu::Window::input() const
 {
-    return *pimpl->input;
+    return *m_impl->input;
 }
 
 Gosu::Input& Gosu::Window::input()
 {
-    return *pimpl->input;
+    return *m_impl->input;
 }
 
 void Gosu::Window::show()
@@ -138,7 +135,7 @@ bool Gosu::Window::tick()
 
 void Gosu::Window::close()
 {
-    throw logic_error("Cannot close windows manually on iOS");
+    throw std::logic_error{"Cannot close windows manually on iOS"};
 }
 
 void Gosu::Window::button_down(Button button)
@@ -147,7 +144,7 @@ void Gosu::Window::button_down(Button button)
 
 void* Gosu::Window::uikit_window() const
 {
-    return (__bridge void*) pimpl->window;
+    return (__bridge void*) m_impl->window;
 }
 
 int Gosu::screen_width(Window*)