gosu 0.9.2.pre1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a1c34fd00bf80dda03420c2469ba363f09790e5
-  data.tar.gz: eb1a0080a88b5aae6a77731cf7f9b0d5a7ddc221
+  metadata.gz: f230854e1ac05d7b61ed5fb830626d5ce35486d9
+  data.tar.gz: da67861b37f7f750891d8c082bdfb9ccca29cdf1
 SHA512:
-  metadata.gz: c7ebb942e9dd669d8cfb8efd51a1f1e796b042067b88beee7d62a3997c550d1fe0794afd1c82026a5d1ce4a71970b5c67611fd1e24a062dd7b1cc8e451745af3
-  data.tar.gz: d227fec88ceb822dcd120923e338e49cee87897b0be3e21eeefa1d0355c050bb4c0ec53ef8867394b2c2e30535ff6a332ea1fc2fdca1b221660b527fd40de3c9
+  metadata.gz: 7fbf834d22e9d7f37f86e428370c8816e4ad57466402a173a90e2edefa2424696b0f8fcb8afa5d8bea8de2437aad0d18e666782b10c53c8e82751e3ba94c5638
+  data.tar.gz: f37312c5e178fc2df0428ce2346c8bea5f2873217baed40578243bef5342138bcf347292ca4eb2dbaa3f5908f6bea258653213103ec1514a8cd9d0237340af15

data/Gosu/Version.hpp

@@ -4,7 +4,7 @@
 #define GOSU_MAJOR_VERSION 0
 #define GOSU_MINOR_VERSION 9
 #define GOSU_POINT_VERSION 2
-#define GOSU_VERSION "0.9.2.pre1"
+#define GOSU_VERSION "0.9.2"
 
 #define GOSU_COPYRIGHT_NOTICE \
     "This software uses the following third-party libraries:\n" \

data/ext/gosu/extconf.rb

@@ -28,6 +28,7 @@ BASE_FILES = %w(
   Graphics/Graphics.cpp
   Graphics/Image.cpp
   Graphics/LargeImageData.cpp
+  Graphics/Macro.cpp
   Graphics/Resolution.cpp
   Graphics/TexChunk.cpp
   Graphics/Texture.cpp

data/ext/gosu/gosu_wrap.cxx

@@ -8,6 +8,10 @@
  * interface file instead.
  * ----------------------------------------------------------------------------- */
 
+// This file was afterwards patched using the following instructions:
+// http://sourceforge.net/tracker/index.php?func=detail&aid=2034216&group_id=1645&atid=101645
+// (Many thanks to Kevin Burge for that.)
+
 #define SWIGRUBY
 #define SWIG_DIRECTORS
 
@@ -844,6 +848,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 
 
 #include <ruby.h>
+#include <map>
 
 /* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
  * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
@@ -1184,7 +1189,7 @@ extern "C" {
 /* Global Ruby hash table to store Trackings from C/C++
    structs to Ruby Objects. 
 */
-static VALUE swig_ruby_trackings = Qnil;
+static std::map<void*, VALUE> swig_ruby_trackings;
 
 /* Global variable that stores a reference to the ruby
    hash table delete function. */
@@ -1201,34 +1206,18 @@ SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
      This is done to allow multiple DSOs to share the same
      tracking table.
   */
-  ID trackings_id = rb_intern( "@__trackings__" );
   VALUE verbose = rb_gv_get("VERBOSE");
   rb_gv_set("VERBOSE", Qfalse);
-  swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
   rb_gv_set("VERBOSE", verbose);
 
   /* No, it hasn't.  Create one ourselves */ 
-  if ( swig_ruby_trackings == Qnil )
-    {
-      swig_ruby_trackings = rb_hash_new();
-      rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
-    }
+  swig_ruby_trackings.clear();
 
   /* Now store a reference to the hash table delete function
      so that we only have to look it up once.*/
   swig_ruby_hash_delete = rb_intern("delete");
 }
 
-/* Get a Ruby number to reference a pointer */
-SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
-  /* We cast the pointer to an unsigned long
-     and then store a reference to it using
-     a Ruby number object. */
-
-  /* Convert the pointer to a Ruby number */
-  return SWIG2NUM(ptr);
-}
-
 /* Get a Ruby number to reference an object */
 SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
   /* We cast the object to an unsigned long
@@ -1250,39 +1239,16 @@ SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
 
 /* Add a Tracking from a C/C++ struct to a Ruby object */
 SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
