gosu 0.11.4.pre3 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94bfc8e22230e0613727dbc03a8bacbc3b39ccf2
-  data.tar.gz: 9a4b29f27d6d2ade8191ef50940693904d88028a
+  metadata.gz: 0d1640e560328b803317616abde6c301648daffb
+  data.tar.gz: 419425be00ae9f09d1cc74702170f55f87ff563b
 SHA512:
-  metadata.gz: 8fd062fda171cb3a06a31abf9dcf97da32e02b2a5de57d251b3ddf1c2bc799d57cfbab7346cd36dcab84be0c49ce8eff3315dd6183e8a51c8ba2ea842b50636c
-  data.tar.gz: 403717d0b239a02e219328ef483884a72ce34841acc9c9c9f5e8b546109f35904ce2cae697ecda874c46803951d0bf209586212b196e50135f825041886d5606
+  metadata.gz: 6ba0ce007bc4fdddd98887d1594f2b106e150fb50282dc859e517f1122a4853c6d8f3ca69cb8d34cde51914e2310c53eba1ba9873dde736fbac58e6dc0bcef32
+  data.tar.gz: 2eb57895d03d4bfcbcc31c28ef79ef35fa5f78684dde4d1f7106b0914470bf2d70b27aa87b3df23e4432f367aa1bdbbd4883bb39e2915405b9b6aba79ed83775

data/Gosu/Graphics.hpp

@@ -37,46 +37,38 @@ namespace Gosu
         unsigned width() const;
         unsigned height() const;
 
-        //! Prepares the graphics object for drawing. Nothing must be drawn
-        //! without calling begin.
-        bool begin(Color clear_with_color = Color::BLACK);
-        //! Every call to begin must have a matching call to end.
-        void end();
+        //! Prepares the graphics object for drawing and then runs the rendering code in f.
+        //! Nothing must be drawn outside of frame() and record().
+        void frame(const std::function<void()>& f);
         
         //! Flushes the Z queue to the screen and starts a new one.
-        //! Useful for games that are *very* composite in nature (splitscreen).
+        //! This can be useful to separate the Z queues of two parts of the game, e.g. the two
+        //! halves of a game that runs in split-screen mode.
         static void flush();
         
-        //! Finishes all pending Gosu drawing operations and executes
-        //! the following OpenGL code in a clean environment.
-        static void begin_gl();
-        //! Resets Gosu into its default rendering state.
-        static void end_gl();
+        //! Finishes all pending Gosu drawing operations and executes the code in f in a clean
+        //! OpenGL environment.
+        static void gl(const std::function<void()>& f);
+
         //! Schedules a custom GL functor to be executed at a certain Z level.
-        //! The functor is called in a clean GL context (as given by begin_gl/end_gl).
-        //! Gosu's rendering up to the Z level may not yet have been glFlush()ed.
+        //! The functor f is run in a clean GL context.
         //! Note: You may not call any Gosu rendering functions from within the
-        //! functor, and you must schedule it from within Window::draw's call tree.
-        static void gl(const std::function<void ()>& functor, ZPos z);
+        //! functor.
+        static void gl(ZPos z, const std::function<void()>& f);
         
-        //! Enables clipping to a specified rectangle.
-        static void begin_clipping(double x, double y, double width, double height);
-        //! Disables clipping.
-        static void end_clipping();
+        //! Renders everything drawn in f clipped to a rectangle on the screen.
+        static void clip_to(double x, double y, double width, double height,
+                            const std::function<void()>& f);
         
-        //! Starts recording a macro. Cannot be nested.
-        static void begin_recording();
-        //! Finishes building the macro and returns it as a drawable object.
-        //! The width and height affect nothing about the recording process,
-        //! the resulting macro will simply return these values when you ask
-        //! it.
-        //! Most usually, the return value is passed to Image::Image().
-        static std::unique_ptr<Gosu::ImageData> end_recording(int width, int height);
+        //! Records a macro and returns it as an ImageData instance.
+        //! Usually, the return value is passed to Image::Image().
+        //! Cannot be nested.
+        static std::unique_ptr<Gosu::ImageData> record(int width, int height,
+                                                       const std::function<void()>& f);
         
         //! Pushes one transformation onto the transformation stack.
-        static void push_transform(const Transform& transform);
-        //! Pops one transformation from the transformation stack.
-        static void pop_transform();
+        static void transform(const Transform& transform,
+                              const std::function<void()>& f);
 
         //! Draws a line from one point to another (last pixel exclusive).
         //! Note: OpenGL lines are not reliable at all and may have a missing pixel at the start

data/Gosu/Version.hpp

@@ -3,8 +3,8 @@
 #include <string>
 
 #define GOSU_MAJOR_VERSION 0
