gosu 0.10.9.pre1 → 0.11.0

data/src/BlockAllocator.cpp

@@ -0,0 +1,133 @@
+#include "BlockAllocator.hpp"
+#include <stdexcept>
+#include <vector>
+
+struct Gosu::BlockAllocator::Impl
+{
+    unsigned width, height;
+
+    std::vector<Block> blocks;
+    unsigned first_x, first_y;
+    unsigned max_w, max_h;
+    
+    void mark_block_used(const Block& block, unsigned a_width, unsigned a_height)
+    {
+        first_x += a_width;
+        if (first_x + a_width >= width) {
+            first_x = 0;
+            first_y += a_height;
+        }
+        blocks.push_back(block);
+    }
+
+    bool is_block_free(const Block& block) const
+    {
+        // right and bottom are exclusive (not part of the block).
+        unsigned right = block.left + block.width;
+        unsigned bottom = block.top + block.height;
+
+        // Block isn't valid.
+        if (right > width || bottom > height) return false;
+
+        // 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) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+Gosu::BlockAllocator::BlockAllocator(unsigned width, unsigned height)
+: pimpl(new Impl)
+{
+    pimpl->width = width;
+    pimpl->height = height;
+
+    pimpl->first_x = 0;
+    pimpl->first_y = 0;
+
+    pimpl->max_w = width;
+    pimpl->max_h = height;
+}
+
+Gosu::BlockAllocator::~BlockAllocator()
+{
+}
+
+unsigned Gosu::BlockAllocator::width() const
+{
+    return pimpl->width;
+}
+
+unsigned Gosu::BlockAllocator::height() const
+{
+    return pimpl->height;
+}
+
+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;
+    }
+
+    // We know there's no space left.
+    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.
+    b = Block(pimpl->first_x, pimpl->first_y, a_width, a_height);
+    if (pimpl->is_block_free(b)) {
+        pimpl->mark_block_used(b, a_width, a_height);
+        return true;
+    }
+
+    // Brute force: Look for a free place on this texture.
+    unsigned& x = b.left;
+    unsigned& y = b.top;
+    for (y = 0; y <= height() - a_height; y += 16) {
+        for (x = 0; x <= width() - a_width; x += 8) {
+            if (!pimpl->is_block_free(b)) continue;
+
+            // Found a nice place!
+
+            // Try to make up for the large for ()-stepping.
+            while (y > 0 && pimpl->is_block_free(Block(x, y - 1, a_width, a_height))) --y;
+            while (x > 0 && pimpl->is_block_free(Block(x - 1, y, a_width, a_height))) --x;
+            
+            pimpl->mark_block_used(b, a_width, a_height);
+            return true;
+        }
+    }
+
+    // So there was no space for the bitmap. Remember this for later.
+    pimpl->max_w = a_width - 1;
+    pimpl->max_h = a_height - 1;
+    return false;
+}
+
+void Gosu::BlockAllocator::block(unsigned left, unsigned top, unsigned width, unsigned height)
+{
+    pimpl->blocks.push_back(Block(left, top, width, height));
+}
+
+void Gosu::BlockAllocator::free(unsigned left, unsigned top, unsigned width, unsigned height)
+{
+    for (auto it = pimpl->blocks.begin(), end = pimpl->blocks.end(); it != end; ++it) {
+        if (it->left == left && it->top == top && it->width == width && it->height == height) {
+            pimpl->blocks.erase(it);
+            // Be optimistic again, since we might have deleted the largest/only block.
+            pimpl->max_w = pimpl->width - 1;
+            pimpl->max_h = pimpl->height - 1;
+            return;
+        }
+    }
+
+    throw std::logic_error("Tried to free an invalid block");
+}

data/src/{Graphics/BlockAllocator.hpp → BlockAllocator.hpp}

