gosu 0.12.1 → 0.13.0

data/src/BlockAllocator.cpp

@@ -1,12 +1,13 @@
 #include "BlockAllocator.hpp"
 #include <stdexcept>
 #include <vector>
+using namespace std;
 
 struct Gosu::BlockAllocator::Impl
 {
     unsigned width, height;
 
-    std::vector<Block> blocks;
+    vector<Block> blocks;
     unsigned first_x, first_y;
     unsigned max_w, max_h;
     
@@ -31,8 +32,8 @@ struct Gosu::BlockAllocator::Impl
 
         // Test if the block collides with any existing rects.
         for (auto b : blocks) {
-            if (b.left < right && block.left < b.left + b.width && b.top < bottom
-                && block.top < b.top + b.height) {
+            if (b.left < right && block.left < b.left + b.width &&
+                    b.top < bottom && block.top < b.top + b.height) {
                 return false;
             }
         }
@@ -71,14 +72,10 @@ unsigned Gosu::BlockAllocator::height() const
 bool Gosu::BlockAllocator::alloc(unsigned a_width, unsigned a_height, Block& b)
 {
     // The rect wouldn't even fit onto the texture!
-    if (a_width > width() || a_height > height()) {
-        return false;
-    }
+    if (a_width > width() || a_height > height()) return false;
 
     // We know there's no space left.
-    if (a_width > pimpl->max_w && a_height > pimpl->max_h) {
-        return false;
-    }
+    if (a_width > pimpl->max_w && a_height > pimpl->max_h) return false;
     
     // Start to look for a place next to the last returned rect. Chances are
     // good we'll find a place there.
@@ -129,5 +126,5 @@ void Gosu::BlockAllocator::free(unsigned left, unsigned top, unsigned width, uns
         }
     }
 
-    throw std::logic_error("Tried to free an invalid block");
+    throw logic_error("Tried to free an invalid block");
 }

data/src/BlockAllocator.hpp

@@ -15,10 +15,8 @@ namespace Gosu
         {
             unsigned left, top, width, height;
             Block() {}
-            Block(unsigned a_left, unsigned a_top, unsigned a_width, unsigned a_height)
-            : left(a_left), top(a_top), width(a_width), height(a_height)
-            {
-            }
+            Block(unsigned left, unsigned top, unsigned width, unsigned height)
+            : left(left), top(top), width(width), height(height) {}
         };
 
         BlockAllocator(unsigned width, unsigned height);

data/src/Channel.cpp

@@ -0,0 +1,89 @@
+#include <Gosu/Audio.hpp>
+#include "AudioImpl.hpp"
+using namespace std;
+
+// Returns the current state of a source
+static ALint state(int& channel) {
+    ALint state;
+    alGetSourcei(Gosu::al_source_for_channel(channel), AL_SOURCE_STATE, &state);
+    if (state != AL_PLAYING && state != AL_PAUSED) {
+        channel = Gosu::NO_CHANNEL;
+    }
+    return state;
+}
+
+Gosu::Channel::Channel(int channel, int token)
+: channel(channel), token(token)
+{
+}
+
+int Gosu::Channel::current_channel() const
+{
+    if (channel != NO_CHANNEL && channel_expired(channel, token)) {
+        channel = NO_CHANNEL;
+    }
+    return channel;
+}
+
+bool Gosu::Channel::playing() const
+{
+    if (current_channel() == NO_CHANNEL) return false;
+    
+    return state(channel) == AL_PLAYING;
+}
+
+bool Gosu::Channel::paused() const
+{
+    if (current_channel() == NO_CHANNEL) return false;
+
+    return state(channel) == AL_PAUSED;
+}
+
+void Gosu::Channel::pause()
+{
+    if (playing()) {
+        ALuint source = al_source_for_channel(channel);
+        alSourcePause(source);
+    }
+}
+
+void Gosu::Channel::resume()
+{
+    if (paused()) {
+        ALuint source = al_source_for_channel(channel);
+        alSourcePlay(source);
+    }
+}
+
+void Gosu::Channel::stop()
+{
+    if (current_channel() == NO_CHANNEL) return;
+
+    ALuint source = al_source_for_channel(channel);
+    alSourceStop(source);
+    channel = NO_CHANNEL;
+}
+
+void Gosu::Channel::set_volume(double volume)
+{
+    if (current_channel() == NO_CHANNEL) return;
+
+    ALuint source = al_source_for_channel(channel);
+    alSourcef(source, AL_GAIN, max(volume, 0.0));
+}
+
+void Gosu::Channel::set_pan(double pan)
+{
+    if (current_channel() == NO_CHANNEL) return;
+
+    ALuint source = al_source_for_channel(channel);
+    alSource3f(source, AL_POSITION, pan * 10, 0, 0);
+}
+
+void Gosu::Channel::set_speed(double speed)
+{
+    if (current_channel() == NO_CHANNEL) return;
+
+    ALuint source = al_source_for_channel(channel);
+    alSourcef(source, AL_PITCH, speed);
+}

data/src/Color.cpp

@@ -55,11 +55,6 @@ Gosu::Color Gosu::Color::from_hsv(double h, double s, double v)
 
 Gosu::Color Gosu::Color::from_ahsv(Channel alpha, double h, double s, double v)
 {
-    if (s == 0) {
-        // Grey.
-        return Color(alpha, v * 255, v * 255, v * 255);
-    }
-    
     // Normalize hue so that is always in the [0, 360) range and wraps around.
     h = normalize_angle(h);
     // Clamp s and v for consistency with the Ruby/Gosu ARGB getters/setters.
@@ -121,10 +116,10 @@ void Gosu::Color::set_value(double v)
 
 Gosu::Color Gosu::interpolate(Color a, Color b, double weight)
 {
-    return Color(clamp<long>(round(Gosu::interpolate(a.alpha(), b.alpha(), weight)), 0, 255),
-                 clamp<long>(round(Gosu::interpolate(a.red(),   b.red(),   weight)), 0, 255),
-                 clamp<long>(round(Gosu::interpolate(a.green(), b.green(), weight)), 0, 255),
-                 clamp<long>(round(Gosu::interpolate(a.blue(),  b.blue(),  weight)), 0, 255));
+    return Color(clamp<long>(round(interpolate(a.alpha(), b.alpha(), weight)), 0, 255),
+                 clamp<long>(round(interpolate(a.red(),   b.red(),   weight)), 0, 255),
+                 clamp<long>(round(interpolate(a.green(), b.green(), weight)), 0, 255),
+                 clamp<long>(round(interpolate(a.blue(),  b.blue(),  weight)), 0, 255));
 }
 
 Gosu::Color Gosu::multiply(Color a, Color b)

data/src/DirectoriesApple.cpp

@@ -4,61 +4,61 @@
 #import <Gosu/Directories.hpp>
 #import <Foundation/Foundation.h>
 #import <unistd.h>
-
+using namespace std;
 
 void Gosu::use_resource_directory()
 {
     chdir(resource_prefix().c_str());
 }
 
-std::string Gosu::user_settings_prefix()
+string Gosu::user_settings_prefix()
 {
-    static std::string result = [] {
+    static string result = [] {
         @autoreleasepool {
             NSString* library =
                 NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES)[0];
             NSString* preferences = [library stringByAppendingPathComponent:@"Preferences"];
             
-            return std::string(preferences.UTF8String ?: ".") + "/";
+            return string(preferences.UTF8String ?: ".") + "/";
         }
     }();
     return result;
 }
 
-std::string Gosu::user_documents_prefix()
+string Gosu::user_documents_prefix()
 {
-    static std::string result = [] {
+    static string result = [] {
         @autoreleasepool {
             NSString* documents =
                 NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0];
             
-            return std::string(documents.UTF8String ?: ".") + "/";
+            return string(documents.UTF8String ?: ".") + "/";
         }
     }();
     return result;
 }
 
-std::string Gosu::resource_prefix()
+string Gosu::resource_prefix()
 {
-    static std::string result = [] {
+    static string result = [] {
         @autoreleasepool {
             NSString* resources = [NSBundle mainBundle].resourcePath;
-            return std::string(resources.UTF8String ?: ".") + "/";
+            return string(resources.UTF8String ?: ".") + "/";
         }
     }();
     return result;
 }
 
-std::string Gosu::shared_resource_prefix()
+string Gosu::shared_resource_prefix()
 {
     #ifdef GOSU_IS_IPHONE
     return resource_prefix();
     #else
-    static std::string result = [] {
+    static string result = [] {
         @autoreleasepool {
             NSString* bundle_path = [NSBundle mainBundle].bundlePath;
             NSString* containing_path = [bundle_path stringByDeletingLastPathComponent];
-            return std::string(containing_path.UTF8String ?: ".");
+            return string(containing_path.UTF8String ?: ".");
         }
     }();
     return result;

data/src/DirectoriesUnix.cpp

@@ -7,8 +7,9 @@
 #include <pwd.h>
 #include <sys/types.h>
 #include <unistd.h>
+using namespace std;
 
-static std::string home_dir()
+static string home_dir()
 {
     passwd* pwd = getpwuid(geteuid());
     assert (pwd && pwd->pw_dir);
@@ -20,22 +21,22 @@ void Gosu::use_resource_directory()
     // Do nothing, we expect the user to have the correct cwd on Linux.
 }
 
-std::string Gosu::resource_prefix()
+string Gosu::resource_prefix()
 {
-    return std::string();
+    return string();
 }
 
-std::string Gosu::shared_resource_prefix()
+string Gosu::shared_resource_prefix()
 {
-    return std::string();
+    return string();
 }
 
-std::string Gosu::user_settings_prefix()
+string Gosu::user_settings_prefix()
 {
     return home_dir() + "/.";
 }
 
-std::string Gosu::user_documents_prefix()
+string Gosu::user_documents_prefix()
 {
     return home_dir() + "/";
 }

data/src/DirectoriesWin.cpp

@@ -6,15 +6,16 @@
 #include <Gosu/Utility.hpp>
 #include <cwchar>
 #include <stdexcept>
-#include <shlobj.h>
+#include <shlobj.h>
+using namespace std;
 
-static std::string special_folder_path(int csidl)
+static string special_folder_path(int csidl)
 {
     WCHAR buf[MAX_PATH + 2];
     if (FAILED(SHGetFolderPathW(nullptr, csidl | CSIDL_FLAG_CREATE, nullptr, 0, buf))) {
-        throw std::runtime_error("Error getting special folder path");
+        throw runtime_error("Error getting special folder path");
     }
-    std::size_t len = std::wcslen(buf);
+    size_t len = wcslen(buf);
     if (buf[len - 1] != L'\\') {
         buf[len] = L'\\';
         buf[len + 1] = 0;
@@ -22,9 +23,9 @@ static std::string special_folder_path(int csidl)
     return Gosu::wstring_to_utf8(buf);
 }
 
-static std::string exe_filename()
+static string exe_filename()
 {
-    static std::string result;
+    static string result;
     if (result.empty()) {
         WCHAR buffer[MAX_PATH * 2];
         Gosu::winapi_check(GetModuleFileNameW(nullptr, buffer, MAX_PATH * 2),
@@ -39,9 +40,9 @@ void Gosu::use_resource_directory()
     SetCurrentDirectory(utf8_to_wstring(resource_prefix()).c_str());
 }
 
-std::string Gosu::resource_prefix()
+string Gosu::resource_prefix()
 {
-    static std::string result;
+    static string result;
     if (result.empty()) {
         result = exe_filename();
         auto last_delim = result.find_last_of("\\/");
@@ -50,17 +51,17 @@ std::string Gosu::resource_prefix()
     return result;
 }
 
-std::string Gosu::shared_resource_prefix()
+string Gosu::shared_resource_prefix()
 {
     return resource_prefix();
 }
 
-std::string Gosu::user_settings_prefix()
+string Gosu::user_settings_prefix()
 {
     return special_folder_path(CSIDL_APPDATA);
 }
 
-std::string Gosu::user_documents_prefix()
+string Gosu::user_documents_prefix()
 {
     return special_folder_path(CSIDL_PERSONAL);
 }

data/src/EmptyImageData.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <Gosu/ImageData.hpp>
+#include <memory>
+
+namespace Gosu
+{
+    class EmptyImageData : public ImageData
+    {
+    public:
+        int width() const override
+        {
+            return 0;
+        }
+        
+        int height() const override
+        {
+            return 0;
+        }
+        
+        void draw(double, double, Color,
+                  double, double, Color,
+                  double, double, Color,
+                  double, double, Color,
+                  ZPos, AlphaMode) const override
+        {
+        }
+        
+        GLTexInfo* gl_tex_info() const override
+        {
+            return nullptr;
+        }
+        
+        Bitmap to_bitmap() const override
+        {
+            return Bitmap();
+        }
+        
+        virtual std::unique_ptr<ImageData> subimage(int, int, int, int) const override
+        {
+            return nullptr;
+        }
+        
+        virtual void insert(const Bitmap&, int x, int y) override
+        {
+        }
+        
+        static const std::shared_ptr<EmptyImageData>& instance_ptr()
+        {
+            static std::shared_ptr<EmptyImageData> instance = std::make_shared<EmptyImageData>();
+            return instance;
+        }
+    };
+}

data/src/FileUnix.cpp

@@ -14,6 +14,8 @@
 #include <sys/stat.h>
 #endif
 
+using namespace std;
+
 struct Gosu::File::Impl
 {
     int fd = -1;
@@ -27,7 +29,7 @@ struct Gosu::File::Impl
     }
 };
 
-Gosu::File::File(const std::string& filename, FileMode mode)
+Gosu::File::File(const string& filename, FileMode mode)
 : pimpl(new Impl)
 {
     int flags;
@@ -47,9 +49,7 @@ Gosu::File::File(const std::string& filename, FileMode mode)
     // TODO: Locking flags?
 
     pimpl->fd = open(filename.c_str(), flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
-    if (pimpl->fd < 0) {
-        throw std::runtime_error("Cannot open file " + filename);
-    }
+    if (pimpl->fd < 0) throw runtime_error("Cannot open file " + filename);
     
     if (mode == FM_READ && size() > 0) {
         pimpl->mapping = mmap(nullptr, size(), PROT_READ, 0, pimpl->fd, 0);
@@ -63,19 +63,22 @@ Gosu::File::~File()
     }
 }
 
-std::size_t Gosu::File::size() const
+size_t Gosu::File::size() const
 {
     // TODO: Error checking?
     return lseek(pimpl->fd, 0, SEEK_END);
 }
 
-void Gosu::File::resize(std::size_t new_size) { ftruncate(pimpl->fd, new_size); }
+void Gosu::File::resize(size_t new_size)
+{
+    ftruncate(pimpl->fd, new_size);
+}
 
-void Gosu::File::read(std::size_t offset, std::size_t length, void* dest_buffer) const
+void Gosu::File::read(size_t offset, size_t length, void* dest_buffer) const
 {
     // TODO: Bounds checks?
     if (pimpl->mapping != MAP_FAILED) {
-        std::memcpy(dest_buffer, static_cast<const char*>(pimpl->mapping) + offset, length);
+        memcpy(dest_buffer, static_cast<const char*>(pimpl->mapping) + offset, length);
     }
     else {
         // TODO: Error checking?
@@ -84,7 +87,7 @@ void Gosu::File::read(std::size_t offset, std::size_t length, void* dest_buffer)
     }
 }
 
-void Gosu::File::write(std::size_t offset, std::size_t length, const void* source_buffer)
+void Gosu::File::write(size_t offset, size_t length, const void* source_buffer)
 {
     // TODO: Error checking?
     lseek(pimpl->fd, offset, SEEK_SET);