ray 0.0.0.pre1

data/ext/color.c

@@ -0,0 +1,147 @@
+#include "ray.h"
+
+VALUE ray_cColor = Qnil;
+
+ray_color ray_rb2col(VALUE object) {
+   if (!RAY_IS_A(object, ray_cColor)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Color",
+               RAY_OBJ_CLASSNAME(object));
+   }
+
+   ray_color *ret = NULL;
+   Data_Get_Struct(object, ray_color, ret);
+
+   return *ret;
+}
+
+VALUE ray_col2rb(ray_color color) {
+   VALUE ret = rb_funcall(ray_cColor, RAY_METH("new"), 4,
+                          INT2FIX(color.r),
+                          INT2FIX(color.g),
+                          INT2FIX(color.b),
+                          INT2FIX(color.a));   
+   return ret;
+}
+
+void ray_free_color(ray_color *color) {
+   free(color);
+}
+
+VALUE ray_alloc_color(VALUE self) {
+   ray_color *ptr = malloc(sizeof(ray_color));
+   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_color, ptr);
+
+   return ret;
+}
+
+/*
+  @overload initialize(red, green, blue, alpha = 255)
+    Creates a new color. All the parameters must be integers between
+    0 and 255. Alpha is the transparency (255: opaque, 0: invisible)
+*/
+VALUE ray_init_color(int argc, VALUE *argv, VALUE self) {
+   VALUE r, g, b, a;
+   rb_scan_args(argc, argv, "31", &r, &g, &b, &a);
+   if (a == Qnil) a = INT2FIX(255);
+
+   ray_color *ret = NULL;
+   Data_Get_Struct(self, ray_color, ret);
+
+   ret->r = NUM2INT(r);
+   ret->g = NUM2INT(g);
+   ret->b = NUM2INT(b);
+   ret->a = NUM2INT(a);
+
+   return Qnil;
+}
+
+/* @return [Integer] red level */
+VALUE ray_color_r(VALUE self) {
+   ray_color *ret;
+   Data_Get_Struct(self, ray_color, ret);
+
+   return INT2FIX(ret->r);
+}
+
+/* @return [Integer] green level */
+VALUE ray_color_g(VALUE self) {
+   ray_color *ret;
+   Data_Get_Struct(self, ray_color, ret);
+
+   return INT2FIX(ret->g);
+}
+
+/* @return [Integer] blue level */
+VALUE ray_color_b(VALUE self) {
+   ray_color *ret;
+   Data_Get_Struct(self, ray_color, ret);
+
+   return INT2FIX(ret->b);
+}
+
+/* @return [Integer] alpha level */
+VALUE ray_color_a(VALUE self) {
+   ray_color *ret;
+   Data_Get_Struct(self, ray_color, ret);
+
+   return INT2FIX(ret->a);
+}
+
+/* Sets the red intensity */
+VALUE ray_color_set_r(VALUE self, VALUE val) {
+   ray_color *ret;
+   Data_Get_Struct(self, ray_color, ret);
+
+   ret->r = NUM2INT(val);
+   return val;
+}
+
+/* Sets the green intensity */
+VALUE ray_color_set_g(VALUE self, VALUE val) {
+   ray_color *ret;
+   Data_Get_Struct(self, ray_color, ret);
+
+   ret->g = NUM2INT(val);
+   return val;
+}
+
+/* Sets the blue intensity */
+VALUE ray_color_set_b(VALUE self, VALUE val) {
+   ray_color *ret;
+   Data_Get_Struct(self, ray_color, ret);
+
+   ret->b = NUM2INT(val);
+   return val;
+}
+
+/* Sets the alpha intensity */
+VALUE ray_color_set_a(VALUE self, VALUE val) {
+   ray_color *ret;
+   Data_Get_Struct(self, ray_color, ret);
+
+   ret->a = NUM2INT(val);
+   return val;
+}
+
+/*
+  Document-class: Ray::Color
+
+  Represents a color, which does not rely on the pixel format of any
+  surfaces.
+*/
+void Init_ray_color() {
+   ray_cColor = rb_define_class_under(ray_mRay, "Color", rb_cObject);
+   
+   rb_define_alloc_func(ray_cColor, ray_alloc_color);
+   rb_define_method(ray_cColor, "initialize", ray_init_color, -1);
+   
+   rb_define_method(ray_cColor, "r", ray_color_r, 0);
+   rb_define_method(ray_cColor, "g", ray_color_g, 0);
+   rb_define_method(ray_cColor, "b", ray_color_b, 0);
+   rb_define_method(ray_cColor, "a", ray_color_a, 0);
+
+   rb_define_method(ray_cColor, "r=", ray_color_set_r, 1);
+   rb_define_method(ray_cColor, "g=", ray_color_set_g, 1);
+   rb_define_method(ray_cColor, "b=", ray_color_set_b, 1);
+   rb_define_method(ray_cColor, "a=", ray_color_set_a, 1);
+}