-#define GOSU_MINOR_VERSION 11
-#define GOSU_POINT_VERSION 4
+#define GOSU_MINOR_VERSION 12
+#define GOSU_POINT_VERSION 0
 
 namespace Gosu
 {

data/rdoc/gosu.rb

@@ -381,17 +381,10 @@ module Gosu
     ##
     # Returns an image that is a smaller, rectangular view of this {Image}.
     # 
-    # This is a very fast operation, and no new textures are allocated.
+    # This is a very fast operation, and no new textures will be allocated.
     # If you update this {Image} or the {#subimage} using {#insert}, the other {Image} will be affected as well.
     # 
-    # This method can be used to load texture atlases created with third-party tools.
-    # The texture atlas must be a power of two (512x512 or 1024x1024) and loaded with :tileable => true.
-    # The individual {Image}s can then be loaded efficiently with {#subimage}.
-    # {#gl_tex_info} will work on a {#subimage}.
-    # 
     # Caveats:
-    # * {#subimage} only works if the image lives on a single texture.
-    #   If the image was too large and had to be split up into several OpenGL textures, subimage will return nil (same as {#gl_tex_info}).
     # * If you stretch or rotate a {#subimage}, the pixels adjacent to it might bleed into it, as Gosu does not manage the 'tileability' of subimages.
     # 
     # @return [Image?] an image that represents a portion of the containing image

data/src/Audio.cpp

@@ -202,13 +202,13 @@ Gosu::Sample::Sample(Reader reader)
             data.reset(new SampleData(audio_file));
         }
         catch (const std::runtime_error& ex) {
+        #ifndef GOSU_IS_MAC
             if (std::string(ex.what()).find("unknown format") != std::string::npos) {
                 MPEGFile mpeg_file(reader);
                 data.reset(new SampleData(mpeg_file));
-            }
-            else {
+            } else
+        #endif
                 throw ex;
-            }
         }
     }
     
@@ -374,10 +374,14 @@ public:
                 file.reset(new WAVE_FILE(filename));
             }
             catch (const std::runtime_error& ex) {
+            #ifndef GOSU_IS_MAC
                 if (std::string(ex.what()).find("unknown format") != std::string::npos) {
                     Gosu::File source_file(filename);
                     file.reset(new MPEGFile(source_file.front_reader()));
                 }
+                else
+            #endif
+                    throw ex;
             }
         }
         alGenBuffers(2, buffers);
@@ -393,9 +397,13 @@ public:
                 file.reset(new WAVE_FILE(reader));
             }
             catch (const std::runtime_error& ex) {
+            #ifndef GOSU_IS_MAC
                 if (std::string(ex.what()).find("unknown format") != std::string::npos) {
                     file.reset(new MPEGFile(reader));
                 }
+                else
+            #endif
+                    throw ex;
             }
         }
         alGenBuffers(2, buffers);

data/src/AudioFile.hpp

