rays 0.1.12 → 0.1.17

data/lib/rays/color.rb

@@ -10,24 +10,19 @@ module Rays
   class Color
 
     include Comparable
+    include Enumerable
 
-    def self.color (*args)
-      c = case arg0 = args[0]
-      when Color                  then arg0
-      when Symbol                 then COLORS[arg0]
-      when /^\s*#[\da-fA-F]+\s*$/ then Color.new arg0
-      when String                 then COLORS[arg0.intern]
-      else                             Color.new *args
-      end
-      raise ArgumentError, "invalid argument '#{args}.'" unless c
-      c
-    end
+    alias r= red=
+    alias r  red
 
-    def initialize (*args)
-      arg0 = args[0]
-      args = parse arg0 if arg0 && arg0.kind_of?(String)
-      setup *args
-    end
+    alias g= green=
+    alias g  green
+
+    alias b= blue=
+    alias b  blue
+
+    alias a= alpha=
+    alias a  alpha
 
     def opaque? ()
       alpha >= 1
@@ -42,12 +37,16 @@ module Rays
       0 < a && a < 1
     end
 
+    def each (&block)
+      to_a.each &block
+    end
+
     def to_a ()
       [red, green, blue, alpha]
     end
 
     def to_s ()
-      to_a.map {|o| o.to_s}
+      to_a.to_s
     end
 
     def [] (index)
@@ -77,6 +76,10 @@ module Rays
             alpha <=> o.alpha
     end
 
+    def hash ()
+      red.hash + green.hash + blue.hash + alpha.hash
+    end
+
     def eql? (o)
       self == o
     end
@@ -85,36 +88,6 @@ module Rays
       "#<#{self.class.name} #{to_s}>"
     end
 
-    COLORS = {
-      black:   [0, 0, 0],
-      red:     [1, 0, 0],
-      green:   [0, 1, 0],
-      blue:    [0, 0, 1],
-      yellow:  [1, 1, 0],
-      cyan:    [0, 1, 1],
-      magenta: [1, 0, 1],
-      white:   [1, 1, 1],
-      gray:    [0.5, 0.5, 0.5],
-      no:      [0, 0],
-      none:    [0, 0],
-      nil:     [0, 0],
-    }.inject({}) {|h, (k, v)| h[k] = Color.new *v; h}
-
-    private
-
-      RE_RGBA     = /^\s*##{'([\da-fA-F]{1})' * 4}?\s*$/
-      RE_RRGGBBAA = /^\s*##{'([\da-fA-F]{2})' * 4}?\s*$/
-
-      def parse (str)
-        case str
-        when RE_RGBA
-          [$1, $2, $3, $4 || 'f' ].map {|s| s.to_i(16) / 15.0}
-        when RE_RRGGBBAA
-          [$1, $2, $3, $4 || 'ff'].map {|s| s.to_i(16) / 255.0}
-        else raise ArgumentError, "can not parse '#{str}'."
-        end
-      end
-
   end# Color
 
 

data/lib/rays/color_space.rb

@@ -9,25 +9,25 @@ module Rays
 
   class ColorSpace
 
-    def initialize (type = :RGBA, premultiplied = true)
-      setup self.class.get_type(type), premultiplied
+    include Comparable
+
+    def <=> (o)
+      type <=> o.type
+    end
+
+    def hash ()
+      type.hash
     end
 
-    def self.get_type (obj)
-      case obj
-      when Integer        then obj
-      when String, Symbol then const_get obj
-      else raise ArgumentError, "can not convert '#{obj}' to ColorSpace type."
-      end
-    rescue NameError
-      raise "ColoeSpace::#{obj} is not found."
+    def eql? (o)
+      self == o
     end
 
-    def self.get_color_space (obj)
-      (ColorSpace === obj) ? obj : (ColorSpace.new get_type(obj))
+    def inspect ()
+      "#<#{self.class.name} #{to_s}>"
     end
 
-  end# ColorSpace
+  end# Color
 
 
 end# Rays

data/lib/rays/image.rb

