ray 0.1.0.pre1 → 0.1.0

data/ext/vertex.c

@@ -0,0 +1,96 @@
+#include "ray.h"
+
+VALUE ray_cVertex = Qnil;
+
+say_vertex *ray_rb2vertex(VALUE obj) {
+  if (!rb_obj_is_kind_of(obj, rb_path2class("Ray::Vertex"))) {
+    rb_raise(rb_eTypeError, "can't convert %s into Ray::Vertex",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_vertex *ptr = NULL;
+  Data_Get_Struct(obj, say_vertex, ptr);
+
+  return ptr;
+}
+
+static
+VALUE ray_vertex_alloc(VALUE self) {
+  say_vertex *vertex = malloc(sizeof(say_vertex));
+  return Data_Wrap_Struct(self, NULL, free, vertex);
+}
+
+/*
+  @overload initialize(pos = [0, 0], color = Color.white, tex = [0, 0])
+    @param [Ray::Vector2] pos Position of the vertex
+    @param [Ray::Color] color Color of the vertex
+    @param [Ray::Vector2] tex Texture position of the vertex
+*/
+static
+VALUE ray_vertex_init(int argc, VALUE *argv, VALUE self) {
+  say_vertex *vertex = ray_rb2vertex(self);
+
+  VALUE pos, col, tex;
+  rb_scan_args(argc, argv, "03", &pos, &col, &tex);
+
+  vertex->pos = NIL_P(pos) ? say_make_vector2(0, 0) : ray_convert_to_vector2(pos);
+  vertex->col = NIL_P(col) ? say_make_color(255, 255, 255, 255) : ray_rb2col(col);
+  vertex->tex = NIL_P(tex) ? say_make_vector2(0, 0) : ray_convert_to_vector2(tex);
+
+  return self;
+}
+
+/* @return [Ray::Vector2] Position of the vertex */
+static
+VALUE ray_vertex_pos(VALUE self) {
+  return ray_vector2_to_rb(ray_rb2vertex(self)->pos);
+}
+
+static
+VALUE ray_vertex_set_pos(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+  ray_rb2vertex(self)->pos = ray_convert_to_vector2(val);
+  return val;
+}
+
+/* @return [Ray::Vector2] Texture position of the vertex */
+static
+VALUE ray_vertex_tex(VALUE self) {
+  return ray_vector2_to_rb(ray_rb2vertex(self)->tex);
+}
+
+static
+VALUE ray_vertex_set_tex(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+  ray_rb2vertex(self)->tex = ray_convert_to_vector2(val);
+  return val;
+}
+
+/* @return [Ray::Color] Color of the vertex */
+static
+VALUE ray_vertex_col(VALUE self) {
+  return ray_col2rb(ray_rb2vertex(self)->col);
+}
+
+static
+VALUE ray_vertex_set_col(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+  ray_rb2vertex(self)->col = ray_rb2col(val);
+  return val;
+}
+
+void Init_ray_vertex() {
+  ray_cVertex = rb_define_class_under(ray_mRay, "Vertex", rb_cObject);
+  rb_define_alloc_func(ray_cVertex, ray_vertex_alloc);
+  rb_define_method(ray_cVertex, "initialize", ray_vertex_init, -1);
+
+  rb_define_method(ray_cVertex, "pos", ray_vertex_pos, 0);
+  rb_define_method(ray_cVertex, "tex", ray_vertex_tex, 0);
+  rb_define_method(ray_cVertex, "col", ray_vertex_col, 0);
+
+  rb_define_method(ray_cVertex, "pos=", ray_vertex_set_pos, 1);
+  rb_define_method(ray_cVertex, "tex=", ray_vertex_set_tex, 1);
+  rb_define_method(ray_cVertex, "col=", ray_vertex_set_col, 1);
+
+  rb_iv_set(ray_cVertex, "@vertex_type_size", INT2FIX(sizeof(say_vertex)));
+}

data/ext/view.c

@@ -0,0 +1,131 @@
+#include "ray.h"
+
+VALUE ray_cView = Qnil;
+
+VALUE ray_view2rb(say_view *view) {
+  say_view *cpy = say_view_create();
+  say_view_copy(cpy, view);
+  return Data_Wrap_Struct(rb_path2class("Ray::View"), NULL, say_view_free, cpy);
+}
+
+say_view *ray_rb2view(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::View"))) {
+    rb_raise(rb_eTypeError, "can't convert %s into Ray::View",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_view *view = NULL;
+  Data_Get_Struct(obj, say_view, view);
+
+  return view;
+}
+
+static
+VALUE ray_view_alloc(VALUE self) {
+  say_view *view = say_view_create();
+  return Data_Wrap_Struct(self, NULL, say_view_free, view);
+}
+
+/*
+  @overload initialize(center, size, viewport = [0, 0, 1, 1])
+    @param [Ray::Vector2] center Center of the view
+    @param [Ray::Vector2] size Size of the view
+
+    @param [Ray::Rect] rect The rect this view occupies. It
+  @overload initialize(matrix)
+    @param [Ray::Matrix] matrix Model view matrix
+*/
+static
+VALUE ray_view_init(int argc, VALUE *argv, VALUE self) {
+  say_view *view = ray_rb2view(self);
+
+  if (argc == 1) {
+    say_view_set_matrix(view, ray_rb2matrix(argv[0]));
+  }
+  else {
+    VALUE center, size, viewport = Qnil;
+    rb_scan_args(argc, argv, "21", &center, &size, &viewport);
+
+    say_view_set_center(view, ray_convert_to_vector2(center));
+    say_view_set_size(view, ray_convert_to_vector2(size));
+
+    if (!NIL_P(viewport)) {
+      say_view_set_viewport(view, ray_convert_to_rect(viewport));
+    }
+  }
+
+  return self;
+}
+
+static
+VALUE ray_view_init_copy(VALUE self, VALUE orig) {
+  say_view_copy(ray_rb2view(self), ray_rb2view(orig));
+  return self;
+}
+
+static
+VALUE ray_view_size(VALUE self) {
+  return ray_vector2_to_rb(say_view_get_size(ray_rb2view(self)));
+}
+
+static
+VALUE ray_view_set_size(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+  say_view_set_size(ray_rb2view(self), ray_convert_to_vector2(val));
+  return val;
+}
+
+static
+VALUE ray_view_center(VALUE self) {
+  return ray_vector2_to_rb(say_view_get_center(ray_rb2view(self)));
+}
+
+static
+VALUE ray_view_set_center(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+  say_view_set_center(ray_rb2view(self), ray_convert_to_vector2(val));
+  return val;
+}
+
+static
+VALUE ray_view_viewport(VALUE self) {
+  return ray_rect2rb(say_view_get_viewport(ray_rb2view(self)));
+}
+
+static
+VALUE ray_view_set_viewport(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+  say_view_set_viewport(ray_rb2view(self), ray_convert_to_rect(val));
+  return val;
+}
+
+static
+VALUE ray_view_matrix(VALUE self) {
+  return ray_matrix2rb(say_view_get_matrix(ray_rb2view(self)));
+}
+
+static
+VALUE ray_view_set_matrix(VALUE self, VALUE val) {
+  rb_check_frozen(self);
+  say_view_set_matrix(ray_rb2view(self), ray_rb2matrix(val));
+  return val;
+}
+
+void Init_ray_view() {
+  ray_cView = rb_define_class_under(ray_mRay, "View", rb_cObject);
+  rb_define_alloc_func(ray_cView, ray_view_alloc);
+  rb_define_method(ray_cView, "initialize", ray_view_init, -1);
+  rb_define_method(ray_cView, "initialize_copy", ray_view_init_copy, 1);
+
+  rb_define_method(ray_cView, "size", ray_view_size, 0);
+  rb_define_method(ray_cView, "size=", ray_view_set_size, 1);
+
+  rb_define_method(ray_cView, "center", ray_view_center, 0);
+  rb_define_method(ray_cView, "center=", ray_view_set_center, 1);
+
+  rb_define_method(ray_cView, "viewport", ray_view_viewport, 0);
+  rb_define_method(ray_cView, "viewport=", ray_view_set_viewport, 1);
+
+  rb_define_method(ray_cView, "matrix", ray_view_matrix, 0);
+  rb_define_method(ray_cView, "matrix=", ray_view_set_matrix, 1);
+}

data/ext/window.c

@@ -0,0 +1,183 @@
+#include "ray.h"
+
+VALUE ray_cWindow = Qnil;
+
+say_window *ray_rb2window(VALUE obj) {
+  if (!RAY_IS_A(obj, rb_path2class("Ray::Window"))) {
+    rb_raise(rb_eTypeError, "Can't convert %s into Ray::Window",
+             RAY_OBJ_CLASSNAME(obj));
+  }
+
+  say_window *win;
+  Data_Get_Struct(obj, say_window, win);
+
+  return win;
+}
+
+static
+VALUE ray_window_alloc(VALUE self) {
+  say_window *obj = say_window_create();
+  return Data_Wrap_Struct(self, NULL, say_window_free, obj);
+}
+
+/*
+  @overload open(size, opts = {})
+    @param [Ray::Vector2] size Size of the window
+
+    @option opts [true, false] :resizable (false) whether the window can be
+      resized.
+    @option opts [true, false] :no_frame (false) whether the window should be
+      decorated.
+    @option opts [true, false] :fullscreen (false) whether the window should be
+      fullscreen.
+*/
+static
+VALUE ray_window_open(int argc, VALUE *argv, VALUE self) {
+  VALUE title = Qnil, size = Qnil, opts = Qnil;
+  rb_scan_args(argc, argv, "21", &title, &size, &opts);
+
+  say_window *window = ray_rb2window(self);
+
+  uint8_t flags = 0;
+  if (!NIL_P(opts)) {
+    if (RTEST(rb_hash_aref(opts, RAY_SYM("resizable"))))
+      flags |= SAY_WINDOW_RESIZABLE;
+
+    if (RTEST(rb_hash_aref(opts, RAY_SYM("no_frame"))))
+      flags |= SAY_WINDOW_NO_FRAME;
+
+    if (RTEST(rb_hash_aref(opts, RAY_SYM("fullscreen"))))
+      flags |= SAY_WINDOW_FULLSCREEN;
+  }
+
+  say_vector2 c_size = ray_convert_to_vector2(size);
+
+  if (!say_window_open(window, c_size.x, c_size.y,
+                       StringValuePtr(title), flags)) {
+    rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  return self;
+}
+
+/* Closes the window */
+static
+VALUE ray_window_close(VALUE self) {
+  say_window_close(ray_rb2window(self));
+  return self;
+}
+
+/*
+  @overload icon=(icon)
+    Sets the icon used by the window
+    @param [Ray::Image] icon Icon to use
+*/
+static
+VALUE ray_window_set_icon(VALUE self, VALUE icon) {
+  if (!say_window_set_icon(ray_rb2window(self), ray_rb2image(icon))) {
+    rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  return icon;
+}
+
+/*
+  @overload title=(title)
+    Sets the title of the window
+    @param [String] title
+ */
+static
+VALUE ray_window_set_title(VALUE self, VALUE title) {
+  say_window_set_title(ray_rb2window(self), StringValuePtr(title));
+  return title;
+}
+
+/*
+  @overload resize(size)
+    Resizes the window
+    @param [Ray::Vector2] size New window size
+*/
+static
+VALUE ray_window_resize(VALUE self, VALUE size) {
+  say_vector2 c_size = ray_convert_to_vector2(size);
+  if (!say_window_resize(ray_rb2window(self), c_size.x, c_size.y)) {
+    rb_raise(rb_eRuntimeError, "%s", say_error_get_last());
+  }
+
+  return size;
+}
+
+/*
+  Updates the content of the window. Must be updated at the end of each frame.
+*/
+static
+VALUE ray_window_update(VALUE self) {
+  say_window_update(ray_rb2window(self));
+  return self;
+}
+
+/* Shows the window cursor */
+static
+VALUE ray_window_show_cursor(VALUE self) {
+  say_window_show_cursor(ray_rb2window(self));
+  return self;
+}
+
+/* Hides the window cursor */
+static
+VALUE ray_window_hide_cursor(VALUE self) {
+  say_window_hide_cursor(ray_rb2window(self));
+  return self;
+}
+
+/*
+  @overload poll_event(ev)
+    Gets the next event from the event queue. If there's none, return directly.
+    @param [Ray::Event] ev Event object to store the result into.
+*/
+static
+VALUE ray_window_poll_event(VALUE self, VALUE ev) {
+  say_window_poll_event(ray_rb2window(self), ray_rb2event(ev));
+  return ev;
+}
+
+/*
+  @overload wait_event(ev)
+    Gets the next event from the event queue. If there's none, waits until
+    there's one. Returns directly if the window is closed.
+
+    @param [Ray::Event] ev Event object to store the result into.
+*/
+static
+VALUE ray_window_wait_event(VALUE self, VALUE ev) {
+  say_window_wait_event(ray_rb2window(self), ray_rb2event(ev));
+  return ev;
+}
+
+/* @return [Ray::Input] The input used by this object */
+static
+VALUE ray_window_input(VALUE self) {
+  return ray_input2rb(say_window_get_input(ray_rb2window(self)), self);
+}
+
+void Init_ray_window() {
+  ray_cWindow = rb_define_class_under(ray_mRay, "Window", ray_cTarget);
+  rb_define_alloc_func(ray_cWindow, ray_window_alloc);
+
+  rb_define_method(ray_cWindow, "open", ray_window_open, -1);
+  rb_define_method(ray_cWindow, "close", ray_window_close, 0);
+
+  rb_define_method(ray_cWindow, "update", ray_window_update, 0);
+
+  rb_define_method(ray_cWindow, "hide_cursor", ray_window_hide_cursor, 0);
+  rb_define_method(ray_cWindow, "show_cursor", ray_window_show_cursor, 0);
+
+  rb_define_method(ray_cWindow, "icon=", ray_window_set_icon, 1);
+  rb_define_method(ray_cWindow, "title=", ray_window_set_title, 1);
+  rb_define_method(ray_cWindow, "resize", ray_window_resize, 1);
+
+  rb_define_method(ray_cWindow, "poll_event", ray_window_poll_event, 1);
+  rb_define_method(ray_cWindow, "wait_event", ray_window_wait_event, 1);
+
+  rb_define_method(ray_cWindow, "input", ray_window_input, 0);
+}

data/lib/ray/animation.rb

@@ -0,0 +1,248 @@
+module Ray
+  # Animations are changes progressively applied to an object.
+  # This class should be subclassed by the actual animations.
+  #
+  # == Creating an animation object
+  # Subclasses create a helper method in Ray::Helper to create the
+  # animation:
+  #   translation(:from => [0, 0], :to => [120, 120], :duration => 30)
+  #   rotation(:from => 10, :to => 360, :duration => 2)
+  #
+  # Then, the animation isn't running yet. It is needed to call #start
+  # with the target of the animation:
+  #   @translation.start some_sprite
+  #
+  # You'd then need to call #update regularily to apply the changes.
+  # For instance, in a scene, you'd do:
+  #   always { @translation.update }
+  #
+  # (See also {AnimationList})
+  #
+  # Animations can be paused (#pause) and resumed (#resume) if needed.
+  #
+  # They also raise an :animation_end event you could use to call another event:
+  #   on :animation_end, @translation do
+  #     @rotation.start some_sprite
+  #   end
+  #
+  # == Creating a custom animation class
+  #   class MyOwnAnimation < Ray::Animation
+  #     # Creates the helper method
+  #     register_for :my_own_animation
+  #
+  #     # hash is the argument passed to the helper method.
+  #     # target is still nil.
+  #     def setup(hash)
+  #       @some_param = hash[:param]
+  #       self.duration = 10 # You *need* to set this
+  #     end
+  #
+  #     # the animation has just started, target is set.
+  #     def setup_target
+  #     end
+  #
+  #     # update has been called
+  #     def update_target
+  #       # progression is a float between 0 and 1.
+  #       target.x += @some_param * progression
+  #     end
+  #
+  #     # the animation has just ended.
+  #     def end_animation
+  #     end
+  #
+  #     # Not required. You can get an animation cancelling the first one
+  #     # using this in most animation classes.
+  #     def -@
+  #       my_own_animation(:param => -@some_param)
+  #     end
+  #   end
+  class Animation
+    include Ray::Helper
+
+    def self.register_for(name)
+      klass = self
+
+      Ray::Helper.send :define_method, name do |*args|
+        animation = klass.new
+        animation.event_runner = event_runner
+        animation.setup(*args)
+
+        animation
+      end
+    end
+
+    def initialize
+      @duration = 0
+
+      @start_time = nil
+      @pause_time = nil
+      @end_time   = nil
+
+      @running = false
+
+      @target = nil
+    end
+
+    # Starts the animation.
+    # @param [Object] on The target of the animation
+    # @return self
+    def start(on)
+      @target = on
+
+      @start_time = Time.now
+      @end_time   = @start_time + duration
+
+      @running = true
+
+      setup_target
+
+      self
+    end
+
+    # Override this in subclasses.
+    # Will be called by the helper method (when target is still nil).
+    def setup(*args)
+      raise NotImplementedError
+    end
+
+    # Method called when the animation is started.
+    # Override it if needed.
+    def setup_target
+    end
+
+    # Pauses the animation.
+    def pause
+      @pause_time = Time.now
+      @running    = false
+
+      pause_animation
+    end
+
+    # Resumes from the pause.
+    # The time when the animation should end is also updated.
+    def resume
+      return unless @pause_time
+
+      # Reset @start_time to compute the progression more easily.
+      @end_time   = Time.now + duration - (@pause_time - @start_time)
+      @start_time = @end_time - duration
+      @pause_time = nil
+
+      @running = true
+
+      resume_animation
+    end
+
+    # Updates the target if the animation is running.
+    # May also end the animation.
+    def update
+      if running?
+        update_target
+
+        if Time.now >= @end_time
+          @running  = false
+          @end_time = nil
+
+          end_animation
+          raise_event :animation_end, self if raiser_runner
+        end
+      end
+    end
+
+    # Registers an event making the animation repeat itself over and over
+    def loop!
+      on :animation_end, self do
+        start @target
+      end
+    end
+
+    # Registers an event making the animation bounce: when animation is
+    # completed, -animation is run on the same target, and when -animation is
+    # done running, animation starts again.
+    #
+    # @return [Ray::Animation] The reversed animation, which you need to update
+    #   as well.
+    def bounce!
+      reverse = -self
+      reverse.event_runner = event_runner
+
+      on :animation_end, self do
+        reverse.start @target
+      end
+
+      on :animation_end, reverse do
+        start @target
+      end
+
+      reverse
+    end
+
+    # Override this method to apply changes to the target.
+    def update_target
+      raise NotImplementedError
+    end
+
+    # Override this method to do something at the end of the animation.
+    def end_animation
+    end
+
+    # Override this if you need to do something when the animation is paused
+    # (for instance, paussing animations used by this object).
+    def pause_animation
+    end
+
+    # Override this if you need to do something when the animation is resumed
+    def resume_animation
+    end
+
+    # @return [Float, nil] The progression of the animation, between 0 and 1.
+    #   Nil if the animation isn't running.
+    def progression
+      if running?
+        if @duration.zero?
+          1.0
+        else
+          ret = (Time.now - @start_time) / duration
+          ret > 1 ? 1.0 : ret
+        end
+      end
+    end
+
+    # @return [Ray::Animation::Combination] Combination of self and the
+    #   argument.
+    def +(other)
+      animation_combination(self, other)
+    end
+
+    # @return [Ray::Animation::Combination] Combination of self and the oppsite
+    #  of the argument.
+    def -(other)
+      animation_combination(self, -other)
+    end
+
+    # @return [true, false] True if the animation is running
+    def running?; @running ; end
+
+    # @return [true, false] True if the animation is paused
+    def paused?; not @pause_time.nil?; end
+
+    # @return [Object] The target of the animation.
+    attr_reader :target
+
+    # @return [Float] Duration of the animation, in seconds.
+    attr_accessor :duration
+
+    # @return [Time] Time when the animation should end.
+    attr_reader :end_time
+  end
+end
+
+require 'ray/animation/block_animation'
+require 'ray/animation/float_variation'
+require 'ray/animation/vector_variation'
+require 'ray/animation/color_variation'
+require 'ray/animation/circular_motion'
+require 'ray/animation/combination'
+require 'ray/animation/sequence'
+require 'ray/animation/sprite_animation'