ray 0.1.1 → 0.2.0

data/ext/text.c

@@ -17,13 +17,19 @@ say_text *ray_rb2text(VALUE obj) {
 static
 VALUE ray_text_alloc(VALUE self) {
   say_text *text = say_text_create();
-  return Data_Wrap_Struct(self, NULL, say_text_free, text);
+  VALUE rb = Data_Wrap_Struct(self, NULL, say_text_free, text);
+
+  say_drawable_set_shader_proc(text->drawable, ray_drawable_shader_proc);
+  say_drawable_set_other_data(text->drawable, (void*)rb);
+
+  return rb;
 }
 
 static
 VALUE ray_text_init_copy(VALUE self, VALUE orig) {
   say_text_copy(ray_rb2text(self), ray_rb2text(orig));
   rb_iv_set(self, "@font", rb_iv_get(orig, "@font"));
+  ray_drawable_copy_attr(self, orig);
   return self;
 }
 
@@ -131,6 +137,39 @@ VALUE ray_text_rect(VALUE self) {
   return ray_rect2rb(say_text_get_rect(ray_rb2text(self)));
 }
 
+/*
+ * @return [Ray::Vector2, nil] Auto-centering ratio. Nil when disabled.
+ */
+static
+VALUE ray_text_auto_center(VALUE self) {
+  say_text *text = ray_rb2text(self);
+
+  if (say_text_auto_center(text))
+    return ray_vector2_to_rb(say_text_get_auto_center_ratio(text));
+  else
+    return Qnil;
+}
+
+/*
+ * @overload auto_center=(val)
+ *   Sets the auto centering ratio. It's a vector2 containing values between 0
+ *   and 1 (typically, at least) to determine the center of the text when it is
+ *   resized. (0.5, 1), for example, would set the origin to (middle, bottom).
+ *
+ *   @param [Ray::Vector2, nil] val New auto centering ratio. If nil, disables
+ *     auto-centering.
+ */
+static
+VALUE ray_text_set_auto_center(VALUE self, VALUE center) {
+  say_text *text = ray_rb2text(self);
+
+  if (NIL_P(center))
+    say_text_disable_auto_center(text);
+  else
+    say_text_enable_auto_center(text, ray_convert_to_vector2(center));
+
+  return center;
+}
 
 void Init_ray_text() {
   ray_cText = rb_define_class_under(ray_mRay, "Text", ray_cDrawable);
@@ -155,6 +194,9 @@ void Init_ray_text() {
 
   rb_define_method(ray_cText, "rect", ray_text_rect, 0);
 
+  rb_define_method(ray_cText, "auto_center", ray_text_auto_center, 0);
+  rb_define_method(ray_cText, "auto_center=", ray_text_set_auto_center, 1);
+
   rb_define_const(ray_cText, "Normal", INT2FIX(SAY_TEXT_NORMAL));
   rb_define_const(ray_cText, "Bold", INT2FIX(SAY_TEXT_BOLD));
   rb_define_const(ray_cText, "Italic", INT2FIX(SAY_TEXT_ITALIC));

data/ext/view.c

@@ -63,11 +63,19 @@ VALUE ray_view_init_copy(VALUE self, VALUE orig) {
   return self;
 }
 
+/*
+ * @see view=
+ */
 static
 VALUE ray_view_size(VALUE self) {
   return ray_vector2_to_rb(say_view_get_size(ray_rb2view(self)));
 }
 
+/*
+ * @overload size=(val)
+ *   Sets the size of the visible world
+ *   @param [Ray::Vector2] val
+ */
 static
 VALUE ray_view_set_size(VALUE self, VALUE val) {
   rb_check_frozen(self);
@@ -75,11 +83,19 @@ VALUE ray_view_set_size(VALUE self, VALUE val) {
   return val;
 }
 
+/*
+ * @see center=
+ */
 static
 VALUE ray_view_center(VALUE self) {
   return ray_vector2_to_rb(say_view_get_center(ray_rb2view(self)));
 }
 
+/*
+ * @overload center=(center)
+ *   Sets the center of the world
+ *   @param [Ray::Vector2] center
+ */
 static
 VALUE ray_view_set_center(VALUE self, VALUE val) {
   rb_check_frozen(self);
@@ -87,11 +103,23 @@ VALUE ray_view_set_center(VALUE self, VALUE val) {
   return val;
 }
 
+/*
+ * @see viewport=
+ */
 static
 VALUE ray_view_viewport(VALUE self) {
   return ray_rect2rb(say_view_get_viewport(ray_rb2view(self)));
 }
 
+/*
+ * @overload viewport=(rect)
+ *   Sets the region of the world where rendering will be done
+ *
+ *   All the components of the rects are values between 0 and 1, allowing to use
+ *   the same rect for two targets of different size
+ *
+ *   @param [Ray::Rect] rect
+ */
 static
 VALUE ray_view_set_viewport(VALUE self, VALUE val) {
   rb_check_frozen(self);
@@ -99,18 +127,42 @@ VALUE ray_view_set_viewport(VALUE self, VALUE val) {
   return val;
 }
 
+/*
+ * @see matrix=
+ */
 static
 VALUE ray_view_matrix(VALUE self) {
   return ray_matrix2rb(say_view_get_matrix(ray_rb2view(self)));
 }
 
+/*
+ * @overload matrix=(mat)
+ *   Sets the projection matrix
+ *
+ *   Setting the projection matrix causes the center and the size of the view to
+ *   be ignored. Passing nil would cancel this.
+ *
+ *   @param [Ray::Matrix, nil] mat New matrix
+ */
 static
 VALUE ray_view_set_matrix(VALUE self, VALUE val) {
   rb_check_frozen(self);
-  say_view_set_matrix(ray_rb2view(self), ray_rb2matrix(val));
+
+  if (NIL_P(val))
+    say_view_set_matrix(ray_rb2view(self), NULL);
+  else
+    say_view_set_matrix(ray_rb2view(self), ray_rb2matrix(val));
+
   return val;
 }
 
+/*
+ * Document-class: Ray::View
+ *
+ * A view is a way to apply some transformations to all the drawables at once,
+ * by defining a projection. It also determines the region of the screen where
+ * the view will draw.
+ */
 void Init_ray_view() {
   ray_cView = rb_define_class_under(ray_mRay, "View", rb_cObject);
   rb_define_alloc_func(ray_cView, ray_view_alloc);

data/ext/window.c

@@ -52,6 +52,10 @@ VALUE ray_window_open(int argc, VALUE *argv, VALUE self) {
 
   say_vector2 c_size = ray_convert_to_vector2(size);
 
+#ifdef SAY_OSX
+  say_osx_flip_pool();
+#endif
+
   if (!say_window_open(window, c_size.x, c_size.y,
                        StringValuePtr(title), flags)) {
     rb_raise(rb_eRuntimeError, "%s", say_error_get_last());

data/lib/ray/animation_list.rb

@@ -10,6 +10,7 @@ module Ray
   #
   class AnimationList
     include Enumerable
+    include Ray::PP
 
     def initialize
       @animations = []
@@ -26,10 +27,15 @@ module Ray
       self
     end
 
-    # Updates all the animations, and removes those that are finished.
+    # Updates all the animations
     def update
+      @animations.each(&:update)
+      self
+    end
+
+    # Removes animations that are no more in use
+    def remove_unused
       @animations.reject! do |anim|
-        anim.update
         !anim.running? && !anim.paused?
       end
 
@@ -43,8 +49,17 @@ module Ray
       self
     end
 
+    # @return [Array<Ray::Animation>]
+    attr_reader :animations
+
+    alias to_a animations
+
     def inspect
       "#{self.class}#{@animations.inspect}"
     end
+
+    def pretty_print(q)
+      pretty_print_attributes q, ["animations"]
+    end
   end
 end

data/lib/ray/audio_source.rb

@@ -0,0 +1,11 @@
+module Ray
+  class AudioSource
+    include Ray::PP
+
+    def pretty_print(q, other_attr = [])
+      attr = ["pos", "relative?", "min_distance", "attenuation",
+              "pitch", "status", "volume"]
+      pretty_print_attributes q, attr + other_attr
+    end
+  end
+end

data/lib/ray/color.rb

@@ -49,6 +49,20 @@ module Ray
       "RGBA(#{r}, #{g}, #{b}, #{a})"
     end
 
+    def pretty_print(q)
+      q.text("RGB#{'A' if a != 255}(")
+      q.pp r
+      q.text ", "
+      q.pp g
+      q.text ", "
+      q.pp b
+      if a != 255
+        q.text ", "
+        q.pp a
+      end
+      q.text ")"
+    end
+
     # @param [Ray::Color] color Another color.
     # @return [Ray::Color] Sum of two colors, adding component pairs.
     def +(color)

data/lib/ray/drawable.rb

@@ -1,5 +1,9 @@
 module Ray
   class Drawable
+    include Ray::PP
+
+    # @group Transformations
+
     def y
       pos.y
     end
@@ -32,6 +36,25 @@ module Ray
       self.scale = [scale_x, val]
     end
 
+    # @endgroup
+
+    def pretty_print(q, other_attributes = [])
+      # Note: This doesn't use %w[...] arrays because YARD can't parse them
+      attributes = [
+                    "origin", "pos", "z", "scale", "angle",
+                    "matrix", "matrix_proc",
+                    "shader", "shader_attributes",
+                    "vertex_count", "index_count", "changed?", "textured?",
+                    "blend_mode"
+                   ]
+
+      pretty_print_attributes q, attributes + other_attributes
+    end
+
+    # @return [Hash, nil] Attributes passed to the shader when the object is
+    #   drawn.
+    attr_accessor :shader_attributes
+
     alias zoom  scale
     alias zoom= scale=
 

data/lib/ray/dsl/event.rb

@@ -1,14 +1,6 @@
 module Ray
   module DSL
     # Used internally to store event when raise_event is called.
-    class Event
-      def initialize(type, args)
-        @type = type
-        @args = args
-      end
-
-      attr_reader :type
-      attr_reader :args
-    end
+    Event = Struct.new(:type, :args)
   end
 end

data/lib/ray/dsl/event_runner.rb

@@ -7,7 +7,6 @@ module Ray
     class EventRunner
       def initialize
         @handlers    = []
-        @event_list  = []
         @next_events = []
 
         @event_groups = Hash.new { |h, k| h[k] = true }
@@ -16,13 +15,13 @@ module Ray
 
       # Sends all the known events to our listeners.
       def run
-        @event_list  = @next_events
+        event_list   = @next_events
         @next_events = []
 
         handlers = @handlers.select { |o| group_enabled?(o.group) }
 
-        @event_list.each do |ev|
-          handlers.select { |o| o.call(ev) if o.match?(ev) }
+        event_list.each do |ev|
+          handlers.each { |o| o.call(ev) if o.match?(ev) }
         end
       end
 

data/lib/ray/dsl/matcher.rb

@@ -1,4 +1,9 @@
 module Ray
+  class NoKeyError < StandardError
+    def initialize(key)
+      super "key #{key} doesn't exist"
+    end
+  end
   # This is the module including all of your matchers as private methods,
   # allowing you to use them when you call on.
   module Matchers
@@ -177,8 +182,17 @@ module Ray
     end
   end
 
+  # A Key object can be used as a matcher to check if a key has been pressed or
+  # released:
+  #
+  #    on :key_press, Key.new(:+) do
+  #      # work
+  #    end
+  #
+  # @see KeyMod
   class Key
     def initialize(name)
+      raise NoKeyError, name unless Keys[name]
       @symbol = name.to_sym
     end
 
@@ -199,13 +213,18 @@ module Ray
     end
   end
 
+  # A KeyMod object can be used as a matcher to check if some modifiers are held
+  # when a key is pressed.
+  #
+  # @see KeyMod
   class KeyMod
     def initialize(name)
+      raise NoKeyError, name unless Mod[name]
       @symbol = name.to_sym
     end
 
     def to_a
-      MOD[@symbol]
+      Mod[@symbol]
     end
 
     def to_sym

data/lib/ray/effect.rb

@@ -0,0 +1,116 @@
+module Ray
+  # Effects are used to generate fragment shaders automatically. They represent
+  # one of the transformations applied to the color.
+  #
+  # Effects must generate a structure to store arguments passed to the effect
+  # (structure generation being done through a DSL), and a function to apply the
+  # effect (a call to the #code method returns )
+  class Effect
+    # @overload effect_name(name)
+    #   Sets the name of the effect
+    #   @param [String] value
+    #
+    # @overload effect_name
+    #   @return [String] Name of the effect
+    def self.effect_name(value = nil)
+      if value
+        @name = value
+
+        klass = self
+        Ray::Helper.send :define_method, @name do |*args|
+          klass.new(*args)
+        end
+      else
+        @name
+      end
+    end
+
+    # Adds an attribute to the shader. It is an element of the struct
+    #
+    # @param [String] name Name of the attribute
+    # @param [String] type Type of the attribute. Arrays are written using this
+    #  notation: type[count].
+    def self.attribute(name, type)
+      attributes[name] = type
+    end
+
+    # @return [Hash] All the attributes of the struct, matched with their type.
+    def self.attributes
+      @attributes ||= {}
+    end
+
+    # @return [String] Name of the effect
+    def name
+      self.class.effect_name
+    end
+
+    # @return [String] GLSL code of the struct.
+    def struct
+      str =  "struct ray_#{self.class.effect_name} {\n"
+      str << "  bool enabled;\n"
+
+      self.class.attributes.each do |name, type|
+        if type =~ /\A(\w+)\[(\d+)\]\z/
+          str << "  #$1 #{name}[#$2];\n"
+        else
+          str << "  #{type} #{name};\n"
+        end
+      end
+
+      str << "};\n"
+    end
+
+    # @abstract
+    #
+    # @return [String] Code that must be written *before* the definiton of the
+    #   structure. Just returns an empty string by default.
+    def header
+      ""
+    end
+
+    # @abstract
+    #
+    # @return [String]
+    #   Code of the function. This must contain the header of the function.
+    #   The name of the function is the name of the effect prepended by
+    #   "do_". It is passed a ray_#{effect_name} structure and the color, and is
+    #   expected to return the changed color.
+    #
+    # @example
+    #   def code
+    #     return %{
+    #       vec4 do_some_effect(ray_some_effect arg, vec4 color) {
+    #         /* Do magic here. */
+    #       }
+    #     }
+    #   end
+    def code
+      raise NotImplementedError
+    end
+
+    # @abstract
+    #
+    # @return [Hash] Default value for each attribute.
+    def defaults
+      {}
+    end
+
+    # Apply the defaults to a shader.
+    # @param [Ray::Shader] shader
+    def apply_defaults(shader)
+      effect_name = self.class.effect_name
+
+      shader["#{effect_name}.enabled"] = true
+
+      defaults.each do |name, value|
+        shader["#{effect_name}.#{name}"] = value
+      end
+    end
+  end
+end
+
+require 'ray/effect/generator'
+
+require 'ray/effect/grayscale'
+require 'ray/effect/color_inversion'
+require 'ray/effect/black_and_white'