gosu 0.12.1 → 0.13.0

data/src/GosuViewController.cpp

@@ -4,6 +4,7 @@
 #import "GosuGLView.h"
 #import "GosuViewController.h"
 #import "GraphicsImpl.hpp"
+#import "AudioImpl.hpp"
 #import <Gosu/Gosu.hpp>
 
 #import <AudioToolbox/AudioSession.h>
@@ -15,19 +16,15 @@ namespace Gosu
     {
         void register_frame();
     }
-    
-    ALCcontext* shared_openal_context();
 }
 
-// TODO: This has been written on iOS 3.x.
-// Is this still the best way to handle interruptions?
 static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
 {
     if (inInterruptionState == kAudioSessionBeginInterruption) {
         alcMakeContextCurrent(nullptr);
     }
     else if (inInterruptionState == kAudioSessionEndInterruption) {
-        alcMakeContextCurrent(Gosu::shared_openal_context());
+        alcMakeContextCurrent(Gosu::al_context());
     }
 }
 

data/src/Graphics.cpp

@@ -13,6 +13,7 @@
 #include <algorithm>
 #include <functional>
 #include <memory>
+using namespace std;
 
 namespace Gosu
 {
@@ -23,20 +24,20 @@ namespace Gosu
         Graphics& current_graphics()
         {
             if (current_graphics_pointer == nullptr) {
-                throw std::logic_error("Gosu::Graphics can only be drawn to while rendering");
+                throw logic_error("Gosu::Graphics can only be drawn to while rendering");
             }
             
             return *current_graphics_pointer;
         }
         
-        std::vector<std::shared_ptr<Texture>> textures;
+        vector<shared_ptr<Texture>> textures;
         
         DrawOpQueueStack queues;
         
         DrawOpQueue& current_queue()
         {
             if (queues.empty()) {
-                throw std::logic_error("There is no rendering queue for this operation");
+                throw logic_error("There is no rendering queue for this operation");
             }
             return queues.back();
         }
@@ -56,7 +57,7 @@ struct Gosu::Graphics::Impl
     {
         double scale_x = 1.0 * phys_width / virt_width;
         double scale_y = 1.0 * phys_height / virt_height;
-        double scale_factor = std::min(scale_x, scale_y);
+        double scale_factor = min(scale_x, scale_y);
 
         Transform scale_transform = scale(scale_factor);
         Transform translate_transform = translate(black_width, black_height);
@@ -130,7 +131,7 @@ void Gosu::Graphics::set_resolution(unsigned virtual_width, unsigned virtual_hei
     double horizontal_black_bar_width, double vertical_black_bar_height)
 {
     if (virtual_width == 0 || virtual_height == 0) {
-        throw std::invalid_argument("Invalid virtual resolution.");
+        throw invalid_argument("Invalid virtual resolution.");
     }
     
     pimpl->virt_width   = virtual_width;
@@ -141,10 +142,10 @@ void Gosu::Graphics::set_resolution(unsigned virtual_width, unsigned virtual_hei
     pimpl->update_base_transform();
 }
 
-void Gosu::Graphics::frame(const std::function<void ()>& f)
+void Gosu::Graphics::frame(const function<void ()>& f)
 {
     if (current_graphics_pointer != nullptr) {
-        throw std::logic_error("Cannot nest calls to Gosu::Graphics::begin()");
+        throw logic_error("Cannot nest calls to Gosu::Graphics::begin()");
     }
     
     // Cancel all recording or whatever that might still be in progress...
@@ -152,7 +153,7 @@ void Gosu::Graphics::frame(const std::function<void ()>& f)
     
     if (pimpl->warmed_up_queues.size() == 1) {
         // If we already have a "warmed up" queue, use that instead.
-        // -> All internals std::vectors will already have a lot of capacity.
+        // -> All internal std::vectors will already have a lot of capacity.
         // This helps reduce allocations during normal operation.
         queues.clear();
         queues.swap(pimpl->warmed_up_queues);
@@ -222,14 +223,14 @@ void Gosu::Graphics::flush()
     current_queue().clear_queue();
 }
 
-void Gosu::Graphics::gl(const std::function<void ()>& f)
+void Gosu::Graphics::gl(const function<void ()>& f)
 {
     if (current_queue().recording()) {
-        throw std::logic_error("Custom OpenGL is not allowed while creating a macro");
+        throw logic_error("Custom OpenGL is not allowed while creating a macro");
     }
     
 #ifdef GOSU_IS_OPENGLES
-    throw std::logic_error("Custom OpenGL ES is not supported yet");
+    throw logic_error("Custom OpenGL ES is not supported yet");
 #else
     Graphics& cg = current_graphics();
 
@@ -243,10 +244,10 @@ void Gosu::Graphics::gl(const std::function<void ()>& f)
 #endif
 }
 
-void Gosu::Graphics::gl(Gosu::ZPos z, const std::function<void ()>& f)
+void Gosu::Graphics::gl(Gosu::ZPos z, const function<void ()>& f)
 {
 #ifdef GOSU_IS_OPENGLES
-    throw std::logic_error("Custom OpenGL ES is not supported yet");
+    throw logic_error("Custom OpenGL ES is not supported yet");
 #else
     current_queue().gl([f] {
         Graphics& cg = current_graphics();
@@ -258,7 +259,7 @@ void Gosu::Graphics::gl(Gosu::ZPos z, const std::function<void ()>& f)
 }
 
 void Gosu::Graphics::clip_to(double x, double y, double width, double height,
-                             const std::function<void ()>& f)
+                             const function<void ()>& f)
 {
     double screen_height = current_graphics().pimpl->phys_height;
     current_queue().begin_clipping(x, y, width, height, screen_height);
@@ -266,21 +267,20 @@ void Gosu::Graphics::clip_to(double x, double y, double width, double height,
     current_queue().end_clipping();
 }
 
-std::unique_ptr<Gosu::ImageData> Gosu::Graphics::record(int width, int height,
-                                                        const std::function<void ()>& f)
+unique_ptr<Gosu::ImageData> Gosu::Graphics::record(int width, int height,
+                                                   const function<void ()>& f)
 {
     queues.resize(queues.size() + 1);
     current_queue().set_recording();
 
     f();
     
-    std::unique_ptr<ImageData> result(new Macro(current_queue(), width, height));
+    unique_ptr<ImageData> result(new Macro(current_queue(), width, height));
     queues.pop_back();
     return result;
 }
 
-void Gosu::Graphics::transform(const Gosu::Transform& transform,
-                               const std::function<void ()>& f)
+void Gosu::Graphics::transform(const Gosu::Transform& transform, const function<void ()>& f)
 {
     current_queue().push_transform(transform);
     f();
@@ -341,6 +341,12 @@ void Gosu::Graphics::draw_quad(double x1, double y1, Color c1, double x2, double
     current_queue().schedule_draw_op(op);
 }
 
+void Gosu::Graphics::draw_rect(double x, double y, double width, double height, Color c,
+                               ZPos z, Gosu::AlphaMode mode)
+{
+    draw_quad(x, y, c, x + width, y, c, x, y + height, c, x + width, y + height, c, z, mode);
+}
+
 void Gosu::Graphics::schedule_draw_op(const Gosu::DrawOp& op)
 {
     current_queue().schedule_draw_op(op);
@@ -363,7 +369,7 @@ void Gosu::Graphics::set_physical_resolution(unsigned phys_width, unsigned phys_
     pimpl->update_base_transform();
 }
 
-std::unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
+unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
     unsigned src_x, unsigned src_y, unsigned src_width, unsigned src_height, unsigned flags)
 {
     static const unsigned max_size = MAX_TEXTURE_SIZE;
@@ -380,8 +386,8 @@ std::unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
             src_width == src_height &&
             (src_width & (src_width - 1)) == 0 &&
             src_width >= 64 && src_width <= max_size) {
-        std::shared_ptr<Texture> texture(new Texture(src_width, wants_retro));
-        std::unique_ptr<ImageData> data;
+        shared_ptr<Texture> texture(new Texture(src_width, wants_retro));
+        unique_ptr<ImageData> data;
         
         // Use the source bitmap directly if the source area completely covers
         // it.
@@ -394,19 +400,17 @@ std::unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
             data = texture->try_alloc(texture, bmp, 0);
         }
         
-        if (!data.get()) {
-            throw std::logic_error("Internal texture block allocation error");
-        }
-        return std::move(data);
+        if (!data.get()) throw logic_error("Internal texture block allocation error");
+        return data;
     }
     
     // Too large to fit on a single texture.
     if (src_width > max_size - 2 || src_height > max_size - 2) {
         Bitmap bmp(src_width, src_height);
         bmp.insert(src, 0, 0, src_x, src_y, src_width, src_height);
-        std::unique_ptr<ImageData> lidi;
+        unique_ptr<ImageData> lidi;
         lidi.reset(new LargeImageData(bmp, max_size - 2, max_size - 2, flags));
-        return std::move(lidi);
+        return lidi;
     }
     
     Bitmap bmp;
@@ -416,24 +420,19 @@ std::unique_ptr<Gosu::ImageData> Gosu::Graphics::create_image(const Bitmap& src,
     for (auto texture : textures) {
         if (texture->retro() != wants_retro) continue;
         
-        std::unique_ptr<ImageData> data;
+        unique_ptr<ImageData> data;
         data = texture->try_alloc(texture, bmp, 1);
-        if (data.get()) {
-            return std::move(data);
-        }
+        if (data.get()) return data;
     }
     
     // All textures are full: Create a new one.
     
-    std::shared_ptr<Texture> texture;
+    shared_ptr<Texture> texture;
     texture.reset(new Texture(max_size, wants_retro));
     textures.push_back(texture);
     
-    std::unique_ptr<ImageData> data;
+    unique_ptr<ImageData> data;
     data = texture->try_alloc(texture, bmp, 1);
-    if (!data.get()) {
-        throw std::logic_error("Internal texture block allocation error");
-    }
-
-    return std::move(data);
+    if (!data.get()) throw logic_error("Internal texture block allocation error");
+    return data;
 }

data/src/IO.cpp

@@ -1,14 +1,15 @@
 #include <Gosu/IO.hpp>
 #include <cassert>
 #include <cstring>
+using namespace std;
 
-void Gosu::Reader::read(void* dest, std::size_t length)
+void Gosu::Reader::read(void* dest, size_t length)
 {
     res->read(pos, length, dest);
     seek(length);
 }
 
-void Gosu::Writer::write(const void* source, std::size_t length)
+void Gosu::Writer::write(const void* source, size_t length)
 {
     // Try to resize the source if necessary.
     if (pos + length > res->size()) {
@@ -19,40 +20,40 @@ void Gosu::Writer::write(const void* source, std::size_t length)
     seek(length);
 }
 
-std::size_t Gosu::Buffer::size() const
+size_t Gosu::Buffer::size() const
 {
     return buf.size();
 }
 
-void Gosu::Buffer::resize(std::size_t new_size)
+void Gosu::Buffer::resize(size_t new_size)
 {
     buf.resize(new_size);
 }
 
-void Gosu::Buffer::read(std::size_t offset, std::size_t length, void* dest_buffer) const
+void Gosu::Buffer::read(size_t offset, size_t length, void* dest_buffer) const
 {
     assert (offset + length <= size());
     if (length) {
-        std::memcpy(dest_buffer, &buf[offset], length);
+        memcpy(dest_buffer, &buf[offset], length);
     }
 }
 
-void Gosu::Buffer::write(std::size_t offset, std::size_t length, const void* source_buffer)
+void Gosu::Buffer::write(size_t offset, size_t length, const void* source_buffer)
 {
     assert (offset + length <= size());
     if (length) {
-        std::memcpy(&buf[offset], source_buffer, length);
+        memcpy(&buf[offset], source_buffer, length);
     }
 }
 
-void Gosu::load_file(Buffer& buffer, const std::string& filename)
+void Gosu::load_file(Buffer& buffer, const string& filename)
 {
     File file(filename);
     buffer.resize(file.size());
     file.read(0, buffer.size(), buffer.data());
 }
 
-void Gosu::save_file(const Buffer& buffer, const std::string& filename)
+void Gosu::save_file(const Buffer& buffer, const string& filename)
 {
     File file(filename, FM_REPLACE);
     file.write(0, buffer.size(), buffer.data());

data/src/Image.cpp

@@ -5,8 +5,15 @@
 #include <Gosu/ImageData.hpp>
 #include <Gosu/Math.hpp>
 #include <stdexcept>
+#include "EmptyImageData.hpp"
+using namespace std;
 
-Gosu::Image::Image(const std::string& filename, unsigned flags)
+Gosu::Image::Image()
+: data_(EmptyImageData::instance_ptr())
+{
+}
+
+Gosu::Image::Image(const string& filename, unsigned flags)
 {
     // Forward.
     Bitmap bmp;
@@ -14,7 +21,7 @@ Gosu::Image::Image(const std::string& filename, unsigned flags)
     Image(bmp, flags).data_.swap(data_);
 }
 
-Gosu::Image::Image(const std::string& filename, unsigned src_x, unsigned src_y, unsigned src_width,
+Gosu::Image::Image(const string& filename, unsigned src_x, unsigned src_y, unsigned src_width,
     unsigned src_height, unsigned flags)
 {
     // Forward.
@@ -35,11 +42,11 @@ Gosu::Image::Image(const Bitmap& source, unsigned src_x, unsigned src_y, unsigne
 {
 }
 
-Gosu::Image::Image(std::unique_ptr<ImageData>&& data)
+Gosu::Image::Image(unique_ptr<ImageData>&& data)
 : data_(data.release())
 {
     if (this->data_.get() == nullptr) {
-        throw std::invalid_argument("Gosu::Image cannot be initialized with nullptr");
+        throw invalid_argument("Gosu::Image cannot be initialized with nullptr");
     }
 }
 
@@ -101,11 +108,11 @@ 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)
+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;
+    vector<Image> images;
     
     if (tile_width > 0) {
         tiles_x = bmp.width() / tile_width;
@@ -133,8 +140,8 @@ std::vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bmp, int tile_width, int
     return images;
 }
 
-std::vector<Gosu::Image> Gosu::load_tiles(const std::string& filename, int tile_width,
-    int tile_height, unsigned flags)
+vector<Gosu::Image> Gosu::load_tiles(const string& filename, int tile_width, int tile_height,
+                                     unsigned flags)
 {
     Bitmap bmp;
     load_image_file(bmp, filename);

data/src/Input.cpp

@@ -9,6 +9,7 @@
 #include <cstdlib>
 #include <algorithm>
 #include <array>
+using namespace std;
 
 static void require_sdl_video()
 {
@@ -16,11 +17,11 @@ static void require_sdl_video()
     if (!initialized) {
         SDL_InitSubSystem(SDL_INIT_VIDEO);
         initialized = true;
-        std::atexit([] { SDL_QuitSubSystem(SDL_INIT_VIDEO); });
+        atexit([] { SDL_QuitSubSystem(SDL_INIT_VIDEO); });
     }
 }
 
-static std::array<bool, Gosu::NUM_BUTTONS> button_states = { { false } };
+static array<bool, Gosu::NUM_BUTTONS> button_states = { { false } };
 
 struct Gosu::Input::Impl
 {
@@ -41,7 +42,7 @@ struct Gosu::Input::Impl
         
         SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
         
-        int num_gamepads = std::min<int>(Gosu::NUM_GAMEPADS, SDL_NumJoysticks());
+        int num_gamepads = min<int>(Gosu::NUM_GAMEPADS, SDL_NumJoysticks());
         
         for (int i = 0; i < num_gamepads; ++i) {
             // Prefer the SDL_GameController API...
@@ -60,9 +61,9 @@ struct Gosu::Input::Impl
     
     ~Impl()
     {
-        std::for_each(joysticks.begin(), joysticks.end(), &SDL_JoystickClose);
+        for_each(joysticks.begin(), joysticks.end(), &SDL_JoystickClose);
         joysticks.clear();
-        std::for_each(game_controllers.begin(), game_controllers.end(), &SDL_GameControllerClose);
+        for_each(game_controllers.begin(), game_controllers.end(), &SDL_GameControllerClose);
         game_controllers.clear();
         
         SDL_QuitSubSystem(SDL_INIT_GAMECONTROLLER);
@@ -139,7 +140,7 @@ struct Gosu::Input::Impl
         return false;
     }
     
-    typedef std::array<bool, GP_NUM_PER_GAMEPAD> GamepadBuffer;
+    typedef array<bool, GP_NUM_PER_GAMEPAD> GamepadBuffer;
     
     void poll_gamepads()
     {
@@ -148,7 +149,7 @@ struct Gosu::Input::Impl
         // true. This is handy for singleplayer games.
         GamepadBuffer any_gamepad = { false };
         
-        std::size_t available_gamepads = game_controllers.size() + joysticks.size();
+        size_t available_gamepads = game_controllers.size() + joysticks.size();
         
         for (int i = 0; i < available_gamepads; ++i) {
             GamepadBuffer current_gamepad = { false };
@@ -213,15 +214,15 @@ struct Gosu::Input::Impl
 private:
     // For button down event: Button name value (>= 0)
     // For button up event: ~Button name value (< 0)
-    std::vector<int> event_queue;
+    vector<int> event_queue;
 
     void enqueue_event(int id, bool down)
     {
         event_queue.push_back(down ? id : ~id);
     }
     
-    std::vector<SDL_Joystick*> joysticks;
-    std::vector<SDL_GameController*> game_controllers;
+    vector<SDL_Joystick*> joysticks;
+    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 (half of that range) the dead zone.
@@ -283,7 +284,7 @@ private:
             if (value & SDL_HAT_DOWN)  gamepad[GP_DOWN  - GP_RANGE_BEGIN] = true;
         }
         
-        int buttons = std::min<int>(GP_NUM_PER_GAMEPAD - 4, SDL_JoystickNumButtons(joystick));
+        int buttons = min<int>(GP_NUM_PER_GAMEPAD - 4, SDL_JoystickNumButtons(joystick));
         for (int button = 0; button < buttons; ++button) {
             if (SDL_JoystickGetButton(joystick, button)) {
                 gamepad[GP_BUTTON_0 + button - GP_RANGE_BEGIN] = true;
@@ -307,7 +308,7 @@ bool Gosu::Input::feed_sdl_event(void* event)
         pimpl->feed_sdl_event(static_cast<SDL_Event*>(event));
 }
 
-std::string Gosu::Input::id_to_char(Button btn)
+string Gosu::Input::id_to_char(Button btn)
 {
     require_sdl_video();
     
@@ -322,17 +323,17 @@ std::string Gosu::Input::id_to_char(Button btn)
     const char* name = SDL_GetKeyName(keycode);
     if (name == nullptr) return "";
     
-    std::wstring wname = utf8_to_wstring(name);
+    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]);
+    wname[0] = (wchar_t) towlower((int) wname[0]);
     return wstring_to_utf8(wname);
 }
 
-Gosu::Button Gosu::Input::char_to_id(std::string ch)
+Gosu::Button Gosu::Input::char_to_id(string ch)
 {
     require_sdl_video();