gosu 0.7.41 → 0.7.43

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (C) 2004-2011 Julian Raschke, Jan Lücker and all contributors.
+Copyright (C) 2004-2012 Julian Raschke, Jan Lücker and all contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),

data/Gosu/ButtonsX.hpp

@@ -67,8 +67,8 @@ namespace Gosu
         kbRightControl = XK_Control_R,
         kbLeftAlt = XK_Alt_L,
         kbRightAlt = XK_Alt_R,
-        kbLeftMeta = 0, // TODO?!
-        kbRightMeta = 0,
+        kbLeftMeta = XK_Meta_L,
+        kbRightMeta = XK_Meta_R,
         kbBackspace = XK_BackSpace,
         kbLeft = XK_Left,
         kbRight = XK_Right,

data/Gosu/Version.hpp

@@ -3,8 +3,8 @@
 
 #define GOSU_MAJOR_VERSION 0
 #define GOSU_MINOR_VERSION 7
-#define GOSU_POINT_VERSION 41
-#define GOSU_VERSION "0.7.41"
+#define GOSU_POINT_VERSION 43
+#define GOSU_VERSION "0.7.43"
 
 #define GOSU_COPYRIGHT_NOTICE \
   " " \

data/GosuImpl/Graphics/Macro.hpp

@@ -13,11 +13,157 @@
 
 class Gosu::Macro : public Gosu::ImageData
 {
+    typedef double Float;
+    
     Graphics& graphics;
     VertexArrays vertexArrays;
-    int givenWidth, givenHeight;
+    int w, h;
     
-    void realDraw(double x1, double y1, double x2, double y3) const
+    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 remainding 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 because they have different transforms! This is insane.
         // They should be premultiplied and have the same transform by definition. Then, the transformation
@@ -27,14 +173,14 @@ class Gosu::Macro : public Gosu::ImageData
         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();
-            
-            glTranslated(x1, y1, 0);
-            glScaled((x2 - x1) / width(), (y3 - y1) / height(), 1);
-            
+            glMultMatrixd(&transform[0]);
             glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &it->vertices[0]);
             glDrawArrays(GL_QUADS, 0, it->vertices.size());
             glPopMatrix();
@@ -44,19 +190,19 @@ class Gosu::Macro : public Gosu::ImageData
     
 public:
     Macro(Graphics& graphics, DrawOpQueue& queue, int width, int height)
-    : graphics(graphics), givenWidth(width), givenHeight(height)
+    : graphics(graphics), w(width), h(height)
     {
         queue.compileTo(vertexArrays);
     }
     
     int width() const
     {
-        return givenWidth;
+        return w;
     }
     
     int height() const
     {
-        return givenHeight;
+        return h;
     }
     
     void draw(double x1, double y1, Color c1,
@@ -65,11 +211,9 @@ public:
         double x4, double y4, Color c4,
         ZPos z, AlphaMode mode) const
     {
-        if (x1 != x3 || x2 != x4 || y1 != y2 || y3 != y4)
-            throw std::invalid_argument("Macros cannot be rotated yet");
         if (c1 != 0xffffffff || c2 != 0xffffffff || c3 != 0xffffffff || c4 != 0xffffffff)
             throw std::invalid_argument("Macros cannot be tinted with colors yet");
-        std::tr1::function<void()> f = std::tr1::bind(&Macro::realDraw, this, x1, y1, x2, y3);
+        std::tr1::function<void()> f = std::tr1::bind(&Macro::drawVertexArrays, this, x1, y1, x2, y2, x3, y3, x4, y4);
         graphics.scheduleGL(f, z);
     }
     

data/GosuImpl/Graphics/TextUnix.cpp

