ray 0.0.0.pre2 → 0.0.1

data/ext/ray_osx.m

@@ -0,0 +1,161 @@
+#ifdef HAVE_SDL_H
+# include <SDL.h>
+#else
+# include <SDL/SDL.h>
+#endif
+
+#include <Cocoa/Cocoa.h>
+
+struct CPSProcessSerNum {
+   UInt32 lo;
+   UInt32 hi;
+};
+
+typedef struct CPSProcessSerNum CPSProcessSerNum;
+
+extern OSErr CPSGetCurrentProcess(CPSProcessSerNum *psn);
+extern OSErr CPSEnableForegroundOperation(CPSProcessSerNum *psn,
+                                          UInt32 _arg2,
+                                          UInt32 _arg3,
+                                          UInt32 _arg4,
+                                          UInt32 _arg5);
+extern OSErr CPSSetFrontProcess(CPSProcessSerNum *psn);
+extern OSErr CPSSetProcessName(CPSProcessSerNum *psn, const char *processname);
+
+static NSAutoreleasePool *ray_pool = nil;
+
+@interface NSApplication (SDL_Missing_Methods)
+- (void)setAppleMenu:(NSMenu *)menu;
+@end
+
+@interface RayApplication : NSApplication
+@end
+
+@implementation RayApplication
+- (void)terminate:(id)sender {
+   SDL_Event event;
+   event.type = SDL_QUIT;
+   SDL_PushEvent(&event);
+}
+@end
+
+NSString *ray_osx_appname() {
+   const NSDictionary *dict;
+   NSString *appName = 0;
+
+   dict = (const NSDictionary *)CFBundleGetInfoDictionary(CFBundleGetMainBundle());
+   if (dict)
+      appName = [dict objectForKey: @"CFBundleName"];
+
+   if ([appName length] == 0)
+      appName = [[NSProcessInfo processInfo] processName];
+
+   return appName;
+}
+
+void ray_osx_setup_application_menu() {
+   NSMenu *appleMenu;
+   NSMenuItem *menuItem;
+   NSString *title;
+   NSString *appName;
+
+   appName = ray_osx_appname();
+   appleMenu = [[NSMenu alloc] initWithTitle:@""];
+
+   /* Add menu items */
+   title = [@"About " stringByAppendingString:appName];
+   [appleMenu addItemWithTitle:title action:@selector(orderFrontStandardAboutPanel:)
+                 keyEquivalent:@""];
+
+   [appleMenu addItem:[NSMenuItem separatorItem]];
+
+   title = [@"Hide " stringByAppendingString:appName];
+   [appleMenu addItemWithTitle:title action:@selector(hide:)
+                 keyEquivalent:@"h"];
+
+   menuItem = (NSMenuItem *)[appleMenu addItemWithTitle:@"Hide Others"
+                                                 action:@selector(hideOtherApplications:)
+                                          keyEquivalent:@"h"];
+   [menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask|NSCommandKeyMask)];
+
+   [appleMenu addItemWithTitle:@"Show All"
+                        action:@selector(unhideAllApplications:)
+                 keyEquivalent:@""];
+
+   [appleMenu addItem:[NSMenuItem separatorItem]];
+
+   title = [@"Quit " stringByAppendingString:appName];
+   [appleMenu addItemWithTitle:title action:@selector(terminate:) keyEquivalent:@"q"];
+
+   /* Put menu into the menubar */
+   menuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
+   [menuItem setSubmenu:appleMenu];
+   [[NSApp mainMenu] addItem:menuItem];
+
+   /* Tell the application object that this is now the application menu */
+   [NSApp setAppleMenu:appleMenu];
+
+   /* Finally give up our references to the objects */
+   [appleMenu release];
+   [menuItem release];
+}
+
+void ray_osx_setup_window_menu() {
+   NSMenu      *windowMenu;
+   NSMenuItem  *windowMenuItem;
+   NSMenuItem  *menuItem;
+
+   windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
+
+   /* "Minimize" item */
+   menuItem = [[NSMenuItem alloc] initWithTitle:@"Minimize"
+                                         action:@selector(performMiniaturize:)
+                                  keyEquivalent:@"m"];
+   [windowMenu addItem:menuItem];
+   [menuItem release];
+
+   /* Put menu into the menubar */
+   windowMenuItem = [[NSMenuItem alloc] initWithTitle:@"Window" action:nil
+                                        keyEquivalent:@""];
+   [windowMenuItem setSubmenu:windowMenu];
+   [[NSApp mainMenu] addItem:windowMenuItem];
+
+   /* Tell the application object that this is now the window menu */
+   [NSApp setWindowsMenu:windowMenu];
+
+   /* Finally give up our references to the objects */
+   [windowMenu release];
+   [windowMenuItem release];
+}
+
+void ray_osx_init() {
+   if (ray_pool)
+      return;
+
+   ray_pool = [[NSAutoreleasePool alloc] init];
+
+   [RayApplication sharedApplication];
+
+   [NSApp setMainMenu:[[[NSMenu alloc] init] autorelease]];
+   ray_osx_setup_application_menu();
+   ray_osx_setup_window_menu();
+
+   CPSProcessSerNum psn;
+
+   CPSGetCurrentProcess(&psn);
+   NSString *nameNSString = ray_osx_appname();
+   const char *nameString = [nameNSString UTF8String];
+   CPSSetProcessName(&psn, nameString);
+
+   CPSEnableForegroundOperation(&psn, 0x03, 0x3C, 0x2C, 0x1103);
+   CPSSetFrontProcess(&psn);   
+
+   [NSApp finishLaunching];
+   [NSApp updateWindows];
+   [NSApp activateIgnoringOtherApps:true];
+}
+
+void ray_osx_close() {
+   [ray_pool drain];
+   ray_pool = nil;
+}

