ray 0.0.0.pre2 → 0.0.1

data/ext/color.c

@@ -55,7 +55,7 @@ VALUE ray_init_color(int argc, VALUE *argv, VALUE self) {
    return Qnil;
 }
 
-/* @return [Integer] red level */
+/* @return [Integer] red intensity */
 VALUE ray_color_r(VALUE self) {
    ray_color *ret;
    Data_Get_Struct(self, ray_color, ret);
@@ -63,7 +63,7 @@ VALUE ray_color_r(VALUE self) {
    return INT2FIX(ret->r);
 }
 
-/* @return [Integer] green level */
+/* @return [Integer] green intensity */
 VALUE ray_color_g(VALUE self) {
    ray_color *ret;
    Data_Get_Struct(self, ray_color, ret);
@@ -71,7 +71,7 @@ VALUE ray_color_g(VALUE self) {
    return INT2FIX(ret->g);
 }
 
-/* @return [Integer] blue level */
+/* @return [Integer] blue intensity */
 VALUE ray_color_b(VALUE self) {
    ray_color *ret;
    Data_Get_Struct(self, ray_color, ret);
@@ -79,7 +79,7 @@ VALUE ray_color_b(VALUE self) {
    return INT2FIX(ret->b);
 }
 
-/* @return [Integer] alpha level */
+/* @return [Integer] alpha intensity */
 VALUE ray_color_a(VALUE self) {
    ray_color *ret;
    Data_Get_Struct(self, ray_color, ret);

data/ext/event.c

@@ -26,7 +26,7 @@ VALUE ray_alloc_event(VALUE self) {
 }
 
 /*
-  Creates the event according to what's happening now.
+  Creates the event according to the next event of the stack.
 */
 VALUE ray_init_event(VALUE self) {
    SDL_Event *event = ray_rb2event(self);
@@ -105,10 +105,11 @@ VALUE ray_event_mod_keys(VALUE self) {
 }
 
 /*
-  @return [Integer, nil] A mask of the focus states, for active event. 
+  @return [Integer, nil] A mask of the focus states, for active events
+                         (when type is TYPE_ACTIVEEVENT) 
 */
 VALUE ray_event_focus_state(VALUE self) {
-      SDL_Event *ev = ray_rb2event(self);
+   SDL_Event *ev = ray_rb2event(self);
    if (ev->type != SDL_ACTIVEEVENT)
       return Qnil;
    return INT2FIX(ev->active.state);
@@ -200,6 +201,24 @@ VALUE ray_event_joystick_button(VALUE self) {
    return Qnil;
 }
 
+/* @return [Integer, nil] The new width of the window */
+VALUE ray_event_window_w(VALUE self) {
+   SDL_Event *ev = ray_rb2event(self);
+   if (ev->type == SDL_VIDEORESIZE)
+      return INT2FIX(ev->resize.w);
+
+   return Qnil;
+}
+
+/* @return [Integer, nil] The new height of the window */
+VALUE ray_event_window_h(VALUE self) {
+   SDL_Event *ev = ray_rb2event(self);
+   if (ev->type == SDL_VIDEORESIZE)
+      return INT2FIX(ev->resize.h);
+
+   return Qnil;
+}
+
 void Init_ray_event() {
    ray_cEvent = rb_define_class_under(ray_mRay, "Event", rb_cObject);
    rb_define_alloc_func(ray_cEvent, ray_alloc_event);
@@ -228,6 +247,9 @@ void Init_ray_event() {
    rb_define_method(ray_cEvent, "axis_value", ray_event_axis_value, 0);
    rb_define_method(ray_cEvent, "joystick_button", ray_event_joystick_button, 0);
 
+   rb_define_method(ray_cEvent, "window_w", ray_event_window_w, 0);
+   rb_define_method(ray_cEvent, "window_h", ray_event_window_h, 0);
+
    rb_define_const(ray_cEvent, "TYPE_NOEVENT", INT2FIX(SDL_NOEVENT));
    rb_define_const(ray_cEvent, "TYPE_ACTIVEEVENT", INT2FIX(SDL_ACTIVEEVENT));
    rb_define_const(ray_cEvent, "TYPE_KEYDOWN", INT2FIX(SDL_KEYDOWN));

data/ext/extconf.rb

@@ -36,8 +36,22 @@ def have_framework(name)
   ret
 end
 
-has_run_node = have_func("ruby_run_node")
-has_run      = have_func("ruby_run")
+def have_sdl_ext(name, header)
+  if res = have_framework(name)
+    ending = header.upcase.tr('/', '_').gsub(/\.H$/, "_H")
+    $CFLAGS << " -DHAVE_#{ending}"
+
+    return res
+  end
+
+  if res = have_library(name)
+    unless have_header(header) or have_header("SDL/#{header}")
+      return false
+    end
+
+    return res
+  end
+end
 
 $CFLAGS << " -pedantic -Wall -std=c99 -Wno-unused-parameter"
 
@@ -60,16 +74,25 @@ unless RUBY_PLATFORM =~ /darwin/
     have_header("SDL/SDL_image.h") or have_header("SDL_image.h")
   end
 
+  if have_library("SDL_gfx")
+    have_header("SDL/SDL_rotozoom.h") or have_header("SDL_rotozoom.h")
+  end
+
+  if have_library("SDL_ttf")
+    have_header("SDL/SDL_ttf.h") or have_header("SDL_ttf.h")
+  end
+
+  if have_library("SDL_mixer")
+    have_header("SDL/SDL_mixer.h") or have_header("SDL_mixer.h")
+  end
+
   create_makefile("ray_ext")
 
-  data = File.read("Makefile").gsub("SDLMain.o", "")
+  data = File.read("Makefile").gsub("ray_osx.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  << " #{ENV["CFLAGS"]}"
+  $LDFLAGS << " #{ENV["LDFLAGS"]}"
 
   $CFLAGS << " -DRAY_USE_FRAMEWORK"
 
@@ -79,20 +102,10 @@ else
     exit 1
   end
 
-  have_framework("SDL_image")
-
-  have_library("ruby", "ruby_init")
+  have_sdl_ext("SDL_image", "SDL_image.h")
+  have_sdl_ext("SDL_gfx", "SDL_rotozoom.h")
+  have_sdl_ext("SDL_ttf", "SDL_ttf.h")
+  have_sdl_ext("SDL_mixer", "SDL_mixer.h")
 
   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/font.c

@@ -0,0 +1,287 @@
+#include "ray.h"
+
+#ifdef HAVE_SDL_TTF
+
+enum ray_encoding {
+   RAY_ENCODING_LATIN1,
+   RAY_ENCODING_UTF8,
+   RAY_ENCODING_UNICODE
+};
+
+VALUE ray_cFont = Qnil;
+
+TTF_Font *ray_rb2font(VALUE object) {
+   if (!RAY_IS_A(object, ray_cFont)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Font",
+               RAY_OBJ_CLASSNAME(object));
+   }
+
+   ray_font *ptr = NULL;
+   Data_Get_Struct(object, ray_font, ptr);
+  
+   return ptr->font;
+}
+
+void ray_free_font(ray_font *font) {
+   if (font->font) TTF_CloseFont(font->font);
+   free(font);
+}
+
+VALUE ray_alloc_font(VALUE self) {
+   ray_font *ptr = malloc(sizeof(ray_font));
+   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_font, ptr);
+
+   ptr->font = NULL;
+   return ret;
+}
+
+void ray_init_font_with_filename(VALUE self, VALUE filename, int size) {
+   ray_font *font = NULL;
+   Data_Get_Struct(self, ray_font, font);
+  
+   font->font = TTF_OpenFont(StringValuePtr(filename), size);
+   if (!font->font) {
+      rb_raise(rb_eRuntimeError, "Could not load the font (%s)",
+               TTF_GetError());
+   }
+}
+
+void ray_init_font_with_io(VALUE self, VALUE io, int size) {
+   ray_font *font = NULL;
+   Data_Get_Struct(self, ray_font, font);
+
+   VALUE string = rb_funcall2(io, RAY_METH("read"), 0, NULL);
+   char *content = StringValuePtr(string);
+
+   SDL_RWops *data = SDL_RWFromMem(content, (int)RSTRING_LEN(string));
+   if (!data) {
+      rb_raise(rb_eRuntimeError, "Could not create image data (%s)",
+               SDL_GetError());
+   }
+
+   font->font = TTF_OpenFontRW(data, 1, size);
+   if (!font->font) {
+      printf("Could not load the font (%s)\n", TTF_GetError());
+      rb_raise(rb_eRuntimeError, "Could not load the font (%s)",
+               TTF_GetError());
+   }
+}
+
+/*
+  Creates a new font.
+
+  @param [String, #read] arg Filename of the font or IO object containing
+                             the content of the font.
+  @param [Integer] size Point size (based on 72DPI).
+ */
+VALUE ray_init_font(VALUE self, VALUE arg, VALUE size) {
+   if (rb_respond_to(arg, RAY_METH("to_str")))
+      ray_init_font_with_filename(self, rb_String(arg), NUM2INT(size));
+   else if (rb_respond_to(arg, RAY_METH("read")))
+      ray_init_font_with_io(self, arg, NUM2INT(size));
+   else {
+      rb_raise(rb_eTypeError, "Can't convert %s into String",
+               RAY_OBJ_CLASSNAME(arg));
+   }
+
+   return Qnil;
+}
+
+/*
+  @return [Integer] Bitmask describing the style of the font.
+                    STYLE_NORMAL for a normal font.
+*/
+VALUE ray_font_style(VALUE self) {
+   TTF_Font *font = ray_rb2font(self);
+   return INT2FIX(TTF_GetFontStyle(font));
+}
+
+/* Sets the font style. */
+VALUE ray_font_set_style(VALUE self, VALUE style) {
+   TTF_Font *font = ray_rb2font(self);
+   TTF_SetFontStyle(font, NUM2INT(style));
+   return style;
+}
+
+/* @return [Integer] the height of the font */
+VALUE ray_font_height(VALUE self) {
+   TTF_Font *font = ray_rb2font(self);
+   return INT2FIX(TTF_FontHeight(font));
+}
+
+/* @return [Integer] the recommended spacing between lines for this font */
+VALUE ray_font_line_skip(VALUE self) {
+   TTF_Font *font = ray_rb2font(self);
+   return INT2FIX(TTF_FontLineSkip(font));
+}
+
+/*
+  @overload size_of(text, encoding = nil)
+    @param [Symbol, nil] encoding nil (for Latin1), :latin1, :utf8, or :unicode.
+    @return [Ray::Rect] Size of the text.
+*/
+VALUE ray_font_size_of(int argc, VALUE *argv, VALUE self) {
+   TTF_Font *font = ray_rb2font(self);
+
+   VALUE string = Qnil, encoding = Qnil;
+   rb_scan_args(argc, argv, "11", &string, &encoding);
+   
+   char *c_string = StringValuePtr(string);
+   
+   int w, h;
+   
+   if (NIL_P(encoding) || encoding == RAY_SYM("latin1"))
+      TTF_SizeText(font, c_string, &w, &h);
+   else if (encoding == RAY_SYM("utf8"))
+      TTF_SizeUTF8(font, c_string, &w, &h);
+   else if (encoding == RAY_SYM("unicode"))
+      TTF_SizeUNICODE(font, (uint16_t*)c_string, &w, &h);
+   else
+      rb_raise(rb_eArgError, "Invalid encoding.");
+
+   SDL_Rect rect = {0, 0, w, h};
+   return ray_rect2rb(rect);
+}
+
+/*
+  @overload draw(string, opts = {})
+    @param [String] string The string which should be drawn.
+    
+    @option opts [Symbol] :mode Drawing mode. :solid (fastest),
+                                :shaded (requires a background set
+                                with :background) or :blended
+    @option opts [Symbol] :encoding :latin1, :utf8, or :unicode. Defaults
+                                    to :latin1.
+    @option opts [Ray::Color] :color Color to draw the text in. Defaults to
+                                     white.
+    @option opts [Ray::Color] :background The background color in :shaded mode.
+                                          defaults to black.
+    @option opts [Ray::Image] :on The image to draw on. In this case,
+                                  it will directly draw instead of returning
+                                  an image containing nothing but the string.
+    @option opts [Ray::Rect, Array<Integer>] :to, :at where to draw on the image.
+
+    @return The surface it drew the string on.
+ */
+VALUE ray_font_draw(int argc, VALUE *argv, VALUE self) {
+   VALUE string, hash;
+   rb_scan_args(argc, argv, "11", &string, &hash);
+
+   if (NIL_P(hash))
+      hash = rb_hash_new();
+
+   TTF_Font *font = ray_rb2font(self);
+
+   char *c_string = StringValuePtr(string);
+
+   /* solid, shaded, blended */
+   VALUE drawing_mode = rb_hash_aref(hash, RAY_SYM("mode"));
+
+   VALUE encoding = rb_hash_aref(hash, RAY_SYM("encoding"));
+   int c_encoding = 0;
+   
+   if (NIL_P(encoding) || encoding == RAY_SYM("latin1"))
+      c_encoding = RAY_ENCODING_LATIN1;
+   else if (encoding == RAY_SYM("utf8"))
+      c_encoding = RAY_ENCODING_UTF8;
+   else if (encoding == RAY_SYM("unicode"))
+      c_encoding = RAY_ENCODING_UNICODE;
+   else
+      rb_raise(rb_eArgError, "Invalid encoding.");
+
+   VALUE rb_color = rb_hash_aref(hash, RAY_SYM("color"));
+   ray_color c_color = {255, 255, 255, 255};
+   if (!NIL_P(rb_color))
+      c_color = ray_rb2col(rb_color);
+   
+   SDL_Color color = {c_color.r, c_color.g, c_color.b};
+   
+   SDL_Surface *surface = NULL;
+   
+   if (NIL_P(drawing_mode) || drawing_mode == RAY_SYM("solid")) {
+      if (c_encoding == RAY_ENCODING_LATIN1)
+         surface = TTF_RenderText_Solid(font, c_string, color);
+      else if (c_encoding == RAY_ENCODING_UTF8)
+         surface = TTF_RenderUTF8_Solid(font, c_string, color);
+      else
+         surface = TTF_RenderUNICODE_Solid(font, (uint16_t*)c_string, color);
+   }
+   else if (drawing_mode == RAY_SYM("shaded")) {
+      VALUE rb_bg = rb_hash_aref(hash, RAY_SYM("background"));
+      ray_color c_bg = {0, 0, 0, 255};
+      if (!NIL_P(rb_bg))
+         c_bg = ray_rb2col(rb_bg);
+      SDL_Color bg = {c_bg.r, c_bg.g, c_bg.b};
+      
+      if (c_encoding == RAY_ENCODING_LATIN1)
+         surface = TTF_RenderText_Shaded(font, c_string, color, bg);
+      else if (c_encoding == RAY_ENCODING_UTF8)
+         surface = TTF_RenderUTF8_Shaded(font, c_string, color, bg);
+      else
+         surface = TTF_RenderUNICODE_Shaded(font, (uint16_t*)c_string, color, bg);
+   }
+   else if (drawing_mode == RAY_SYM("blended")) {
+      if (c_encoding == RAY_ENCODING_LATIN1)
+         surface = TTF_RenderText_Blended(font, c_string, color);
+      else if (c_encoding == RAY_ENCODING_UTF8)
+         surface = TTF_RenderUTF8_Blended(font, c_string, color);
+      else
+         surface = TTF_RenderUNICODE_Blended(font, (uint16_t*)c_string, color);
+   }
+   else
+      rb_raise(rb_eArgError, "Invalid drawing mode.");
+
+   if (!surface) {
+      rb_raise(rb_eRuntimeError, "Could not drawstring (%s)",
+               TTF_GetError());
+   }
+
+   VALUE on = rb_hash_aref(hash, RAY_SYM("on"));
+   if (NIL_P(on))
+      return ray_create_gc_image(surface);
+
+   SDL_Surface *target = ray_rb2surface(on);
+
+   VALUE rb_rect = rb_hash_aref(hash, RAY_SYM("at"));
+   if (NIL_P(rb_rect))
+      rb_rect = rb_hash_aref(hash, RAY_SYM("to"));
+
+   SDL_Rect rect;
+   
+   if (RTEST(rb_obj_is_kind_of(rb_rect, ray_cRect)))
+      rect = ray_rb2rect(rb_rect);
+   else if (RTEST(rb_obj_is_kind_of(rb_rect, rb_cArray)))
+      rect = ray_rb2rect(rb_apply(ray_cRect, RAY_METH("new"), rb_rect));
+   else {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Rect",
+               RAY_OBJ_CLASSNAME(rb_rect));
+   }
+   
+   SDL_BlitSurface(surface, NULL, target, &rect);
+   SDL_FreeSurface(surface);
+
+   return on;
+}
+
+void Init_ray_font() {
+   ray_cFont = rb_define_class_under(ray_mRay, "Font", rb_cObject);
+   rb_define_alloc_func(ray_cFont, ray_alloc_font);
+   rb_define_method(ray_cFont, "initialize", ray_init_font, 2);
+
+   rb_define_method(ray_cFont, "style", ray_font_style, 0);
+   rb_define_method(ray_cFont, "style=", ray_font_set_style, 1);
+   
+   rb_define_method(ray_cFont, "height", ray_font_height, 0);
+   rb_define_method(ray_cFont, "line_skip", ray_font_line_skip, 0);
+
+   rb_define_method(ray_cFont, "size_of", ray_font_size_of, -1);
+
+   rb_define_method(ray_cFont, "draw", ray_font_draw, -1);
+   
+   rb_define_const(ray_cFont, "STYLE_NORMAL", INT2FIX(TTF_STYLE_NORMAL));
+   rb_define_const(ray_cFont, "STYLE_ITALIC", INT2FIX(TTF_STYLE_ITALIC));
+   rb_define_const(ray_cFont, "STYLE_BOLD", INT2FIX(TTF_STYLE_BOLD));
+   rb_define_const(ray_cFont, "STYLE_UNDERLINE", INT2FIX(TTF_STYLE_UNDERLINE));
+}
+
+#endif