@@ -180,7 +180,9 @@ namespace Gosu
         public:
             SDLSurface(TTF_Font* font, const std::wstring& text, Gosu::Color c)
             {
-                SDL_Color color = { c.red(), c.green(), c.blue() };
+                // This is intentionally re-ordered to BGR. This way, the surface pixels do not
+                // have to be converted from RGB to BGR later in the process.
+                SDL_Color color = { c.blue(), c.green(), c.red() };
                 surface = TTF_RenderUTF8_Blended(font, Gosu::wstringToUTF8(text).c_str(), color);
                 if (!surface)
                     throw std::runtime_error("Could not render text " + Gosu::wstringToUTF8(text));

data/GosuImpl/RubyGosu.swg

@@ -657,8 +657,7 @@ namespace Gosu {
 %markfunc Gosu::Window "markWindow";
 %include "../Gosu/Window.hpp"
 
-// TODO: Why is this even necessary, does the GC not trace into my Window privates?
-// If necessary, can I fake this using an @ivar?
+// TODO: Can I fake this using an @ivar?
 %header %{
     static void markWindow(void* window) {
         #ifndef __MACRUBY__
@@ -739,12 +738,12 @@ namespace Gosu {
         return $self->graphics().fullscreen();
     }
     
-    void gl() {
+    void unsafe_gl() {
         $self->graphics().beginGL();
         rb_yield(Qnil);
         $self->graphics().endGL();
     }
-    void gl(Gosu::ZPos z) {
+    void unsafe_gl(Gosu::ZPos z) {
         $self->graphics().scheduleGL(std::tr1::bind(callRubyBlock, rb_block_proc()), z);
     }
     void clipTo(double x, double y, double width, double height) {

data/GosuImpl/RubyGosu_SWIG_RENAME_PATCH.patch

@@ -13,7 +13,7 @@
    VALUE result;
    
 -  result = rb_funcall(swig_get_self(), rb_intern("draw"), 0, NULL);
-+  result = rb_funcall(swig_get_self(), rb_intern("protected_draw"), 0, NULL);
++  result = rb_funcall(swig_get_self(), rb_intern("protected_draw_2"), 0, NULL);
  }
  
  

data/GosuImpl/RubyGosu_wrap.cxx

@@ -2795,12 +2795,12 @@ SWIGINTERN int Gosu_Window_height(Gosu::Window const *self){
 SWIGINTERN bool Gosu_Window_fullscreen(Gosu::Window const *self){
         return self->graphics().fullscreen();
     }
-SWIGINTERN void Gosu_Window_gl__SWIG_0(Gosu::Window *self){
+SWIGINTERN void Gosu_Window_unsafe_gl__SWIG_0(Gosu::Window *self){
         self->graphics().beginGL();
         rb_yield(Qnil);
         self->graphics().endGL();
     }
-SWIGINTERN void Gosu_Window_gl__SWIG_1(Gosu::Window *self,Gosu::ZPos z){
+SWIGINTERN void Gosu_Window_unsafe_gl__SWIG_1(Gosu::Window *self,Gosu::ZPos z){
         self->graphics().scheduleGL(std::tr1::bind(callRubyBlock, rb_block_proc()), z);
     }
 SWIGINTERN void Gosu_Window_clipTo(Gosu::Window *self,double x,double y,double width,double height){
@@ -2913,7 +2913,7 @@ void SwigDirector_Window::update() {
 void SwigDirector_Window::draw() {
   VALUE result;
   
-  result = rb_funcall(swig_get_self(), rb_intern("protected_draw"), 0, NULL);
+  result = rb_funcall(swig_get_self(), rb_intern("protected_draw_2"), 0, NULL);
 }
 
 
@@ -10176,7 +10176,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_gl__SWIG_0(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_unsafe_gl__SWIG_0(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -10186,12 +10186,12 @@ _wrap_Window_gl__SWIG_0(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","gl", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","unsafe_gl", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      Gosu_Window_gl__SWIG_0(arg1);
+      Gosu_Window_unsafe_gl__SWIG_0(arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10203,7 +10203,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_gl__SWIG_1(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_unsafe_gl__SWIG_1(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   Gosu::ZPos arg2 ;
   void *argp1 = 0 ;
@@ -10216,17 +10216,17 @@ _wrap_Window_gl__SWIG_1(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","gl", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","unsafe_gl", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::ZPos","gl", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::ZPos","unsafe_gl", 2, argv[0] ));
   } 
   arg2 = static_cast< Gosu::ZPos >(val2);
   {
     try {
-      Gosu_Window_gl__SWIG_1(arg1,arg2);
+      Gosu_Window_unsafe_gl__SWIG_1(arg1,arg2);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10237,7 +10237,7 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_Window_gl(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_Window_unsafe_gl(int nargs, VALUE *args, VALUE self) {
   int argc;
   VALUE argv[3];
   int ii;
@@ -10254,7 +10254,7 @@ SWIGINTERN VALUE _wrap_Window_gl(int nargs, VALUE *args, VALUE self) {
     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      return _wrap_Window_gl__SWIG_0(nargs, args, self);
+      return _wrap_Window_unsafe_gl__SWIG_0(nargs, args, self);
     }
   }
   if (argc == 2) {
@@ -10268,15 +10268,15 @@ SWIGINTERN VALUE _wrap_Window_gl(int nargs, VALUE *args, VALUE self) {
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        return _wrap_Window_gl__SWIG_1(nargs, args, self);
+        return _wrap_Window_unsafe_gl__SWIG_1(nargs, args, self);
       }
     }
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 3, "gl", 
-    "    void gl()\n"
-    "    void gl(Gosu::ZPos z)\n");
+  Ruby_Format_OverloadedError( argc, 3, "unsafe_gl", 
+    "    void unsafe_gl()\n"
+    "    void unsafe_gl(Gosu::ZPos z)\n");
   
   return Qnil;
 }
@@ -11228,8 +11228,8 @@ SWIGEXPORT void Init_gosu(void) {
   SWIG_RubyInitializeTrackings();
   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 >(7)));
-  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(41)));
-  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.41"));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(43)));
+  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.43"));
   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);
@@ -11579,7 +11579,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassWindow.klass, "width", VALUEFUNC(_wrap_Window_width), -1);
   rb_define_method(SwigClassWindow.klass, "height", VALUEFUNC(_wrap_Window_height), -1);
   rb_define_method(SwigClassWindow.klass, "fullscreen?", VALUEFUNC(_wrap_Window_fullscreenq___), -1);
-  rb_define_method(SwigClassWindow.klass, "gl", VALUEFUNC(_wrap_Window_gl), -1);
+  rb_define_method(SwigClassWindow.klass, "unsafe_gl", VALUEFUNC(_wrap_Window_unsafe_gl), -1);
   rb_define_method(SwigClassWindow.klass, "clip_to", VALUEFUNC(_wrap_Window_clip_to), -1);
   rb_define_method(SwigClassWindow.klass, "record", VALUEFUNC(_wrap_Window_record), -1);
   rb_define_method(SwigClassWindow.klass, "transform", VALUEFUNC(_wrap_Window_transform), -1);

data/GosuImpl/WindowWin.cpp

@@ -468,6 +468,9 @@ LRESULT Gosu::Window::handleMessage(UINT message, WPARAM wparam, LPARAM lparam)
 
     if (message == WM_PAINT)
     {
+        PAINTSTRUCT ps;
+        pimpl->hdc = BeginPaint(handle(), &ps);
+        
         if (pimpl->graphics.get() && graphics().begin())
         {
             try
@@ -481,11 +484,12 @@ LRESULT Gosu::Window::handleMessage(UINT message, WPARAM wparam, LPARAM lparam)
             }
             graphics().end();
         }
+        
         SwapBuffers(pimpl->hdc);
-        ValidateRect(handle(), 0);
+        EndPaint(handle(), &ps);
         return 0;
     }
-
+    
     if (message == WM_SYSCOMMAND)
     {
         switch(wparam)

data/examples/GosuZen.rb

@@ -0,0 +1,68 @@
+# Gosu Zen example based on erisdiscord's comment here:
+# https://github.com/jlnr/gosu/pull/120
+
+# Gosu Zen is the (inline) Sinatra of Ruby multimedia programming.
+# The interface is still in flux. If you want to tune the interface
+# a little further or provide more examples, please fork Gosu and
+# send a pull request. Thanks!
+
+require 'rubygems'
+require 'gosu/zen'
+include Gosu::Zen
+
+window 480, 240, :fullscreen => false
+
+button_down Gosu::KbEscape do
+  close
+end
+
+update do
+  t = Gosu.milliseconds / 1000.0
+
+  @radius = [width, height].min * 0.37
+  @angle = t * Math::PI
+
+  a, b =\
+    (Math.cos(t) + 0.5) * 0xff,
+    (Math.sin(t) + 0.5) * 0xff
+
+  c = (a + b) / 2
+
+  @colors = [
+    Gosu::Color.rgb(a, b, 0xff),
+    Gosu::Color.rgb(a, 0x00, b),
+    Gosu::Color.rgb(0xff, b, a),
+    Gosu::Color.rgb(b, a, 0x00),
+    Gosu::Color.rgb(b, 0xff, a),
+    Gosu::Color.rgb(0x00, a, b) ]
+
+  @background = Gosu::Color.rgb(c, c, c)
+end
+
+draw do
+  draw_quad\
+    0,     0,      @background,
+    0,     height, @background,
+    width, height, @background,
+    width, 0,      @background, 0
+
+  translate width / 2, height / 2 do
+    @colors.each.with_index do |color, i|
+
+      angle = @angle + i.to_f / @colors.length * 2.0 * Math::PI
+      x = @radius * Math.sin(angle)
+      y = @radius * Math.cos(angle)
+      w, h = x, y
+
+      translate x, y do
+        rotate Gosu.radians_to_degrees(angle) do
+          draw_quad\
+            -w, +h, color,
+            -w, -h, color,
+            +w, -h, color,
+            +w, +h, color, 0
+        end
+      end
+    end
+  end
+end

data/lib/gosu/preview.rb

@@ -85,37 +85,55 @@ module Gosu
     end
   end
   
+  def self.button_down? id
+    $window.button_down? id
+  end
+  
+  def self.mouse_x
+    $window.mouse_x
+  end
+  
+  def self.mouse_y
+    $window.mouse_y
+  end
+  
+  def self.draw_line *args
+    $window.draw_line *args
+  end
+  
+  def self.draw_triangle *args
+    $window.draw_triangle *args
+  end
+  
   def self.draw_quad *args
     $window.draw_quad *args
   end
   
-  def self.clip_to *args
-    $window.clip_to *args do
-      yield
-    end
+  def self.clip_to *args, &draw
+    $window.clip_to *args, &draw
   end
   
-  def self.translate *args
-    $window.translate *args do
-      yield
-    end
+  def self.translate *args, &draw
+    $window.translate *args, &draw
   end
   
-  def self.scale *args
-    $window.scale *args do
-      yield
-    end
+  def self.scale *args, &draw
+    $window.scale *args, &draw
   end
   
-  def self.rotate *args
-    $window.rotate *args do
-      yield
-    end
+  def self.rotate *args, &draw
+    $window.rotate *args, &draw
   end
   
-  def self.transform *args
-    $window.transform *args do
-      yield
-    end
+  def self.transform *args, &draw
+    $window.transform *args, &draw
+  end
+  
+  def self.record width, height, &draw
+    $window.record width, height, &draw
+  end
+  
+  def self.gl *args, &draw
+    $window.gl *args, &draw
   end
 end

data/lib/gosu/swig_patches.rb

@@ -10,8 +10,8 @@ class Gosu::Window
      lose_focus button_down button_up).each do |callback|
     define_method "protected_#{callback}" do |*args|
       begin
-        # Turn into a boolean result for needs_cursor? etc while we are at it.
         # If there has been an exception, don't do anything as to not make matters worse.
+        # Conveniently turn the return value into a boolean result (for needs_cursor? etc).
         defined?(@_exception) ? false : !!send(callback, *args)
       rescue Exception => e
         # Exit the message loop naturally, then re-throw
@@ -21,6 +21,17 @@ class Gosu::Window
     end
   end
   
+  def protected_draw_2
+    protected_draw
+    $gosu_gl_blocks = nil
+  end
+  
+  def gl(*args, &block)
+    $gosu_blocks ||= []
+    $gosu_blocks << block
+    unsafe_gl(*args, &block)
+  end
+  
   alias show_internal show
   def show
     show_internal

data/lib/gosu/zen.rb

@@ -1,28 +1,77 @@
-require 'gosu'
-require 'singleton'
+require 'gosu/preview'
 
 module Gosu
+  module Zen
+    
+    @@window_args = [800, 600, {}]
+    @@options = {}
+    
+    def window width, height, options = nil
+      if $window.nil?
+        @@window_args[0] = width
+        @@window_args[1] = height
+        @@window_args[2].merge! options if options
+      else
+        raise "window size can only be set before the window is created"
+      end
+    end
+    
+    def set what, value
+      if $window.nil?
+        @@options[what.to_sym] = value
+      else
+        $window.send "#{what}=", value
+      end
+    end
+    
+    def button_down id = nil, &body
+      m = id ? "button_down_#{id}" : :button_down_other
+      ZenWindow.send :define_method, m, &body
+    end
+    
+    def button_up id = nil, &body
+      m = id ? "button_up_#{id}" : :button_up_other
+      ZenWindow.send :define_method, m, &body
+    end
+    
+    def update &body
+      ZenWindow.send :define_method, :update, &body
+    end
+    
+    def draw &body
+      ZenWindow.send :define_method, :draw, &body
+    end
+    
+    def run!
+      window = ZenWindow.new *@@window_args
+      @@options.each do |opt, value|
+        window.send "#{opt}=", value
+      end
+      window.show
+    end
+    
+    def Zen.included mod
+      at_exit { run! unless $! }
+    end
+    
+  end
+  
   class ZenWindow < Window
-    include Singleton
+    def button_down id
+      m = :"button_down_#{id}"
+      respond_to?(m) ? send(m) : button_down_other(id)
+    end
+    
+    def button_up id
+      m = :"button_up_#{id}"
+      respond_to?(m) ? send(m) : button_up_other(id)
+    end
+    
+    def button_down_other id
+    end
     
-    def initialize
-      super 800, 600, false
+    def button_up_other id
     end
+    
   end
 end
-
-def set what, value
-  Gosu::ZenWindow.instance.send "#{what}=", value
-end
-
-def update(&proc)
-  Gosu::ZenWindow.send :define_method, :update, proc
-end
-
-# WIP - needs all other callbacks, even with arguments
-
-# WIP - needs to be compatible with gosu/preview.rb later
-
-at_exit do
-  Gosu::ZenWindow.instance.show
-end

data/linux/extconf.rb

@@ -59,6 +59,7 @@ LINUX_FILES = %w(
 )
 
 require 'mkmf'
+require 'fileutils'
 
 $INCFLAGS << " -I../ -I../GosuImpl"
 
@@ -66,41 +67,43 @@ if `uname`.chomp == 'Darwin' then
   SOURCE_FILES = BASE_FILES + MAC_FILES
   
   # Apple curiously distributes libpng only inside X11
-  $INCFLAGS << " -I/usr/X11/include"
+  $INCFLAGS  << " -I/usr/X11/include"
   # To make everything work with the Objective C runtime
-  $CFLAGS   << " -x objective-c++ -fobjc-gc -DNDEBUG"
-  $LDFLAGS  << " -L/usr/X11/lib -logg -lvorbis -lvorbisfile -liconv"
+  $CFLAGS    << " -x objective-c++ -fobjc-gc -DNDEBUG"
+  $LDFLAGS   << " -L/usr/X11/lib -logg -lvorbis -lvorbisfile -liconv"
   %w(AudioToolbox IOKit OpenAL OpenGL AppKit ApplicationServices Foundation Carbon).each do |f|
-    #$INCFLAGS << " -framework #{f}" <- not necessary? I only get lots of warnings
-    $LDFLAGS  << " -framework #{f}"
+    $LDFLAGS << " -framework #{f}"
   end
-
+  
   # Symlink our pretty gosu.so into ../lib
   # FIXME gosu.rb should just look in the right place.
-  `ln -s ../linux/gosu.bundle ../lib/gosu.bundle`
+  FileUtils.ln_s("../linux/gosu.bundle", "../lib/gosu.bundle")
 else
   SOURCE_FILES = BASE_FILES + LINUX_FILES
 
   # Symlink our pretty gosu.so into ../lib
   # FIXME gosu.rb should just look in the right place.
-  `ln -s ../linux/gosu.so ../lib/gosu.so`
-
-  sdl_config = with_config("sdl-config", "sdl-config")
-  pango_config = "pkg-config pangoft2"
+  FileUtils.ln_s("../linux/gosu.so", "../lib/gosu.so")
 
-  $INCFLAGS << " `#{sdl_config} --cflags` `#{pango_config} --cflags`"
-  $LDFLAGS  << " `#{sdl_config} --libs`   `#{pango_config} --libs` -lX11"
-  have_header('SDL_ttf.h') if have_library('SDL_ttf', 'TTF_RenderUTF8_Blended')
-  have_header('gl.h') if have_library('GL', 'glMatrixMode')
+  pkg_config("sdl")
+  pkg_config("pangoft2")
+  pkg_config("x11")
+  
+  pkg_config("gl")
+  pkg_config("vorbisfile")
+  pkg_config("openal")
+  pkg_config("sndfile")
+  pkg_config("xinerama")
+  
+  have_header('SDL_ttf.h')   if have_library('SDL_ttf', 'TTF_RenderUTF8_Blended')
   have_header('FreeImage.h') if have_library('freeimage', 'FreeImage_ConvertFromRawBits')
-  have_header('vorbisfile.h') if have_library('vorbisfile', 'ov_open_callbacks')
-  have_header('AL/al.h') if have_library('openal')
-  have_header('sndfile.h') if have_library('sndfile')
-  have_header('X11/extensions/Xinerama.h') if have_library('Xinerama', 'XineramaQueryScreens')
+  have_header('AL/al.h')     if have_library('openal')
 end
 
 # Copy all relevant C++ files into the current directory
 # FIXME Could be done by gem task instead.
-SOURCE_FILES.each { |file| `cp ../GosuImpl/#{file} #{File.basename(file).sub(/\.mm$/, '.cpp')}` }
+SOURCE_FILES.each do |file|
+  FileUtils.cp("../GosuImpl/#{file}", File.basename(file).sub(/\.mm$/, '.cpp'))
+end
 
 create_makefile("gosu")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gosu
 version: !ruby/object:Gem::Version 
-  hash: 81
+  hash: 85
   prerelease: 
   segments: 
   - 0
   - 7
-  - 41
-  version: 0.7.41
+  - 43
+  version: 0.7.43
 platform: ruby
 authors: 
 - Julian Raschke
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-17 00:00:00 Z
+date: 2012-03-18 00:00:00 Z
 dependencies: []
 
 description: "  2D game development library.\n\n  Gosu features easy to use and game-friendly interfaces to 2D graphics\n  and text (accelerated by 3D hardware), sound samples and music as well as\n  keyboard, mouse and gamepad/joystick input.\n\n  Also includes demos for integration with RMagick, Chipmunk and OpenGL.\n"
@@ -68,6 +68,7 @@ files:
 - lib/gosu.rb
 - examples/ChipmunkIntegration.rb
 - examples/CptnRuby.rb
+- examples/GosuZen.rb
 - examples/MoreChipmunkAndRMagick.rb
 - examples/OpenGLIntegration.rb
 - examples/RMagickIntegration.rb
@@ -219,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - See https://github.com/jlnr/gosu/wiki/Getting-Started-on-Linux
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.16
 signing_key: 
 specification_version: 3
 summary: 2D game development library.