gosu 0.7.50 → 0.8.0.pre1

data/GosuImpl/Graphics/DrawOp.hpp

@@ -38,7 +38,7 @@ namespace Gosu
             assert (verticesOrBlockIndex >= 2);
             assert (verticesOrBlockIndex <= 4);
             
-            #ifdef GOSU_IS_IPHONE
+            #ifdef GOSU_IS_OPENGLES
             static const unsigned MAX_AUTOGROUP = 24;
             
             static int spriteCounter = 0;
@@ -61,9 +61,7 @@ namespace Gosu
                 
                 isSetup = true;
             }
-            #endif
             
-            #ifdef GOSU_IS_IPHONE
             if (renderState.texture)
             {
                 spriteTexcoords[spriteCounter*12 + 0] = left;
@@ -80,9 +78,29 @@ namespace Gosu
                 spriteTexcoords[spriteCounter*12 + 10] = right;
                 spriteTexcoords[spriteCounter*12 + 11] = bottom;
             }
-            #endif
+
+            for (int i = 0; i < 3; ++i)
+            {
+                spriteVertices[spriteCounter*12 + i*2] = vertices[i].x;
+                spriteVertices[spriteCounter*12 + i*2+1] = vertices[i].y;
+                spriteColors[spriteCounter*6 + i] = vertices[i].c.abgr();
+            }
+            for (int i = 0; i < 3; ++i)
+            {
+                spriteVertices[spriteCounter*12 + 6 + i*2] = vertices[i + 1].x;
+                spriteVertices[spriteCounter*12 + 6 + i*2+1] = vertices[i + 1].y;
+                spriteColors[spriteCounter*6 + 3 + i] = vertices[i + 1].c.abgr();
+            }
             
-            #ifndef GOSU_IS_IPHONE
+            ++spriteCounter;
+            if (spriteCounter == MAX_AUTOGROUP || next == 0 || !(next->renderState == renderState))
+            {
+                glDrawArrays(GL_TRIANGLES, 0, 6 * spriteCounter);
+                //if (spriteCounter > 1)
+                //    printf("grouped %d quads\n", spriteCounter);
+                spriteCounter = 0;
+            }
+            #else
             if (verticesOrBlockIndex == 2)
                 glBegin(GL_LINES);
             else if (verticesOrBlockIndex == 3)
@@ -113,28 +131,6 @@ namespace Gosu
             }
             
             glEnd();
-            #else
-            for (int i = 0; i < 3; ++i)
-            {
-                spriteVertices[spriteCounter*12 + i*2] = vertices[i].x;
-                spriteVertices[spriteCounter*12 + i*2+1] = vertices[i].y;
-                spriteColors[spriteCounter*6 + i] = vertices[i].c.abgr();
-            }
-            for (int i = 0; i < 3; ++i)
-            {
-                spriteVertices[spriteCounter*12 + 6 + i*2] = vertices[i + 1].x;
-                spriteVertices[spriteCounter*12 + 6 + i*2+1] = vertices[i + 1].y;
-                spriteColors[spriteCounter*6 + 3 + i] = vertices[i + 1].c.abgr();
-            }
-            
-            ++spriteCounter;
-            if (spriteCounter == MAX_AUTOGROUP || next == 0 || !(next->renderState == renderState))
-            {
-                glDrawArrays(GL_TRIANGLES, 0, 6 * spriteCounter);
-                //if (spriteCounter > 1)
-                //    printf("grouped %d quads\n", spriteCounter);
-                spriteCounter = 0;
-            }
             #endif
         }
         

data/GosuImpl/Graphics/DrawOpQueue.hpp

@@ -28,7 +28,7 @@ public:
         if (clipRectStack.clippedWorldAway())
             return;
 
-        #ifdef GOSU_IS_IPHONE
+        #ifdef GOSU_IS_OPENGLES
         // No triangles, no lines supported
         assert (op.verticesOrBlockIndex == 4);
         #endif