@@ -34,7 +34,7 @@ namespace Gosu
         
         const std::vector<char>& decoded_data()
         {
-            static const unsigned INCREMENT = 512 * 1024;
+            static const std::size_t INCREMENT = 512 * 1024;
             
             if (!data_.empty()) {
                 return data_;
@@ -43,7 +43,7 @@ namespace Gosu
             for (;;) {
                 data_.resize(data_.size() + INCREMENT);
                 
-                int read_bytes = read_data(&data_[data_.size() - INCREMENT], INCREMENT);
+                auto read_bytes = read_data(&data_[data_.size() - INCREMENT], INCREMENT);
                 
                 if (read_bytes < INCREMENT) {
                     data_.resize(data_.size() - INCREMENT + read_bytes);

data/src/BitmapIO.cpp

@@ -25,7 +25,7 @@ namespace
         std::size_t remaining = reader->resource().size() - reader->position();
         std::size_t actual_size = (size < remaining ? size : remaining);
         reader->read(data, actual_size);
-        return actual_size;
+        return static_cast<int>(actual_size);
     }
 
     void skip_callback(void* user, int n)

data/src/Font.cpp

@@ -159,7 +159,7 @@ void Gosu::Font::set_image(wchar_t wc, unsigned font_flags, const Image& image)
 void Gosu::Font::draw_rot(const string& text, double x, double y, ZPos z, double angle,
     double scale_x, double scale_y, Color c, AlphaMode mode) const
 {
-    Gosu::Graphics::push_transform(rotate(angle, x, y));
-    draw(text, x, y, z, scale_x, scale_y, c, mode);
-    Gosu::Graphics::pop_transform();
+    Gosu::Graphics::transform(rotate(angle, x, y), [&] {
+        draw(text, x, y, z, scale_x, scale_y, c, mode);
+    });
 }

data/src/GosuViewController.cpp

@@ -192,12 +192,10 @@ static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
     
     if (window.needs_redraw()) {
         [self.GLView redrawGL:^{
-            if (window.graphics().begin()) {
+            window.graphics().frame([&window] {
                 window.draw();
-                window.graphics().end();
-                
                 Gosu::FPS::register_frame();
-            }
+            });
         }];
     }
     

data/src/Graphics.cpp

@@ -62,6 +62,35 @@ struct Gosu::Graphics::Impl
         Transform translate_transform = translate(black_width, black_height);
         base_transform = concat(translate_transform, scale_transform);
     }
+    
+#ifndef GOSU_IS_OPENGLES
+    void begin_gl()
+    {
+        glPushAttrib(GL_ALL_ATTRIB_BITS);
+        glDisable(GL_BLEND);
+        // Reset the colour to white to avoid surprises.
+        // https://www.libgosu.org/cgi-bin/mwf/topic_show.pl?pid=9115#pid9115
+        glColor4ubv(reinterpret_cast<const GLubyte*>(&Color::WHITE));
+        while (glGetError() != GL_NO_ERROR);
+    }
+    
+    void end_gl()
+    {
+        glPopAttrib();
+        
+        // Restore matrices.
+        // TODO: Should be merged into RenderState and removed from Graphics.
+        
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        glViewport(0, 0, phys_width, phys_height);
+        glOrtho(0, phys_width, phys_height, 0, -1, 1);
+        
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+        glEnable(GL_BLEND);
+    }
+#endif
 };
 
 Gosu::Graphics::Graphics(unsigned phys_width, unsigned phys_height)
@@ -112,7 +141,7 @@ void Gosu::Graphics::set_resolution(unsigned virtual_width, unsigned virtual_hei
     pimpl->update_base_transform();
 }
 
-bool Gosu::Graphics::begin(Gosu::Color clear_with_color)
+void Gosu::Graphics::frame(const std::function<void()>& f)
 {
     if (current_graphics_pointer != nullptr) {
         throw std::logic_error("Cannot nest calls to Gosu::Graphics::begin()");
@@ -135,17 +164,13 @@ bool Gosu::Graphics::begin(Gosu::Color clear_with_color)
     
     queues.back().set_base_transform(pimpl->base_transform);
     
-    glClearColor(clear_with_color.red() / 255.f, clear_with_color.green() / 255.f,
-        clear_with_color.blue() / 255.f, clear_with_color.alpha() / 255.f);
+    glClearColor(0, 0, 0, 1);
     glClear(GL_COLOR_BUFFER_BIT);
     
     current_graphics_pointer = this;
     
-    return true;
-}
-
-void Gosu::Graphics::end()
-{
+    f();
+    
     // If recording is in process, cancel it.
     while (current_queue().recording()) {
         queues.pop_back();
@@ -164,7 +189,7 @@ void Gosu::Graphics::end()
                      0, height() + pimpl->black_height, Color::BLACK,
                      width(), height() + pimpl->black_height, Color::BLACK, 0);
         }
-        else if (pimpl->black_width) {
+        if (pimpl->black_width) {
             draw_quad(-pimpl->black_width, 0, Color::BLACK,
                      0, 0, Color::BLACK,
                      -pimpl->black_width, height(), Color::BLACK,
@@ -197,121 +222,68 @@ void Gosu::Graphics::flush()
     current_queue().clear_queue();
 }
 
-void Gosu::Graphics::begin_gl()
+void Gosu::Graphics::gl(const std::function<void()>& f)
 {
     if (current_queue().recording()) {
         throw std::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");
-#else
-    flush();
-    glPushAttrib(GL_ALL_ATTRIB_BITS);
-    glDisable(GL_BLEND);
-    while (glGetError() != GL_NO_ERROR);
-#endif
-}
-
-void Gosu::Graphics::end_gl()
-{
 #ifdef GOSU_IS_OPENGLES
     throw std::logic_error("Custom OpenGL ES is not supported yet");
 #else
     Graphics& cg = current_graphics();
-    
-    glPopAttrib();
 
-    // Restore matrices.
-    // TODO: Should be merged into RenderState and removed from Graphics.
+    flush();
+    
+    cg.pimpl->begin_gl();
 
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    glViewport(0, 0, cg.pimpl->phys_width, cg.pimpl->phys_height);
-    glOrtho(0, cg.pimpl->phys_width, cg.pimpl->phys_height, 0, -1, 1);
+    f();
 
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-    glEnable(GL_BLEND);
+    cg.pimpl->end_gl();
 #endif
 }
 
-#ifdef GOSU_IS_OPENGLES
-void Gosu::Graphics::gl(const std::function<void ()>& functor, Gosu::ZPos z)
+void Gosu::Graphics::gl(Gosu::ZPos z, const std::function<void ()>& f)
 {
+#ifdef GOSU_IS_OPENGLES
     throw std::logic_error("Custom OpenGL ES is not supported yet");
-}
 #else
-namespace Gosu
-{
-    struct RunGLFunctor
-    {
-        Graphics& graphics;
-        std::function<void ()> functor;
-        
-        RunGLFunctor(Graphics& graphics, const std::function<void ()>& functor)
-        : graphics(graphics), functor(functor)
-        {
-        }
-        
-        void operator()() const
-        {
-            // Duplicated from begin_gl() (which we don't call, to avoid flushing).
-            glPushAttrib(GL_ALL_ATTRIB_BITS);
-            glDisable(GL_BLEND);
-            // Reset the colour to white to avoid surprises.
-            // https://www.libgosu.org/cgi-bin/mwf/topic_show.pl?pid=9115#pid9115
-            glColor4ubv(reinterpret_cast<const GLubyte*>(&Color::WHITE));
-            while (glGetError() != GL_NO_ERROR);
-            
-            functor();
-            
-            graphics.end_gl();
-        }
-    };
-}
-
-void Gosu::Graphics::gl(const std::function<void ()>& functor, Gosu::ZPos z)
-{
-    current_queue().gl(RunGLFunctor(current_graphics(), functor), z);
-}
+    current_queue().gl([f] {
+        Graphics& cg = current_graphics();
+        cg.pimpl->begin_gl();
+        f();
+        cg.pimpl->end_gl();
+    }, z);
 #endif
+}
 
-void Gosu::Graphics::begin_clipping(double x, double y, double width, double height)
+void Gosu::Graphics::clip_to(double x, double y, double width, double height,
+                             const std::function<void()>& f)
 {
     double screen_height = current_graphics().pimpl->phys_height;
     current_queue().begin_clipping(x, y, width, height, screen_height);
-}
-
-void Gosu::Graphics::end_clipping()
-{
+    f();
     current_queue().end_clipping();
 }
 
-void Gosu::Graphics::begin_recording()
+std::unique_ptr<Gosu::ImageData> Gosu::Graphics::record(int width, int height,
+                                                        const std::function<void()>& f)
 {
     queues.resize(queues.size() + 1);
     current_queue().set_recording();
-}
 
-std::unique_ptr<Gosu::ImageData> Gosu::Graphics::end_recording(int width, int height)
-{
-    if (!current_queue().recording()) {
-        throw std::logic_error("No macro recording in progress that can be captured");
-    }
+    f();
     
     std::unique_ptr<ImageData> result(new Macro(current_queue(), width, height));
     queues.pop_back();
     return result;
 }
 
-void Gosu::Graphics::push_transform(const Gosu::Transform& transform)
+void Gosu::Graphics::transform(const Gosu::Transform& transform,
+                               const std::function<void()>& f)
 {
     current_queue().push_transform(transform);
-}
-
-void Gosu::Graphics::pop_transform()
-{
+    f();
     current_queue().pop_transform();
 }
 

data/src/GraphicsImpl.hpp

@@ -58,6 +58,7 @@ namespace Gosu
     class DrawOpQueue;
     typedef std::list<Transform> Transforms;
     typedef std::list<DrawOpQueue> DrawOpQueueStack;
+    class LargeImageData;
     class Macro;
     struct ArrayVertex
     {

data/src/LargeImageData.cpp

@@ -1,35 +1,37 @@
 #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)
+Gosu::LargeImageData::LargeImageData(const Bitmap& source, int tile_width, int tile_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;
+    w = source.width();
+    h = source.height();
+    tiles_x = static_cast<int>(ceil(1.0 * w / tile_width));
+    tiles_y = static_cast<int>(ceil(1.0 * h / tile_height));
+
+    // When there are no tiles, set both fields to 0 to avoid entering any for() loop in this class.
+    if (tiles_x == 0 || tiles_y == 0) {
+        tiles_x = tiles_y = 0;
+    }
+
+    tiles.reserve(tiles_x * tiles_y);
+
+    for (int y = 0; y < tiles_y; ++y) {
+        for (int x = 0; x < tiles_x; ++x) {
+            int src_width = tile_width;
+            if (x == tiles_x - 1 && w % tile_width != 0) {
+                // The right-most parts don't necessarily have the full width.
+                src_width = w % tile_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;
+            int src_height = tile_height;
+            if (y == tiles_y - 1 && h % tile_height != 0) {
+                // Same for the parts on the bottom.
+                src_height = h % tile_height;
             }
 
             unsigned local_flags = IF_TILEABLE | image_flags;
@@ -40,7 +42,7 @@ Gosu::LargeImageData::LargeImageData(const Bitmap& source,
                 local_flags |= (image_flags & IF_TILEABLE_LEFT);
             }
             // Right edge, only tileable if requested in image_flags.
-            if (x == parts_x - 1) {
+            if (x == tiles_x - 1) {
                 local_flags &= ~IF_TILEABLE_RIGHT;
                 local_flags |= (image_flags & IF_TILEABLE_RIGHT);
             }
@@ -50,102 +52,156 @@ Gosu::LargeImageData::LargeImageData(const Bitmap& source,
                 local_flags |= (image_flags & IF_TILEABLE_TOP);
             }
             // Bottom edge, only tileable if requested in image_flags.
-            if (y == parts_y - 1) {
+            if (y == tiles_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());
+            tiles.emplace_back(Graphics::create_image(source,
+                                                      x * tile_width, y * tile_height,
+                                                      src_width, src_height, local_flags));
         }
     }
 }
 
-int Gosu::LargeImageData::width() const
-{
-    return full_width;
-}
-
-int Gosu::LargeImageData::height() const
+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
 {
-    return full_height;
+    normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
+    
+    double y = 0;
+    for (int ty = 0; ty < tiles_y; ++ty) {
+        double x = 0;
+        for (int tx = 0; tx < tiles_x; ++tx) {
+            ImageData& tile = *tiles[ty * tiles_x + tx];
+
+            double rel_x_l = x / w;
+            double rel_x_r = (x + tile.width()) / w;
+            double rel_y_t = y / h;
+            double rel_y_b = (y + tile.height()) / h;
+            
+        #define INTERPOLATE(what, x_weight, y_weight) \
+            interpolate(interpolate(what##1, what##3, y_weight), \
+                        interpolate(what##2, what##4, y_weight), \
+                        x_weight);
+
+            double x_t_l = INTERPOLATE(x, rel_x_l, rel_y_t);
+            double x_t_r = INTERPOLATE(x, rel_x_r, rel_y_t);
+            double x_b_l = INTERPOLATE(x, rel_x_l, rel_y_b);
+            double x_b_r = INTERPOLATE(x, rel_x_r, rel_y_b);
+
+            double y_t_l = INTERPOLATE(y, rel_x_l, rel_y_t);
+            double y_t_r = INTERPOLATE(y, rel_x_r, rel_y_t);
+            double y_b_l = INTERPOLATE(y, rel_x_l, rel_y_b);
+            double y_b_r = INTERPOLATE(y, rel_x_r, rel_y_b);
+
+            Color  c_t_l = INTERPOLATE(c, rel_x_l, rel_y_t);
+            Color  c_t_r = INTERPOLATE(c, rel_x_r, rel_y_t);
+            Color  c_b_l = INTERPOLATE(c, rel_x_l, rel_y_b);
+            Color  c_b_r = INTERPOLATE(c, rel_x_r, rel_y_b);
+
+            tile.draw(x_t_l, y_t_l, c_t_l,
+                      x_t_r, y_t_r, c_t_r,
+                      x_b_l, y_b_l, c_b_l,
+                      x_b_r, y_b_r, c_b_r,
+                      z, mode);
+            
+            x += tile.width();
+        }
+        y += tiles[ty * tiles_x]->height();
+    }
 }
 
-namespace
+unique_ptr<Gosu::ImageData>
+    Gosu::LargeImageData::subimage(int left, int top, int width, int height) const
 {
-    // Local interpolation helper functions. - TODO why not from Math.hpp?
-
-    double ipl(double a, double b, double ratio)
-    {
-        return a + (b - a) * ratio;
+    if (left < 0 || top < 0 || left + width > w || top + height > h) {
+        throw invalid_argument("subimage bounds exceed those of its parent");
     }
-
-    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;
+    if (width <= 0 || height <= 0) {
+        throw invalid_argument("cannot create empty image");
     }
-}
-
-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);
+    int sub_tiles_y = 0;
+    vector<unique_ptr<ImageData>> sub_tiles;
+    
+    int y = 0;
+    for (int ty = 0; ty < tiles_y; ++ty) {
+        int row_height = tiles[ty * tiles_x]->height();
+        
+        if (y + row_height <= top) {
+            y += tiles[ty * tiles_x]->height();
+            continue;
         }
+        if (y >= top + height) break;
+        
+        sub_tiles_y += 1;
+
+        int x = 0;
+        for (int tx = 0; tx < tiles_x; ++tx) {
+            ImageData& tile = *tiles[ty * tiles_x + tx];
+            
+            if (x + tile.width() <= left) {
+                x += tile.width();
+                continue;
+            }
+            if (x >= left + width) break;
+            
+            int sub_left   = max(0, left - x);
+            int sub_top    = max(0, top  - y);
+            int sub_right  = min(tile.width(),  left + width  - x);
+            int sub_bottom = min(tile.height(), top  + height - y);
+            
+            sub_tiles.emplace_back(tile.subimage(sub_left, sub_top, sub_right - sub_left, sub_bottom - sub_top));
+            
+            x += tile.width();
+        }
+        y += tiles[ty * tiles_x]->height();
+    }
+    
+    if (sub_tiles.size() == 1) {
+        return move(sub_tiles[0]);
+    }
+    else {
+        unique_ptr<LargeImageData> result(new LargeImageData());
+        result->w = width;
+        result->h = height;
+        result->tiles_x = static_cast<int>(sub_tiles.size()) / sub_tiles_y;
+        result->tiles_y = sub_tiles_y;
+        result->tiles.swap(sub_tiles);
+        return move(result);
     }
 }
 
 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);
+    int y = 0;
+    for (int ty = 0; ty < tiles_y; ++ty) {
+        int x = 0;
+        for (int tx = 0; tx < tiles_x; ++tx) {
+            ImageData& tile = *tiles[ty * tiles_x + tx];
+            bitmap.insert(tile.to_bitmap(), x, y);
+            x += tile.width();
         }
+        y += tiles[ty * tiles_x]->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);
+    int y = 0;
+    for (int ty = 0; ty < tiles_y; ++ty) {
+        int x = 0;
+        for (int tx = 0; tx < tiles_x; ++tx) {
+            ImageData& tile = *tiles[ty * tiles_x + tx];
+            tile.insert(bitmap, at_x - x, at_y - y);
+            x += tile.width();
         }
+        y += tiles[ty * tiles_x]->height();
     }
 }

data/src/LargeImageData.hpp

@@ -1,43 +1,37 @@
 #pragma once
 
+#include "GraphicsImpl.hpp"
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
 #include <Gosu/Platform.hpp>
 #include <memory>
 #include <vector>
 
-namespace Gosu
+class Gosu::LargeImageData : public Gosu::ImageData
 {
-    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;
+    int w, h;
+    int tiles_x, tiles_y;
+    std::vector<std::unique_ptr<ImageData>> tiles;
+    
+    LargeImageData() {}
 
-    public:
-        LargeImageData(const Bitmap& source, unsigned part_width, unsigned part_height,
-            unsigned image_flags);
+public:
+    LargeImageData(const Bitmap& source, int tile_width, int tile_height, unsigned image_flags);
 
-        int width() const override;
-        int height() const override;
+    int width() const override  { return w; }
+    int height() const override { return h; }
 
-        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;
+    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;
-    };
-}
+    const GLTexInfo* gl_tex_info() const override { return nullptr; }
+    
+    std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
+    
+    Bitmap to_bitmap() const override;
+    
+    void insert(const Bitmap& bitmap, int x, int y) override;
+};

data/src/Macro.cpp

@@ -211,7 +211,7 @@ void Gosu::Macro::draw(double x1, double y1, Color c1, double x2, double y2, Col
     normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
     
     std::function<void ()> f = [=] { pimpl->draw_vertex_arrays(x1, y1, x2, y2, x3, y3, x4, y4); };
-    Gosu::Graphics::gl(f, z);
+    Gosu::Graphics::gl(z, f);
 }
 
 const Gosu::GLTexInfo* Gosu::Macro::gl_tex_info() const

data/src/RubyGosu.cxx

@@ -2400,30 +2400,24 @@ namespace Gosu
     
     void unsafe_gl()
     {
-        Gosu::Graphics::begin_gl();
-        rb_yield(Qnil);
-        Gosu::Graphics::end_gl();
+        Gosu::Graphics::gl([] { rb_yield(Qnil); });
     }
     
     void unsafe_gl(Gosu::ZPos z)
     {
         VALUE block = rb_block_proc();
-        Gosu::Graphics::gl([block] {
+        Gosu::Graphics::gl(z, [block] {
             Gosu::call_ruby_block(block);
-        }, z);
+        });
     }
     
     void clip_to(double x, double y, double width, double height)
     {
-        Gosu::Graphics::begin_clipping(x, y, width, height);
-        rb_yield(Qnil);
-        Gosu::Graphics::end_clipping();
+        Gosu::Graphics::clip_to(x, y, width, height, [] { rb_yield(Qnil); });
     }
     
     Gosu::Image* record(int width, int height) {
-        Gosu::Graphics::begin_recording();
-        rb_yield(Qnil);
-        return new Gosu::Image(Gosu::Graphics::end_recording(width, height));
+        return new Gosu::Image(Gosu::Graphics::record(width, height, [] { rb_yield(Qnil); }));
     }
     
     // This method cannot be called "transform" because then it would be an ambiguous overload of
@@ -2437,44 +2431,38 @@ namespace Gosu
         Gosu::Transform transform = {
             m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15
         };
-        Gosu::Graphics::push_transform(transform);
-        rb_yield(Qnil);
-        Gosu::Graphics::pop_transform();
+        Gosu::Graphics::transform(transform,
+                                  [] { rb_yield(Qnil); });
     }
     
     void rotate_for_ruby(double angle, double around_x = 0, double around_y = 0)
     {
-        Gosu::Graphics::push_transform(Gosu::rotate(angle, around_x, around_y));
-        rb_yield(Qnil);
-        Gosu::Graphics::pop_transform();
+        Gosu::Graphics::transform(Gosu::rotate(angle, around_x, around_y),
+                                  [] { rb_yield(Qnil); });
     }
     
     void scale_for_ruby(double factor)
     {
-        Gosu::Graphics::push_transform(Gosu::scale(factor));
-        rb_yield(Qnil);
-        Gosu::Graphics::pop_transform();
+        Gosu::Graphics::transform(Gosu::scale(factor),
+                                  [] { rb_yield(Qnil); });
     }
     
     void scale_for_ruby(double scale_x, double scale_y)
     {
-        Gosu::Graphics::push_transform(Gosu::scale(scale_x, scale_y));
-        rb_yield(Qnil);
-        Gosu::Graphics::pop_transform();
+        Gosu::Graphics::transform(Gosu::scale(scale_x, scale_y),
+                                  [] { rb_yield(Qnil); });
     }
     
     void scale_for_ruby(double scale_x, double scale_y, double around_x, double around_y)
     {
-        Gosu::Graphics::push_transform(Gosu::scale(scale_x, scale_y, around_x, around_y));
-        rb_yield(Qnil);
-        Gosu::Graphics::pop_transform();
+        Gosu::Graphics::transform(Gosu::scale(scale_x, scale_y, around_x, around_y),
+                                  [] { rb_yield(Qnil); });
     }
     
     void translate_for_ruby(double x, double y)
     {
-        Gosu::Graphics::push_transform(Gosu::translate(x, y));
-        rb_yield(Qnil);
-        Gosu::Graphics::pop_transform();
+        Gosu::Graphics::transform(Gosu::translate(x, y),
+                                  [] { rb_yield(Qnil); });
     }
 }
 
@@ -11638,8 +11626,8 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_const(mGosu, "VERSION", SWIG_From_std_string(static_cast< std::string >(Gosu::VERSION)));
   rb_define_const(mGosu, "LICENSES", SWIG_From_std_string(static_cast< std::string >(Gosu::LICENSES)));
   rb_define_const(mGosu, "MAJOR_VERSION", SWIG_From_int(static_cast< int >(0)));
-  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(11)));
-  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(4)));
+  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(12)));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(0)));
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);
   rb_define_module_function(mGosu, "degrees_to_radians", VALUEFUNC(_wrap_degrees_to_radians), -1);