-  /* In a Ruby hash table we store the pointer and
-     the associated Ruby object.  The trick here is
-     that we cannot store the Ruby object directly - if
-     we do then it cannot be garbage collected.  So
-     instead we typecast it as a unsigned long and
-     convert it to a Ruby number object.*/
-
-  /* Get a reference to the pointer as a Ruby number */
-  VALUE key = SWIG_RubyPtrToReference(ptr);
-
-  /* Get a reference to the Ruby object as a Ruby number */
-  VALUE value = SWIG_RubyObjectToReference(object);
-
   /* Store the mapping to the global hash table. */
-  rb_hash_aset(swig_ruby_trackings, key, value);
+  swig_ruby_trackings[ptr] = object;
 }
 
 /* Get the Ruby object that owns the specified C/C++ struct */
 SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
-  /* Get a reference to the pointer as a Ruby number */
-  VALUE key = SWIG_RubyPtrToReference(ptr);
-
-  /* Now lookup the value stored in the global hash table */
-  VALUE value = rb_hash_aref(swig_ruby_trackings, key);
-	
-  if (value == Qnil) {
-    /* No object exists - return nil. */
+  if (swig_ruby_trackings.count(ptr) == 0)
     return Qnil;
-  }
-  else {
-    /* Convert this value to Ruby object */
-    return SWIG_RubyReferenceToObject(value);
-  }
+  else
+    return swig_ruby_trackings[ptr];
 }
 
 /* Remove a Tracking from a C/C++ struct to a Ruby object.  It
@@ -1290,12 +1256,7 @@ SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
    since the same memory address may be reused later to create
    a new object. */
 SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
