ray 0.0.0.pre1

data/ext/ray.h

@@ -0,0 +1,82 @@
+#include "ruby.h"
+
+#if defined(HAVE_SDL_H) || defined(RAY_USE_FRAMEWORK)
+# include <SDL.h>
+#else
+# include <SDL/SDL.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+}
+#endif
+#endif
+
+/* Classes and modules */
+extern VALUE ray_mRay;
+
+extern VALUE ray_cImage;
+extern VALUE ray_cColor;
+extern VALUE ray_cRect;
+
+/* Macros for Ruby's C API */
+
+#define RAY_IS_A(obj, klass) (RTEST(rb_obj_is_kind_of(obj, klass)))
+
+#define RAY_OBJ_CLASSNAME(obj) (rb_class2name(rb_class_of(obj)))
+
+#define RAY_SYM(string) (ID2SYM(rb_intern(string)))
+#define RAY_METH(string) (rb_intern(string))
+
+/* Data types */
+
+typedef struct {
+   VALUE self;
+   SDL_Surface *surface;
+
+   int mustFree; /* Should we call SDL_FreeSurface? */
+} ray_image;
+
+typedef struct {
+   uint8_t r, g, b, a;
+} ray_color;
+
+typedef SDL_Rect ray_rect;
+
+/* Convertion functions */
+
+/** Converts a surface into a ruby object */
+VALUE ray_create_image(SDL_Surface *surface);
+
+/** Converts a color into a ruby object */
+VALUE ray_col2rb(ray_color color);
+
+/** Converts a rect into a ruby object */
+VALUE ray_rect2rb(ray_rect rect);
+
+/** Converts a ruby object into a color */
+ray_color ray_rb2col(VALUE object);
+
+/** Converts a ruby object into an image*/
+ray_image *ray_rb2image(VALUE object);
+
+/** Converts a ruby object into a color */
+SDL_Surface *ray_rb2surface(VALUE object);
+
+/** Converts a ruby object into a rect */
+ray_rect ray_rb2rect(VALUE object);
+
+/* Initilizers */
+
+void Init_ray_ext();
+void Init_ray_image();
+void Init_ray_color();
+void Init_ray_rect();
+
+#ifdef __cplusplus
+#if 0
+{
+#endif
+}
+#endif

data/ext/rect.c