data/src/TexChunk.cpp

@@ -3,27 +3,35 @@
 #include "Texture.hpp"
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>
+using namespace std;
 
 void Gosu::TexChunk::set_tex_info()
 {
+    double texture_size = texture->size();
+
     info.tex_name = texture->tex_name();
-    float texture_size = texture->size();
-    info.left = x / texture_size;
-    info.top = y / texture_size;
-    info.right = (x + w) / texture_size;
+    info.left   = x / texture_size;
+    info.top    = y / texture_size;
+    info.right  = (x + w) / texture_size;
     info.bottom = (y + h) / texture_size;
 }
 
-Gosu::TexChunk::TexChunk(std::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
+Gosu::TexChunk::TexChunk(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)
 {
     set_tex_info();
 }
 
-Gosu::TexChunk::TexChunk(const TexChunk& parent_chunk, int x, int y, int w, int h)
-: texture(parent_chunk.texture), x(parent_chunk.x + x), y(parent_chunk.y + y), w(w), h(h),
-  padding(0)
+Gosu::TexChunk::TexChunk(const TexChunk& parent, int x, int y, int w, int h)
+: texture(parent.texture), x(parent.x + x), y(parent.y + y), w(w), h(h), padding(0)
 {
+    if (x < 0 || y < 0 || x + w > parent.w || y + h > parent.h) {
+        throw invalid_argument("subimage bounds exceed those of its parent");
+    }
+    if (w <= 0 || h <= 0) {
+        throw invalid_argument("cannot create empty image");
+    }
+    
     set_tex_info();
     texture->block(this->x, this->y, this->w, this->h);
 }
@@ -62,9 +70,9 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2,
     Graphics::schedule_draw_op(op);
 }
 