@@ -104,7 +104,7 @@ public:
         std::stable_sort(ops.begin(), ops.end());
 
         RenderStateManager manager;
-        #ifdef GOSU_IS_IPHONE
+        #ifdef GOSU_IS_OPENGLES
         if (ops.empty())
             return;
 

data/GosuImpl/Graphics/Graphics.cpp

@@ -16,6 +16,7 @@ struct Gosu::Graphics::Impl
 {
     unsigned virtWidth, virtHeight;
     unsigned physWidth, physHeight;
+    double blackWidth, blackHeight;
     bool fullscreen;
     DrawOpQueueStack queues;
     typedef std::vector<std::tr1::shared_ptr<Texture> > Textures;
@@ -30,13 +31,14 @@ Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscree
     pimpl->virtWidth  = physWidth;
     pimpl->virtHeight = physHeight;
     pimpl->fullscreen = fullscreen;
+    pimpl->blackWidth = 0;
+    pimpl->blackHeight = 0;
     
-    // Should be merged into RenderState altogether.
-    
+    // TODO: Should be merged into RenderState and removed from Graphics.
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     glViewport(0, 0, physWidth, physHeight);
-    #ifdef GOSU_IS_IPHONE
+    #ifdef GOSU_IS_OPENGLES
     glOrthof(0, physWidth, physHeight, 0, -1, 1);
     #else
     glOrtho(0, physWidth, physHeight, 0, -1, 1);
@@ -70,15 +72,26 @@ bool Gosu::Graphics::fullscreen() const
     return pimpl->fullscreen;
 }
 
-void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight)
+void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight,
+    double horizontalBlackBarWidth, double verticalBlackBarHeight)
 {
     if (virtualWidth == 0 || virtualHeight == 0)
         throw std::invalid_argument("Invalid virtual resolution.");
     
-    pimpl->virtWidth = virtualWidth, pimpl->virtHeight = virtualHeight;
-    double scaleX = 1.0 / virtualWidth * pimpl->physWidth;
-    double scaleY = 1.0 / virtualHeight * pimpl->physHeight;
-    pimpl->queues.front().setBaseTransform(scale(scaleX, scaleY));
+    pimpl->virtWidth = virtualWidth;
+    pimpl->virtHeight = virtualHeight;
+    pimpl->blackWidth = horizontalBlackBarWidth;
+    pimpl->blackHeight = verticalBlackBarHeight;
+
+    double scaleX = 1.0 * pimpl->physWidth / virtualWidth;
+    double scaleY = 1.0 * pimpl->physHeight / virtualHeight;
+    double scaleFactor = std::min(scaleX, scaleY);
+
+    Transform scaleTransform = scale(scaleFactor);
+    Transform translateTransform = translate(pimpl->blackWidth, pimpl->blackHeight);
+    Transform baseTransform = concat(translateTransform, scaleTransform);
+    
+    pimpl->queues.front().setBaseTransform(baseTransform);
 }
 
 bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
@@ -99,11 +112,34 @@ bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
 void Gosu::Graphics::end()
 {
     // If recording is in process, cancel it.
-    assert (pimpl->queues.size() == 1);
     pimpl->queues.resize(1);
     
     flush();
     
+    if (pimpl->blackHeight || pimpl->blackWidth) {
+        if (pimpl->blackHeight) {
+            drawQuad(0, -pimpl->blackHeight, Color::BLACK,
+                     width(), -pimpl->blackHeight, Color::BLACK,
+                     0, 0, Color::BLACK,
+                     width(), 0, Color::BLACK, 0);
+            drawQuad(0, height(), Color::BLACK,
+                     width(), height(), Color::BLACK,
+                     0, height() + pimpl->blackHeight, Color::BLACK,
+                     width(), height() + pimpl->blackHeight, Color::BLACK, 0);
+        }
+        else if (pimpl->blackWidth) {
+            drawQuad(-pimpl->blackWidth, 0, Color::BLACK,
+                     0, 0, Color::BLACK,
+                     -pimpl->blackWidth, height(), Color::BLACK,
+                     0, height(), Color::BLACK, 0);
+            drawQuad(width(), 0, Color::BLACK,
+                     width() + pimpl->blackWidth, 0, Color::BLACK,
+                     width(), height(), Color::BLACK,
+                     width() + pimpl->blackWidth, height(), Color::BLACK, 0);
+        }
+        flush();
+    }
+    
     glFlush();
 }
 
