gosu 0.8.7.2 → 0.9.0.pre1

data/src/Graphics/LargeImageData.cpp

@@ -6,9 +6,8 @@
 #include <cmath>
 using namespace std;
 
-Gosu::LargeImageData::LargeImageData(Graphics& graphics,
-    const Bitmap& source, unsigned partWidth, unsigned partHeight,
-    unsigned borderFlags)
+Gosu::LargeImageData::LargeImageData(const Bitmap& source,
+    unsigned partWidth, unsigned partHeight, unsigned flags)
 {
     fullWidth = source.width();
     fullHeight = source.height();
@@ -32,19 +31,19 @@ Gosu::LargeImageData::LargeImageData(Graphics& graphics,
             if (y == partsY - 1 && source.height() % partHeight != 0)
                 srcHeight = source.height() % partHeight;
 
-            unsigned localBorderFlags = bfTileable;
+            unsigned localFlags = ifTileable;
             if (x == 0)
-                localBorderFlags = (localBorderFlags & ~bfTileableLeft) | (borderFlags & bfTileableLeft);
+                localFlags = (localFlags & ~ifTileableLeft) | (flags & ifTileableLeft);
             if (x == partsX - 1)
-                localBorderFlags = (localBorderFlags & ~bfTileableRight) | (borderFlags & bfTileableRight);
+                localFlags = (localFlags & ~ifTileableRight) | (flags & ifTileableRight);
             if (y == 0)
-                localBorderFlags = (localBorderFlags & ~bfTileableTop) | (borderFlags & bfTileableTop);
+                localFlags = (localFlags & ~ifTileableTop) | (flags & ifTileableTop);
             if (y == partsY - 1)
-                localBorderFlags = (localBorderFlags & ~bfTileableBottom) | (borderFlags & bfTileableBottom);
+                localFlags = (localFlags & ~ifTileableBottom) | (flags & ifTileableBottom);
             
-            parts[y * partsX + x].reset(graphics.createImage(source,
+            parts[y * partsX + x].reset(Graphics::createImage(source,
                 x * partWidth, y * partHeight, srcWidth, srcHeight,
-                localBorderFlags).release());
+                localFlags).release());
         }
 }
 

data/src/Graphics/LargeImageData.hpp

@@ -16,7 +16,7 @@ namespace Gosu
         std::vector<std::tr1::shared_ptr<ImageData> > parts;
 
     public:
-        LargeImageData(Graphics& graphics, const Bitmap& source,
+        LargeImageData(const Bitmap& source,
             unsigned partWidth, unsigned partHeight, unsigned borderFlags);
 
         int width() const;

data/src/Graphics/TexChunk.cpp

@@ -14,16 +14,15 @@ void Gosu::TexChunk::setTexInfo()
     info.bottom = (y + h) / textureSize;
 }
 