@@ -0,0 +1,204 @@
+#include "ray.h"
+
+VALUE ray_cRect = Qnil;
+
+void ray_free_rect(ray_rect *ptr) {
+   free(ptr);
+}
+
+VALUE ray_rect2rb(ray_rect rect) {
+   ray_rect *ptr = malloc(sizeof(ray_rect));
+   memcpy(ptr, &rect, sizeof(ray_rect));
+
+   VALUE obj = Data_Wrap_Struct(ray_cRect, NULL, ray_free_rect, ptr);
+   return obj;
+}
+
+ray_rect ray_rb2rect(VALUE obj) {
+   if (!RAY_IS_A(obj, ray_cRect)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Rect",
+               RAY_OBJ_CLASSNAME(obj));
+   }
+
+   ray_rect *rect;
+   Data_Get_Struct(obj, ray_rect, rect);
+
+   return *rect;
+}
+
+VALUE ray_alloc_rect(VALUE self) {
+   ray_rect *rect = malloc(sizeof(ray_rect));
+   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_rect, rect);
+
+   return ret;
+}
+
+/*
+  @overload initialize(x, y)
+    Creates a new rect with size set to 0, 0.
+
+  @overload initialize(x, y, w, h)
+    Creates a new rect with the specified size.
+
+  @overload initialize(hash)
+    Creates a new rect according to the keys specified in hash.
+
+    @option hash [Integer] :x
+    @option hash [Integer] :y
+    @option hash [Integer, optional] :width
+    @option hash [Integer, optional] :height required if width is set
+*/
+VALUE ray_init_rect(int argc, VALUE *argv, VALUE self) {
+   VALUE x_or_hash, y, w, h;
+   rb_scan_args(argc, argv, "13", &x_or_hash, &y, &w, &h);
+
+   int type = TYPE(x_or_hash);
+   if (type == T_HASH) {
+      if (!NIL_P(y)) {
+         rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
+                  argc);
+      }
+
+      VALUE hash = x_or_hash;
+
+      x_or_hash = rb_hash_aref(hash, RAY_SYM("x"));
+      y = rb_hash_aref(hash, RAY_SYM("y"));
+
+      w = rb_hash_aref(hash, RAY_SYM("width"));
+      h = rb_hash_aref(hash, RAY_SYM("height"));
+
+      if (NIL_P(w)) w = rb_hash_aref(hash, RAY_SYM("w"));
+      if (NIL_P(h)) h = rb_hash_aref(hash, RAY_SYM("h"));
+
+      if (NIL_P(y)) {
+         rb_raise(rb_eArgError, "Missing argument 'y'");
+      }
+
+      if (!NIL_P(w) && NIL_P(h)) {
+         rb_raise(rb_eArgError, "missing argument 'height'");
+      }
+   }
+   else {
+      if (NIL_P(y)) {
+         rb_raise(rb_eArgError, "wrong number of arguments (1 for 2)");
+      }
+
+      if (!NIL_P(w) && NIL_P(h)) {
+         rb_raise(rb_eArgError, "wrong number of arguments (3 for 4)");
+      }
+   }
+
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   rect->x = NUM2INT(x_or_hash);
+   rect->y = NUM2INT(y);
+
+   if (!NIL_P(w)) {
+      rect->w = NUM2INT(w);
+      rect->h = NUM2INT(h);
+   }
+   else {
+      rect->w = 0;
+      rect->h = 0;
+   }
+
+   return Qnil;
+}
+
+/* @return [Integer] position of the rect */
+VALUE ray_rect_x(VALUE self) {
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   return INT2FIX(rect->x);
+}
+
+/* @return [Integer] position of the rect */
+VALUE ray_rect_y(VALUE self) {
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   return INT2FIX(rect->y);
+}
+
+/* @return [Integer] size of the rect */
+VALUE ray_rect_w(VALUE self) {
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   return INT2FIX(rect->w);
+}
+
+/* @return [Integer] size of the rect */
+VALUE ray_rect_h(VALUE self) {
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   return INT2FIX(rect->h);
+}
+
+/* Sets the position of the rect */
+VALUE ray_rect_set_x(VALUE self, VALUE val) {
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   rect->x = NUM2INT(val);
+
+   return val;
+}
+
+/* Sets the position of the rect */
+VALUE ray_rect_set_y(VALUE self, VALUE val) {
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   rect->y = NUM2INT(val);
+
+   return val;
+}
+
+/* Sets the size of the rect */
+VALUE ray_rect_set_w(VALUE self, VALUE val) {
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   rect->w = NUM2INT(val);
+
+   return val;
+}
+
+/* Sets the size of the rect */
+VALUE ray_rect_set_h(VALUE self, VALUE val) {
+   ray_rect *rect;
+   Data_Get_Struct(self, ray_rect, rect);
+
+   rect->h = NUM2INT(val);
+
+   return val;
+}
+
+/*
+  Document-class: Ray::Rect
+
+  Rects are used to represent a part of a surface, using
+  two attributes to represent its position, and two
+  others to represent its size.
+*/
+
+void Init_ray_rect() {
+   ray_cRect = rb_define_class_under(ray_mRay, "Rect", rb_cObject);
+
+   rb_define_alloc_func(ray_cRect, ray_alloc_rect);
+   rb_define_method(ray_cRect, "initialize", ray_init_rect, -1);
+
+   rb_define_method(ray_cRect, "x", ray_rect_x, 0);
+   rb_define_method(ray_cRect, "y", ray_rect_y, 0);
+   rb_define_method(ray_cRect, "width", ray_rect_w, 0);
+   rb_define_method(ray_cRect, "height", ray_rect_h, 0);
+
+   rb_define_method(ray_cRect, "x=", ray_rect_set_x, 1);
+   rb_define_method(ray_cRect, "y=", ray_rect_set_y, 1);
+   rb_define_method(ray_cRect, "width=", ray_rect_set_w, 1);
+   rb_define_method(ray_cRect, "height=", ray_rect_set_h, 1);
+}

data/ext/test.rb

@@ -0,0 +1,21 @@
+Ray.init
+
+width  = 255
+height = 1
+
+win = Ray.create_window(:width => width, :height => 255 * height)
+win.fill Ray::Color.new(0, 0, 255)
+win.flip
+
+(0...256).each do |i|
+  img = Ray::Image.new(:w => width, :h => height)
+  img.fill Ray::Color.new(i, i, i)
+
+  img.blit(:from => [0, 0], :to => win, :at => [0, i * height])
+end
+
+win.flip
+
+sleep 3
+
+Ray.stop