data/ext/extconf.rb

@@ -0,0 +1,92 @@
+require 'mkmf'
+
+def find_macosx_framework(name)
+  paths = [
+           "/opt/local/Library/Frameworks",
+           "/Library/Frameworks",
+           "/Network/Library/Frameworks",
+           "/System/Library/Frameworks"
+          ]
+  paths.reverse!
+
+  paths.each do |dir|
+    dir = File.join(dir, "#{name}.framework")
+    next unless File.directory? dir
+
+    return dir
+  end
+
+  nil
+end
+
+def have_framework(name)
+  print "checking for framweork #{name}... "
+  ret = find_macosx_framework(name)
+
+  if ret
+    puts "yes"
+
+    $LDFLAGS << " -F#{File.dirname(ret)}"
+    $LDFLAGS << " -framework #{name}"
+    $CFLAGS  << " -I#{File.join(ret, "Headers")}"
+    $CFLAGS  << " -DHAVE_FRAMEWORK_#{name.upcase}"
+  else
+    puts "no"
+  end
+  ret
+end
+
+has_run_node = have_func("ruby_run_node")
+has_run      = have_func("ruby_run")
+
+$CFLAGS << " -pedantic -Wall -std=c99 -Wno-unused-parameter"
+
+unless RUBY_PLATFORM =~ /darwin/
+  unless have_library("SDL", "SDL_Init")
+    $stdder.puts "SDL not found"
+  end
+
+  unless (have_header("SDL/SDL.h") or have_header("SDL.h"))
+    $stderr.puts "SDL.h not found."
+    exit 1
+  end
+
+  unless have_library("SDLmain")
+    $stderr.puts "SDL_main not found."
+    exit 1
+  end
+
+  create_makefile("ray_ext")
+
+  data = File.read("Makefile").gsub("SDLMain.o", "")
+  open("Makefile", 'w') { |f| f.write(data) }
+else
+  if !has_run and !has_run_node
+    $stderr.puts "Unsupported configuration: Mac OS X and a ruby " +
+                 "implementation that does not implement ruby_run"
+    exit 1
+  end
+
+  $CFLAGS << " -DRAY_USE_FRAMEWORK"
+
+  unless have_framework("SDL") and have_framework("Cocoa") and
+      have_framework("Foundation")
+    $stderr.puts "missing frameworks"
+    exit 1
+  end
+
+  have_library("ruby", "ruby_init")
+
+  create_makefile("ray_ext")
+end
+
+if has_run or has_run_node
+  open("Makefile", 'a') do |file|
+    file.puts "ray: $(OBJS)"
+    file.puts "\t$(CC) -o ray $(OBJS) $(LIBPATH) $(DLDFLAGS) " +
+      "$(LOCAL_LIBS) $(LIBS) -lruby"
+  end
+
+  data = File.read("Makefile").gsub("all:", "all: ray")
+  open("Makefile", 'w') { |f| f.write(data) }
+end

data/ext/image.c

