gosu 0.10.9.pre1 → 0.11.0

data/src/InputUIKit.cpp

@@ -0,0 +1,197 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_IPHONE)
+
+#import <Gosu/Input.hpp>
+#import <Gosu/TextInput.hpp>
+#import <functional>
+#import <UIKit/UIKit.h>
+
+struct Gosu::TextInput::Impl {};
+Gosu::TextInput::TextInput() {}
+Gosu::TextInput::~TextInput() {}
+std::string Gosu::TextInput::text() const { return ""; }
+void Gosu::TextInput::set_text(const std::string& text) {}
+unsigned Gosu::TextInput::caret_pos() const { return 0; }
+void Gosu::TextInput::set_caret_pos(unsigned) {}
+unsigned Gosu::TextInput::selection_start() const { return 0; }
+void Gosu::TextInput::set_selection_start(unsigned) {}
+
+struct Gosu::Input::Impl
+{
+    UIView* view;
+    float mouse_x, mouse_y;
+    float scale_x, scale_y;
+    float update_interval;
+    
+    NSMutableSet* current_touches_set;
+    std::unique_ptr<Gosu::Touches> current_touches_vector;
+    
+    Touch translate_touch(UITouch* ui_touch)
+    {
+        CGPoint point = [ui_touch locationInView:view];
+        
+        return (Touch) {
+            .id = (__bridge void*) ui_touch,
+            .x  = (float)point.x * scale_x,
+            .y  = (float)point.y * scale_y,
+        };
+    }
+};
+
+Gosu::Input::Input(void* view, float update_interval)
+: pimpl(new Impl)
+{
+    pimpl->view = (__bridge UIView*) view;
+    pimpl->update_interval = update_interval;
+    pimpl->current_touches_set = [NSMutableSet new];
+    pimpl->mouse_x = pimpl->mouse_y = -1000;
+    set_mouse_factors(1, 1);
+}
+
+Gosu::Input::~Input()
+{
+}
+
+void Gosu::Input::feed_touch_event(int type, void* touches)
+{
+    NSSet* ui_touches = (__bridge NSSet*) touches;
+    
+    pimpl->current_touches_vector.reset();
+    
+    std::function<void (Touch)>* callback = nullptr;
+    
+    if (type == 0) {
+        [pimpl->current_touches_set unionSet:ui_touches];
+        callback = &on_touch_began;
+    }
+    else if (type == 1) {
+        callback = &on_touch_moved;
+    }
+    else if (type == 2) {
+        [pimpl->current_touches_set minusSet:ui_touches];
+        callback = &on_touch_ended;
+    }
+    else if (type == 3) {
+        [pimpl->current_touches_set minusSet:ui_touches];
+        callback = &on_touch_cancelled;
+    }
+    
+    if (callback && *callback) {
+        for (UITouch* ui_touch in ui_touches) {
+            (*callback)(pimpl->translate_touch(ui_touch));
+        }
+    }
+}
+
+std::string Gosu::Input::id_to_char(Button btn)
+{
+    return std::string();
+}
+
+Gosu::Button Gosu::Input::char_to_id(std::string ch)
+{
+    return NO_BUTTON;
+}
+
+bool Gosu::Input::down(Button btn)
+{
+    return false;
+}
+
+double Gosu::Input::mouse_x() const
+{
+    return pimpl->mouse_x;
+}
+
+double Gosu::Input::mouse_y() const
+{
+    return pimpl->mouse_y;
+}
+
+void Gosu::Input::set_mouse_position(double x, double y)
+{
+    pimpl->mouse_x = x;
+    pimpl->mouse_y = y;
+}
+
+void Gosu::Input::set_mouse_factors(double scale_x, double scale_y, double offset_x,
+    double offset_y)
+{
+    pimpl->scale_x = scale_x;
+    pimpl->scale_y = scale_y;
+    
+    // TODO - use offset
+}
+
+const Gosu::Touches& Gosu::Input::current_touches() const
+{
+    if (!pimpl->current_touches_vector.get()) {
+        pimpl->current_touches_vector.reset(new Gosu::Touches);
+        for (UITouch* ui_touch in pimpl->current_touches_set) {
+            pimpl->current_touches_vector->push_back(pimpl->translate_touch(ui_touch));
+        }
+    }
+    return *pimpl->current_touches_vector;
+}
+
+double Gosu::Input::accelerometer_x() const
+{
+    return 0;
+}
+
+double Gosu::Input::accelerometer_y() const
+{
+    return 0;
+}
+
+double Gosu::Input::accelerometer_z() const
+{
+    return 0;
+}
+
+void Gosu::Input::update()
+{
+    // Check for dead touches and remove from vector if
+    // necessary
+
+    NSMutableSet* dead_touches = nil;
+
+    for (UITouch* touch in pimpl->current_touches_set) {
+        UITouchPhase phase = [touch phase];
+        if (phase == UITouchPhaseBegan ||
+                phase == UITouchPhaseMoved ||
+                phase == UITouchPhaseStationary) {
+            continue;
+        }
+        
+        // Something was deleted, we will need the set.
+        if (!dead_touches) {
+            dead_touches = [NSMutableSet new];
+        }
+        [dead_touches addObject:touch];
+    }
+    
+    // Has something been deleted?
+    if (dead_touches) {
+        pimpl->current_touches_vector.reset();
+        [pimpl->current_touches_set minusSet:dead_touches];
+        
+        if (on_touch_ended) {
+            for (UITouch* ui_touch in dead_touches) {
+                on_touch_ended(pimpl->translate_touch(ui_touch));
+            }
+        }
+    }
+}
+
+Gosu::TextInput* Gosu::Input::text_input() const
+{
+    return nullptr;
+}
+
+void Gosu::Input::set_text_input(TextInput* input)
+{
+    throw "NYI";
+}
+
+#endif