@@ -121,8 +157,8 @@ void Gosu::Graphics::beginGL()
     if (pimpl->queues.size() > 1)
         throw std::logic_error("Custom OpenGL is not allowed while creating a macro");
     
-#ifdef GOSU_IS_IPHONE
-    throw std::logic_error("Custom OpenGL is unsupported on the iPhone");
+#ifdef GOSU_IS_OPENGLES
+    throw std::logic_error("Custom OpenGL ES is not supported yet");
 #else
     flush();
     glPushAttrib(GL_ALL_ATTRIB_BITS);
@@ -133,13 +169,14 @@ void Gosu::Graphics::beginGL()
 
 void Gosu::Graphics::endGL()
 {
-#ifdef GOSU_IS_IPHONE
-    throw std::logic_error("Custom OpenGL is unsupported on the iPhone");
+#ifdef GOSU_IS_OPENGLES
+    throw std::logic_error("Custom OpenGL ES is not supported yet");
 #else
     glPopAttrib();
 
     // Restore matrices.
-    
+    // TODO: Should be merged into RenderState and removed from Graphics.
+
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     glViewport(0, 0, pimpl->physWidth, pimpl->physHeight);
@@ -151,10 +188,10 @@ void Gosu::Graphics::endGL()
 #endif
 }
 
-#ifdef GOSU_IS_IPHONE
+#ifdef GOSU_IS_OPENGLES
 void Gosu::Graphics::scheduleGL(const std::tr1::function<void()>& functor, Gosu::ZPos z)
 {
-    throw std::logic_error("Custom OpenGL is unsupported on the iPhone");
+    throw std::logic_error("Custom OpenGL ES is not supported yet");
 }
 #else
 namespace Gosu
@@ -250,7 +287,7 @@ void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
     op.vertices[2] = DrawOp::Vertex(x3, y3, c3);
-#ifdef GOSU_IS_IPHONE
+#ifdef GOSU_IS_OPENGLES
     op.verticesOrBlockIndex = 4;
     op.vertices[3] = op.vertices[2];
 #endif
@@ -270,7 +307,7 @@ void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
 // TODO: Should be harmonized
-#ifdef GOSU_IS_IPHONE
+#ifdef GOSU_IS_OPENGLES
     op.vertices[2] = DrawOp::Vertex(x3, y3, c3);
     op.vertices[3] = DrawOp::Vertex(x4, y4, c4);
 #else

data/GosuImpl/Graphics/Macro.hpp

@@ -170,7 +170,7 @@ class Gosu::Macro : public Gosu::ImageData
         // They should be premultiplied and have the same transform by definition. Then, the transformation
         // only had to be performed here once.
         
-        #ifndef GOSU_IS_IPHONE
+        #ifndef GOSU_IS_OPENGLES
         glEnable(GL_BLEND);
         glMatrixMode(GL_MODELVIEW);
         

data/GosuImpl/Graphics/RenderState.hpp

@@ -58,7 +58,7 @@ struct Gosu::RenderState
     }
     
     // Only used by Macro so far