@@ -1,35 +1,34 @@
-#ifndef GOSU_SRC_BLOCKALLOCATOR_HPP
-#define GOSU_SRC_BLOCKALLOCATOR_HPP
-
-#include <memory>
-#include <Gosu/Platform.hpp>
-
-namespace Gosu
-{
-    class BlockAllocator
-    {
-        struct Impl;
-        const GOSU_UNIQUE_PTR<Impl> pimpl;
-
-    public:
-        struct Block
-        {
-            unsigned left, top, width, height;
-            Block() {}
-            Block(unsigned aLeft, unsigned aTop, unsigned aWidth, unsigned aHeight)
-            : left(aLeft), top(aTop), width(aWidth), height(aHeight) {}
-        };
-    
-        BlockAllocator(unsigned width, unsigned height);
-        ~BlockAllocator();
-
-        unsigned width() const;
-        unsigned height() const;
-
-        bool alloc(unsigned width, unsigned height, Block& block);
-        void block(unsigned left, unsigned top, unsigned width, unsigned height);
-        void free(unsigned left, unsigned top, unsigned width, unsigned height);
-    };
-}
-
-#endif
+#pragma once
+
+#include <Gosu/Platform.hpp>
+#include <memory>
+
+namespace Gosu
+{
+    class BlockAllocator
+    {
+        struct Impl;
+        const std::unique_ptr<Impl> pimpl;
+
+    public:
+        struct Block
+        {
+            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)
+            {
+            }
+        };
+
+        BlockAllocator(unsigned width, unsigned height);
+        ~BlockAllocator();
+
+        unsigned width() const;
+        unsigned height() const;
+
+        bool alloc(unsigned width, unsigned height, Block& block);
+        void block(unsigned left, unsigned top, unsigned width, unsigned height);
+        void free(unsigned left, unsigned top, unsigned width, unsigned height);
+    };
+}

data/src/ClipRectStack.hpp

@@ -0,0 +1,87 @@
+#pragma once
+
+#include "GraphicsImpl.hpp"
+#include <cassert>
+#include <vector>
+
+class Gosu::ClipRectStack
+{
+    std::vector<ClipRect> stack;
+    bool has_effective_rect; // is effective_rect valid?
+    ClipRect effective_rect;
+    
+    void update_effective_rect()
+    {
+        // Nothing to do, no clipping in place.
+        if (stack.empty()) {
+            has_effective_rect = false;
+            return;
+        }
+        
+        ClipRect result = { 0.0, 0.0, 1e10, 1e10 };
+        for (std::size_t i = 0, end = stack.size(); i < end; ++i) {
+            const ClipRect& rect = stack[i];
+            int result_right     = std::min(result.x + result.width, rect.x + rect.width);
+            int result_bottom    = std::min(result.y + result.height, rect.y + rect.height);
+            result.x             = std::max(result.x, rect.x);
+            result.y             = std::max(result.y, rect.y);
+            
+            if (result.x >= result_right || result.y >= result_bottom) {
+                // We have clipped the world away!
+                has_effective_rect = false;
+                return;
+            }
+            
+            result.width  = result_right - result.x;
+            result.height = result_bottom - result.y;
+        }
+        
+        // On the iPhone, we may have to multiply everything by 2 for Retina displays.
+        // TODO: Doesn't this affect Retina Macs as well?
+        // TODO: This should be handled by a global transform.
+        int fac = clip_rect_base_factor();
+        result.x *= fac, result.y *= fac, result.width *= fac, result.height *= fac;
+        
+        // Normal clipping.
+        effective_rect     = result;
+        has_effective_rect = true;
+    }
+    
+public:
+    ClipRectStack()
+    : has_effective_rect(false)
+    {
+    }
+    
+    void clear()
+    {
+        stack.clear();
+        has_effective_rect = false;
+    }
+    
+    void begin_clipping(double x, double y, double width, double height)
+    {
+        ClipRect rect = { x, y, width, height };
+        stack.push_back(rect);
+        update_effective_rect();
+    }
+    
+    void end_clipping()
+    {
+        assert (!stack.empty());
+        stack.pop_back();
+        update_effective_rect();
+    }
+    
+    const ClipRect* maybe_effective_rect() const
+    {
+        return has_effective_rect ? &effective_rect : 0;
+    }
+    
+    bool clipped_world_away() const
+    {
+        // When we have no effective rect but the stack is not empty, we have clipped
+        // the whole world away and don't need to render things.
+        return !has_effective_rect && !stack.empty();
+    }
+};

