rays 0.1.12 → 0.1.13

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
 
@@ -27,10 +27,6 @@ module Rays
       Bounds.new 0, 0, *size
     end
 
-    def self.load (path, alpha_only = false)
-      load_image path, alpha_only
-    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,9 @@
 # -*- coding: utf-8 -*-
 
 
+require 'xot/universal_accessor'
 require 'xot/block_util'
 require 'rays/ext'
-require 'rays/color'
 
 
 module Rays
@@ -11,128 +11,91 @@ 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 color= (fill, stroke = nil)
+      self.fill   fill
+      self.stroke stroke
     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 color ()
+      return fill, stroke
     end
 
-    def pop ()
-      pop_shader
-      pop_attr
-      pop_matrix
+    def shader= (shader, **uniforms)
+      shader.uniform **uniforms if shader && !uniforms.empty?
+      set_shader shader
     end
 
-    def begin (*args, &block)
-      begin_paint
-      Xot::BlockUtil.instance_eval_or_block_call self, *args, &block
-      end_paint
-    end
+    universal_accessor :background, :fill, :stroke, :color,
+      :stroke_width, :nsegment, :shader, :clip, :font
 
     private
 
-      NONES = [:no, :none, nil]
-
-      def send_set (setter, getter, no, args, mode = nil)
-        args = args[0] if args[0].kind_of? Array
-        raise ArgumentError if args.empty?
-
-        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
-
-      def set_or_get (setter, getter, args, block)
-        unless args.empty?
-          set_or_push setter, getter, args, block
-        else
-          send getter
-        end
-      end
-
-      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

data/lib/rays/point.rb

@@ -10,6 +10,7 @@ module Rays
   class Point
 
     include Comparable
+    include Enumerable
 
     def move_to (*args)
       dup.move_to! *args
@@ -19,6 +20,14 @@ module Rays
       dup.move_by! *args
     end
 
+    def zero? ()
+      length == 0
+    end
+
+    def each (&block)
+      to_a.each &block
+    end
+
     def to_a (dimension = 2)
       case dimension
       when 1 then [x]
@@ -28,20 +37,8 @@ module Rays
       end
     end
 
-    def + (*args)
-      op_add Point.from(*args)
-    end
-
-    def - (*args)
-      op_sub Point.from(*args)
-    end
-
-    def * (*args)
-      op_mult Point.from(*args)
-    end
-
-    def / (*args)
-      op_div Point.from(*args)
+    def to_s (dimension = 2)
+      to_a(dimension).to_s
     end
 
     def <=> (o)
@@ -50,13 +47,8 @@ module Rays
             z <=> o.z
     end
 
-    def self.from (*args)
-      case arg0 = args[0]
-      when Point   then arg0
-      when Array   then Point.new *arg0
-      when Numeric then Point.new arg0, arg0, arg0
-      else raise ArgumentError
-      end
+    def inspect ()
+      "#<Rays::Point #{to_a(3).join ', '}>"
     end
 
   end# Point

data/lib/rays/polygon.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/ext'
+require 'rays/polyline'
+
+
+module Rays
+
+
+  class Polygon
+
+    include Enumerable
+
+    def initialize (*args, loop: true)
+      setup args, loop
+    end
+
+    def transform (matrix = nil, &block)
+      lines = to_a
+      lines = lines.map {|line| line.transform matrix} if matrix
+      lines = block.call lines if block
+      self.class.new *lines
+    end
+
+    def intersects (obj)
+      !(self & obj).empty?
+    end
+
+    def self.line (*args, loop: false)
+      new *args, loop: loop
+    end
+
+    def self.rect (
+      *args, round: nil, lt: nil, rt: nil, lb: nil, rb: nil, nsegment: nil)
+
+      create_rect args, round, lt, rt, lb, rb, nsegment
+    end
+
+    def self.ellipse (
+      *args, center: nil, radius: nil, hole: nil, from: nil, to: nil,
+      nsegment: nil)
+
+      create_ellipse args, center, radius, hole, from, to, nsegment
+    end
+
+  end# Polygon
+
+
+end# Rays

data/lib/rays/polygon_line.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/ext'
+
+
+module Rays
+
+
+  class Polygon
+
+
+    class Line < Polyline
+
+      def initialize (*points, loop: true, hole: false)
+        setup points, loop, hole
+      end
+
+      def transform (matrix = nil, loop: loop?, hole: hole?, &block)
+        points = to_a
+        points = points.map {|point| matrix * point} if matrix
+        points = block.call points if block
+        self.class.new *points, loop: loop, hole: hole
+      end
+
+      def inspect ()
+        "#<Rays::Polygon::Line #{to_a.join ', '}, loop: #{loop?}, hole: #{hole?}>"
+      end
+
+    end# Line
+
+
+  end# Polygon
+
+
+end# Rays

data/lib/rays/polyline.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+
+require 'rays/ext'
+
+
+module Rays
+
+
+  class Polyline
+
+    include Enumerable
+
+    def initialize (*points, loop: false)
+      setup points, loop
+    end
+
+    def transform (matrix = nil, loop: loop?, &block)
+      points = to_a
+      points = points.map {|point| matrix * point} if matrix
+      points = block.call points if block
+      self.class.new *points, loop: loop
+    end
+
+    def inspect ()
+      "#<Rays::Polyline #{to_a.join ', '}, loop: #{loop?}>"
+    end
+
+  end# Polyline
+
+
+end# Rays