-    #ifndef GOSU_IS_IPHONE
+    #ifndef GOSU_IS_OPENGLES
     void apply() const
     {
         applyTexture();
@@ -81,7 +81,7 @@ class Gosu::RenderStateManager : private Gosu::RenderState
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
         
-        #ifndef GOSU_IS_IPHONE
+        #ifndef GOSU_IS_OPENGLES
         glMultMatrixd(&(*transform)[0]);
         #else
         // TODO: Ouch, should always use floats!

data/GosuImpl/Graphics/TexChunk.cpp

@@ -50,7 +50,7 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
 // TODO: Should be harmonized
-#ifdef GOSU_IS_IPHONE
+#ifdef GOSU_IS_OPENGLES
     op.vertices[2] = DrawOp::Vertex(x3, y3, c3);
     op.vertices[3] = DrawOp::Vertex(x4, y4, c4);
 #else

data/GosuImpl/Graphics/TextUnix.cpp

@@ -5,7 +5,7 @@
 #include <pango/pango.h>
 #include <pango/pangoft2.h>
 #include <glib.h>
-#include <SDL/SDL_ttf.h>
+#include <SDL2/SDL_ttf.h>
 
 #include <string>
 #include <cstring>

data/GosuImpl/Graphics/Texture.cpp

@@ -20,7 +20,7 @@ Gosu::Texture::Texture(unsigned size)
    
     // Create empty texture.
     glBindTexture(GL_TEXTURE_2D, name);
-#ifdef GOSU_IS_IPHONE
+#ifdef GOSU_IS_OPENGLES
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, allocator.width(), allocator.height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, 0);
 #else
@@ -95,7 +95,7 @@ void Gosu::Texture::free(unsigned x, unsigned y, unsigned width, unsigned height
 
 Gosu::Bitmap Gosu::Texture::toBitmap(unsigned x, unsigned y, unsigned width, unsigned height) const
 {
-#ifdef GOSU_IS_IPHONE
+#ifdef GOSU_IS_OPENGLES
     throw std::logic_error("Texture::toBitmap not supported on iOS");
 #else
     Gosu::Bitmap fullTexture(size(), size());

data/GosuImpl/Graphics/Transform.cpp

@@ -1,7 +1,7 @@
 // Default matrices, adapted from original Transform support
 // contribution by erisdiscord. Thank you!
 
-#include <Gosu/Graphics.hpp>
+#include <Gosu/GraphicsBase.hpp>
 #include <Gosu/Math.hpp>
 #include "Common.hpp"
 #include <cmath>
@@ -18,7 +18,7 @@ Gosu::rotate(double angle, double aroundX, double aroundY)
         0,  0,  0, 1
     };
     if (aroundX != 0 || aroundY != 0)
-        result = multiply(multiply(translate(-aroundX, -aroundY), result), translate(aroundX, aroundY));
+        result = concat(concat(translate(-aroundX, -aroundY), result), translate(aroundX, aroundY));
     return result;
 }
 
@@ -56,6 +56,18 @@ Gosu::scale(double factorX, double factorY, double aroundX, double aroundY)
         0,       0,       0, 1
     };
     if (aroundX != 0 || aroundY != 0)
-        result = multiply(multiply(translate(-aroundX, -aroundY), result), translate(aroundX, aroundY));
+        result = concat(concat(translate(-aroundX, -aroundY), result), translate(aroundX, aroundY));
+    return result;
+}
+
+Gosu::Transform
+Gosu::concat(const Transform& left, const Transform& right)
+{
+    Gosu::Transform result;
+    for (int i = 0; i < 16; ++i) {
+        result[i] = 0;
+        for (int j = 0; j < 4; ++j)
+            result[i] += left[i / 4 * 4 + j] * right[i % 4 + j * 4];
+    }
     return result;
 }

data/GosuImpl/Graphics/TransformStack.hpp

@@ -79,7 +79,7 @@ namespace Gosu
         void push(const Transform& transform)
         {
             individual.push_back(transform);
-            Transform result = multiply(transform, current());
+            Transform result = concat(transform, current());
             makeCurrent(result);
         }
         