data/lib/ray.rb

@@ -0,0 +1 @@
+require 'ray/ray'

data/lib/ray/color.rb

@@ -0,0 +1,30 @@
+module Ray
+  class Color
+    class << self
+      def red;     new(255, 0, 0);     end
+      def green;   new(0, 255, 0);     end
+      def blue;    new(0, 0, 255);     end
+      def black;   new(0, 0,0);        end
+      def white;   new(255, 255, 255); end
+      def none;    new(0, 0, 0, 0);    end
+      def gray;    new(128, 128, 128); end
+      def cyan;    new(0, 255, 255);   end
+      def yellow;  new(255, 255, 0);   end
+      def fuschia; new(255, 0, 255);   end
+    end
+
+    def inspect
+      "RGBA(#{r}, #{g}, #{b}, #{a})"
+    end
+
+    alias :red :r
+    alias :green :g
+    alias :blue :b
+    alias :alpha :a
+
+    alias :red= :r=
+    alias :green= :g=
+    alias :blue= :b=
+    alias :alpha= :a=
+  end
+end

data/lib/ray/ray.rb

@@ -0,0 +1,11 @@
+unless defined? Ray
+  unless RUBY_PLATFORM =~ /darwin/
+    require 'ray_ext'
+  else
+    $stderr.puts "Please run this program using ray: ray #$0"
+    exit 1
+  end
+end
+
+require 'ray/color'
+require 'ray/rect'

data/lib/ray/rect.rb

@@ -0,0 +1,13 @@
+module Ray
+  class Rect
+    def inspect
+      "#<#{self.class} {{#{x}, #{y}}, {#{w}, #{h}}}>"
+    end
+
+    alias :w :width
+    alias :h :height
+
+    alias :w= :width=
+    alias :h= :height=
+  end
+end

data/spec/ray/color_spec.rb

@@ -0,0 +1,44 @@
+describe Ray::Color do
+  describe "#initialize" do
+    it "should accept 3 integers" do
+      lambda {
+        Ray::Color.new(10, 20, 30)
+      }.should_not raise_exception(ArgumentError)
+    end
+
+    it "should accept 4 integers" do
+      lambda {
+        Ray::Color.new(10, 20, 30, 40)
+      }.should_not raise_exception(ArgumentError)
+    end
+
+    it "should only work with numerics" do
+      [Ray, "string", Ray::Color].each do |obj|
+        lambda {
+          Ray::Color.new(obj, 0, 0, obj)
+        }.should raise_exception(TypeError)
+      end
+    end
+  end
+
+  [:r, :g, :b, :a].each do |meth|
+    describe "#{meth}=" do
+      it "should only work with numerics" do
+        color = Ray::Color.new(0, 0, 0, 0)
+        [Ray, "string", Ray::Color].each do |obj|
+          lambda {
+            color.send("#{meth}=", obj)
+          }.should raise_exception(TypeError)
+        end
+      end
+
+      it "should set a new value" do
+        color = Ray::Color.new(0, 0, 0, 0)
+
+        lambda {
+          color.send("#{meth}=", 30)
+        }.should change(color, meth).from(0).to(30)
+      end
+    end
+  end
+end

data/spec/ray/image_spec.rb

@@ -0,0 +1,34 @@
+describe Ray::Image do
+  before :each do
+    Ray.init
+    @win = Ray.create_window(:w => 100, :h => 100)
+  end
+
+ describe "#blit" do
+    context "when trying to blit on a non-surface" do
+      it "should raise a type error" do
+        img = Ray::Image.new(:w => 50, :h => 50)
+        lambda {
+          img.blit(:on => Ray::Color.new(10, 20, 30))
+        }.should raise_exception(TypeError)
+      end
+    end
+
+    context "when trying to use a non-rect as a position" do
+      it "should raise a type error" do
+        img = Ray::Image.new(:w => 50, :h => 50)
+        lambda {
+          img.blit(:from => Ray::Color.new(10, 20, 30), :on => @win)
+        }.should raise_exception(TypeError)
+
+        lambda {
+          img.blit(:on => @win, :at => Ray::Color.new(10, 20, 30))
+        }.should raise_exception(TypeError)
+      end
+    end
+  end
+
+  after :each do
+    Ray.stop
+  end
+end