-  /* Get a reference to the pointer as a Ruby number */
-  VALUE key = SWIG_RubyPtrToReference(ptr);
-
-  /* Delete the object from the hash table by calling Ruby's
-     do this we need to call the Hash.delete method.*/
-  rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
+  swig_ruby_trackings.erase(ptr);
 }
 
 /* This is a helper method that unlinks a Ruby object from its
@@ -3101,14 +3062,14 @@ SwigDirector_Window::~SwigDirector_Window() {
 void SwigDirector_Window::update() {
   VALUE result;
   
-  result = rb_funcall(swig_get_self(), rb_intern("update"), 0, NULL);
+  result = rb_funcall(swig_get_self(), rb_intern("protected_update"), 0, NULL);
 }
 
 
 void SwigDirector_Window::draw() {
   VALUE result;
   
-  result = rb_funcall(swig_get_self(), rb_intern("draw"), 0, NULL);
+  result = rb_funcall(swig_get_self(), rb_intern("protected_draw_2"), 0, NULL);
 }
 
 
@@ -3116,7 +3077,7 @@ bool SwigDirector_Window::needsRedraw() const {
   bool c_result ;
   VALUE result;
   
-  result = rb_funcall(swig_get_self(), rb_intern("needs_redraw?"), 0, NULL);
+  result = rb_funcall(swig_get_self(), rb_intern("protected_needs_redraw?"), 0, NULL);
   bool swig_val;
   int swig_res = SWIG_AsVal_bool(result, &swig_val);
   if (!SWIG_IsOK(swig_res)) {
@@ -3131,7 +3092,7 @@ bool SwigDirector_Window::needsCursor() const {
   bool c_result ;
   VALUE result;
   
-  result = rb_funcall(swig_get_self(), rb_intern("needs_cursor?"), 0, NULL);
+  result = rb_funcall(swig_get_self(), rb_intern("protected_needs_cursor?"), 0, NULL);
   bool swig_val;
   int swig_res = SWIG_AsVal_bool(result, &swig_val);
   if (!SWIG_IsOK(swig_res)) {
@@ -3145,7 +3106,7 @@ bool SwigDirector_Window::needsCursor() const {
 void SwigDirector_Window::loseFocus() {
   VALUE result;
   
-  result = rb_funcall(swig_get_self(), rb_intern("lose_focus"), 0, NULL);
+  result = rb_funcall(swig_get_self(), rb_intern("protected_lose_focus"), 0, NULL);
 }
 
 
@@ -3166,7 +3127,7 @@ void SwigDirector_Window::buttonDown(Gosu::Button arg0) {
     else
     obj0 = LONG2NUM((&arg0)->id());
   }
-  result = rb_funcall(swig_get_self(), rb_intern("button_down"), 1,obj0);
+  result = rb_funcall(swig_get_self(), rb_intern("protected_button_down"), 1,obj0);
 }
 
 
@@ -3180,7 +3141,7 @@ void SwigDirector_Window::buttonUp(Gosu::Button arg0) {
     else
     obj0 = LONG2NUM((&arg0)->id());
   }
-  result = rb_funcall(swig_get_self(), rb_intern("button_up"), 1,obj0);
+  result = rb_funcall(swig_get_self(), rb_intern("protected_button_up"), 1,obj0);
 }
 
 
@@ -11135,7 +11096,7 @@ SWIGEXPORT void Init_gosu(void) {
   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 >(9)));
   rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(2)));
-  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.9.2.pre1"));
+  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.9.2"));
   rb_define_const(mGosu, "GOSU_COPYRIGHT_NOTICE", SWIG_FromCharPtr("This software uses the following third-party libraries:\n\nGosu, http://www.libgosu.org, MIT License, http://opensource.org/licenses/MIT\nSDL 2, http://www.libsdl.org, MIT License, http://opensource.org/licenses/MIT\nFreeImage, http://freeimage.sourceforge.net, FreeImage Public License\nlibogg & libvorbis, http://www.xiph.org, BSD License, 3-Clause Version, http://www.xiph.org/licenses/bsd\nlibsndfile, http://www.mega-nerd.com/libsndfile, GNU LGPL 3, http://www.gnu.org/copyleft/lesser.html\nOpenAL Soft, http://kcat.strangesoft.net/openal.html, GNU LGPL 2, http://www.gnu.org/licenses/old-licenses/lgpl-2.0.html\n"));
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);

data/src/Graphics/DrawOpQueue.hpp

@@ -16,6 +16,7 @@ class Gosu::DrawOpQueue
 {
     TransformStack transformStack;
     ClipRectStack clipRectStack;
+    bool rec;
 
     typedef std::vector<DrawOp> DrawOps;
     DrawOps ops;
@@ -23,6 +24,21 @@ class Gosu::DrawOpQueue
     GLBlocks glBlocks;
 
 public:
+    DrawOpQueue()
+    : rec(false)
+    {
+    }
+    
+    bool recording() const
+    {
+        return rec;
+    }
+    
+    void setRecording()
+    {
+        rec = true;
+    }
+    
     void scheduleDrawOp(DrawOp op)
     {
         if (clipRectStack.clippedWorldAway())
@@ -59,6 +75,9 @@ public:
 
     void beginClipping(double x, double y, double width, double height, double screenHeight)
     {
+        if (recording())
+            throw std::logic_error("Clipping is not allowed while creating a macro yet");
+        
         // Apply current transformation.
 
         double left = x, right = x + width;
@@ -100,6 +119,9 @@ public:
 
     void performDrawOpsAndCode()
     {
+        if (recording())
+            throw std::logic_error("Flushing to the screen is not allowed while recording a macro");
+        
         // Apply Z-Ordering.
         std::stable_sort(ops.begin(), ops.end());
 
@@ -139,7 +161,7 @@ public:
     void compileTo(VertexArrays& vas)
     {
         if (!glBlocks.empty())
-            throw std::logic_error("Custom code cannot be recorded into a macro");
+            throw std::logic_error("Custom OpenGL code cannot be recorded as a macro");
 
         std::stable_sort(ops.begin(), ops.end());
         for (DrawOps::const_iterator op = ops.begin(), end = ops.end(); op != end; ++op)

data/src/Graphics/Graphics.cpp

@@ -1,6 +1,7 @@
 #include <Gosu/Graphics.hpp>
 #include "Common.hpp"
 #include "DrawOp.hpp"
+#include "DrawOpQueue.hpp"
 #include "Texture.hpp"
 #include "TexChunk.hpp"
 #include "LargeImageData.hpp"
@@ -28,6 +29,15 @@ namespace Gosu
         
         typedef std::vector<std::tr1::shared_ptr<Texture> > Textures;
         Textures textures;
+        
+        DrawOpQueueStack queues;
+        
+        DrawOpQueue& currentQueue()
+        {
+            if (queues.empty())
+                throw std::logic_error("There is no rendering queue for this operation");
+            return queues.back();
+        }
     }
 }
 
@@ -37,7 +47,9 @@ struct Gosu::Graphics::Impl
     unsigned physWidth, physHeight;
     double blackWidth, blackHeight;
     bool fullscreen;
-    DrawOpQueueStack queues;
+    Transform baseTransform;
+    
+    DrawOpQueueStack warmedUpQueues;
 };
 
 Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscreen)
@@ -65,9 +77,6 @@ Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscree
     glLoadIdentity();
     
     glEnable(GL_BLEND);
-    
-    // Create default draw-op queue.
-    pimpl->queues.resize(1);
 }
 
 Gosu::Graphics::~Graphics()
@@ -108,26 +117,37 @@ void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight
 
     Transform scaleTransform = scale(scaleFactor);
     Transform translateTransform = translate(pimpl->blackWidth, pimpl->blackHeight);
-    Transform baseTransform = concat(translateTransform, scaleTransform);
-    
-    pimpl->queues.front().setBaseTransform(baseTransform);
+    pimpl-> baseTransform = concat(translateTransform, scaleTransform);
 }
 
 bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
 {
-    // If recording is in process, cancel it.
-    assert (pimpl->queues.size() == 1);
-    pimpl->queues.resize(1);
-    // Clear leftover transforms, clip rects etc.
-    pimpl->queues.front().reset();
+    if (currentGraphicsPointer != 0)
+        throw std::logic_error("Cannot nest calls to Gosu::Graphics::begin()");
+    
+    // Cancel all recording or whatever that might still be in progress...
+    queues.clear();
+    
+    if (pimpl->warmedUpQueues.size() == 1)
+    {
+        // If we already have a "warmed up" queue, use that instead.
+        // -> All internals std::vectors will already have a lot of capacity.
+        // This helps reduce allocations during normal operation.
+        queues.clear();
+        queues.swap(pimpl->warmedUpQueues);
+    }
+    else
+    {
+        // Create default draw-op queue.
+        queues.resize(1);
+    }
+    
+    queues.back().setBaseTransform(pimpl->baseTransform);
     
     glClearColor(clearWithColor.red() / 255.f, clearWithColor.green() / 255.f,
         clearWithColor.blue() / 255.f, clearWithColor.alpha() / 255.f);
     glClear(GL_COLOR_BUFFER_BIT);
     
-    if (currentGraphicsPointer != 0)
-        throw std::logic_error("Cannot nest calls to Gosu::Graphics::begin()");
-    
     currentGraphicsPointer = this;
     
     return true;
@@ -136,10 +156,12 @@ bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
 void Gosu::Graphics::end()
 {
     // If recording is in process, cancel it.
-    pimpl->queues.resize(1);
+    while (currentQueue().recording()) {
+        queues.pop_back();
+    }
     
     flush();
-
+    
     if (pimpl->blackHeight || pimpl->blackWidth) {
         if (pimpl->blackHeight) {
             drawQuad(0, -pimpl->blackHeight, Color::BLACK,
@@ -165,26 +187,30 @@ void Gosu::Graphics::end()
     }
     
     glFlush();
-
+    
     currentGraphicsPointer = 0;
+    
+    // Clear leftover transforms, clip rects etc.
+    if (queues.size() == 1)
+    {
+        queues.swap(pimpl->warmedUpQueues);
+        pimpl->warmedUpQueues.back().reset();
+    }
+    else
+    {
+        queues.clear();
+    }
 }
 
 void Gosu::Graphics::flush()
 {
-    Graphics& cg = currentGraphics();
-    
-    if (cg.pimpl->queues.size() != 1)
-        throw std::logic_error("Flushing to screen is not allowed while creating a macro");
-    
-    cg.pimpl->queues.front().performDrawOpsAndCode();
-    cg.pimpl->queues.front().clearQueue();
+    currentQueue().performDrawOpsAndCode();
+    currentQueue().clearQueue();
 }
 
 void Gosu::Graphics::beginGL()
 {
-    Graphics& cg = currentGraphics();
-    
-    if (cg.pimpl->queues.size() > 1)
+    if (currentQueue().recording())
         throw std::logic_error("Custom OpenGL is not allowed while creating a macro");
     
 #ifdef GOSU_IS_OPENGLES
@@ -247,90 +273,71 @@ namespace Gosu
             
             functor();
             
-            // Does not have to be inlined.
-            graphics.endGL();            
+            graphics.endGL();
         }
     };
 }
 
 void Gosu::Graphics::scheduleGL(const std::tr1::function<void()>& functor, Gosu::ZPos z)
 {
-    Graphics& cg = currentGraphics();
-    
-    cg.pimpl->queues.back().scheduleGL(RunGLFunctor(cg, functor), z);
+    currentQueue().scheduleGL(RunGLFunctor(currentGraphics(), functor), z);
 }
 #endif
 
 void Gosu::Graphics::beginClipping(double x, double y, double width, double height)
 {
-    Graphics& cg = currentGraphics();
-    
-    if (cg.pimpl->queues.size() > 1)
-        throw std::logic_error("Clipping is not allowed while creating a macro yet");
-    
-    cg.pimpl->queues.back().beginClipping(x, y, width, height, cg.pimpl->physHeight);
+    double screenHeight = currentGraphics().pimpl->physHeight;
+    currentQueue().beginClipping(x, y, width, height, screenHeight);
 }
 
 void Gosu::Graphics::endClipping()
 {
-    Graphics& cg = currentGraphics();
-    
-    cg.pimpl->queues.back().endClipping();
+    currentQueue().endClipping();
 }
 
 void Gosu::Graphics::beginRecording()
 {
-    Graphics& cg = currentGraphics();
-    
-    cg.pimpl->queues.resize(cg.pimpl->queues.size() + 1);
+    queues.resize(queues.size() + 1);
+    currentQueue().setRecording();
 }
 
 GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Graphics::endRecording(int width, int height)
 {
-    Graphics& cg = currentGraphics();
-    
-    if (cg.pimpl->queues.size() == 1)
+    if (! currentQueue().recording())
         throw std::logic_error("No macro recording in progress that can be captured");
     
-    GOSU_UNIQUE_PTR<ImageData> result(new Macro(cg, cg.pimpl->queues.back(), width, height));
-    cg.pimpl->queues.pop_back();
+    GOSU_UNIQUE_PTR<ImageData> result(new Macro(currentQueue(), width, height));
+    queues.pop_back();
     return result;
 }
 
 void Gosu::Graphics::pushTransform(const Gosu::Transform& transform)
 {
-    Graphics& cg = currentGraphics();
-    
-    cg.pimpl->queues.back().pushTransform(transform);
+    currentQueue().pushTransform(transform);
 }
 
 void Gosu::Graphics::popTransform()
 {
-    Graphics& cg = currentGraphics();
-    
-    cg.pimpl->queues.back().popTransform();
+    currentQueue().popTransform();
 }
 
 void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
     double x2, double y2, Color c2, ZPos z, AlphaMode mode)
 {
-    Graphics& cg = currentGraphics();
-    
     DrawOp op;
     op.renderState.mode = mode;
     op.verticesOrBlockIndex = 2;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
     op.z = z;
-    cg.pimpl->queues.back().scheduleDrawOp(op);
+    
+    currentQueue().scheduleDrawOp(op);
 }
 
 void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
     double x2, double y2, Color c2, double x3, double y3, Color c3,
     ZPos z, AlphaMode mode)
 {
-    Graphics& cg = currentGraphics();
-    
     DrawOp op;
     op.renderState.mode = mode;
     op.verticesOrBlockIndex = 3;
@@ -342,15 +349,14 @@ void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
     op.vertices[3] = op.vertices[2];
 #endif
     op.z = z;
-    cg.pimpl->queues.back().scheduleDrawOp(op);
+    
+    currentQueue().scheduleDrawOp(op);
 }
 
 void Gosu::Graphics::drawQuad(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)
 {
-    Graphics& cg = currentGraphics();
-    
     reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
 
     DrawOp op;
@@ -367,14 +373,13 @@ void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
     op.vertices[2] = DrawOp::Vertex(x4, y4, c4);
 #endif
     op.z = z;
-    cg.pimpl->queues.back().scheduleDrawOp(op);
+    
+    currentQueue().scheduleDrawOp(op);
 }
 
 void Gosu::Graphics::scheduleDrawOp(const Gosu::DrawOp &op)
 {
-    Graphics& cg = currentGraphics();
-    
-    cg.pimpl->queues.back().scheduleDrawOp(op);
+    currentQueue().scheduleDrawOp(op);
 }
 
 GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Graphics::createImage(

data/src/Graphics/Macro.cpp

@@ -0,0 +1,234 @@
+#include "Macro.hpp"
+#include "DrawOpQueue.hpp"
+#include <cmath>
+#include <algorithm>
+#include <memory>
+#include <stdexcept>
+
+struct Gosu::Macro::Impl
+{
+    typedef double Float;
+    
+    VertexArrays vertexArrays;
+    int width, height;
+    
+    Transform findTransformForTarget(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).
+        
+        // To draw a macro at an arbitrary position, we solve the following system:
+        
+        // 0, 0, 1, 0, 0, 0,    0,    0 | x1
+        // 0, 0, 0, 0, 0, 1,    0,    0 | y1
+        // w, 0, 1, 0, 0, 0, -x2w,    0 | x2
+        // 0, 0, 0, w, 0, 1, -y2w,    0 | y2
+        // 0, h, 1, 0, 0, 0,    0, -x3h | x3
+        // 0, 0, 0, 0, h, 1,    0, -y3h | y3
+        // w, h, 1, 0, 0, 0, -x4w, -x4h | x4
+        // 0, 0, 0, w, h, 1, -y4w, -y4h | y4
+        
+        // Equivalent:
+        
+        // 0, 0, 1, 0, 0, 0,        0,        0 | x1
+        // 0, 0, 0, 0, 0, 1,        0,        0 | y1
+        // w, 0, 0, 0, 0, 0,     -x2w,        0 | x2-x1
+        // 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, (x2-x4)w, (x3-x4)h | x1-x2-x3+x4
+        // 0, 0, 0, 0, 0, 0, (y2-y4)w, (y3-y4)h | y1-y2-y3+y4
+        
+        // Since this matrix is relatively sparse, we unroll all three solving paths.
+        
+        static const Transform nullTransform = {{ 0 }};
+        
+        // Row 7 is completely useless
+        if (x2 == x4 && x3 == x4)
+            return nullTransform;
+        // Row 8 is completely useless
+        if (y2 == y3 && y3 == y4)
+            return nullTransform;
+        // Col 7 is completely useless
+        if (x2 == x4 && y2 == y4)
+            return nullTransform;
+        // Col 8 is completely useless
+        if (x3 == x4 && y3 == y4)
+            return nullTransform;
+        
+        Float c[8];
+        
+        // Rows 1, 2
+        c[2] = x1, c[5] = y1;
+        
+        // The logic below assumes x2 != x4, i.e. row7 can be used to eliminate
+        // the leftmost value in row 8 and afterwards the values in rows 3 & 4.
+        // If x2 == x4, we need to exchange rows 7 and 8.
+        
+        // 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);
+        }
+        
+        // 0, 0, 1, 0, 0, 0,         0,           0 | x1
+        // 0, 0, 0, 0, 0, 1,         0,           0 | y1
+        // w, 0, 0, 0, 0, 0,      -x2w,           0 | x2-x1
+        // 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
+        
+        // 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;
+        
+        // 0, 0, 1, 0, 0, 0,         0,          0 | x1
+        // 0, 0, 0, 0, 0, 1,         0,          0 | y1
+        // w, 0, 0, 0, 0, 0,      -x2w,          0 | x2-x1
+        // 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
+        
+        // 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;
+        
+        // 0, 0, 1, 0, 0, 0,        0,        0 | x1
+        // 0, 0, 0, 0, 0, 1,        0,        0 | y1
+        // w, 0, 0, 0, 0, 0,     -x2w,        0 | x2-x1
+        // 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
+        
+        // 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;
+        // Row4 = Row4 - factor74 * Row7
+        Float factor74 = -y2*width / remCell7;
+        Float remCell4 = width;
+        Float rightSide4 = (y2-y1) - rightSide7 * factor74;
+        c[3] = rightSide4 / remCell4;
+        // Row5 = Row5 - factor85 * Row7
+        Float factor85 = -x3*height / remCell8;
+        Float remCell5 = height;
+        Float rightSide5 = (x3-x1) - rightSide8 * factor85;
+        c[1] = rightSide5 / remCell5;
+        // Row6 = Row6 - factor86 * Row8
+        Float factor86 = -y3*height / remCell8;
+        Float remCell6 = height;
+        Float rightSide6 = (y3-y1) - rightSide8 * factor86;
+        c[4] = rightSide6 / remCell6;
+        
+        if (swapRows78)
+            std::swap(c[6], c[7]);
+        
+        // Let's hope I never have to debug/understand this again! :D
+        
+        Transform result = {{
+            c[0], c[3], 0, c[6],
+            c[1], c[4], 0, c[7],
+            0, 0, 1, 0,
+            c[2], c[5], 0, 1
+        }};
+        return result;
+    }
+    
+    void drawVertexArrays(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.
+        
+    #ifndef GOSU_IS_OPENGLES
+        glEnable(GL_BLEND);
+        glMatrixMode(GL_MODELVIEW);
+        
+        Transform transform =
+        findTransformForTarget(x1, y1, x2, y2, x3, y3, x4, y4);
+        
+        for (VertexArrays::const_iterator it = vertexArrays.begin(), end = vertexArrays.end(); it != end; ++it)
+        {
+            glPushMatrix();
+            it->renderState.apply();
+            glMultMatrixd(&transform[0]);
+            glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &it->vertices[0]);
+            glDrawArrays(GL_QUADS, 0, (GLsizei)it->vertices.size());
+            glPopMatrix();
+        }
+    #endif
+    }
+};
+
+Gosu::Macro::Macro(DrawOpQueue& queue, int width, int height)
+: pimpl(new Impl)
+{
+    pimpl->width = width;
+    pimpl->height = height;
+    queue.compileTo(pimpl->vertexArrays);
+}
+
+int Gosu::Macro::width() const
+{
+    return pimpl->width;
+}
+
+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
+{
+    if (c1 != Color::WHITE || c2 != Color::WHITE || c3 != Color::WHITE || c4 != Color::WHITE)
+        throw std::invalid_argument("Macros cannot be tinted with colors yet");
+    
+    std::tr1::function<void()> f = std::tr1::bind(&Impl::drawVertexArrays, pimpl, x1, y1, x2, y2, x3, y3, x4, y4);
+    Gosu::Graphics::scheduleGL(f, z);
+}
+
+const Gosu::GLTexInfo* Gosu::Macro::glTexInfo() const
+{
+    return 0;
+}
+
+Gosu::Bitmap Gosu::Macro::toBitmap() 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
+{
+    return GOSU_UNIQUE_PTR<ImageData>();
+}
+
+void Gosu::Macro::insert(const Bitmap& bitmap, int x, int y)
+{
+    throw std::logic_error("Gosu::Macro cannot be updated with a Gosu::Bitmap yet");
+}

data/src/Graphics/Macro.hpp

@@ -6,237 +6,31 @@
 #include <Gosu/TR1.hpp>
 #include <Gosu/Platform.hpp>
 #include "Common.hpp"
-#include "DrawOpQueue.hpp"
-#include <cmath>
-#include <algorithm>
-#include <memory>
-#include <stdexcept>
 
 class Gosu::Macro : public Gosu::ImageData
 {
-    typedef double Float;
-    
-    Graphics& graphics;
-    VertexArrays vertexArrays;
-    int w, h;
-    
-    Transform findTransformForTarget(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).
-        
-        // To draw a macro at an arbitrary position, we solve the following system:
-        
-        // 0, 0, 1, 0, 0, 0,    0,    0 | x1
-        // 0, 0, 0, 0, 0, 1,    0,    0 | y1
-        // w, 0, 1, 0, 0, 0, -x2w,    0 | x2
-        // 0, 0, 0, w, 0, 1, -y2w,    0 | y2
-        // 0, h, 1, 0, 0, 0,    0, -x3h | x3
-        // 0, 0, 0, 0, h, 1,    0, -y3h | y3
-        // w, h, 1, 0, 0, 0, -x4w, -x4h | x4
-        // 0, 0, 0, w, h, 1, -y4w, -y4h | y4
-        
-        // Equivalent:
-        
-        // 0, 0, 1, 0, 0, 0,        0,        0 | x1
-        // 0, 0, 0, 0, 0, 1,        0,        0 | y1
-        // w, 0, 0, 0, 0, 0,     -x2w,        0 | x2-x1
-        // 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, (x2-x4)w, (x3-x4)h | x1-x2-x3+x4
-        // 0, 0, 0, 0, 0, 0, (y2-y4)w, (y3-y4)h | y1-y2-y3+y4
-        
-        // Since this matrix is relatively sparse, we unroll all three solving paths.
-        
-        static const Transform nullTransform = {{ 0 }};
-        
-        // Row 7 is completely useless
-        if (x2 == x4 && x3 == x4)
-            return nullTransform;
-        // Row 8 is completely useless
-        if (y2 == y3 && y3 == y4)
-            return nullTransform;
-        // Col 7 is completely useless
-        if (x2 == x4 && y2 == y4)
-            return nullTransform;
-        // Col 8 is completely useless
-        if (x3 == x4 && y3 == y4)
-            return nullTransform;
-        
-        Float c[8];
-        
-        // Rows 1, 2
-        c[2] = x1, c[5] = y1;
-        
-        // The logic below assumes x2 != x4, i.e. row7 can be used to eliminate
-        // the leftmost value in row 8 and afterwards the values in rows 3 & 4.
-        // If x2 == x4, we need to exchange rows 7 and 8.
-        
-        // 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)*w, rightCell7 = (x3-x4)*h, origRightSide7 = (x1-x2-x3+x4);
-        Float leftCell8 = (y2-y4)*w, rightCell8 = (y3-y4)*h, origRightSide8 = (y1-y2-y3+y4);
-        
-        bool swapRows78 = x2 == x4;
-        if (swapRows78)
-        {
-            std::swap(leftCell7, leftCell8);
-            std::swap(rightCell7, rightCell8);
-            std::swap(origRightSide7, origRightSide8);
-        }
-        
-        // 0, 0, 1, 0, 0, 0,         0,           0 | x1
-        // 0, 0, 0, 0, 0, 1,         0,           0 | y1
-        // w, 0, 0, 0, 0, 0,      -x2w,           0 | x2-x1
-        // 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
-        
-        // 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;
-        
-        // 0, 0, 1, 0, 0, 0,         0,          0 | x1
-        // 0, 0, 0, 0, 0, 1,         0,          0 | y1
-        // w, 0, 0, 0, 0, 0,      -x2w,          0 | x2-x1
-        // 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
-        
-        // 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;
-        
-        // 0, 0, 1, 0, 0, 0,        0,        0 | x1
-        // 0, 0, 0, 0, 0, 1,        0,        0 | y1
-        // w, 0, 0, 0, 0, 0,     -x2w,        0 | x2-x1
-        // 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
-        
-        // Use the new rows 7 and 8 to calculate c0, c1, c3 & c4.
-        // Row3 = Row3 - factor73 * Row7
-        Float factor73 = -x2*w / remCell7;
-        Float remCell3 = w;
-        Float rightSide3 = (x2-x1) - rightSide7 * factor73;
-        c[0] = rightSide3 / remCell3;
-        // Row4 = Row4 - factor74 * Row7
-        Float factor74 = -y2*w / remCell7;
-        Float remCell4 = w;
-        Float rightSide4 = (y2-y1) - rightSide7 * factor74;
-        c[3] = rightSide4 / remCell4;
-        // Row5 = Row5 - factor85 * Row7
-        Float factor85 = -x3*h / remCell8;
-        Float remCell5 = h;
-        Float rightSide5 = (x3-x1) - rightSide8 * factor85;
-        c[1] = rightSide5 / remCell5;
-        // Row6 = Row6 - factor86 * Row8
-        Float factor86 = -y3*h / remCell8;
-        Float remCell6 = h;
-        Float rightSide6 = (y3-y1) - rightSide8 * factor86;
-        c[4] = rightSide6 / remCell6;
-        
-        if (swapRows78)
-            std::swap(c[6], c[7]);
-        
-        // Let's hope I never have to debug/understand this again! :D
-        
-        Transform result = {{
-            c[0], c[3], 0, c[6],
-            c[1], c[4], 0, c[7],
-            0, 0, 1, 0,
-            c[2], c[5], 0, 1
-        }};
-        return result;
-    }
-    
-    void drawVertexArrays(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 had to be performed here once.
-        
-        #ifndef GOSU_IS_OPENGLES
-        glEnable(GL_BLEND);
-        glMatrixMode(GL_MODELVIEW);
-        
-        Transform transform =
-            findTransformForTarget(x1, y1, x2, y2, x3, y3, x4, y4);
-        
-        for (VertexArrays::const_iterator it = vertexArrays.begin(), end = vertexArrays.end(); it != end; ++it)
-        {
-            glPushMatrix();
-            it->renderState.apply();
-            glMultMatrixd(&transform[0]);
-            glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &it->vertices[0]);
-            glDrawArrays(GL_QUADS, 0, (GLsizei)it->vertices.size());
-            glPopMatrix();
-        }
-        #endif
-    }
+    struct Impl;
+    std::tr1::shared_ptr<Impl> pimpl;
     
 public:
-    Macro(Graphics& graphics, DrawOpQueue& queue, int width, int height)
-    : graphics(graphics), w(width), h(height)
-    {
-        queue.compileTo(vertexArrays);
-    }
-    
-    int width() const
-    {
-        return w;
-    }
+    Macro(DrawOpQueue& queue, int width, int height);
     
-    int height() const
-    {
-        return h;
-    }
+    int width() const;
+    int height() const;
     
     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
-    {
-        if (c1 != Color::WHITE || c2 != Color::WHITE || c3 != Color::WHITE || c4 != Color::WHITE)
-            throw std::invalid_argument("Macros cannot be tinted with colors yet");
-        std::tr1::function<void()> f = std::tr1::bind(&Macro::drawVertexArrays, this, x1, y1, x2, y2, x3, y3, x4, y4);
-        graphics.scheduleGL(f, z);
-    }
+        ZPos z, AlphaMode mode) const;
     
-    const Gosu::GLTexInfo* glTexInfo() const
-    {
-        return 0;
-    }
+    const Gosu::GLTexInfo* glTexInfo() const;
     
-    Gosu::Bitmap toBitmap() const
-    {
-        throw std::logic_error("Gosu::Macro cannot be rendered as Gosu::Bitmap yet");
-    }
+    Gosu::Bitmap toBitmap() const;
     
-    GOSU_UNIQUE_PTR<ImageData> subimage(int x, int y, int width, int height) const
-    {
-        return GOSU_UNIQUE_PTR<ImageData>();
-    }
+    GOSU_UNIQUE_PTR<ImageData> subimage(int x, int y, int width, int height) const;
     
-    void insert(const Bitmap& bitmap, int x, int y)
-    {
-        throw std::logic_error("Gosu::Macro cannot be updated with a Gosu::Bitmap yet");
-    }
+    void insert(const Bitmap& bitmap, int x, int y);
 };
 
 #endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gosu
 version: !ruby/object:Gem::Version
-  version: 0.9.2.pre1
+  version: 0.9.2
 platform: ruby
 authors:
 - Julian Raschke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-23 00:00:00.000000000 Z
+date: 2015-05-24 00:00:00.000000000 Z
 dependencies: []
 description: |2
       2D game development library.
@@ -75,6 +75,7 @@ files:
 - src/Graphics/Graphics.cpp
 - src/Graphics/Image.cpp
 - src/Graphics/LargeImageData.cpp
+- src/Graphics/Macro.cpp
 - src/Graphics/Resolution.cpp
 - src/Graphics/TexChunk.cpp
 - src/Graphics/Texture.cpp
@@ -162,9 +163,9 @@ 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.0.14