@@ -91,7 +91,7 @@ namespace Gosu
             Transform result = scale(1);
             for (Transforms::reverse_iterator it = individual.rbegin(),
                     end = individual.rend(); it != end; ++it)
-                result = multiply(result, *it);
+                result = concat(result, *it);
             makeCurrent(result);
         }
     };

data/GosuImpl/Input.cpp

@@ -0,0 +1,329 @@
+#include <Gosu/Input.hpp>
+#include <Gosu/TextInput.hpp>
+#include <Gosu/TR1.hpp>
+#include <Gosu/Utility.hpp>
+#include <SDL2/SDL.h>
+#include <algorithm>
+#include <cwctype>
+
+struct Gosu::Input::Impl
+{
+    Input& input;
+    TextInput* textInput;
+    std::tr1::array<bool, Gosu::numButtons> buttonStates;
+    double mouseX, mouseY;
+    double mouseFactorX, mouseFactorY;
+    double mouseOffsetX, mouseOffsetY;
+    
+    Impl(Input& input)
+    : input(input), textInput(NULL)
+    {
+        std::fill(buttonStates.begin(), buttonStates.end(), false);
+        
+        mouseFactorX = mouseFactorY = 1;
+        mouseOffsetX = mouseOffsetY = 0;
+    }
+    
+    void updateMousePosition()
+    {
+        int x, y;
+        SDL_GetMouseState(&x, &y);
+        mouseX = x, mouseY = y;
+    }
+    
+    void enqueueEvent(int id, bool down)
+    {
+        eventQueue.push_back(down ? id : ~id);
+    }
+    
+    void dispatchEnqueuedEvents()
+    {
+        for (unsigned i = 0; i < eventQueue.size(); ++i) {
+            int event = eventQueue[i];
+            bool down = (event >= 0);
+            Button button(down ? event : ~event);
+            
+            buttonStates[button.id()] = down;
+            if (down && input.onButtonDown) {
+                input.onButtonDown(button);
+            }
+            else if (!down && input.onButtonUp) {
+                input.onButtonUp(button);
+            }
+        }
+        eventQueue.clear();
+    }
+    
+    void initializeGamepads()
+    {
+        int numGamepads = std::min<int>(Gosu::numGamepads, SDL_NumJoysticks());
+        
+        for (int i = 0; i < numGamepads; ++i) {
+            SDL_Joystick *joystick = SDL_JoystickOpen(i);
+            if (joystick) {
+                joysticks.push_back(joystick);
+            }
+        }
+    }
+    
+    void pollGamepads()
+    {
+        std::tr1::array<bool, gpNumPerGamepad> anyGamepad = { false };
+        
+        for (int i = 0; i < joysticks.size(); ++i) {
+            std::tr1::array<bool, gpNumPerGamepad> currentGamepad = { false };
+            
+            int axes = SDL_JoystickNumAxes(joysticks[i]),
+                hats = SDL_JoystickNumHats(joysticks[i]),
+                buttons = std::min<int>(gpNumPerGamepad - 4, SDL_JoystickNumButtons(joysticks[i]));
+            
+            for (int axis = 0; axis < axes; ++axis) {
+                Sint16 value = SDL_JoystickGetAxis(joysticks[i], axis);
+
+                if (value < -(1 << 14)) {
+                    if (axis % 2 == 0)
+                        currentGamepad[gpLeft - gpRangeBegin] = true;
+                    else
+                        currentGamepad[gpUp - gpRangeBegin] = true;
+                }
+                else if (value > +(1 << 14)) {
+                    if (axis % 2 == 0)
+                        currentGamepad[gpRight - gpRangeBegin] = true;
+                    else
+                        currentGamepad[gpDown - gpRangeBegin] = true;
+                }
+            }
+            
+            for (int hat = 0; hat < hats; ++hat) {
+                Uint8 value = SDL_JoystickGetHat(joysticks[i], hat);
+                
+                if (value == SDL_HAT_LEFT || value == SDL_HAT_LEFTUP || value == SDL_HAT_LEFTDOWN)
+                    currentGamepad[gpLeft - gpRangeBegin] = true;
+                if (value == SDL_HAT_RIGHT || value == SDL_HAT_RIGHTUP || value == SDL_HAT_RIGHTDOWN)
+                    currentGamepad[gpRight - gpRangeBegin] = true;
+                if (value == SDL_HAT_UP || value == SDL_HAT_LEFTUP || value == SDL_HAT_RIGHTUP)
+                    currentGamepad[gpUp - gpRangeBegin] = true;
+                if (value == SDL_HAT_DOWN || value == SDL_HAT_LEFTDOWN || value == SDL_HAT_RIGHTDOWN)
+                    currentGamepad[gpDown - gpRangeBegin] = true;
+            }
+            
+            for (int button = 0; button < buttons; ++button) {
+                if (SDL_JoystickGetButton(joysticks[i], button)) {
+                    currentGamepad[gpButton0 + button - gpRangeBegin] = true;
+                }
+            }
+            
+            int offset = gpRangeBegin + gpNumPerGamepad * (i + 1);
+            
+            for (int j = 0; j < currentGamepad.size(); ++j) {
+                anyGamepad[j] = anyGamepad[j] || currentGamepad[j];
+                
+                if (currentGamepad[j] && !buttonStates[j + offset]) {
+                    buttonStates[j + offset] = true;
+                    enqueueEvent(j + offset, true);
+                }
+                else if (!currentGamepad[j] && buttonStates[j + offset]) {
+                    buttonStates[j + offset] = false;
+                    enqueueEvent(j + offset, false);
+                }
+            }
+        }
+        
+        for (int j = 0; j < anyGamepad.size(); ++j) {
+            if (anyGamepad[j] && !buttonStates[j + gpRangeBegin]) {
+                buttonStates[j + gpRangeBegin] = true;
+                enqueueEvent(j + gpRangeBegin, true);
+            }
+            else if (!anyGamepad[j] && buttonStates[j + gpRangeBegin]) {
+                buttonStates[j + gpRangeBegin] = false;
+                enqueueEvent(j + gpRangeBegin, false);
+            }
+        }
+    }
+    
+private:
+    // For button down event: Button name value (>= 0)
+    // For button up event: ~Button name value (< 0)
+    std::vector<int> eventQueue;
+    
+    std::vector<SDL_Joystick*> joysticks;
+};
+
+Gosu::Input::Input()
+: pimpl(new Impl(*this))
+{
+    SDL_InitSubSystem(SDL_INIT_JOYSTICK);
+    
+    pimpl->initializeGamepads();
+}
+
+Gosu::Input::~Input()
+{
+    SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
+}
+
+bool Gosu::Input::feedSDLEvent(void* event)
+{
+    const SDL_Event* e = static_cast<SDL_Event*>(event);
+    
+    if (pimpl->textInput && pimpl->textInput->feedSDLEvent(event)) {
+        return true;
+    }
+    
+    switch (e->type) {
+        case SDL_KEYDOWN:
+        case SDL_KEYUP: {
+            if (e->key.repeat == 0 && e->key.keysym.scancode <= kbRangeEnd) {
+                pimpl->enqueueEvent(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->enqueueEvent(msLeft + e->button.button - 1, e->type == SDL_MOUSEBUTTONDOWN);
+                return true;
+            }
+            break;
+        }
+        case SDL_MOUSEWHEEL: {
+            if (e->wheel.y < 0) {
+                pimpl->enqueueEvent(msWheelUp, true);
+                return true;
+            }
+            else if (e->wheel.y > 0) {
+                pimpl->enqueueEvent(msWheelDown, false);
+                return true;
+            }
+            break;
+        }
+    }
+    return false;
+}
+
+wchar_t Gosu::Input::idToChar(Button btn)
+{
+    if (btn.id() > kbRangeEnd)
+        return 0;
+    
+    // SDL_GetKeyName would return "Space" for this value.
+    if (btn.id() == kbSpace)
+        return L' ';
+    
+    SDL_Keycode keycode = SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(btn.id()));
+    if (keycode == SDLK_UNKNOWN)
+        return 0;
+    
+    const char* name = SDL_GetKeyName(keycode);
+    if (name == NULL)
+        return 0;
+    
+    std::wstring wname = utf8ToWstring(name);
+    if (wname.length() != 1)
+        return 0;
+    
+    // Convert to lower case to be consistent with previous versions of Gosu.
+    // Also, German umlauts are already reported in lower-case by the SDL, so
+    // this makes everything a little more consistent.
+    //
+    // This should handle Turkish i/I just fine because it uses the current
+    // locale, but if we ever receive bug reports from Turkish users, they are
+    // likely caused by a combination of this line and an invalid locale :)
+    return std::towlower(wname[0]);
+}
+
+Gosu::Button Gosu::Input::charToId(wchar_t ch)
+{
+    std::wstring string(1, ch);
+    SDL_Keycode keycode = SDL_GetKeyFromName(wstringToUTF8(string).c_str());
+    
+    if (keycode == SDLK_UNKNOWN) {
+        return noButton;
+    }
+    else {
+        return Button(SDL_GetScancodeFromKey(keycode));
+    }
+}
+
+bool Gosu::Input::down(Gosu::Button btn) const
+{
+    if (btn == noButton || btn.id() >= numButtons)
+        return false;
+    
+    return pimpl->buttonStates[btn.id()];
+}
+
+double Gosu::Input::mouseX() const
+{
+    return pimpl->mouseX * pimpl->mouseFactorX + pimpl->mouseOffsetX;
+}
+
+double Gosu::Input::mouseY() const
+{
+    return pimpl->mouseY * pimpl->mouseFactorY + pimpl->mouseOffsetY;
+}
+
+void Gosu::Input::setMousePosition(double x, double y)
+{
+    // TODO - Input needs SDL Window handle to pass into this
+    SDL_WarpMouseInWindow(NULL,
+        (x - pimpl->mouseOffsetX) / pimpl->mouseFactorX,
+        (y - pimpl->mouseOffsetY) / pimpl->mouseFactorY);
+}
+
+void Gosu::Input::setMouseFactors(double factorX, double factorY,
+    double blackBarWidth, double blackBarHeight)
+{
+    pimpl->mouseFactorX = factorX;
+    pimpl->mouseFactorY = factorY;
+    pimpl->mouseOffsetX = -blackBarWidth;
+    pimpl->mouseOffsetY = -blackBarHeight;
+}
+
+const Gosu::Touches& Gosu::Input::currentTouches() const
+{
+    // Note: We can actually use the SDL's touch API to implement this, even on OS X! Neat.
+    
+    static Gosu::Touches none;
+    return none;
+}
+
+double Gosu::Input::accelerometerX() const
+{
+    return 0.0;
+}
+
+double Gosu::Input::accelerometerY() const
+{
+    return 0.0;
+}
+
+double Gosu::Input::accelerometerZ() const
+{
+    return 0.0;
+}
+
+void Gosu::Input::update()
+{
+    pimpl->updateMousePosition();
+    pimpl->dispatchEnqueuedEvents();
+    pimpl->pollGamepads();
+}
+
+Gosu::TextInput* Gosu::Input::textInput() const
+{
+    return pimpl->textInput;
+}
+
+void Gosu::Input::setTextInput(TextInput* textInput)
+{
+    if (pimpl->textInput && textInput == NULL) {
+        SDL_StopTextInput();
+    }
+    else if (pimpl->textInput == NULL && textInput) {
+        SDL_StartTextInput();
+    }
+    
+    pimpl->textInput = textInput;
+}