-const Gosu::GLTexInfo* Gosu::TexChunk::gl_tex_info() const
+unique_ptr<Gosu::ImageData> Gosu::TexChunk::subimage(int x, int y, int width, int height) const
 {
-    return &info;
+    return unique_ptr<Gosu::ImageData>(new TexChunk(*this, x, y, width, height));
 }
 
 Gosu::Bitmap Gosu::TexChunk::to_bitmap() const
@@ -72,15 +80,8 @@ Gosu::Bitmap Gosu::TexChunk::to_bitmap() const
     return texture->to_bitmap(x, y, w, h);
 }
 
-std::unique_ptr<Gosu::ImageData> Gosu::TexChunk::subimage(int x, int y, int width, int height) const
-{
-    return std::unique_ptr<Gosu::ImageData>(new TexChunk(*this, x, y, width, height));
-}
-
 void Gosu::TexChunk::insert(const Bitmap& original, int x, int y)
 {
-    // TODO: Should respect border_flags.
-    
     Bitmap alternate;
     const Bitmap* bitmap = &original;
     

data/src/TexChunk.hpp

@@ -5,46 +5,37 @@
 #include <Gosu/ImageData.hpp>
 #include <memory>
 #include <stdexcept>
-#include <vector>
 
 class Gosu::TexChunk : public Gosu::ImageData
 {
     std::shared_ptr<Texture> texture;
     int x, y, w, h, padding;
     
-    // Cached for faster access.
     GLTexInfo info;
     
     void set_tex_info();
     
 public:
     TexChunk(std::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
-    TexChunk(const TexChunk& parent_chunk, int x, int y, int w, int h);
-    ~TexChunk();
+    TexChunk(const TexChunk& parent, int x, int y, int w, int h);
+    ~TexChunk() override;
 
-    int width() const
-    {
-        return w;
-    }
+    int width() const override  { return w; }
+    int height() const override { return h; }
     
-    int height() const
-    {
-        return h;
-    }
-    
-    GLuint tex_name() const
-    {
-        return info.tex_name;
-    }
+    GLuint tex_name() const { return info.tex_name; }
     
     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;
+        ZPos z, AlphaMode mode) const override;
 
-    const GLTexInfo* gl_tex_info() const;
-    Gosu::Bitmap to_bitmap() const;
-    std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const;
-    void insert(const Bitmap& bitmap, int x, int y);
+    const GLTexInfo* gl_tex_info() const override { return &info; }
+    
+    std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
+    
+    Gosu::Bitmap to_bitmap() const override;
+    
+    void insert(const Bitmap& bitmap, int x, int y) override;
 };

data/src/Version.cpp

@@ -9,14 +9,16 @@ const std::string Gosu::VERSION = std::to_string(GOSU_MAJOR_VERSION) + '.' +
 const std::string Gosu::LICENSES =
     "This software may utilize code from the following third-party libraries:\n"
     "\n"
-    "Gosu, https://www.libgosu.org, MIT License, http://opensource.org/licenses/MIT\n"
-    "SDL 2, http://www.libsdl.org, MIT License, http://opensource.org/licenses/MIT\n"
+    "Gosu, https://www.libgosu.org, MIT License, https://opensource.org/licenses/MIT\n"
+    "SDL 2, https://www.libsdl.org, MIT License, https://opensource.org/licenses/MIT\n"
 #if defined(GOSU_IS_WIN) || defined(GOSU_IS_X)
     "libsndfile, http://www.mega-nerd.com/libsndfile, GNU LGPL 3, "
-        "http://www.gnu.org/copyleft/lesser.html\n"
+        "https://www.gnu.org/copyleft/lesser.html\n"
+    "mpg123, https://mpg123.de, GNU LGPL 3, "
+        "https://www.gnu.org/copyleft/lesser.html\n"
 #endif
 #if defined(GOSU_IS_WIN)
     "OpenAL Soft, http://kcat.strangesoft.net/openal.html, GNU LGPL 2, "
-        "http://www.gnu.org/licenses/old-licenses/lgpl-2.0.html\n"
+        "https://www.gnu.org/licenses/old-licenses/lgpl-2.0.html\n"
 #endif
     ;

data/src/Window.cpp

@@ -283,11 +283,10 @@ bool Gosu::Window::tick()
     
     if (needs_redraw()) {
         ensure_current_context();
-        if (graphics().begin()) {
+        graphics().frame([&] {
             draw();
-            graphics().end();
             FPS::register_frame();
-        }
+        });
         
         SDL_GL_SwapWindow(shared_window());
     }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gosu
 version: !ruby/object:Gem::Version
-  version: 0.11.4.pre3
+  version: 0.12.0
 platform: ruby
 authors:
 - Julian Raschke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-04 00:00:00.000000000 Z
+date: 2017-04-23 00:00:00.000000000 Z
 dependencies: []
 description: |2
       2D game development library.
@@ -152,12 +152,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.8.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: 2D game development library.