data/src/{Graphics/Color.cpp → Color.cpp}

@@ -6,7 +6,7 @@ namespace
 {
     struct HSV { double h, s, v; };
     
-    HSV colorToHSV(const Gosu::Color& c)
+    HSV color_to_hsv(const Gosu::Color& c)
     {
         double r = c.red() / 255.0;
         double g = c.green() / 255.0;
@@ -15,8 +15,7 @@ namespace
         double min = std::min(std::min(r, g), b);
         double max = std::max(std::max(r, g), b);
 
-        if (max == 0)
-        {
+        if (max == 0) {
             HSV hsv = { 0, 0, 0 };
             return hsv;
         }
@@ -29,41 +28,44 @@ namespace
         hsv.s = delta / max;
         
         // Hue.
-        if (r == max)
+        if (r == max) {
             hsv.h = (g - b) / delta + (g < b ? 6 : 0);
-        else if (g == max)
+        }
+        else if (g == max) {
             hsv.h = (b - r) / delta + 2;
-        else
+        }
+        else {
             hsv.h = (r - g) / delta + 4;
+        }
         hsv.h *= 60;
         
         return hsv;
     }
 }
 
-Gosu::Color Gosu::Color::fromHSV(double h, double s, double v)
+Gosu::Color Gosu::Color::from_hsv(double h, double s, double v)
 {
-    return fromAHSV(255, h, s, v);
+    return from_ahsv(255, h, s, v);
 }
 
-Gosu::Color Gosu::Color::fromAHSV(Channel alpha, double h, double s, double v)
+Gosu::Color Gosu::Color::from_ahsv(Channel alpha, double h, double s, double v)
 {
-	if (s == 0)
-		// Grey.
+    if (s == 0) {
+        // Grey.
         return Color(alpha, v * 255, v * 255, v * 255);
+    }
     
     // Normalize hue
-    h = normalizeAngle(h);
+    h = normalize_angle(h);
     
-	int sector = h / 60;
+    int sector       = h / 60;
     double factorial = h / 60 - sector;
     
-	double p = v * (1 - s);
-	double q = v * (1 - s * factorial);
-	double t = v * (1 - s * (1 - factorial));
-	
-    switch (sector) 
-    {
+    double p = v * (1 - s);
+    double q = v * (1 - s * factorial);
+    double t = v * (1 - s * (1 - factorial));
+    
+    switch (sector) {
     case 0:
         return Color(alpha, v * 255, t * 255, p * 255);
     case 1:
@@ -81,32 +83,32 @@ Gosu::Color Gosu::Color::fromAHSV(Channel alpha, double h, double s, double v)
 
 double Gosu::Color::hue() const
 {
-    return colorToHSV(*this).h;
+    return color_to_hsv(*this).h;
 }
 
-void Gosu::Color::setHue(double h)
+void Gosu::Color::set_hue(double h)
 {
-    *this = fromAHSV(alpha(), h, saturation(), value());
+    *this = from_ahsv(alpha(), h, saturation(), value());
 }
 
 double Gosu::Color::saturation() const
 {
-    return colorToHSV(*this).s;
+    return color_to_hsv(*this).s;
 }
 
-void Gosu::Color::setSaturation(double s)
+void Gosu::Color::set_saturation(double s)
 {
-    *this = fromAHSV(alpha(), hue(), s, value());
+    *this = from_ahsv(alpha(), hue(), s, value());
 }
 
 double Gosu::Color::value() const
 {
-    return colorToHSV(*this).v;
+    return color_to_hsv(*this).v;
 }
 
-void Gosu::Color::setValue(double v)
+void Gosu::Color::set_value(double v)
 {
-    *this = fromAHSV(alpha(), hue(), saturation(), v);
+    *this = from_ahsv(alpha(), hue(), saturation(), v);
 }
 
 Gosu::Color Gosu::interpolate(Color a, Color b, double weight)

data/src/DirectoriesApple.cpp

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