data/ext/rect.c

@@ -26,6 +26,21 @@ ray_rect ray_rb2rect(VALUE obj) {
    return *rect;
 }
 
+ray_rect ray_convert_to_rect(VALUE obj) {
+   if (RAY_IS_A(obj, ray_cRect))
+      return ray_rb2rect(obj);
+   else if (RAY_IS_A(obj, rb_cArray))
+      return ray_rb2rect(rb_apply(ray_cRect, RAY_METH("new"), obj));
+   else {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Rect",
+               RAY_OBJ_CLASSNAME(obj));
+   }
+
+   /* Should never happen */
+   ray_rect empty_rect = {0, 0, 0, 0};
+   return empty_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);
@@ -138,7 +153,10 @@ VALUE ray_rect_h(VALUE self) {
    return INT2FIX(rect->h);
 }
 
-/* Sets the position of the rect */
+/*
+  @overload x=(val)
+    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);
@@ -148,7 +166,10 @@ VALUE ray_rect_set_x(VALUE self, VALUE val) {
    return val;
 }
 
-/* Sets the position of the rect */
+/*
+  @overload y=(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);
@@ -158,7 +179,10 @@ VALUE ray_rect_set_y(VALUE self, VALUE val) {
    return val;
 }
 
-/* Sets the size of the rect */
+/*
+  @overload w=(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);
@@ -168,7 +192,10 @@ VALUE ray_rect_set_w(VALUE self, VALUE val) {
    return val;
 }
 
-/* Sets the size of the rect */
+/*
+  @overload h=(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);

data/lib/ray/audio.rb

@@ -0,0 +1,52 @@
+module Ray
+  # Represents an audio channel, where sounds are played.
+  class Channel
+    # Creates a channel.
+    # @param [Integer] id Identifer of the channel.
+    def initialize(id)
+      @id = id
+    end
+
+    # Plays a sound on the channel.
+    # @param [Ray::Sound] sound The sound to be played
+    # @param [Integer, :forever] times How many times the sound should be played.
+    def play(sound, times = 1)
+      sound.play(@id, times)
+    end
+
+    # Stops playing on the channel, without being able to resume.
+    def stop
+      Ray::Audio.stop(@id)
+    end
+
+    # Pauses the channel.
+    def pause
+      Ray::Audio.pause(@id)
+    end
+
+    # Resumes from pause.
+    def resume
+      Ray::Audio.resume(@id)
+    end
+
+    # @return [true, false] True if the channel is paused.
+    def paused?
+      Ray::Audio.paused?(@id)
+    end
+
+    # @return [true, false] True if a sound is being played.
+    def playing?
+      Ray::Audio.playing?(@id)
+    end
+  end
+
+  class Sound
+    extend Ray::ResourceSet
+    add_set(/^(.*)$/) { |filename| new(filename) }
+  end
+
+  class Music
+    extend Ray::ResourceSet
+    add_set(/^(.*)$/) { |filename| new(filename) }
+  end
+end

data/lib/ray/color.rb

@@ -17,6 +17,15 @@ module Ray
       "RGBA(#{r}, #{g}, #{b}, #{a})"
     end
 
+    def ==(obj)
+      return false unless obj.is_a? Color
+      r == obj.r && g == obj.g && b == obj.b && a == obj.a
+    end
+
+    def to_color
+      self
+    end
+
     alias :red :r
     alias :green :g
     alias :blue :b
@@ -28,3 +37,10 @@ module Ray
     alias :alpha= :a=
   end
 end
+
+class Array
+  # Converts an Array to a color
+  def to_color
+    Ray::Color.new(*self)
+  end
+end

data/lib/ray/dsl.rb

@@ -5,15 +5,13 @@ module Ray
   module DSL; end
 end
 
-require 'ray/dsl/type'
 require 'ray/dsl/matcher'
-require 'ray/dsl/converter'
 
 require 'ray/dsl/event'
 require 'ray/dsl/handler'
 require 'ray/dsl/event_runner'
 
-require 'ray/dsl/listener'
+require 'ray/dsl/event_listener'
 require 'ray/dsl/event_raiser'
 
 require 'ray/dsl/event_translator'

data/lib/ray/dsl/event.rb

@@ -1,52 +1,14 @@
 module Ray
   module DSL
-    # The events you can raise and listen to are instances of this class.
-    # You should not manipulate them directly. In fact, they are created
-    # and handled by the event runner, which happens to be greedy, and
-    # therefore won't give an event to you. It will only give you its
-    # arguments (you already know its type anyway.)
+    # Used internally to store event when raise_event is caled.
     class Event
-      @@descriptions = {}
-
-      def self.add_description(name, types)
-        @@descriptions[name] = types
-      end
-
-      def self.description_of(name)
-        @@descriptions[name]
-      end
-
       def initialize(type, args)
         @type = type
         @args = args
-
-        if desc = @@descriptions[@type]
-          desc.each_with_index do |type, i|
-            begin
-              @args[i] = Ray.convert(@args[i], type)
-            rescue TypeError
-              return
-            end
-          end
-        end
       end
 
       attr_reader :type
       attr_reader :args
     end
   end
-
-  # This method decribes an event, which means Ray will be able to understand
-  # that, when you say "image.png", you actually meant Ray::Image.new("image.png").
-  #
-  # If Ray can't convert your arguments, it will just let you continue that way.
-  def self.describe_event(name, *types)
-    DSL::Event.add_description(name, types.map { |i| Ray.resolve_type(i) })
-  end
-
-  # @return [Array<Module>] The types of the arguments for a given event, in the
-  #                         right order.
-  def self.description_for_event(name)
-    DSL::Event.description_of(name)
-  end
 end

data/lib/ray/dsl/event_listener.rb

@@ -0,0 +1,38 @@
+module Ray
+  module DSL
+    # The module that allows you to do something when something else happened.
+    module EventListener
+      # Registers a block to listen to an event.
+      #
+      # Arguments are compared with the ones of the regex using === and,
+      # if it failed, ==.
+      #
+      # @param [Symbol] event Name of the event to listen to
+      # @param [DSL::Matcher, Regexp, Object] args List of arguments that should
+      #                                            match the event's (if empty,
+      #                                            the block will be called anyway)
+      def on(event, *args, &block)
+        return unless listener_runner
+        listener_runner.add_handler(event, args, block)
+      end
+
+      # @overload add_hook(event, ..., callable)
+      #   Same as on, but the last argument is an object which responds to
+      #   to_proc.
+      #
+      #   @example
+      #     add_hook :quit, method(:exit!)
+      def add_hook(event, *args)
+        on(event, *args[0...-1], &args.last)
+      end
+
+      def listener_runner
+        @__listener_runner
+      end
+
+      def listener_runner=(arg)
+        @__listener_runner = arg
+      end
+    end
+  end
+end

data/lib/ray/dsl/event_runner.rb

@@ -1,9 +1,11 @@
+require 'thread'
+
 module Ray
   module DSL
     # This class is the one that dispatches events in your program, the one that
     # makes everything work. You may want to create one by yourself if you don't
     # want to use the other classes that use it. You just have to call run every
-    # time you need the events to be said.
+    # time you need the events to be processed.
     class EventRunner
       def initialize
         @handlers    = []

data/lib/ray/dsl/event_translator.rb

@@ -1,36 +1,102 @@
 module Ray
   module DSL
     # Module charged to translate an instance of Ray::Event into the arguments
-    # you pass to raise_event.
+    # you pass to raise_event. It is for instance used in Ray::Scene.
+    #
+    # == Raised events
+    # 1. quit
+    # 2. focus_gain(focus_type)
+    # 3. mouse_motion(rect), where [rect.x, rect.y] is where the user clicked.
+    # 4. mouse_press(button, rect)
+    # 5. mouse_release(button, rect)
+    # 6. key_press(key, mod_keys)
+    # 7. key_release(key, mod_keys)
+    # 8. window_resize(rect), where [rect.w, rect.h] is the size of the window.
+    # 9. joy_motion(joystick_id, axis_id, axis_value)
+    # 10. joy_press(joystick_id, button_id)
+    # 11. joy_release(joystick_id, button_id)
     module EventTranslator
-      FOCUS_TYPE = {
+      FOCUS_TYPES = {
         Ray::Event::APPMOUSEFOCUS => :mouse_focus,
         Ray::Event::APPINPUTFOCUS => :input_focus,
         Ray::Event::APPACTIVE     => :app_activity
       }
 
+      MOUSE_BUTTONS = {
+        Ray::Event::BUTTON_LEFT      => :left,
+        Ray::Event::BUTTON_MIDDLE    => :middle,
+        Ray::Event::BUTTON_RIGHT     => :right,
+        Ray::Event::BUTTON_WHEELUP   => :wheel_up,
+        Ray::Event::BUTTON_WHEELDOWN => :wheel_down
+      }
+
       class << self
-        # @return [Array, nil] The arguments you should pass to raise_event.
+        # @return [Array] The arguments you should pass to raise_event.
         def translate_event(ev)
           case ev.type
-          when 0 then nil
+          when Ray::Event::TYPE_NOEVENT then []
           when Ray::Event::TYPE_QUIT then quit(ev)
           when Ray::Event::TYPE_ACTIVEEVENT then active_event(ev)
           when Ray::Event::TYPE_MOUSEMOTION then mouse_motion(ev)
-          else nil
+          when Ray::Event::TYPE_MOUSEBUTTONDOWN then mouse_press(ev)
+          when Ray::Event::TYPE_MOUSEBUTTONUP then mouse_release(ev)
+          when Ray::Event::TYPE_KEYDOWN then key_press(ev)
+          when Ray::Event::TYPE_KEYUP then key_release(ev)
+          when Ray::Event::TYPE_VIDEORESIZE then resize(ev)
+          when Ray::Event::TYPE_JOYAXISMOTION then joy_motion(ev)
+          when Ray::Event::TYPE_JOYBUTTONDOWN then joy_press(ev)
+          when Ray::Event::TYPE_JOYBUTTONUP then joy_release(ev)
+          else []
           end
         end
 
         def quit(ev)
-          [:quit]
+          [[:quit]]
         end
 
         def active_event(ev)
-          [ev.is_gain? ? :focus_gain : :focus_loss, FOCUS_TYPE[ev.focus_state]]
+          [[ev.is_gain? ? :focus_gain : :focus_loss,
+            FOCUS_TYPES[ev.focus_state]]]
         end
 
         def mouse_motion(ev)
-          [:mouse_motion, Ray::Rect.new(ev.mouse_x, ev.mouse_y)]
+          [[:mouse_motion, Ray::Rect.new(ev.mouse_x, ev.mouse_y)]]
+        end
+
+        def mouse_press(ev)
+          [[:mouse_press,
+            MOUSE_BUTTONS[ev.mouse_button],
+            Ray::Rect.new(ev.mouse_x, ev.mouse_y)]]
+        end
+
+        def mouse_release(ev)
+          [[:mouse_release,
+            MOUSE_BUTTONS[ev.mouse_button],
+            Ray::Rect.new(ev.mouse_x, ev.mouse_y)]]
+        end
+
+        def key_press(ev)
+          [[:key_press, ev.key, ev.mod_keys]]
+        end
+
+        def key_release(ev)
+          [[:key_release, ev.key, ev.mod_keys]]
+        end
+
+        def resize(ev)
+          [[:window_resize, Ray::Rect.new(0, 0, ev.window_w, ev.window_h)]]
+        end
+
+        def joy_motion(ev)
+          [[:joy_motion, ev.joystick_id, ev.axis_id, ev.axis_value]]
+        end
+
+        def joy_press(ev)
+          [[:joy_press, ev.joystick_id, ev.joystick_button]]
+        end
+
+        def joy_release(ev)
+          [[:joy_release, ev.joystick_id, ev.joystick_button]]
         end
       end
     end