data/src/Inspection.cpp

@@ -8,13 +8,12 @@ namespace Gosu
         int fps, accum;
         unsigned long sec;
 
-        void registerFrame()
+        void register_frame()
         {
             ++accum;
-            unsigned long newSec = Gosu::milliseconds() / 1000;
-            if (sec != newSec)
-            {
-                sec = newSec;
+            unsigned long new_sec = Gosu::milliseconds() / 1000;
+            if (sec != new_sec) {
+                sec = new_sec;
                 fps = accum;
                 accum = 0;
             }

data/src/LargeImageData.cpp

@@ -0,0 +1,151 @@
+#include "LargeImageData.hpp"
+#include "GraphicsImpl.hpp"
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Math.hpp>
+#include <cmath>
+using namespace std;
+
+Gosu::LargeImageData::LargeImageData(const Bitmap& source,
+    unsigned part_width, unsigned part_height, unsigned image_flags)
+{
+    full_width = source.width();
+    full_height = source.height();
+    parts_x = static_cast<unsigned>(trunc(ceil(1.0 * source.width() / part_width)));
+    parts_y = static_cast<unsigned>(trunc(ceil(1.0 * source.height() / part_height)));
+    this->part_width = part_width;
+    this->part_height = part_height;
+
+    parts.resize(parts_x * parts_y);
+
+    for (unsigned y = 0; y < parts_y; ++y) {
+        for (unsigned x = 0; x < parts_x; ++x) {
+            // The right-most parts don't necessarily have the full width.
+            unsigned src_width = part_width;
+            if (x == parts_x - 1 && source.width() % part_width != 0) {
+                src_width = source.width() % part_width;
+            }
+
+            // Same for the parts on the bottom.
+            unsigned src_height = part_height;
+            if (y == parts_y - 1 && source.height() % part_height != 0) {
+                src_height = source.height() % part_height;
+            }
+
+            unsigned local_flags = IF_TILEABLE | image_flags;
+            
+            // Left edge, only tileable if requested in image_flags.
+            if (x == 0) {
+                local_flags &= ~IF_TILEABLE_LEFT;
+                local_flags |= (image_flags & IF_TILEABLE_LEFT);
+            }
+            // Right edge, only tileable if requested in image_flags.
+            if (x == parts_x - 1) {
+                local_flags &= ~IF_TILEABLE_RIGHT;
+                local_flags |= (image_flags & IF_TILEABLE_RIGHT);
+            }
+            // Top edge, only tileable if requested in image_flags.
+            if (y == 0) {
+                local_flags &= ~IF_TILEABLE_TOP;
+                local_flags |= (image_flags & IF_TILEABLE_TOP);
+            }
+            // Bottom edge, only tileable if requested in image_flags.
+            if (y == parts_y - 1) {
+                local_flags &= ~IF_TILEABLE_BOTTOM;
+                local_flags |= (image_flags & IF_TILEABLE_BOTTOM);
+            }
+            
+            parts[y * parts_x + x].reset(Graphics::create_image(source,
+                                                                x * part_width, y * part_height,
+                                                                src_width, src_height,
+                                                                local_flags).release());
+        }
+    }
+}
+
+int Gosu::LargeImageData::width() const
+{
+    return full_width;
+}
+
+int Gosu::LargeImageData::height() const
+{
+    return full_height;
+}
+
+namespace
+{
+    // Local interpolation helper functions. - TODO why not from Math.hpp?
+
+    double ipl(double a, double b, double ratio)
+    {
+        return a + (b - a) * ratio;
+    }
+
+    Gosu::Color ipl(Gosu::Color a, Gosu::Color b, double ratio)
+    {
+        Gosu::Color result;
+        result.set_alpha(Gosu::round(ipl(a.alpha(), b.alpha(), ratio)));
+        result.set_red  (Gosu::round(ipl(a.red(),   b.red(),   ratio)));
+        result.set_green(Gosu::round(ipl(a.green(), b.green(), ratio)));
+        result.set_blue (Gosu::round(ipl(a.blue(),  b.blue(),  ratio)));
+        return result;
+    }
+}
+
+void Gosu::LargeImageData::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
+    double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z, AlphaMode mode) const
+{
+    if (parts.empty()) return;
+
+    normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
+    
+    for (unsigned py = 0; py < parts_y; ++py) {
+        for (unsigned px = 0; px < parts_x; ++px) {
+            ImageData& part = *parts[py * parts_x + px];
+
+            double rel_x_l = static_cast<double>(px * part_width) / width();
+            double rel_x_r = static_cast<double>(px * part_width + part.width()) / width();
+            double rel_y_t = static_cast<double>(py * part_height) / height();
+            double rel_y_b = static_cast<double>(py * part_height + part.height()) / height();
+
+            double abs_x_t_l = ipl(ipl(x1, x3, rel_y_t), ipl(x2, x4, rel_y_t), rel_x_l);
+            double abs_x_t_r = ipl(ipl(x1, x3, rel_y_t), ipl(x2, x4, rel_y_t), rel_x_r);
+            double abs_x_b_l = ipl(ipl(x1, x3, rel_y_b), ipl(x2, x4, rel_y_b), rel_x_l);
+            double abs_x_b_r = ipl(ipl(x1, x3, rel_y_b), ipl(x2, x4, rel_y_b), rel_x_r);
+
+            double abs_y_t_l = ipl(ipl(y1, y3, rel_y_t), ipl(y2, y4, rel_y_t), rel_x_l);
+            double abs_y_t_r = ipl(ipl(y1, y3, rel_y_t), ipl(y2, y4, rel_y_t), rel_x_r);
+            double abs_y_b_l = ipl(ipl(y1, y3, rel_y_b), ipl(y2, y4, rel_y_b), rel_x_l);
+            double abs_y_b_r = ipl(ipl(y1, y3, rel_y_b), ipl(y2, y4, rel_y_b), rel_x_r);
+
+            Color abs_c_t_l = ipl(ipl(c1, c3, rel_y_t), ipl(c2, c4, rel_y_t), rel_x_l);
+            Color abs_c_t_r = ipl(ipl(c1, c3, rel_y_t), ipl(c2, c4, rel_y_t), rel_x_r);
+            Color abs_c_b_l = ipl(ipl(c1, c3, rel_y_b), ipl(c2, c4, rel_y_b), rel_x_l);
+            Color abs_c_b_r = ipl(ipl(c1, c3, rel_y_b), ipl(c2, c4, rel_y_b), rel_x_r);
+
+            part.draw(abs_x_t_l, abs_y_t_l, abs_c_t_l, abs_x_t_r, abs_y_t_r, abs_c_t_r,
+                      abs_x_b_l, abs_y_b_l, abs_c_b_l, abs_x_b_r, abs_y_b_r, abs_c_b_r, z, mode);
+        }
+    }
+}
+
+Gosu::Bitmap Gosu::LargeImageData::to_bitmap() const
+{
+    Bitmap bitmap(width(), height());
+    for (int x = 0; x < parts_x; ++x) {
+        for (int y = 0; y < parts_y; ++y) {
+            bitmap.insert(parts[y * parts_x + x]->to_bitmap(), x * part_width, y * part_height);
+        }
+    }
+    return bitmap;
+}
+
+void Gosu::LargeImageData::insert(const Bitmap& bitmap, int at_x, int at_y)
+{
+    for (int x = 0; x < parts_x; ++x) {
+        for (int y = 0; y < parts_y; ++y) {
+            parts[y * parts_x + x]->insert(bitmap, at_x - x * part_width, at_y - y * part_height);
+        }
+    }
+}

data/src/LargeImageData.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/ImageData.hpp>
+#include <Gosu/Platform.hpp>
+#include <memory>
+#include <vector>
+
+namespace Gosu
+{
+    class LargeImageData : public ImageData
+    {
+        unsigned full_width, full_height;
+        unsigned parts_x, parts_y;
+        unsigned part_width, part_height;
+        std::vector<std::shared_ptr<ImageData>> parts;
+
+    public:
+        LargeImageData(const Bitmap& source, unsigned part_width, unsigned part_height,
+            unsigned image_flags);
+
+        int width() const override;
+        int height() const override;
+
+        void draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
+            double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z,
+            AlphaMode mode) const override;
+
+        const GLTexInfo* gl_tex_info() const override
+        {
+            return nullptr;
+        }
+        
+        std::unique_ptr<ImageData> subimage(int x, int y, int w, int h) const override
+        {
+            return std::unique_ptr<ImageData>();
+        }
+        
+        Bitmap to_bitmap() const override;
+        
+        void insert(const Bitmap& bitmap, int x, int y) override;
+    };
+}

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