@@ -0,0 +1,192 @@
+#include "ray.h"
+
+VALUE ray_cImage = Qnil;
+
+ray_image *ray_rb2image(VALUE object) {
+   if (!RAY_IS_A(object, ray_cImage)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Image",
+               RAY_OBJ_CLASSNAME(object));
+   }
+
+   ray_image *ptr = NULL;
+   Data_Get_Struct(object, ray_image, ptr);
+   
+   return ptr;
+}
+
+SDL_Surface *ray_rb2surface(VALUE object) {
+   return ray_rb2image(object)->surface;
+}
+
+/*
+  Creates a new image. You must call Ray.create_window before
+  this function.
+
+  @overload initialize(hash)
+    @option hash [Integer] :width Width of the surface
+    @option hash [Integer] :height Height of the surface
+    
+    @option hash [Integer] :w Alias for width
+    @option hash [Integer] :h Alias for height
+
+    @option hash [Integer] :bits_per_pixel See Ray.create_window
+    @option hash [Integer] :pp Alias for bits_per_pixel
+
+    @option hash [true, false] :hw_surface See Ray.create_window
+    @option hash [true, false] :sw_surface See Ray.create_window
+ */
+VALUE ray_init_image(VALUE self, VALUE arg) {
+   VALUE width = rb_hash_aref(arg, RAY_SYM("width"));
+   if (NIL_P(width)) width = rb_hash_aref(arg, RAY_SYM("w"));
+
+   VALUE height = rb_hash_aref(arg, RAY_SYM("height"));
+   if (NIL_P(height)) height = rb_hash_aref(arg, RAY_SYM("h"));
+   
+   VALUE bitsperpixel = rb_hash_aref(arg, RAY_SYM("bits_per_pixel"));
+   if (NIL_P(bitsperpixel)) bitsperpixel = rb_hash_aref(arg, RAY_SYM("bpp"));   
+   if (NIL_P(bitsperpixel)) bitsperpixel = INT2FIX(32);
+
+   uint32_t flags = 0;
+   if (RTEST(rb_hash_aref(arg, RAY_SYM("sw_surface"))))
+      flags = SDL_SWSURFACE;
+   else
+      flags = SDL_HWSURFACE;
+
+   ray_image *image = ray_rb2image(self);
+   image->surface = SDL_CreateRGBSurface(flags,
+                                         NUM2INT(width),
+                                         NUM2INT(height),
+                                         NUM2INT(bitsperpixel),
+                                         0, 0, 0, 0);
+
+   if (!image->surface) {
+      rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+               SDL_GetError());
+   }
+   
+   return Qnil;
+}
+
+void ray_free_image(ray_image *ptr) {
+   if (ptr->mustFree && ptr->surface) SDL_FreeSurface(ptr->surface);
+   free(ptr);
+}
+
+VALUE ray_create_image(SDL_Surface *surface) {
+   ray_image *ptr = malloc(sizeof(ray_image));
+   VALUE ret = Data_Wrap_Struct(ray_cImage, 0, ray_free_image, ptr);
+
+   ptr->self    = ret;
+   ptr->surface = surface;
+
+   ptr->mustFree = 0;
+
+   return ret;
+}
+
+VALUE ray_alloc_image(VALUE self) {
+   ray_image *ptr = malloc(sizeof(ray_image));
+   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_image, ptr);
+
+   ptr->self    = ret;
+   ptr->surface = NULL;
+
+   ptr->mustFree = 1;
+
+   return ret;
+}
+
+/*
+  Fills the image with a given color.
+  @param [Ray::Color] col The color used to fill the image.
+ */
+VALUE ray_image_fill(VALUE self, VALUE col) {
+   ray_color rcol = ray_rb2col(col);
+   
+   SDL_Surface *surf = ray_rb2surface(self);
+   uint32_t specific_col = SDL_MapRGBA(surf->format,
+                                       rcol.r, rcol.g, rcol.b,
+                                       rcol.a);
+   
+   SDL_FillRect(surf, NULL, specific_col);
+   return self;
+}
+
+/* Updates the image. */
+VALUE ray_image_flip(VALUE self) {
+   SDL_Flip(ray_rb2surface(self));
+   return self;
+}
+
+/*
+  Blits the receiver on another image.
+  
+  @option hash [Ray::Rect, Array] :at Rects in which the image will be
+                                      drawn. If an array is given, it
+                                      passed to Ray::Rect.new. Only the
+                                      position is read.
+  @option hash [Ray::Rect, Array] :rect Rects that will be copied.
+                                        If an array is given, it
+                                        passed to Ray::Rect.new.
+                                        If the size is (0, 0), it will
+                                        be reset to the image's size.
+  @option hash [Ray::Rect, Array] :from Alias for rect
+
+  @option hash [Ray::Image, required] :on The image on which the receiver should
+                                          be drawn.
+
+  @option hash [Ray::Image, required] :to Alias for on.
+*/
+VALUE ray_image_blit(VALUE self, VALUE hash) {
+   SDL_Surface *origin = ray_rb2surface(self);
+
+   SDL_Rect from_rect = {0, 0, origin->w, origin->h};
+   SDL_Rect to_rect   = {0, 0, 0, 0};
+   
+   VALUE rect = rb_hash_aref(hash, RAY_SYM("at"));
+
+   if (RTEST(rb_obj_is_kind_of(rect, ray_cRect)))
+      to_rect = ray_rb2rect(rect);
+   else if (RTEST(rb_obj_is_kind_of(rect, rb_cArray)))
+      to_rect = ray_rb2rect(rb_apply(ray_cRect, RAY_METH("new"), rect));
+   else if (rect != Qnil) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Rect",
+               RAY_OBJ_CLASSNAME(rect));
+   }
+
+   rect = Qnil;
+   rect = rb_hash_aref(hash, RAY_SYM("rect"));
+   if (rect == Qnil) rect = rb_hash_aref(hash, RAY_SYM("from"));
+
+   if (RAY_IS_A(rect, ray_cRect))
+      from_rect = ray_rb2rect(rect);
+   else if (RAY_IS_A(rect, rb_cArray))
+      from_rect = ray_rb2rect(rb_apply(ray_cRect, RAY_METH("new"), rect));
+   else if (!NIL_P(rect)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Rect",
+               RAY_OBJ_CLASSNAME(rect));
+   }
+
+   if (from_rect.w == 0 && from_rect.h == 0) {
+      from_rect.w = origin->w;
+      from_rect.h = origin->h;
+   }
+
+   VALUE surf = rb_hash_aref(hash, RAY_SYM("on"));
+   if (surf == Qnil) surf = rb_hash_aref(hash, RAY_SYM("to"));
+   SDL_BlitSurface(origin, &from_rect,  ray_rb2surface(surf), &to_rect);
+
+   return surf;
+}
+
+void Init_ray_image() {
+   ray_cImage = rb_define_class_under(ray_mRay, "Image", rb_cObject);
+   
+   rb_define_alloc_func(ray_cImage, ray_alloc_image);
+   rb_define_method(ray_cImage, "initialize", ray_init_image, 1);
+
+   rb_define_method(ray_cImage, "fill", ray_image_fill, 1);
+   rb_define_method(ray_cImage, "flip", ray_image_flip, 0);
+
+   rb_define_method(ray_cImage, "blit", ray_image_blit, 1);
+}

