gosu 0.10.9.pre1 → 0.11.0

data/src/{Graphics/Common.hpp → GraphicsImpl.hpp}

@@ -1,5 +1,4 @@
-#ifndef GOSU_SRC_GRAPHICS_COMMON_HPP
-#define GOSU_SRC_GRAPHICS_COMMON_HPP
+#pragma once
 
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>
@@ -44,7 +43,7 @@ namespace Gosu
         {
             // No clipping
             return (width == NO_CLIPPING && other.width == NO_CLIPPING) ||
-            // Clipping, but same
+                // Clipping, but same
                 (x == other.x && y == other.y && width == other.width && height == other.height);
         }
     };
@@ -62,64 +61,62 @@ namespace Gosu
     class Macro;
     struct ArrayVertex
     {
-        GLfloat texCoords[2];
+        GLfloat tex_coords[2];
         GLuint color;
         GLfloat vertices[3];
     };
     
     template<typename T>
-    bool isPToTheLeftOfAB(T xa, T ya,
-        T xb, T yb, T xp, T yp)
+    bool is_p_to_the_left_of_ab(T xa, T ya, T xb, T yb, T xp, T yp)
     {
         return (xb - xa) * (yp - ya) - (xp - xa) * (yb - ya) > 0;
     }
     
     template<typename T, typename C>