@@ -12,10 +12,10 @@ module Rays
 
     extend Forwardable
 
-    def_delegators :bitmap, :draw_string, :[], :[]=
+    def_delegators :bitmap, :[], :[]=
 
     def paint (&block)
-      painter.begin self, &block
+      painter.paint self, &block
       self
     end
 
@@ -24,11 +24,7 @@ module Rays
     end
 
     def bounds ()
-      Bounds.new 0, 0, *size
-    end
-
-    def self.load (path, alpha_only = false)
-      load_image path, alpha_only
+      Bounds.new 0, 0, width, height
     end
 
   end# Image

data/lib/rays/matrix.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/ext'
+
+
+module Rays
+
+
+  class Matrix
+
+    include Comparable
+    include Enumerable
+
+    def each (&block)
+      to_a.each &block
+    end
+
+    alias inspect_org inspect
+
+    def inspect ()
+      inspect_org.gsub(/\.?0+([^\.\d]|$)/) {$1}
+    end
+
+  end# Matrix
+
+
+end# Rays

data/lib/rays/module.rb

@@ -6,6 +6,8 @@ module Rays
 
   module Module
 
+    module_function
+
     def name ()
       super.split('::')[-2]
     end
@@ -15,10 +17,10 @@ module Rays
     end
 
     def root_dir (path = '')
-      File.expand_path "../../../#{path}", __FILE__
+      File.expand_path "../../#{path}", __dir__
     end
 
-    def include_dir ()
+    def inc_dir ()
       root_dir 'include'
     end
 
@@ -26,23 +28,6 @@ module Rays
       root_dir 'lib'
     end
 
-    def task_dir ()
-      root_dir 'task'
-    end
-
-    def load_tasks (*names)
-      if names.empty?
-        Dir["#{task_dir}/**/*.rake"].each {|path| load path}
-      else
-        names.each do |name|
-          path = "#{task_dir}/#{name}.rake"
-          load path if File.exist? path
-        end
-      end
-    end
-
-    extend self
-
   end# Module
 
 

data/lib/rays/painter.rb

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
 
 
+require 'xot/const_symbol_accessor'
+require 'xot/universal_accessor'
 require 'xot/block_util'
 require 'rays/ext'
-require 'rays/color'
 
 
 module Rays
@@ -11,128 +12,112 @@ module Rays
 
   class Painter
 
-    def background (*args, &block)
-      set_or_get :background=, :get_background, args, block
-    end
+    def push (*types, **attributes, &block)
+      each_type types do |type|
+        case type
+        when :state  then push_state
+        when :matrix then push_matrix
+        else raise ArgumentError, "invalid push/pop type '#{type}'."
+        end
+      end
 
-    def background= (*args)
-      send_set :set_background, :get_background, :no_background, args, :color
-    end
+      raise ArgumentError, 'missing block with pushing attributes.' if
+        !attributes.empty? && !block
 
-    def fill (*args, &block)
-      set_or_get :fill=, :get_fill, args, block
-    end
+      if block
+        attributes.each do |key, value|
+          attributes[key] = __send__ key
+          __send__ key, *value
+        end
 
-    def fill= (*args)
-      send_set :set_fill, :get_fill, :no_fill, args, :color
-    end
+        Xot::BlockUtil.instance_eval_or_block_call self, &block
 
-    def stroke (*args, &block)
-      set_or_get :stroke=, :get_stroke, args, block
-    end
+        attributes.each do |key, value|
+          __send__ key, *value
+        end
 
-    def stroke= (*args)
-      send_set :set_stroke, :get_stroke, :no_stroke, args, :color
+        pop *types
+      end
     end
 
-    def clip (*args, &block)
-      set_or_get :clip=, :get_clip, args, block
+    def pop (*types)
+      each_type types, reverse: true do |type|
+        case type
+        when :state  then pop_state
+        when :matrix then pop_matrix
+        else raise ArgumentError, "invalid push/pop type '#{type}'."
+        end
+      end
     end
 