data/ext/ray.c

@@ -0,0 +1,125 @@
+#include "ray.h"
+
+VALUE ray_mRay = Qnil;
+
+/* Inits ray */
+VALUE ray_init(VALUE self) {
+   SDL_Init(SDL_INIT_VIDEO);
+   return Qnil;
+}
+
+/* Stops ray */
+VALUE ray_stop(VALUE self) {
+   SDL_Quit();
+   return Qnil;
+}
+
+/*
+  Creates a new window.
+
+  @note If both hw_surface and sws_urface are false, hw_surface
+        will be considered as true. :sw_surface should be true
+        if you want to acess
+
+  @return [Ray::Image] An image representing the window
+
+  @option hash [Integer] :width Width of the window
+  @option hash [Integer] :height Height of the window
+
+  @option hash [Integer] :w Alias for width
+  @option hash [Integer] :h Alias for height
+
+  @option hash [Integer] :bits_per_pixel Bits per pixel. Valid values are
+                                         8, 15, 16, 24, and 32.
+  @option hash [Integer] :bpp Alias for bits_per_pixel
+
+  @option hash [true, false] :hw_surface Creates the surface in video memory
+                                        (default)
+  @option hash [true, false] :sw_surface Creates the surface in system memory
+  @option hash [true, false] :async_blit Enables asynchronous updates of the
+                                         the surface
+  @option hash [true, false] :double_buf Enables double buffering. Ignored
+                                         if sw_surface is set.
+  @option hash [true, false] :fullscreen Creates a full screen window.
+  @option hash [true, false] :resizable  Creates a resizable window.
+  @option hash [true, false] :no_frame   Disables window decoration if
+                                         possible.
+ */
+VALUE ray_create_window(VALUE self, VALUE hash) {
+   VALUE width  = rb_hash_aref(hash, RAY_SYM("width"));
+   VALUE height = rb_hash_aref(hash, RAY_SYM("height"));
+
+   if (NIL_P(width))  width  = rb_hash_aref(hash, RAY_SYM("h"));
+   if (NIL_P(height)) height = rb_hash_aref(hash, RAY_SYM("w"));
+
+   if (NIL_P(width) || NIL_P(height))
+      rb_raise(rb_eArgError, "Missing parameter: width or height");
+
+   VALUE bitsperpixel = rb_hash_aref(hash, RAY_SYM("bits_per_pixel"));
+   if (NIL_P(bitsperpixel)) bitsperpixel = rb_hash_aref(hash, RAY_SYM("bpp"));
+
+   if (NIL_P(bitsperpixel))
+      bitsperpixel = INT2FIX(32);
+
+   uint32_t flags = 0;
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("sw_surface"))))
+      flags |= SDL_SWSURFACE;
+   else
+      flags |= SDL_HWSURFACE; /* even if hwsurface was false and not nil */
+
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("async_blit"))))
+      flags |= SDL_ASYNCBLIT;
+
+   if (!(flags & SDL_SWSURFACE) &&
+       RTEST(rb_hash_aref(hash, RAY_SYM("double_buf")))) {
+      flags |= SDL_DOUBLEBUF;
+   }
+
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("fullscreen"))))
+      flags |= SDL_FULLSCREEN;
+
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("no_frame"))))
+      flags |= SDL_NOFRAME;
+
+   SDL_Surface *screen = SDL_SetVideoMode(NUM2INT(width),
+                                          NUM2INT(height),
+                                          NUM2INT(bitsperpixel),
+                                          flags);
+   if (!screen) {
+      rb_raise(rb_eRuntimeError, "Could not create the window (%s)",
+               SDL_GetError());
+   }
+
+   return ray_create_image(screen);
+}
+
+void Init_ray_ext() {
+   ray_mRay = rb_define_module("Ray");
+
+   rb_define_module_function(ray_mRay, "init", ray_init, 0);
+   rb_define_module_function(ray_mRay, "stop", ray_stop, 0);
+   rb_define_module_function(ray_mRay, "create_window", ray_create_window, 1);
+
+   Init_ray_image();
+   Init_ray_color();
+   Init_ray_rect();
+}
+
+int main(int argc, char *argv[]) {
+#if defined(HAVE_RUBY_RUN_NODE)
+   ruby_init();
+   Init_ray_ext();
+   ruby_run_node(ruby_options(argc, argv));
+#elif defined(HAVE_RUBY_RUN)
+   ruby_init();
+   Init_ray_ext();
+   ruby_init_loadpath();
+   ruby_options(argc, argv);
+   ruby_run();
+#else
+   fprintf(stderr, "Please use \"require 'ray'\" on this platform\n");
+   return 1;
+#endif
+
+   return 0;
+}