-Gosu::TexChunk::TexChunk(Graphics& graphics, DrawOpQueueStack& queues,
-    std::tr1::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
-: graphics(graphics), queues(queues), texture(texture), x(x), y(y), w(w), h(h), padding(padding)
+Gosu::TexChunk::TexChunk(std::tr1::shared_ptr<Texture> texture,
+    int x, int y, int w, int h, int padding)
+: texture(texture), x(x), y(y), w(w), h(h), padding(padding)
 {
     setTexInfo();
 }
 
 Gosu::TexChunk::TexChunk(const TexChunk& parentChunk, int x, int y, int w, int h)
-: graphics(parentChunk.graphics), queues(parentChunk.queues), texture(parentChunk.texture),
-    x(parentChunk.x + x), y(parentChunk.y + y), w(w), h(h), padding(0)
+: texture(parentChunk.texture), x(parentChunk.x + x), y(parentChunk.y + y), w(w), h(h), padding(0)
 {
     setTexInfo();
     texture->block(this->x, this->y, this->w, this->h);
@@ -63,7 +62,7 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     op.bottom = info.bottom;
     
     op.z = z;
-    queues.back().scheduleDrawOp(op);
+    Graphics::scheduleDrawOp(op);
 }
 
 const Gosu::GLTexInfo* Gosu::TexChunk::glTexInfo() const

data/src/Graphics/TexChunk.hpp

@@ -11,8 +11,6 @@
 
 class Gosu::TexChunk : public Gosu::ImageData
 {
-    Graphics& graphics;
-    DrawOpQueueStack& queues;
     std::tr1::shared_ptr<Texture> texture;
     int x, y, w, h, padding;
     
@@ -22,8 +20,7 @@ class Gosu::TexChunk : public Gosu::ImageData
     void setTexInfo();
     
 public:
-    TexChunk(Graphics& graphics, DrawOpQueueStack& queues,
-             std::tr1::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
+    TexChunk(std::tr1::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
     TexChunk(const TexChunk& parentChunk, int x, int y, int w, int h);
     ~TexChunk();
 

data/src/Graphics/Texture.cpp

@@ -13,6 +13,8 @@ namespace Gosu
 Gosu::Texture::Texture(unsigned size)
 : allocator(size, size)
 {
+    ensureCurrentContext();
+    
     // Create texture name.
     glGenTextures(1, &name);
     if (name == static_cast<GLuint>(-1))
@@ -50,6 +52,8 @@ Gosu::Texture::Texture(unsigned size)
 
 Gosu::Texture::~Texture()
 {
+    ensureCurrentContext();
+    
     glDeleteTextures(1, &name);
 }
 
@@ -64,8 +68,7 @@ GLuint Gosu::Texture::texName() const
 }
 
 GOSU_UNIQUE_PTR<Gosu::TexChunk>
-    Gosu::Texture::tryAlloc(Graphics& graphics, DrawOpQueueStack& queues,
-        std::tr1::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding)
+    Gosu::Texture::tryAlloc(std::tr1::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding)
 {
     GOSU_UNIQUE_PTR<Gosu::TexChunk> result;
     
@@ -73,9 +76,11 @@ GOSU_UNIQUE_PTR<Gosu::TexChunk>
     if (!allocator.alloc(bmp.width(), bmp.height(), block))
         return result;
     
-    result.reset(new TexChunk(graphics, queues, ptr, block.left + padding, block.top + padding,
+    result.reset(new TexChunk(ptr, block.left + padding, block.top + padding,
                               block.width - 2 * padding, block.height - 2 * padding, padding));
     
+    ensureCurrentContext();
+    
     glBindTexture(GL_TEXTURE_2D, name);
     glTexSubImage2D(GL_TEXTURE_2D, 0, block.left, block.top, block.width, block.height,
                  Color::GL_FORMAT, GL_UNSIGNED_BYTE, bmp.data());
@@ -98,6 +103,8 @@ Gosu::Bitmap Gosu::Texture::toBitmap(unsigned x, unsigned y, unsigned width, uns
 #ifdef GOSU_IS_OPENGLES
     throw std::logic_error("Texture::toBitmap not supported on iOS");
 #else
+    ensureCurrentContext();
+    
     Gosu::Bitmap fullTexture(size(), size());
     glBindTexture(GL_TEXTURE_2D, name);
     glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, fullTexture.data());

data/src/Graphics/Texture.hpp

@@ -22,8 +22,7 @@ namespace Gosu
         unsigned size() const;
         GLuint texName() const;
         GOSU_UNIQUE_PTR<TexChunk>
-            tryAlloc(Graphics& graphics, DrawOpQueueStack& queues,
-                std::tr1::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding);
+            tryAlloc(std::tr1::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding);
         void block(unsigned x, unsigned y, unsigned width, unsigned height);
         void free(unsigned x, unsigned y, unsigned width, unsigned height);
         Gosu::Bitmap toBitmap(unsigned x, unsigned y, unsigned width, unsigned height) const;

data/src/Iconv.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSIMPL_ICONV_HPP
-#define GOSIMPL_ICONV_HPP
+#ifndef GOSUIMPL_ICONV_HPP
+#define GOSUIMPL_ICONV_HPP
 
 #include <Gosu/Platform.hpp>
 

data/src/Input/Input.cpp

@@ -3,14 +3,30 @@
 #include <Gosu/TR1.hpp>
 #include <Gosu/Utility.hpp>
 #include <SDL2/SDL.h>
-#include <algorithm>
 #include <cwctype>
+#include <cstdlib>
+#include <algorithm>
+
+namespace
+{
+    void requireSDLVideo()
+    {
+        static bool initializedSDLVideo = false;
+        if (!initializedSDLVideo)
+        {
+            SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER);
+            std::atexit(SDL_Quit);
+            initializedSDLVideo = true;
+        }
+    }
+    
+    std::tr1::array<bool, Gosu::numButtons> buttonStates { { false } };
+}
 
 struct Gosu::Input::Impl
 {
     Input& input;
     TextInput* textInput;
-    std::tr1::array<bool, Gosu::numButtons> buttonStates;
     double mouseX, mouseY;
     double mouseFactorX, mouseFactorY;
     double mouseOffsetX, mouseOffsetY;
@@ -18,8 +34,6 @@ struct Gosu::Input::Impl
     Impl(Input& input)
     : input(input), textInput(NULL)
     {
-        std::fill(buttonStates.begin(), buttonStates.end(), false);
-        
         mouseFactorX = mouseFactorY = 1;
         mouseOffsetX = mouseOffsetY = 0;
     }
@@ -225,7 +239,7 @@ private:
 Gosu::Input::Input()
 : pimpl(new Impl(*this))
 {
-    SDL_InitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
+    requireSDLVideo();
     
     pimpl->initializeGamepads();
 }
@@ -233,8 +247,6 @@ Gosu::Input::Input()
 Gosu::Input::~Input()
 {
     pimpl->releaseGamepads();
-    
-    SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
 }
 
 bool Gosu::Input::feedSDLEvent(void* event)
@@ -281,6 +293,8 @@ bool Gosu::Input::feedSDLEvent(void* event)
 
 wchar_t Gosu::Input::idToChar(Button btn)
 {
+    requireSDLVideo();
+    
     if (btn.id() > kbRangeEnd)
         return 0;
     
@@ -312,6 +326,8 @@ wchar_t Gosu::Input::idToChar(Button btn)
 
 Gosu::Button Gosu::Input::charToId(wchar_t ch)
 {
+    requireSDLVideo();
+    
     std::wstring string(1, ch);
     SDL_Keycode keycode = SDL_GetKeyFromName(wstringToUTF8(string).c_str());
     
@@ -323,12 +339,12 @@ Gosu::Button Gosu::Input::charToId(wchar_t ch)
     }
 }
 
-bool Gosu::Input::down(Gosu::Button btn) const
+bool Gosu::Input::down(Gosu::Button btn)
 {
     if (btn == noButton || btn.id() >= numButtons)
         return false;
     
-    return pimpl->buttonStates[btn.id()];
+    return buttonStates[btn.id()];
 }
 
 double Gosu::Input::mouseX() const

data/src/Input/InputTouch.mm

@@ -2,7 +2,7 @@
 #include <Gosu/TextInput.hpp>
 
 #include "MacUtility.hpp"
-#include "Input/AccelerometerReader.hpp"
+#include "AccelerometerReader.hpp"
 #import <UIKit/UIKit.h>
 
 struct Gosu::TextInput::Impl {};
@@ -26,7 +26,7 @@ struct Gosu::Input::Impl
     Touch translateTouch(UITouch* uiTouch)
     {
         CGPoint point = [uiTouch locationInView: view];
-        Touch touch = { uiTouch, point.x, point.y };
+        Touch touch = { uiTouch, (float)point.x, (float)point.y };
         touch.x *= factorX, touch.y *= factorY;
         return touch;
     }
@@ -100,9 +100,11 @@ void Gosu::Input::setMousePosition(double x, double y) {
     pimpl->mouseY = y;
 }
 
-void Gosu::Input::setMouseFactors(double factorX, double factorY) {
+void Gosu::Input::setMouseFactors(double factorX, double factorY, double offsetX, double offsetY) {
     pimpl->factorX = factorX;
     pimpl->factorY = factorY;
+    
+    // TODO - use offset
 }
 
 const Gosu::Touches& Gosu::Input::currentTouches() const

data/src/Text/Font.cpp

@@ -12,7 +12,6 @@ using namespace std;
 
 struct Gosu::Font::Impl
 {
-    Graphics* graphics;
     wstring name;
     unsigned height, flags;
 
@@ -49,7 +48,7 @@ struct Gosu::Font::Impl
         {
             tr1::shared_ptr<Image>& ptr = entityCache[fs.entityAt(i)];
             if (!ptr)
-                ptr.reset(new Image(*graphics, entityBitmap(fs.entityAt(i)), false));
+                ptr.reset(new Image(entityBitmap(fs.entityAt(i)), ifSmooth));
             return *ptr;
         }
         
@@ -68,7 +67,7 @@ struct Gosu::Font::Impl
         
         Bitmap bitmap(charWidth, height);
         drawText(bitmap, charString, 0, 0, Color::WHITE, name, height, flags);
-        info.image.reset(new Image(*graphics, bitmap));
+        info.image.reset(new Image(bitmap));
         info.factor = 0.5;
         return *info.image;
     }
@@ -81,11 +80,9 @@ struct Gosu::Font::Impl
     }
 };
 
-Gosu::Font::Font(Graphics& graphics, const wstring& fontName, unsigned fontHeight,
-    unsigned fontFlags)
+Gosu::Font::Font(unsigned fontHeight, const wstring& fontName, unsigned fontFlags)
 : pimpl(new Impl)
 {
-    pimpl->graphics = &graphics;
     pimpl->name = fontName;
     pimpl->height = fontHeight * 2;
     pimpl->flags = fontFlags;
@@ -164,7 +161,15 @@ void Gosu::Font::setImage(wchar_t wc, unsigned fontFlags, const Image& image)
 void Gosu::Font::drawRot(const wstring& text, double x, double y, ZPos z, double angle,
     double factorX, double factorY, Color c, AlphaMode mode) const
 {
-    pimpl->graphics->pushTransform(rotate(angle, x, y));
+    Gosu::Graphics::pushTransform(rotate(angle, x, y));
     draw(text, x, y, z, factorX, factorY, c, mode);
-    pimpl->graphics->popTransform();
+    Gosu::Graphics::popTransform();
+}
+
+// Deprecated constructors
+
+Gosu::Font::Font(Graphics& graphics, const wstring& fontName, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    Font(fontHeight, fontName, fontFlags).pimpl.swap(pimpl);
 }

data/src/Window.cpp

@@ -1,4 +1,5 @@
 #include <Gosu/Gosu.hpp>
+#include "Graphics/Common.hpp"
 #include <SDL2/SDL.h>
 #include <cstdlib>
 #include <memory>
@@ -18,12 +19,56 @@ namespace Gosu
         const char *error = SDL_GetError();
         throw std::runtime_error(operation + ": " + (error ? error : "(unknown error)"));
     }
+    
+    SDL_Window* sharedWindow()
+    {
+        static SDL_Window *window = 0;
+        if (window == 0)
+        {
+            if (SDL_Init(SDL_INIT_VIDEO) < 0)
+                throwSDLError("Could not initialize SDL Video");
+            
+            atexit(SDL_Quit);
+            
+            Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN;
+            
+            #if SDL_VERSION_ATLEAST(2, 0, 1)
+            flags |= SDL_WINDOW_ALLOW_HIGHDPI;
+            #endif
+            
+            window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 64, 64, flags);
+            if (window == 0)
+                throwSDLError("Could not create window");
+        }
+        return window;
+    }
+    
+    SDL_GLContext sharedGLContext()
+    {
+        static SDL_GLContext context = 0;
+        if (context == 0)
+        {
+            #ifdef GOSU_IS_OPENGLES
+            SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
+            SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+            #endif
+            
+            context = SDL_GL_CreateContext(sharedWindow());
+            
+            if (context == 0)
+                throwSDLError("Could not create OpenGL context");
+        }
+        return context;
+    }
+    
+    void ensureCurrentContext()
+    {
+        SDL_GL_MakeCurrent(sharedWindow(), sharedGLContext());
+    }
 }
 
 struct Gosu::Window::Impl
 {
-    SDL_Window *window;
-    SDL_GLContext context;
     double updateInterval;
     
     std::auto_ptr<Graphics> graphics;
@@ -33,8 +78,6 @@ struct Gosu::Window::Impl
 Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double updateInterval)
 : pimpl(new Impl)
 {
-    if (SDL_Init(SDL_INIT_VIDEO) < 0)
-        throwSDLError("Could not initialize SDL Video");
     
     int actualWidth = width;
     int actualHeight = height;
@@ -68,34 +111,22 @@ Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double up
         }
     }
     
-    Uint32 flags = SDL_WINDOW_OPENGL;
-#if SDL_VERSION_ATLEAST(2, 0, 1)
-    flags |= SDL_WINDOW_ALLOW_HIGHDPI;
-#endif
-    if (fullscreen) {
-        flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
-    }
-    
-    pimpl->window = SDL_CreateWindow("",
-        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
-        actualWidth, actualHeight, flags);
-    if (! pimpl->window)
-        throwSDLError("Could not open window");
-
-#ifdef GOSU_IS_OPENGLES
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
-#endif
-
-#if SDL_VERSION_ATLEAST(2, 0, 1)
-    SDL_GL_GetDrawableSize(pimpl->window, &actualWidth, &actualHeight);
-#endif
+    // TODO - it would be better/enough to only do this in show()
     
-    pimpl->context = SDL_GL_CreateContext(pimpl->window);
-    if (! pimpl->context)
-        throwSDLError("Could not create OpenGL context");
+    SDL_SetWindowTitle(sharedWindow(), "");
+    SDL_SetWindowSize(sharedWindow(), actualWidth, actualHeight);
+    SDL_SetWindowPosition(sharedWindow(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    if (fullscreen)
+    {
+        SDL_SetWindowFullscreen(sharedWindow(), fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
+    }
+    SDL_ShowWindow(sharedWindow());
+
+    #if SDL_VERSION_ATLEAST(2, 0, 1)
+    SDL_GL_GetDrawableSize(sharedWindow(), &actualWidth, &actualHeight);
+    #endif
     
-    SDL_GL_MakeCurrent(pimpl->window, pimpl->context);
+    ensureCurrentContext();
     SDL_GL_SetSwapInterval(1);
     
     pimpl->graphics.reset(new Graphics(actualWidth, actualHeight, fullscreen));
@@ -109,21 +140,18 @@ Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double up
 
 Gosu::Window::~Window()
 {
-    SDL_GL_DeleteContext(pimpl->context);
-    SDL_DestroyWindow(pimpl->window);
-    
-    SDL_QuitSubSystem(SDL_INIT_VIDEO);
+    SDL_HideWindow(sharedWindow());
 }
 
 std::wstring Gosu::Window::caption() const
 {
-    return utf8ToWstring(SDL_GetWindowTitle(pimpl->window));
+    return utf8ToWstring(SDL_GetWindowTitle(sharedWindow()));
 }
 
 void Gosu::Window::setCaption(const std::wstring& caption)
 {
     std::string utf8 = wstringToUTF8(caption);
-    SDL_SetWindowTitle(pimpl->window, utf8.c_str());
+    SDL_SetWindowTitle(sharedWindow(), utf8.c_str());
 }
 
 double Gosu::Window::updateInterval() const
@@ -162,13 +190,14 @@ void Gosu::Window::show()
         SDL_ShowCursor(needsCursor());
         
         if (needsRedraw()) {
+            ensureCurrentContext();
             if (graphics().begin()) {
                 draw();
                 graphics().end();
                 FPS::registerFrame();
             }
             
-            SDL_GL_SwapWindow(pimpl->window);
+            SDL_GL_SwapWindow(sharedWindow());
             
             if (GosusDarkSide::oncePerTick) GosusDarkSide::oncePerTick();
         }