-    def clip= (*args)
-      send_set :set_clip, :get_clip, :no_clip, args
+    def paint (*args, &block)
+      begin_paint
+      Xot::BlockUtil.instance_eval_or_block_call self, *args, &block
+      self
+    ensure
+      end_paint
     end
 
-    def font (*args, &block)
-      set_or_get :font=, :get_font, args, block
+    def line (*args, loop: false)
+      if args.first.kind_of?(Polyline)
+        draw_polyline args.first
+      else
+        draw_line args, loop
+      end
     end
 
-    def font= (*args)
-      send_set :set_font, :get_font, nil, args
+    def rect (*args, round: nil, lt: nil, rt: nil, lb: nil, rb: nil)
+      draw_rect args, round, lt, rt, lb, rb
     end
 
-    def color (fill, stroke = nil, &block)
-      org = [self.fill, self.stroke]
-      self.fill, self.stroke = fill, stroke
-      if block
-        Xot::BlockUtil.instance_eval_or_block_call self, &block
-        self.fill, self.stroke = org
-      end
-      org
+    def ellipse (*args, center: nil, radius: nil, hole: nil, from: nil, to: nil)
+      draw_ellipse args, center, radius, hole, from, to
     end
 
-    def attach (shader, uniforms = {})
-      shader =
-        case shader
-        when Shader then shader
-        when String then Shader.new shader
-        else raise ArgumentError
-        end
-      attach_shader shader
-      uniforms.each {|name, args| set_uniform name, *args}
-      shader
+    def curve (*args, loop: false)
+      draw_curve args, loop
     end
 
-    alias detach detach_shader
-
-    def push (&block)
-      push_matrix
-      push_attr
-      push_shader
-      if block
-        Xot::BlockUtil.instance_eval_or_block_call self, &block
-        pop
-      end
+    def bezier (*args, loop: false)
+      draw_bezier args, loop
     end
 
-    def pop ()
-      pop_shader
-      pop_attr
-      pop_matrix
+    def color= (fill, stroke = nil)
+      self.fill   fill
+      self.stroke stroke
     end
 
-    def begin (*args, &block)
-      begin_paint
-      Xot::BlockUtil.instance_eval_or_block_call self, *args, &block
-      end_paint
+    def color ()
+      return fill, stroke
     end
 
-    private
+    def shader= (shader, **uniforms)
+      shader.uniform **uniforms if shader && !uniforms.empty?
+      set_shader shader
+    end
 
-      NONES = [:no, :none, nil]
+    const_symbol_accessor :stroke_cap, {
+      butt:   CAP_BUTT,
+      round:  CAP_ROUND,
+      square: CAP_SQUARE
+    }
 
-      def send_set (setter, getter, no, args, mode = nil)
-        args = args[0] if args[0].kind_of? Array
-        raise ArgumentError if args.empty?
+    const_symbol_accessor :stroke_join, {
+      miter:  JOIN_MITER,
+      round:  JOIN_ROUND,
+      square: JOIN_SQUARE
+    }
 
-        arg0 = args[0]
-        if args.size == 1 && NONES.include?(arg0)
-          no ? send(no) : send(setter, nil)
-        else
-          case mode
-          when :color then args = Color.color *args
-          end
-          send setter, *args
-        end
-        send getter
-      end
+    universal_accessor :background, :fill, :stroke, :color,
+      :stroke_width, :stroke_cap, :stroke_join, :miter_limit,
+      :nsegment, :shader, :clip, :font
 
-      def set_or_get (setter, getter, args, block)
-        unless args.empty?
-          set_or_push setter, getter, args, block
-        else
-          send getter
-        end
-      end
+    private
 
-      def set_or_push (setter, getter, args, block)
-        org = send getter
-        send setter, *args
-        if block
-          Xot::BlockUtil.instance_eval_or_block_call self, &block
-          send setter, org
-        end
-        org
+      def each_type (types, reverse: false, &block)
+        types = [:state, :matrix] if types.empty? || types.include?(:all)
+        types = types.reverse if reverse
+        types.each &block
       end
 
   end# Painter