-    void reorderCoordinatesIfNecessary(T& x1, T& y1,
-        T& x2, T& y2, T& x3, T& y3, C& c3, T& x4, T& y4, C& c4)
+    void normalize_coordinates(T& x1, T& y1, T& x2, T& y2, T& x3, T& y3, C& c3, T& x4, T& y4, C& c4)
     {
-        if (isPToTheLeftOfAB(x1, y1, x2, y2, x3, y3) ==
-            isPToTheLeftOfAB(x2, y2, x3, y3, x4, y4))
-        {
-            std::swap(x3, x4);
-            std::swap(y3, y4);
-            std::swap(c3, c4);
+        if (is_p_to_the_left_of_ab(x1, y1, x2, y2, x3, y3) ==
+                is_p_to_the_left_of_ab(x2, y2, x3, y3, x4, y4)) {
+            using std::swap;
+            swap(x3, x4);
+            swap(y3, y4);
+            swap(c3, c4);
         }
     }
     
     template<typename Float>
-    void applyTransform(const Transform& transform, Float& x, Float& y)
+    void apply_transform(const Transform& transform, Float& x, Float& y)
     {
-        Float in[4] = { x, y, 0, 1 };
+        Float in[4]  = { x, y, 0, 1 };
         Float out[4] = { 0, 0, 0, 0 };
-        for (int i = 0; i < 4; ++i)
-            for (int j = 0; j < 4; ++j)
+        for (int i = 0; i < 4; ++i) {
+            for (int j = 0; j < 4; ++j) {
                 out[i] += in[j] * transform[j * 4 + i];
+            }
+        }
         x = out[0] / out[3];
         y = out[1] / out[3];
     }
     
-    inline void multiplyBitmapAlpha(Bitmap& bmp, Color::Channel alpha)
+    inline void multiply_bitmap_alpha(Bitmap& bmp, Color::Channel alpha)
     {
-        for (int y = 0; y < bmp.height(); ++y)
-            for (int x = 0; x < bmp.width(); ++x)
-            {
-                Color c = bmp.getPixel(x, y);
-                c.setAlpha(c.alpha() * alpha / 255);
-                bmp.setPixel(x, y, c);
+        for (int y = 0; y < bmp.height(); ++y) {
+            for (int x = 0; x < bmp.width(); ++x) {
+                Color c = bmp.get_pixel(x, y);
+                c.set_alpha(c.alpha() * alpha / 255);
+                bmp.set_pixel(x, y, c);
             }
+        }
     }
     
     #ifdef GOSU_IS_IPHONE
-    int clipRectBaseFactor();
+    int clip_rect_base_factor();
     #else
-    inline int clipRectBaseFactor() { return 1; }
+    inline int clip_rect_base_factor() { return 1; }
     #endif
     
-    bool isEntity(const std::wstring& name);
-    const Bitmap& entityBitmap(const std::wstring& name);
+    bool is_entity(const std::string& name);
+    const Bitmap& entity_bitmap(const std::string& name);
     
-    void ensureCurrentContext();
+    void ensure_current_context();
 }
-
-#endif

data/src/IO.cpp

@@ -11,8 +11,9 @@ void Gosu::Reader::read(void* dest, std::size_t length)
 void Gosu::Writer::write(const void* source, std::size_t length)
 {
     // Try to resize the source if necessary.
-    if (pos + length > res->size())
+    if (pos + length > res->size()) {
         res->resize(pos + length);
+    }
 
     res->write(pos, length, source);
     seek(length);
@@ -23,36 +24,36 @@ std::size_t Gosu::Buffer::size() const
     return buf.size();
 }
 
-void Gosu::Buffer::resize(std::size_t newSize)
+void Gosu::Buffer::resize(std::size_t new_size)
 {
-    buf.resize(newSize);
+    buf.resize(new_size);
 }
 
-void Gosu::Buffer::read(std::size_t offset, std::size_t length,
-    void* destBuffer) const
+void Gosu::Buffer::read(std::size_t offset, std::size_t length, void* dest_buffer) const
 {
-    assert(offset + length <= size());
-    if (length)
-        std::memcpy(destBuffer, &buf[offset], length);
+    assert (offset + length <= size());
+    if (length) {
+        std::memcpy(dest_buffer, &buf[offset], length);
+    }
 }
 
-void Gosu::Buffer::write(std::size_t offset, std::size_t length,
-    const void* sourceBuffer)
+void Gosu::Buffer::write(std::size_t offset, std::size_t length, const void* source_buffer)
 {
-    assert(offset + length <= size());
-    if (length)
-        std::memcpy(&buf[offset], sourceBuffer, length);
+    assert (offset + length <= size());
+    if (length) {
+        std::memcpy(&buf[offset], source_buffer, length);
+    }
 }
 
-void Gosu::loadFile(Buffer& buffer, const std::wstring& filename)
+void Gosu::load_file(Buffer& buffer, const std::string& filename)
 {
     File file(filename);
     buffer.resize(file.size());
     file.read(0, buffer.size(), buffer.data());
 }
 
-void Gosu::saveFile(const Buffer& buffer, const std::wstring& filename)
+void Gosu::save_file(const Buffer& buffer, const std::string& filename)
 {
-    File file(filename, fmReplace);
+    File file(filename, FM_REPLACE);
     file.write(0, buffer.size(), buffer.data());
 }

data/src/Iconv.hpp

@@ -1,5 +1,4 @@
-#ifndef GOSU_SRC_ICONV_HPP
-#define GOSU_SRC_ICONV_HPP
+#pragma once
 
 #include <Gosu/Platform.hpp>
 
@@ -11,50 +10,42 @@ namespace Gosu
     template<typename Out, const char* to, const char* from, typename In>
     Out iconvert(const In& in)
     {
-        if (in.empty())
-            return Out();
-    
-        const size_t bufferLen = 128;
+        if (in.empty()) return Out();
+
+        const size_t buffer_len = 128;
         typedef typename In::value_type InElem;
         typedef typename Out::value_type OutElem;
 
         static iconv_t cd = iconv_open(to, from);
         
         Out result;
-        OutElem buffer[bufferLen];
+        OutElem buffer[buffer_len];
         
         char* inbuf = const_cast<char*>(reinterpret_cast<const char*>(&in[0]));
         size_t inbytesleft = in.size() * sizeof(InElem);
         char* outbuf = reinterpret_cast<char*>(buffer);
         size_t outbytesleft = sizeof buffer;
         
-        for (;;)
-        {
+        for (;;) {
             size_t ret = ::iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
-            if (ret == static_cast<size_t>(-1) && errno == EILSEQ)
-            {
+            if (ret == static_cast<size_t>(-1) && errno == EILSEQ) {
                 // Skip illegal sequence part, repeat loop.
                 // TODO: Or retry w/ different encoding?
                 ++inbuf;
                 --inbytesleft;
             }
-            else if (ret == static_cast<size_t>(-1) && errno == E2BIG)
-            {
+            else if (ret == static_cast<size_t>(-1) && errno == E2BIG) {
                 // Append new characters, reset out buffer, then repeat loop.
-                result.insert(result.end(), buffer, buffer + bufferLen);
+                result.insert(result.end(), buffer, buffer + buffer_len);
                 outbuf = reinterpret_cast<char*>(buffer);
                 outbytesleft = sizeof buffer;
             }
-            else
-            {
+            else {
                 // Append what's new in the buffer, then LEAVE loop.
-                result.insert(result.end(), buffer, buffer + bufferLen - outbytesleft / sizeof(OutElem));
+                result.insert(result.end(), buffer,
+                              buffer + buffer_len - outbytesleft / sizeof(OutElem));
                 return result;
             }
-        }        
+        }
     }
 }
-
-
-#endif
-

data/src/Image.cpp

@@ -0,0 +1,142 @@
+#include <Gosu/Image.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/IO.hpp>
+#include <Gosu/ImageData.hpp>
+#include <Gosu/Math.hpp>
+#include <stdexcept>
+
+Gosu::Image::Image(const std::string& filename, unsigned flags)
+{
+    // Forward.
+    Bitmap bmp;
+    load_image_file(bmp, filename);
+    Image(bmp, flags).data_.swap(data_);
+}
+
+Gosu::Image::Image(const std::string& filename, unsigned src_x, unsigned src_y, unsigned src_width,
+    unsigned src_height, unsigned flags)
+{
+    // Forward.
+    Bitmap bmp;
+    load_image_file(bmp, filename);
+    Image(bmp, src_x, src_y, src_width, src_height, flags).data_.swap(data_);
+}
+
+Gosu::Image::Image(const Bitmap& source, unsigned flags)
+{
+    // Forward.
+    Image(source, 0, 0, source.width(), source.height(), flags).data_.swap(data_);
+}
+
+Gosu::Image::Image(const Bitmap& source, unsigned src_x, unsigned src_y, unsigned src_width,
+    unsigned src_height, unsigned flags)
+: data_(Graphics::create_image(source, src_x, src_y, src_width, src_height, flags))
+{
+}
+
+Gosu::Image::Image(std::unique_ptr<ImageData>&& data)
+: data_(data.release())
+{
+    if (this->data_.get() == nullptr) {
+        throw std::invalid_argument("Gosu::Image cannot be initialized with nullptr");
+    }
+}
+
+unsigned Gosu::Image::width() const
+{
+    return data_->width();
+}
+
+unsigned Gosu::Image::height() const
+{
+    return data_->height();
+}
+
+void Gosu::Image::draw(double x, double y, ZPos z, double scale_x, double scale_y, Color c,
+    AlphaMode mode) const
+{
+    double x2 = x + width() * scale_x;
+    double y2 = y + height() * scale_y;
+
+    data_->draw(x, y, c, x2, y, c, x, y2, c, x2, y2, c, z, mode);
+}
+
+void Gosu::Image::draw_mod(double x, double y, ZPos z, double scale_x, double scale_y, Color c1,
+    Color c2, Color c3, Color c4, AlphaMode mode) const
+{
+    double x2 = x + width() * scale_x;
+    double y2 = y + height() * scale_y;
+
+    data_->draw(x, y, c1, x2, y, c2, x, y2, c3, x2, y2, c4, z, mode);
+}
+
+void Gosu::Image::draw_rot(double x, double y, ZPos z, double angle,
+    double center_x, double center_y, double scale_x, double scale_y, Color c, AlphaMode mode) const
+{
+    double size_x = width() * scale_x;
+    double size_y = height() * scale_y;
+    double offs_x = offset_x(angle, 1);
+    double offs_y = offset_y(angle, 1);
+
+    // Offset to the centers of the original Image's edges after rotation.
+    double dist_to_left_x   = +offs_y * size_x * center_x;
+    double dist_to_left_y   = -offs_x * size_x * center_x;
+    double dist_to_right_x  = -offs_y * size_x * (1 - center_x);
+    double dist_to_right_y  = +offs_x * size_x * (1 - center_x);
+    double dist_to_top_x    = +offs_x * size_y * center_y;
+    double dist_to_top_y    = +offs_y * size_y * center_y;
+    double dist_to_bottom_x = -offs_x * size_y * (1 - center_y);
+    double dist_to_bottom_y = -offs_y * size_y * (1 - center_y);
+
+    data_->draw(x + dist_to_left_x  + dist_to_top_x,    y + dist_to_left_y  + dist_to_top_y,    c,
+                x + dist_to_right_x + dist_to_top_x,    y + dist_to_right_y + dist_to_top_y,    c,
+                x + dist_to_left_x  + dist_to_bottom_x, y + dist_to_left_y  + dist_to_bottom_y, c,
+                x + dist_to_right_x + dist_to_bottom_x, y + dist_to_right_y + dist_to_bottom_y, c,
+                z, mode);
+}
+
+Gosu::ImageData& Gosu::Image::data() const
+{
+    return *data_;
+}
+
+std::vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bmp, int tile_width, int tile_height,
+    unsigned flags)
+{
+    int tiles_x, tiles_y;
+    std::vector<Image> images;
+    
+    if (tile_width > 0) {
+        tiles_x = bmp.width() / tile_width;
+    }
+    else {
+        tiles_x = -tile_width;
+        tile_width = bmp.width() / tiles_x;
+    }
+    
+    if (tile_height > 0) {
+        tiles_y = bmp.height() / tile_height;
+    }
+    else {
+        tiles_y = -tile_height;
+        tile_height = bmp.height() / tiles_y;
+    }
+    
+    for (int y = 0; y < tiles_y; ++y) {
+        for (int x = 0; x < tiles_x; ++x) {
+            images.emplace_back(bmp, x * tile_width, y * tile_height, tile_width, tile_height,
+                                flags);
+        }
+    }
+    
+    return images;
+}
+
+std::vector<Gosu::Image> Gosu::load_tiles(const std::string& filename, int tile_width,
+    int tile_height, unsigned flags)
+{
+    Bitmap bmp;
+    load_image_file(bmp, filename);
+    return load_tiles(bmp, tile_width, tile_height, flags);
+}

data/src/Input.cpp

@@ -0,0 +1,459 @@
+#include <Gosu/Platform.hpp>
+#if !defined(GOSU_IS_IPHONE)
+
+#include <Gosu/Input.hpp>
+#include <Gosu/TextInput.hpp>
+#include <Gosu/Utility.hpp>
+#include <SDL.h>
+#include <cwctype>
+#include <cstdlib>
+#include <algorithm>
+#include <array>
+
+namespace
+{
+    void cleanup();
+
+    void require_sdl_video()
+    {
+        static bool initialized = false;
+        if (!initialized) {
+            SDL_InitSubSystem(SDL_INIT_VIDEO);
+            initialized = true;
+            std::atexit(cleanup);
+        }
+    }
+    
+    void cleanup()
+    {
+        SDL_QuitSubSystem(SDL_INIT_VIDEO);
+    }
+
+    std::array<bool, Gosu::NUM_BUTTONS> button_states = { { false } };
+}
+
+struct Gosu::Input::Impl
+{
+    Input& input;
+    SDL_Window* window;
+    TextInput* text_input;
+    double mouse_x, mouse_y;
+    double mouse_scale_x, mouse_scale_y;
+    double mouse_offset_x, mouse_offset_y;
+    
+    Impl(Input& input, SDL_Window* window)
+    : input(input), window(window), text_input(nullptr)
+    {
+        mouse_scale_x = mouse_scale_y = 1;
+        mouse_offset_x = mouse_offset_y = 0;
+    }
+    
+    void update_mouse_position()
+    {
+    // Do not use GetGlobalMouseState on Linux for now to prevent this bug:
+    // https://github.com/gosu/gosu/issues/326
+    // Once SDL 2.0.5 has been released, we can use this function as a workaround:
+    // https://wiki.libsdl.org/SDL_GetWindowBordersSize
+    #if SDL_VERSION_ATLEAST(2, 0, 4) && !defined(GOSU_IS_X)
+        int x, y, window_x, window_y;
+        SDL_GetWindowPosition(window, &window_x, &window_y);
+        SDL_GetGlobalMouseState(&x, &y);
+        mouse_x = x - window_x, mouse_y = y - window_y;
+    #else
+        int x, y;
+        SDL_GetMouseState(&x, &y);
+        mouse_x = x, mouse_y = y;
+    #endif
+    }
+    
+    void set_mouse_position(double x, double y)
+    {
+        SDL_WarpMouseInWindow(window,
+                              (x - mouse_offset_x) / mouse_scale_x,
+                              (y - mouse_offset_y) / mouse_scale_y);
+
+    #if SDL_VERSION_ATLEAST(2, 0, 4) && !defined(GOSU_IS_X)
+        // On systems where we have a working GetGlobalMouseState, we can warp the mouse and
+        // retrieve its position directly afterwards.
+        update_mouse_position();
+    #else
+        // Otherwise, we have to assume that setting the position worked, because if we update the
+        // mouse position now, we'll get the previous position.
+        mouse_x = x, mouse_y = y;
+    #endif
+    }
+    
+    void enqueue_event(int id, bool down)
+    {
+        event_queue.push_back(down ? id : ~id);
+    }
+    
+    void dispatch_enqueued_events()
+    {
+        for (int event : event_queue) {
+            bool down = (event >= 0);
+            Button button(down ? event : ~event);
+            
+            button_states[button.id()] = down;
+            if (down && input.on_button_down) {
+                input.on_button_down(button);
+            }
+            else if (!down && input.on_button_up) {
+                input.on_button_up(button);
+            }
+        }
+        event_queue.clear();
+    }
+    
+    void initialize_gamepads()
+    {
+        SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
+
+        int num_gamepads = std::min<int>(Gosu::NUM_GAMEPADS, SDL_NumJoysticks());
+        
+        for (int i = 0; i < num_gamepads; ++i) {
+            // Prefer the SDL_GameController API...
+            if (SDL_IsGameController(i)) {
+                SDL_GameController* game_controller = SDL_GameControllerOpen(i);
+                if (game_controller) {
+                    game_controllers.push_back(game_controller);
+                    continue;
+                }
+            }
+            // ...but fall back on the good, old SDL_Joystick API :)
+            SDL_Joystick* joystick = SDL_JoystickOpen(i);
+            if (joystick) {
+                joysticks.push_back(joystick);
+            }
+        }
+    }
+    
+    void release_gamepads()
+    {
+        std::for_each(joysticks.begin(), joysticks.end(), &SDL_JoystickClose);
+        joysticks.clear();
+        std::for_each(game_controllers.begin(), game_controllers.end(), &SDL_GameControllerClose);
+        game_controllers.clear();
+        
+        SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER);
+    }
+    
+    typedef std::array<bool, GP_NUM_PER_GAMEPAD> GamepadBuffer;
+    
+    void poll_gamepads()
+    {
+        // This gamepad is an OR-ed version of all the other gamepads. If button
+        // 3 is pressed on any attached gamepad, down(GP_BUTTON_3) will return
+        // true. This is handy for singleplayer games.
+        GamepadBuffer any_gamepad = { false };
+        
+        std::size_t available_gamepads = game_controllers.size() + joysticks.size();
+        
+        for (int i = 0; i < available_gamepads; ++i) {
+            GamepadBuffer current_gamepad = { false };
+            
+            // Poll data from SDL, using either of two API interfaces.
+            if (i < game_controllers.size()) {
+                SDL_GameController* game_controller = game_controllers[i];
+                poll_game_controller(game_controller, current_gamepad);
+            }
+            else {
+                SDL_Joystick* joystick = joysticks[i - game_controllers.size()];
+                poll_joystick(joystick, current_gamepad);
+            }
+            
+            // Now at the same time, enqueue all events for this particular
+            // gamepad, and OR the keyboard state into any_gamepad.
+            int offset = GP_RANGE_BEGIN + GP_NUM_PER_GAMEPAD * (i + 1);
+            for (int j = 0; j < current_gamepad.size(); ++j) {
+                any_gamepad[j] = any_gamepad[j] || current_gamepad[j];
+                
+                if (current_gamepad[j] && !button_states[j + offset]) {
+                    button_states[j + offset] = true;
+                    enqueue_event(j + offset, true);
+                }
+                else if (!current_gamepad[j] && button_states[j + offset]) {
+                    button_states[j + offset] = false;
+                    enqueue_event(j + offset, false);
+                }
+            }
+        }
+        
+        // And lastly, enqueue events for the virtual "any" gamepad.
+        for (int j = 0; j < any_gamepad.size(); ++j) {
+            if (any_gamepad[j] && !button_states[j + GP_RANGE_BEGIN]) {
+                button_states[j + GP_RANGE_BEGIN] = true;
+                enqueue_event(j + GP_RANGE_BEGIN, true);
+            }
+            else if (!any_gamepad[j] && button_states[j + GP_RANGE_BEGIN]) {
+                button_states[j + GP_RANGE_BEGIN] = false;
+                enqueue_event(j + GP_RANGE_BEGIN, false);
+            }
+        }
+    }
+    
+private:
+    // For button down event: Button name value (>= 0)
+    // For button up event: ~Button name value (< 0)
+    std::vector<int> event_queue;
+    
+    std::vector<SDL_Joystick*> joysticks;
+    std::vector<SDL_GameController*> game_controllers;
+    
+    // SDL returns axis values in the range -2^15 through 2^15-1, so we consider
+    // -2^14 through 2^14 the dead zone.
+    
+    enum { DEAD_ZONE = (1 << 14) };
+    
+    void poll_game_controller(SDL_GameController* controller, GamepadBuffer& gamepad)
+    {
+        gamepad[GP_LEFT - GP_RANGE_BEGIN] =
+            SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_DPAD_LEFT) ||
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTX) < -DEAD_ZONE ||
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTX) < -DEAD_ZONE;
+        
+        gamepad[GP_RIGHT - GP_RANGE_BEGIN] =
+            SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_DPAD_RIGHT) ||
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTX) > +DEAD_ZONE ||
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTX) > +DEAD_ZONE;
+        
+        gamepad[GP_UP - GP_RANGE_BEGIN] =
+            SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_DPAD_UP) ||
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTY) < -DEAD_ZONE ||
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTY) < -DEAD_ZONE;
+        
+        gamepad[GP_DOWN - GP_RANGE_BEGIN] =
+            SDL_GameControllerGetButton(controller, SDL_CONTROLLER_BUTTON_DPAD_DOWN) ||
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTY) > +DEAD_ZONE ||
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTY) > +DEAD_ZONE;
+        
+        int button = 0;
+        for (button; button < SDL_CONTROLLER_BUTTON_DPAD_UP; ++button) {
+            gamepad[GP_BUTTON_0 + button - GP_RANGE_BEGIN] =
+                SDL_GameControllerGetButton(controller, (SDL_GameControllerButton) button);
+        }
+        gamepad[GP_BUTTON_0 + button++ - GP_RANGE_BEGIN] =
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_TRIGGERLEFT) > +DEAD_ZONE;
+        gamepad[GP_BUTTON_0 + button++ - GP_RANGE_BEGIN] =
+            SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT) > +DEAD_ZONE;
+    }
+    
+    void poll_joystick(SDL_Joystick* joystick, GamepadBuffer& gamepad)
+    {
+        int axes = SDL_JoystickNumAxes(joystick);
+        int hats = SDL_JoystickNumHats(joystick);
+        int buttons = std::min<int>(GP_NUM_PER_GAMEPAD - 4, SDL_JoystickNumButtons(joystick));
+        
+        for (int axis = 0; axis < axes; ++axis) {
+            Sint16 value = SDL_JoystickGetAxis(joystick, axis);
+            
+            if (value < -DEAD_ZONE) {
+                if (axis % 2 == 0) {
+                    gamepad[GP_LEFT - GP_RANGE_BEGIN] = true;
+                }
+                else {
+                    gamepad[GP_UP - GP_RANGE_BEGIN] = true;
+                }
+            }
+            else if (value > +DEAD_ZONE) {
+                if (axis % 2 == 0) {
+                    gamepad[GP_RIGHT - GP_RANGE_BEGIN] = true;
+                }
+                else {
+                    gamepad[GP_DOWN - GP_RANGE_BEGIN] = true;
+                }
+            }
+        }
+        
+        for (int hat = 0; hat < hats; ++hat) {
+            Uint8 value = SDL_JoystickGetHat(joystick, hat);
+            
+            if (value & SDL_HAT_LEFT) {
+                gamepad[GP_LEFT - GP_RANGE_BEGIN] = true;
+            }
+            if (value & SDL_HAT_RIGHT) {
+                gamepad[GP_RIGHT - GP_RANGE_BEGIN] = true;
+            }
+            if (value & SDL_HAT_UP) {
+                gamepad[GP_UP - GP_RANGE_BEGIN] = true;
+            }
+            if (value & SDL_HAT_DOWN) {
+                gamepad[GP_DOWN - GP_RANGE_BEGIN] = true;
+            }
+        }
+        
+        for (int button = 0; button < buttons; ++button) {
+            if (SDL_JoystickGetButton(joystick, button)) {
+                gamepad[GP_BUTTON_0 + button - GP_RANGE_BEGIN] = true;
+            }
+        }
+    }
+};
+
+Gosu::Input::Input(void* window)
+: pimpl(new Impl(*this, (SDL_Window*)window))
+{
+    require_sdl_video();
+    
+    pimpl->initialize_gamepads();
+}
+
+Gosu::Input::~Input()
+{
+    pimpl->release_gamepads();
+}
+
+bool Gosu::Input::feed_sdl_event(void* event)
+{
+    const SDL_Event* e = static_cast<SDL_Event*>(event);
+    
+    if (pimpl->text_input && pimpl->text_input->feed_sdl_event(event)) {
+        return true;
+    }
+    
+    switch (e->type) {
+    case SDL_KEYDOWN:
+    case SDL_KEYUP: {
+        if (e->key.repeat == 0 && e->key.keysym.scancode <= KB_RANGE_END) {
+            pimpl->enqueue_event(e->key.keysym.scancode, e->type == SDL_KEYDOWN);
+            return true;
+        }
+        break;
+    }
+    case SDL_MOUSEBUTTONDOWN:
+    case SDL_MOUSEBUTTONUP: {
+        if (e->button.button >= 1 && e->button.button <= 3) {
+            pimpl->enqueue_event(MS_LEFT + e->button.button - 1, e->type == SDL_MOUSEBUTTONDOWN);
+            return true;
+        }
+        break;
+    }
+    case SDL_MOUSEWHEEL: {
+        if (e->wheel.y > 0) {
+            pimpl->enqueue_event(MS_WHEEL_UP, true);
+            pimpl->enqueue_event(MS_WHEEL_UP, false);
+            return true;
+        }
+        else if (e->wheel.y < 0) {
+            pimpl->enqueue_event(MS_WHEEL_DOWN, true);
+            pimpl->enqueue_event(MS_WHEEL_DOWN, false);
+            return true;
+        }
+        break;
+    }
+    }
+    return false;
+}
+
+std::string Gosu::Input::id_to_char(Button btn)
+{
+    require_sdl_video();
+    
+    if (btn.id() > KB_RANGE_END) return "";
+    
+    // SDL_GetKeyName returns "Space" for this value, but we want the character value.
+    if (btn.id() == KB_SPACE) return " ";
+    
+    SDL_Keycode keycode = SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(btn.id()));
+    if (keycode == SDLK_UNKNOWN) return "";
+    
+    const char* name = SDL_GetKeyName(keycode);
+    if (name == nullptr) return "";
+    
+    std::wstring wname = utf8_to_wstring(name);
+    if (wname.length() != 1) return "";
+    
+    // Convert to lower case to be consistent with previous versions of Gosu.
+    // German umlauts are already reported in lower-case by SDL, anyway.
+    // (This should handle Turkish i/I just fine because it uses the current locale.)
+    wname[0] = (wchar_t)std::towlower((int)wname[0]);
+    return wstring_to_utf8(wname);
+}
+
+Gosu::Button Gosu::Input::char_to_id(std::string ch)
+{
+    require_sdl_video();
+    
+    SDL_Keycode keycode = SDL_GetKeyFromName(ch.c_str());
+    return keycode == SDLK_UNKNOWN ? NO_BUTTON : Button(SDL_GetScancodeFromKey(keycode));
+}
+
+bool Gosu::Input::down(Gosu::Button btn)
+{
+    if (btn == NO_BUTTON || btn.id() >= NUM_BUTTONS) return false;
+    
+    return button_states[btn.id()];
+}
+
+double Gosu::Input::mouse_x() const
+{
+    return pimpl->mouse_x * pimpl->mouse_scale_x + pimpl->mouse_offset_x;
+}
+
+double Gosu::Input::mouse_y() const
+{
+    return pimpl->mouse_y * pimpl->mouse_scale_y + pimpl->mouse_offset_y;
+}
+
+void Gosu::Input::set_mouse_position(double x, double y)
+{
+    pimpl->set_mouse_position(x, y);
+}
+
+void Gosu::Input::set_mouse_factors(double scale_x, double scale_y,
+    double black_bar_width, double black_bar_height)
+{
+    pimpl->mouse_scale_x = scale_x;
+    pimpl->mouse_scale_y = scale_y;
+    pimpl->mouse_offset_x = -black_bar_width;
+    pimpl->mouse_offset_y = -black_bar_height;
+}
+
+const Gosu::Touches& Gosu::Input::current_touches() const
+{
+    // Note: We can actually use the SDL's touch API to implement this, even on macOS! Neat.
+    
+    static Gosu::Touches none;
+    return none;
+}
+
+double Gosu::Input::accelerometer_x() const
+{
+    return 0.0;
+}
+
+double Gosu::Input::accelerometer_y() const
+{
+    return 0.0;
+}
+
+double Gosu::Input::accelerometer_z() const
+{
+    return 0.0;
+}
+
+void Gosu::Input::update()
+{
+    pimpl->update_mouse_position();
+    pimpl->dispatch_enqueued_events();
+    pimpl->poll_gamepads();
+}
+
+Gosu::TextInput* Gosu::Input::text_input() const
+{
+    return pimpl->text_input;
+}
+
+void Gosu::Input::set_text_input(TextInput* text_input)
+{
+    if (pimpl->text_input && text_input == nullptr) {
+        SDL_StopTextInput();
+    }
+    else if (pimpl->text_input == nullptr && text_input) {
+        SDL_StartTextInput();
+    }
+    
+    pimpl->text_input = text_input;
+}
+
+#endif