@@ -2,6 +2,7 @@
 #include "DrawOpQueue.hpp"
 #include <cmath>
 #include <algorithm>
+#include <functional>
 #include <memory>
 #include <stdexcept>
 
@@ -9,10 +10,11 @@ struct Gosu::Macro::Impl
 {
     typedef double Float;
     
-    VertexArrays vertexArrays;
+    VertexArrays vertex_arrays;
     int width, height;
     
-    Transform findTransformForTarget(Float x1, Float y1, Float x2, Float y2, Float x3, Float y3, Float x4, Float y4) const
+    Transform find_transform_for_target(Float x1, Float y1, Float x2, Float y2,
+        Float x3, Float y3, Float x4, Float y4) const
     {
         // Transformation logic follows a discussion on the ImageMagick mailing
         // list (on which ImageMagick's perspective_transform.pl is based).
@@ -41,20 +43,16 @@ struct Gosu::Macro::Impl
         
         // Since this matrix is relatively sparse, we unroll all three solving paths.
         
-        static const Transform nullTransform = {{ 0 }};
+        static const Transform null_transform = {{ 0 }};
         
         // Row 7 is completely useless
-        if (x2 == x4 && x3 == x4)
-            return nullTransform;
+        if (x2 == x4 && x3 == x4) return null_transform;
         // Row 8 is completely useless
-        if (y2 == y3 && y3 == y4)
-            return nullTransform;
+        if (y2 == y3 && y3 == y4) return null_transform;
         // Col 7 is completely useless
-        if (x2 == x4 && y2 == y4)
-            return nullTransform;
+        if (x2 == x4 && y2 == y4) return null_transform;
         // Col 8 is completely useless
-        if (x3 == x4 && y3 == y4)
-            return nullTransform;
+        if (x3 == x4 && y3 == y4) return null_transform;
         
         Float c[8];
         
@@ -68,15 +66,18 @@ struct Gosu::Macro::Impl
         // TODO: x2==x4 is the normal case where an image is
         // drawn upright; the code should rather swap in the rare case that x3==x4!
         
-        Float leftCell7 = (x2-x4)*width, rightCell7 = (x3-x4)*height, origRightSide7 = (x1-x2-x3+x4);
-        Float leftCell8 = (y2-y4)*width, rightCell8 = (y3-y4)*height, origRightSide8 = (y1-y2-y3+y4);
-        
-        bool swapRows78 = x2 == x4;
-        if (swapRows78)
-        {
-            std::swap(leftCell7, leftCell8);
-            std::swap(rightCell7, rightCell8);
-            std::swap(origRightSide7, origRightSide8);
+        Float left_cell7 = (x2 - x4) * width;
+        Float right_cell7 = (x3 - x4) * height;
+        Float orig_right_side7 = (x1 - x2 - x3 + x4);
+        Float left_cell8 = (y2 - y4) * width;
+        Float right_cell8 = (y3 - y4) * height;
+        Float orig_right_side8 = (y1 - y2 - y3 + y4);
+        
+        bool swap_rows78 = x2 == x4;
+        if (swap_rows78) {
+            std::swap(left_cell7, left_cell8);
+            std::swap(right_cell7, right_cell8);
+            std::swap(orig_right_side7, orig_right_side8);
         }
         
         // 0, 0, 1, 0, 0, 0,         0,           0 | x1
@@ -85,15 +86,15 @@ struct Gosu::Macro::Impl
         // 0, 0, 0, w, 0, 0,      -y2w,           0 | y2-y1
         // 0, h, 0, 0, 0, 0,         0,        -x3h | x3-x1
         // 0, 0, 0, 0, h, 0,         0,        -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, leftCell7, rightCell7 | origRightSide7
-        // 0, 0, 0, 0, 0, 0, leftCell8, rightCell8 | origRightSide8
+        // 0, 0, 0, 0, 0, 0, left_cell7, right_cell7 | orig_right_side7
+        // 0, 0, 0, 0, 0, 0, left_cell8, right_cell8 | orig_right_side8
         
         // Use row 7 to eliminate the left cell in row 8
         // Row8 = Row8 - factor78 * Row7
-        Float factor78 = leftCell8 / leftCell7;
-        Float remCell8 = rightCell8 - rightCell7 * factor78;
-        Float rightSide8 = origRightSide8 - origRightSide7 * factor78;
-        c[7] = rightSide8 / remCell8;
+        Float factor78 = left_cell8 / left_cell7;
+        Float rem_cell8 = right_cell8 - right_cell7 * factor78;
+        Float right_side8 = orig_right_side8 - orig_right_side7 * factor78;
+        c[7] = right_side8 / rem_cell8;
         
         // 0, 0, 1, 0, 0, 0,         0,          0 | x1
         // 0, 0, 0, 0, 0, 1,         0,          0 | y1
@@ -101,15 +102,15 @@ struct Gosu::Macro::Impl
         // 0, 0, 0, w, 0, 0,      -y2w,          0 | y2-y1
         // 0, h, 0, 0, 0, 0,         0,       -x3h | x3-x1
         // 0, 0, 0, 0, h, 0,         0,       -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, leftCell7, rightCell7 | origRightSide7
-        // 0, 0, 0, 0, 0, 0,         0,   remCell8 | rightSide8
+        // 0, 0, 0, 0, 0, 0, left_cell7, right_cell7 | orig_right_side7
+        // 0, 0, 0, 0, 0, 0,         0,   rem_cell8 | right_side8
         
         // Use the remaining value in row 8 to eliminate the right value in row 7.
         // Row7 = Row7 - factor87 * Row8
-        Float factor87 = rightCell7 / remCell8;
-        Float remCell7 = leftCell7;
-        Float rightSide7 = origRightSide7 - rightSide8 * factor87;
-        c[6] = rightSide7 / remCell7;
+        Float factor87 = right_cell7 / rem_cell8;
+        Float rem_cell7 = left_cell7;
+        Float right_side7 = orig_right_side7 - right_side8 * factor87;
+        c[6] = right_side7 / rem_cell7;
         
         // 0, 0, 1, 0, 0, 0,        0,        0 | x1
         // 0, 0, 0, 0, 0, 1,        0,        0 | y1
@@ -117,33 +118,34 @@ struct Gosu::Macro::Impl
         // 0, 0, 0, w, 0, 0,     -y2w,        0 | y2-y1
         // 0, h, 0, 0, 0, 0,        0,     -x3h | x3-x1
         // 0, 0, 0, 0, h, 0,        0,     -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, remCell7,        0 | rightSide7
-        // 0, 0, 0, 0, 0, 0,        0, remCell8 | rightSide8
+        // 0, 0, 0, 0, 0, 0, rem_cell7,        0 | right_side7
+        // 0, 0, 0, 0, 0, 0,        0, rem_cell8 | right_side8
         
         // Use the new rows 7 and 8 to calculate c0, c1, c3 & c4.
         // Row3 = Row3 - factor73 * Row7
-        Float factor73 = -x2*width / remCell7;
-        Float remCell3 = width;
-        Float rightSide3 = (x2-x1) - rightSide7 * factor73;
-        c[0] = rightSide3 / remCell3;
+        Float factor73 = -x2 * width / rem_cell7;
+        Float rem_cell3 = width;
+        Float right_side3 = (x2 - x1) - right_side7 * factor73;
+        c[0] = right_side3 / rem_cell3;
         // Row4 = Row4 - factor74 * Row7
-        Float factor74 = -y2*width / remCell7;
-        Float remCell4 = width;
-        Float rightSide4 = (y2-y1) - rightSide7 * factor74;
-        c[3] = rightSide4 / remCell4;
+        Float factor74 = -y2 * width / rem_cell7;
+        Float rem_cell4 = width;
+        Float right_side4 = (y2 - y1) - right_side7 * factor74;
+        c[3] = right_side4 / rem_cell4;
         // Row5 = Row5 - factor85 * Row7
-        Float factor85 = -x3*height / remCell8;
-        Float remCell5 = height;
-        Float rightSide5 = (x3-x1) - rightSide8 * factor85;
-        c[1] = rightSide5 / remCell5;
+        Float factor85 = -x3 * height / rem_cell8;
+        Float rem_cell5 = height;
+        Float right_side5 = (x3 - x1) - right_side8 * factor85;
+        c[1] = right_side5 / rem_cell5;
         // Row6 = Row6 - factor86 * Row8
-        Float factor86 = -y3*height / remCell8;
-        Float remCell6 = height;
-        Float rightSide6 = (y3-y1) - rightSide8 * factor86;
-        c[4] = rightSide6 / remCell6;
+        Float factor86 = -y3 * height / rem_cell8;
+        Float rem_cell6 = height;
+        Float right_side6 = (y3 - y1) - right_side8 * factor86;
+        c[4] = right_side6 / rem_cell6;
         
-        if (swapRows78)
+        if (swap_rows78) {
             std::swap(c[6], c[7]);
+        }
         
         // Let's hope I never have to debug/understand this again! :D
         
@@ -156,26 +158,25 @@ struct Gosu::Macro::Impl
         return result;
     }
     
-    void drawVertexArrays(Float x1, Float y1, Float x2, Float y2, Float x3, Float y3, Float x4, Float y4) const
+    void draw_vertex_arrays(Float x1, Float y1, Float x2, Float y2, Float x3, Float y3,
+        Float x4, Float y4) const
     {
-        // TODO: Macros should not be split up just because they have different transforms! This is insane.
-        // They should be premultiplied and have the same transform by definition. Then the transformation
-        // only has to be performed once.
+        // TODO: Macros should not be split up just because they have different transforms.
+        // They should be premultiplied and have the same transform by definition. Then the
+        // transformation only has to be performed once.
         
     #ifndef GOSU_IS_OPENGLES
         glEnable(GL_BLEND);
         glMatrixMode(GL_MODELVIEW);
         
-        Transform transform =
-        findTransformForTarget(x1, y1, x2, y2, x3, y3, x4, y4);
+        Transform transform = find_transform_for_target(x1, y1, x2, y2, x3, y3, x4, y4);
         
-        for (VertexArrays::const_iterator it = vertexArrays.begin(), end = vertexArrays.end(); it != end; ++it)
-        {
+        for (const auto& vertex_array : vertex_arrays) {
             glPushMatrix();
-            it->renderState.apply();
+            vertex_array.render_state.apply();
             glMultMatrixd(&transform[0]);
-            glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &it->vertices[0]);
-            glDrawArrays(GL_QUADS, 0, (GLsizei)it->vertices.size());
+            glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &vertex_array.vertices[0]);
+            glDrawArrays(GL_QUADS, 0, (GLsizei) vertex_array.vertices.size());
             glPopMatrix();
         }
     #endif
@@ -187,7 +188,7 @@ Gosu::Macro::Macro(DrawOpQueue& queue, int width, int height)
 {
     pimpl->width = width;
     pimpl->height = height;
-    queue.compileTo(pimpl->vertexArrays);
+    queue.compile_to(pimpl->vertex_arrays);
 }
 
 int Gosu::Macro::width() const
@@ -200,34 +201,32 @@ int Gosu::Macro::height() const
     return pimpl->height;
 }
 
-void Gosu::Macro::draw(double x1, double y1, Color c1,
-    double x2, double y2, Color c2,
-    double x3, double y3, Color c3,
-    double x4, double y4, Color c4,
-    ZPos z, AlphaMode mode) const
+void Gosu::Macro::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
+    double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z, AlphaMode mode) const
 {
-    if (c1 != Color::WHITE || c2 != Color::WHITE || c3 != Color::WHITE || c4 != Color::WHITE)
-        throw std::invalid_argument("Macros cannot be tinted with colors yet");
+    if (c1 != Color::WHITE || c2 != Color::WHITE || c3 != Color::WHITE || c4 != Color::WHITE) {
+        throw std::invalid_argument("Macros cannot be tinted with colors");
+    }
     
-    reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
+    normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
     
-    std::tr1::function<void()> f = std::tr1::bind(&Impl::drawVertexArrays, pimpl, x1, y1, x2, y2, x3, y3, x4, y4);
-    Gosu::Graphics::scheduleGL(f, z);
+    std::function<void ()> f = [=] { pimpl->draw_vertex_arrays(x1, y1, x2, y2, x3, y3, x4, y4); };
+    Gosu::Graphics::gl(f, z);
 }
 
-const Gosu::GLTexInfo* Gosu::Macro::glTexInfo() const
+const Gosu::GLTexInfo* Gosu::Macro::gl_tex_info() const
 {
-    return 0;
+    return nullptr;
 }
 
-Gosu::Bitmap Gosu::Macro::toBitmap() const
+Gosu::Bitmap Gosu::Macro::to_bitmap() const
 {
     throw std::logic_error("Gosu::Macro cannot be rendered as Gosu::Bitmap yet");
 }
 
-GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const
+std::unique_ptr<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const
 {
-    return GOSU_UNIQUE_PTR<ImageData>();
+    return std::unique_ptr<ImageData>();
 }
 
 void Gosu::Macro::insert(const Bitmap& bitmap, int x, int y)