cyross-ruby-miyako 2.0.0 → 2.0.5.1.0

data/lib/Miyako/API/shape.rb

@@ -2,7 +2,7 @@
 =begin
 --
 Miyako v2.0
-Copyright (C) 2007-2008  Cyross Makoto
+Copyright (C) 2007-2009  Cyross Makoto
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -35,7 +35,9 @@ module Miyako
       @ray = parameter[:ray] ||= 0
       @edge = parameter[:edge] ||= nil
       @align = parameter[:align] ||= :left
+      @valign = parameter[:valign] ||= :middle
 			@lines = parameter[:lines] ||= 2
+      @vertexes = parameter[:vertexes] ||= []
     end
 
     @@shape_executer = Shape.new
@@ -44,6 +46,7 @@ module Miyako
     #_param_:: 設定パラメータ。ハッシュ形式。
     #(:font => 描画するフォントのインスタンス(デフォルトはFont.sans_serif),
     #(:align => 複数行描画するときの文字列のアライン(:left,:center,:rightの三種。デフォルトは:left))
+    #(:valign => 行中の小さい文字を描画するときの縦の位置(:top,:middle,:bottomの三種。デフォルトは:middle))
     #_&block_:: 描画するテキスト(Ｙｕｋｉ形式)
     #返却値:: テキストを描画したスプライト
     def Shape.text(param, &block)
@@ -60,6 +63,7 @@ module Miyako
     #(:font => 描画するフォントのインスタンス(デフォルトはFont.sans_serif),
     #(:align => 複数行描画するときの文字列のアライン(:left,:center,:rightの三種。デフォルトは:left),
     #(:size => 描画するサイズ(ピクセル単位、Size構造体のインスタンス、デフォルトは[100,100]))
+    #(:valign => 行中の小さい文字を描画するときの縦の位置(:top,:middle,:bottomの三種。デフォルトは:middle))
     #(:lines => 描画する行数(デフォルトは2))
     #_&block_:: 描画するテキスト(Ｙｕｋｉ形式)
     #返却値:: テキストを描画したスプライト
@@ -108,24 +112,45 @@ module Miyako
       @@shape_executer.ellipse(param)
     end
 
+    #===多角形を描画する
+    #_param_:: 設定パラメータ。ハッシュ形式。
+    #:vertexes => 頂点リスト。[x,y]形式の配列の配列,
+    #:color => 円の色[r,g,b(,a)]、デフォルトはColor[:white],
+    #返却値:: 描画したスプライト
+    def Shape.polygon(param)
+      @@shape_executer.polygon(param)
+    end
+
     def create_text(param, text_block) #:nodoc:
       init_parameter(param)
       text_block = lambda{ @text } if @text
       org_size = @font.size
       org_color = @font.color
       @margins = []
+      @heights = []
       area_size = calc(text_block)
-      @sprite = Sprite.new({:size => area_size, :type => :alpha_channel, :is_fill => true})
+      @sprite = Sprite.new({size: area_size, type: :ac})
+      Drawing.fill(@sprite, [0, 0, 0])
+      Bitmap.ck_to_ac!(@sprite, [0, 0, 0])
       case @align
         when :left
-        @margins = @margins.map{|v| 0 }
+          @margins = @margins.map{|v| 0 }
         when :center
-        @margins = @margins.map{|v| (area_size.w - v) >> 1 }
+          @margins = @margins.map{|v| (area_size.w - v) >> 1 }
         when :right
-        @margins = @margins.map{|v| area_size.w - v }
+          @margins = @margins.map{|v| area_size.w - v }
       end
 			@lines = @margins.length
-      @locate = Point.new(@margins.shift, 0)
+      vmargin = 0
+      case @valign
+        when :top
+          vmargin = 0
+        when :middle
+          vmargin = (area_size.h - @heights.inject(:+)) >> 1
+        when :bottom
+          vmargin = area_size.h - @heights.inject(:+)
+      end
+      @locate = Point.new(@margins.shift, vmargin)
       text instance_eval(&text_block)
       @font.size = org_size
       @font.color = org_color
@@ -136,11 +161,18 @@ module Miyako
       init_parameter(param)
       org_size = @font.size
       org_color = @font.color
+      olines = @lines
 			# calc font size
       @font.size = @size[1] / @lines
 			# calc font size incldue line_height
       @font.size = @font.size * @font.size / @font.line_height
       set_font_size_inner(text_block)
+      # over lines?
+      if @lines > olines
+        @font.size = @size[1] / @lines
+        @font.size = @font.size * @font.size / @font.line_height
+        set_font_size_inner(text_block)
+      end
       # over width?
       if @img_size.w > @size[0]
         @font.size = @font.size * @size[0] / @img_size.w
@@ -148,14 +180,25 @@ module Miyako
       end
       case @align
         when :left
-        @margins = @margins.map{|v| 0 }
+          @margins = @margins.map{|v| 0 }
         when :center
-        @margins = @margins.map{|v| (@size.w - v) / 2 }
+          @margins = @margins.map{|v| (@size[0] - v) / 2 }
         when :right
-        @margins = @margins.map{|v| @size.w - v }
+          @margins = @margins.map{|v| @size[0] - v }
       end
-      @sprite = Sprite.new({:size => @size, :type => :alpha_channel, :is_fill => true})
-      @locate = Point.new(@margins.shift, 0)
+      vmargin = 0
+      case @valign
+        when :top
+          vmargin = 0
+        when :middle
+          vmargin = (@size[1] - @heights.inject(:+)) >> 1
+        when :bottom
+          vmargin = @size[1] - @heights.inject(:+)
+      end
+      @sprite = Sprite.new({size: @size, type: :ac})
+      Drawing.fill(@sprite, [0, 0, 0])
+      Bitmap.ck_to_ac!(@sprite, [0, 0, 0])
+      @locate = Point.new(@margins.shift, vmargin)
       text instance_eval(&text_block)
       @font.size = org_size
       @font.color = org_color
@@ -165,6 +208,8 @@ module Miyako
     def set_font_size_inner(text_block) #:nodoc:
       @max_height = @font.line_height
       @margins = []
+      @heights = []
+      @lines = 1
       tcalc(text_block)
     end
 
@@ -172,6 +217,7 @@ module Miyako
       @locate = Point.new(0, 0)
       @img_size = Size.new(0, 0)
       @max_height = @font.line_height
+      @lines = 1
       @calc_mode = true
       text instance_eval(&block)
       @calc_mode = false
@@ -179,6 +225,7 @@ module Miyako
         @margins << @locate.x
         @img_size.w = [@locate.x, @img_size.w].max
         @img_size.h += @max_height
+        @heights << @max_height
       end
       return @img_size
     end
@@ -189,7 +236,11 @@ module Miyako
       @calc_mode = true
       text instance_eval(&block)
       @calc_mode = false
-      @margins << @locate.x if @locate.x != 0
+      if @locate.x != 0
+        @margins << @locate.x if @locate.x != 0
+        @heights << @max_height
+      end
+      @img_size.w = [@locate.x, @img_size.w].max
     end
 		
     #===Shape.textメソッドのブロック内で使用する、文字描画指示メソッド
@@ -223,7 +274,7 @@ module Miyako
     def size(size, &block)
       @font.size_during(size){
         @max_height = [@max_height, @font.line_height].max
-        size_inner(@font.margin_height(:middle, @max_height)){ text instance_eval(&block) }
+        size_inner(@font.margin_height(@valign, @max_height), &block)
       }
       return self
     end
@@ -269,9 +320,11 @@ module Miyako
     def cr
       if @calc_mode
         @margins << @locate.x
+        @heights << @max_height
         @img_size.w = [@locate.x, @img_size.w].max
         @img_size.h += @max_height
         @locate.x = 0
+        @lines += 1
       else
         @locate.x = @margins.shift || 0
       end
@@ -281,53 +334,58 @@ module Miyako
     
     def box(param) #:nodoc:
       init_parameter(param)
-      s = Sprite.new({:size => [w, h], :type => :alpha_channel, :is_fill => true})
+      s = Sprite.new(size: [w, h], type: :alpha_channel)
       w = @size[0]
       h = @size[1]
+      Drawing.fill(s, [0, 0, 0])
+      Bitmap.ck_to_ac!(s, [0, 0, 0])
       if @edge
         width = @edge[:width]
-        s.bitmap.fill_rect(0, 0, w-1, h-1, Color.to_rgb(@edge[:color]))
-        s.bitmap.fill_rect(width, width, w-width*2-1, h-width*2-1, Color.to_rgb(@color))
+        Drawing.rect(s, [0, 0, w, h], Color.to_rgb(@edge[:color]), true)
+        Drawing.rect(s, [width, width, w-width*2-1, h-width*2-1], Color.to_rgb(@color), true)
       else
-        s.bitmap.fill_rect(0, 0, w-1, h-1, Color.to_rgb(@color))
+        Drawing.rect(s, [0, 0, w, h], Color.to_rgb(@color), true)
       end
       return s
     end
 
     def roundbox_basic(s, x, y, w, h, r, c) #:nodoc:
       color = Color.to_rgb(c)
-      s.bitmap.draw_aa_filled_circle(r+x, r+y, r, color)
-      s.bitmap.draw_aa_filled_circle(w-r-x-1, r+y, r, color)
-      s.bitmap.draw_aa_filled_circle(r+x, h-r-y-1, r, color)
-      s.bitmap.draw_aa_filled_circle(w-r-x-1, h-r-y-1, r, color)
-      s.bitmap.fill_rect(x, y+r, w-x*2, h-y*2-r*2, color)
-      s.bitmap.fill_rect(x+r, y, w-x*2-r*2, h-x*2, color)
+      Drawing.circle(s, [r+x,     r+y],     r, color, true)
+      Drawing.circle(s, [w-r-x-1, r+y],     r, color, true)
+      Drawing.circle(s, [r+x,     h-r-y-1], r, color, true)
+      Drawing.circle(s, [w-r-x-1, h-r-y-1], r, color, true)
+      Drawing.rect(s, [x, y+r, w-x*2, h-y*2-r*2], color, true)
+      Drawing.rect(s, [x+r, y, w-x*2-r*2, h-x*2], color, true)
     end
 
     def roundbox(param) #:nodoc:
       init_parameter(param)
       w = @size[0]
       h = @size[1]
-      s = Sprite.new(@size, nil, nil)
-      s.fill([0, 0, 0, 0])
+      s = Sprite.new(size: @size, type: :ac)
+      Drawing.fill(s, [0, 0, 0])
+      Bitmap.ck_to_ac!(s, [0, 0, 0])
       if @edge
-        roundbox_basic(s, 0, 0, w, h, @ray, Color.to_rgb(@edge[:color]))
-        roundbox_basic(s, @edge[:width], @edge[:width], w, h, @ray, Color.to_rgb(@color))
+        roundbox_basic(s, [0, 0, w, h], @ray, Color.to_rgb(@edge[:color]))
+        roundbox_basic(s, [@edge[:width], @edge[:width], w, h], @ray, Color.to_rgb(@color))
       else
-        roundbox_basic(s, 0, 0, w, h, @ray, Color.to_rgb(@color))
+        roundbox_basic(s, [0, 0, w, h], @ray, Color.to_rgb(@color))
       end
       return s
     end
 
     def circle(param) #:nodoc:
       init_parameter(param)
-      s = Sprite.new({:size => [@ray*2+1, @ray*2+1], :type => :alpha_channel, :is_fill => true})
+      s = Sprite.new(size: [@ray*2+1, @ray*2+1], type: :alpha_channel)
+      Drawing.fill(s, [0, 0, 0])
+      Bitmap.ck_to_ac!(s, [0, 0, 0])
       if @edge
         et, ec = sp.get_param(:edge)[0..1]
-        s.bitmap.draw_aa_filled_circle(@ray, @ray, @ray, Color.to_rgb(@edge[:color]))
-        s.bitmap.draw_aa_filled_circle(@ray, @ray, @ray-@edge[:width], Color.to_rgb(@color))
+        Drawing.circle(s, [@ray, @ray], @ray, Color.to_rgb(@edge[:color]), true)
+        Drawing.circle(s, [@ray, @ray], @ray-@edge[:width], Color.to_rgb(@color), true)
       else
-        s.bitmap.draw_aa_filled_circle(@ray, @ray, @ray, Color.to_rgb(@color))
+        Drawing.circle(s, [@ray, @ray], @ray, Color.to_rgb(@color), true)
       end
       return s
     end
@@ -338,16 +396,36 @@ module Miyako
       w2 = w * 2 + 1
       h = @size[1]
       h2 = h * 2 + 1
-      s = Sprite.new({:size => [w2, h2], :type => :alpha_channel, :is_fill => true})
+      s = Sprite.new(size: [w2, h2], type: :alpha_channel)
+      Drawing.fill(s, [0, 0, 0])
+      Bitmap.ck_to_ac!(s, [0, 0, 0])
       if @edge
-        s.bitmap.drawAAFilledEllipse(w, h, w, h, Color.to_rgb(@edge[:color]))
-        s.bitmap.drawAAFilledEllipse(w, h, w-@edge[:width], h-@edge[:width], Color.to_rgb(@color))
+        Drawing.ellipse(s, [w, h], w, h, Color.to_rgb(@edge[:color]), true)
+        Drawing.ellipse(s, [w, h], w-@edge[:width], h-@edge[:width], Color.to_rgb(@color), true)
       else
-        s.bitmap.drawAAFilledEllipse(w, h, w, h, Color.to_rgb(@color))
+        Drawing.ellipse(s, [w, h], w, h, Color.to_rgb(@color), true)
       end
       return s
     end
 
+    def polygon(param) #:nodoc:
+      init_parameter(param)
+      
+      min_x, max_x = @vertexes.map{|v| v[0]}.minmax
+      min_y, max_y = @vertexes.map{|v| v[1]}.minmax
+      
+      w = max_x - min_x
+      h = max_y - min_y
+      
+      @vertexes = @vertexes.map{|v| [v[0]-min_x, v[1]-min_y]}
+      
+      s = Sprite.new(size: [w, h], type: :alpha_channel)
+      Drawing.fill(s, [0, 0, 0])
+      Bitmap.ck_to_ac!(s, [0, 0, 0])
+      Drawing.polygon(s, @vertexes, Color.to_rgb(@color), true)
+      return s
+    end
+
     private :roundbox_basic
   end
 end
@@ -355,8 +433,11 @@ end
 class String
   #===文字列から、その文字を描画したスプライトを作成する
   #自分自身が持つ文字列をShape.textメソッドを使用して画像を作成する
+    #引数1個のブロックを渡せば、スプライトに補正をかけることが出来る
   #_data_:: 描画するフォント(Fontクラスのインスタンス)
   def to_sprite(data)
-    return Miyako::Shape.text({:text => self, :font => data})
+    sprite = Miyako::Shape.text({:text => self, :font => data})
+    yield sprite if block_given?
+    return sprite
   end
 end

data/lib/Miyako/API/sprite.rb

@@ -2,7 +2,7 @@
 =begin
 --
 Miyako v2.0
-Copyright (C) 2007-2008  Cyross Makoto
+Copyright (C) 2007-2009  Cyross Makoto
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -30,6 +30,7 @@ module Miyako
     include SingleEnumerable
     extend Forwardable
 
+    attr_accessor :visible #レンダリングの可否(true->描画 false->非描画)
     attr_reader :tr_color  #カラーキーが有向になっている場合のRGB値。[R,G,B]の配列(各要素は0～255の整数)
     attr_reader :type      #画像の透明度・透過タイプを取得する(詳細はSprite.newメソッドを参照)
 
@@ -43,6 +44,7 @@ module Miyako
       @w = 0
       @h = 0
       @draw_list = nil
+      @visible = true
     end
 
     private :setup
@@ -59,15 +61,24 @@ module Miyako
     #<引数の内容>
     #* 1.画像の元データ(括弧内は省略形)。以下の３種類のどれかを必ず指定する。
     #  * 画像ファイル(ファイル名)から生成。　(書式):filename(:file)=>画像ファイル名　(例):file=>"image.png"
-    #  * 画像サイズ(2要素の整数の配列もしくはSize構造体)から生成。　(書式1):size=>２要素の配列((例):size=>[100,100])　(書式2):size=>Size構造体((例):size=>Size.new(100,100))
-    #  * SDL::Surfaceクラスのインスタンスから生成。　(書式):bitmap(:bmp)=>SDL::Surfaceクラスのインスタンス((例):bmp=>@surface)
-    #  * SpriteUnit構造体のインスタンスから生成(ビットマップ以外のUnitの値は引き継がれる。しかし、snapの親子関係は引き継がれない)。
+    #  * 画像サイズ(2要素の整数の配列もしくはSize構造体)から生成。
+    #  　(書式1):size=>２要素の配列((例):size=>[100,100])
+    #　  (書式2):size=>Size構造体((例):size=>Size.new(100,100))
+    #  * SDL::Surfaceクラスのインスタンスから生成。　
+    #    (書式):bitmap(:bmp)=>SDL::Surfaceクラスのインスタンス((例):bmp=>@surface)
+    #  * SpriteUnit構造体のインスタンスから生成(ビットマップ以外のUnitの値は引き継がれる。
+    #    しかし、snapの親子関係は引き継がれない)。
     #　(書式):unit=>SpriteUnit構造体のインスタンス((例):unit=>@spr.to_unit)
     #* 2.透過設定(括弧内は省略形)。以下の３種類のどれかを必ず指定する。
     #  * カラーキーによる透過は行わない方式(デフォルトの方式)　(書式):type=>:alpha_surface(:as)
     #  * カラーキーの指定。　(書式):type=>:color_key(:ck)　カラーキー指定の方法は以下のとおり
-    #    * 透明色にするピクセルの位置(2要素の整数の配列、Point構造体)　(書式1):point=>２要素の配列((例):type=>:ck, :point=>[20,20])　(書式2):point=>Point構造体((例):type=>:ck, :point=>Point.new(20,20))
-    #    * 色を直接指定　(書式):tr_color=>色情報(Color.to_rgbメソッドで生成できるパラメータ)((例1):type=>:ck, :tr_color=>[255,0,255] # 紫色を透明色に　(例2):type=>:ck, :tr_color=>:red # 赤色を透明色に)
+    #    * 透明色にするピクセルの位置(2要素の整数の配列、Point構造体)
+    #    　(書式1):point=>２要素の配列((例):type=>:ck, :point=>[20,20])
+    #    　(書式2):point=>Point構造体((例):type=>:ck, :point=>Point.new(20,20))
+    #    * 色を直接指定
+    #    　(書式):tr_color=>色情報(Color.to_rgbメソッドで生成できるパラメータ)
+    #       ((例1):type=>:ck, :tr_color=>[255,0,255] # 紫色を透明色に
+    #      　(例2):type=>:ck, :tr_color=>:red # 赤色を透明色に)
     #    * デフォルト：画像の[0,0]の位置にあるピクセルの色
     #* 3. αチャネル付き画像を使用(設定変更不可)　(書式):type=>:alpha_channel(:ac)
     def initialize(param)
@@ -110,7 +121,7 @@ module Miyako
         bitmap  = Bitmap.create(bitmap.w, bitmap.h, SDL::HWSURFACE)
         bitmap  = bitmap.display_format_alpha
         nunit = SpriteUnitFactory.create(:bitmap => bitmap)
-        Bitmap.ck_to_ac!(tunit, nunit, @tr_color)
+        Bitmap.ck_to_ac(tunit, nunit, @tr_color)
         self.bitmap = bitmap
         @unit.bitmap.fill_rect(0,0,@unit.bitmap.w,@unit.bitmap.h,[0, 0, 0, 0]) if param[:is_fill]
         tbitmap = nil
@@ -121,7 +132,7 @@ module Miyako
         bitmap  = Bitmap.create(bitmap.w, bitmap.h, SDL::HWSURFACE)
         bitmap  = bitmap.display_format_alpha
         nunit = SpriteUnitFactory.create(:bitmap => bitmap)
-        Bitmap.normal_to_ac!(tunit, nunit)
+        Bitmap.normal_to_ac(tunit, nunit)
         self.bitmap = bitmap
         @unit.bitmap.fill_rect(0,0,@unit.bitmap.w,@unit.bitmap.h,[0, 0, 0, 0]) if param[:is_fill]
         tbitmap = nil
@@ -135,8 +146,6 @@ module Miyako
 
       if param.has_key?(:unit)
         SpriteUnitFactory.apply(@unit, :ow=>param[:unit].ow, :oh=>param[:unit].oh,
-                                       :angle => param[:unit].angle,
-                                       :xscale => param[:unit].xscale, :yscale => param[:unit].yscale,
                                        :cx => param[:unit].cx, :cy => param[:unit].cy)
         self.move_to(param[:unit].x, param[:unit].y)
       end
@@ -183,79 +192,42 @@ module Miyako
 
     #===画像の表示開始位置(X座標)を指定する
     #oxを指定すると、表示の左上位置が変更される。
+    #値が画像の幅の範囲外(値がマイナス、画像の幅を超える値)のときは例外が発生する
     #_v_:: 表示開始位置。整数で指定
     def ox=(v)
+      raise MiyakoError, "Illegal ox parameter! : #{v}" if (v < 0 || (v+@unit.ow) > @w)
       @unit.ox = v
     end
     
     #===画像の表示開始位置(Y座標)を指定する
     #oyを指定すると、表示の左上位置が変更される。
+    #値が画像の高さの範囲外(値がマイナス、画像の高さを超える値)のときは例外が発生する
     #_v_:: 表示開始位置。整数で指定
     def oy=(v)
+      raise MiyakoError, "Illegal oy parameter! : #{v}" if (v < 0 || (v+@unit.oh) > @h)
       @unit.oy = v
     end
     
     #===画像の表示幅を指定する
     #owを指定すると、横方向の一部のみ表示される。
+    #値が画像の幅の範囲外(値がマイナス、画像の幅を超える値)のときは例外が発生する
     #_v_:: 表示幅。整数で指定
     def ow=(v)
+      raise MiyakoError, "Illegal ox parameter! : #{v}" if (v < 0 || (@unit.ox+v) > @w)
       @unit.ow = v
       set_layout_size(v, @unit.oh)
     end
 
     #===画像の表示高を指定する
     #ohを指定すると、縦方向の一部のみ表示される。
+    #値が画像の高さの範囲外(値がマイナス、画像の高さを超える値)のときは例外が発生する
     #_v_:: 表示高。整数で指定
     def oh=(v)
+      raise MiyakoError, "Illegal ox parameter! : #{v}" if (v < 0 || (@unit.oy+v) > @h)
       @unit.oh = v
       set_layout_size(@unit.ow, v)
     end
 
-    #===画像の回転角度を取得する
-    #値はラジアン。範囲は0<=angle<PI*2
-    #値が正の時は右回りに回転する。
-    #返却値:: 回転角度。ラジアン(実数)
-    def angle
-      return @unit.angle
-    end
-
-    #===画像の回転角度を設定する
-    #値はラジアン。範囲は0<=angle<PI*2
-    #値が正の時は右回りに回転する。
-    #_radian_:: 回転角度。ラジアン(実数)を指定
-    def angle=(radian)
-      raise MiyakoError, "Illegal radian! : #{radian}" if (radian < 0.0 || radian > Math::PI * 2)
-      @unit.angle = radian
-    end
-
-    #===画像の拡大縮小度を取得する
-    #x方向の拡大縮小度を取得する
-    #返却値:: 拡大縮小度。1.0で等倍。-1.0でミラー反転
-    def xscale
-      return @unit.xscale
-    end
-
-    #===画像の拡大縮小度を設定する
-    #x方向の拡大縮小度を設定する
-    #_scale_:: 拡大縮小度。1.0で等倍。-1.0でミラー反転
-    def xscale=(scale)
-      @unit.xscale = scale
-    end
-
-    #===画像の拡大縮小度を取得する
-    #y方向の拡大縮小度を取得する
-    #返却値:: 拡大縮小度。1.0で等倍。-1.0でミラー反転
-    def yscale
-      return @unit.yscale
-    end
-
-    #===画像の拡大縮小度を設定する
-    #y方向の拡大縮小度を設定する
-    #_scale_:: 拡大縮小度。1.0で等倍。-1.0でミラー反転
-    def yscale=(scale)
-      @unit.yscale = scale
-    end
-
     #===画像の回転・拡大・縮小の中心座標を取得する
     #x方向の中心座標を取得する
     #返却値:: 中心座標。
@@ -285,8 +257,8 @@ module Miyako
     end
 
     #===画像の表示矩形を取得する
-    #画像が表示されているときの矩形を取得する。矩形は、[x,y,ow,oh]で取得する。
-    #返却値:: 生成された矩形
+    #画像が表示されているときの矩形(Rect構造体)を取得する
+    #返却値:: 生成された矩形(Rect構造体インスタンス)
     def rect
       return Rect.new(@unit.x, @unit.y, @unit.ow, @unit.oh)
     end
@@ -317,22 +289,464 @@ module Miyako
     end
 
     #===インスタンスをSpriteUnit構造体に変換して取得する
+    #得られるインスタンスは複写していないので、インスタンスの値を調整するには、dupメソッドで複製する必要がある
     #返却値:: SpriteUnit化したスプライト
     def to_unit
-      return @unit.dup
+      return @unit
     end
 
     #===インスタンスをスプライト化して返す
     #インスタンスの複製を行う(画像インスタンスも複製)
+    #引数1個のブロックを渡せば、スプライトに補正をかけることが出来る
     #注意事項：
     #１．複製のため、呼び出していくとメモリ使用量が著しく上がる
     #２．レイアウト情報がリセットされる(snapの親子関係が解消される)
-    #返却値:: 自分自身を返す
+    #返却値:: 生成したインスタンスを返す
     def to_sprite
       unit = @unit.dup
       unit.bitmap = Bitmap.create(unit.bitmap.w, unit.bitmap.h)
-      Bitmap.blit_aa!(@unit, unit, 0, 0)
-      return Sprite.new(:unit=>unit, :type=>:ac)
+      sprite = Sprite.new(size: [unit.bitmap.w, unit.bitmap.h], type: :ac)
+      Drawing.fill(sprite, [0,0,0])
+      Bitmap.ck_to_ac!(sprite, [0,0,0])
+      Bitmap.blit_aa(self, sprite, 0, 0)
+      yield sprite if block_given?
+      return sprite
+    end
+
+    #===画像の内容を破壊的に消去する
+    #インスタンスの複製を行う(画像インスタンスも複製)
+    #引数1個のブロックを渡せば、スプライトに補正をかけることが出来る
+    #注意事項：
+    #１．複製のため、呼び出していくとメモリ使用量が著しく上がる
+    #２．レイアウト情報がリセットされる(snapの親子関係が解消される)
+    #返却値:: 自分自身を返す
+    def clear!
+      Drawing.fill(self, [0,0,0])
+      Bitmap.ck_to_ac!(self, [0,0,0])
+      return self
+    end
+
+    #===インスタンスの内容を別のインスタンスに描画する
+    #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。
+    #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に設定にする。
+    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+    #ブロックの引数は、|転送元のSpriteUnit,転送先のSpriteUnit|となる。
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 自分自身を返す
+    def Sprite.render_to(src, dst)
+    end
+
+    #===インスタンスの内容を画面に描画する
+    #現在の画像を、現在の状態で描画するよう指示する
+    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|インスタンスのSpriteUnit, 画面のSpriteUnit|となる。
+    #visibleメソッドの値がfalseのときは描画されない。
+    #返却値:: 自分自身を返す
+    def render
+    end
+
+    #===インスタンスの内容を別のインスタンスに描画する
+    #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。
+    #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に設定にする。
+    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|インスタンスのSpriteUnit,転送先のSpriteUnit|となる。
+    #visibleメソッドの値がfalseのときは描画されない。
+    #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 自分自身を返す
+    def render_to(dst)
+    end
+
+    #===インスタンスの内容を画面に描画する(回転/拡大/縮小/鏡像付き)
+    #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。回転の中心はsrc側(ox,oy)を起点に、src側(cx,cy)が中心になるように設定する。
+    #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に、画面側SpriteUnitの(cx,cy)が中心になるように設定にする。
+    #回転角度が正だと右回り、負だと左回りに回転する
+    #変形の度合いは、src側SpriteUnitのxscale, yscaleを使用する(ともに実数で指定する)。それぞれ、x方向、y方向の度合いとなる
+    #度合いが scale > 1.0 だと拡大、 0 < scale < 1.0 だと縮小、scale < 0.0 負だと鏡像の拡大・縮小になる(scale == -1.0 のときはミラー反転になる)
+    #また、変形元の幅・高さのいずれかが32768以上の時は回転・転送を行わない
+    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|インスタンスのSpriteUnit,画面のSpriteUnit|となる。
+    #visibleメソッドの値がfalseのときは描画されない。
+    #_radian_:: 回転角度。単位はラジアン。値の範囲は0<=radian<2pi
+    #_xscale_:: 拡大率(x方向)
+    #_yscale_:: 拡大率(y方向)
+    #返却値:: 自分自身を返す
+    def render_transform(radian, xscale, yscale)
+    end
+
+    #===インスタンスの内容を画面に描画する(回転/拡大/縮小/鏡像付き)
+    #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。回転の中心はsrc側(ox,oy)を起点に、src側(cx,cy)が中心になるように設定する。
+    #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に、画面側SpriteUnitの(cx,cy)が中心になるように設定にする。
+    #回転角度が正だと右回り、負だと左回りに回転する
+    #変形の度合いは、src側SpriteUnitのxscale, yscaleを使用する(ともに実数で指定する)。それぞれ、x方向、y方向の度合いとなる
+    #度合いが scale > 1.0 だと拡大、 0 < scale < 1.0 だと縮小、scale < 0.0 負だと鏡像の拡大・縮小になる(scale == -1.0 のときはミラー反転になる)
+    #また、変形元の幅・高さのいずれかが32768以上の時は回転・転送を行わない
+    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|インスタンスのSpriteUnit,転送先のSpriteUnit|となる。
+    #visibleメソッドの値がfalseのときは描画されない。
+    #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #_radian_:: 回転角度。単位はラジアン。値の範囲は0<=radian<2pi
+    #_xscale_:: 拡大率(x方向)
+    #_yscale_:: 拡大率(y方向)
+    #返却値:: 自分自身を返す
+    def render_to_transform(dst, radian, xscale, yscale)
+    end
+
+    #===２つの画像のandを取り、別の画像へ転送する
+    #重ね合わせの式は、"src and self -> dst"で表される。自分自身と転送先画像は同じ大きさとなる。
+    #範囲は、インスタンス側とsrc側との(ow,oh)の小さい方の範囲で転送する。
+    #src側の(x,y)をインスタンス側の起点として、src側の(ow,oh)の範囲で転送する。
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の新しい画像インスタンス
+    def and(src, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      self.render_to(dst)
+      raise MiyakoError, "illegal range!" unless Bitmap.blit_and(src, dst, &block)
+      return dst
+    end
+
+    #===２つの画像のandを破壊的に行う
+    #重ね合わせの式は、"src and self -> self"で表される。
+    #範囲は、インスタンス側とsrc側との(ow,oh)の小さい方の範囲で転送する。
+    #src側の(x,y)をインスタンス側の起点として、src側の(ow,oh)の範囲で転送する。
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の自分自身を返す
+    def and!(src, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.blit_and(src, self, &block)
+      return self
+    end
+
+    #===２つの画像のorを取り、別の画像へ転送する
+    #重ね合わせの式は、"src or self -> dst"で表される。自分自身と転送先画像は同じ大きさとなる。
+    #範囲は、インスタンス側とsrc側との(ow,oh)の小さい方の範囲で転送する。
+    #src側の(x,y)をインスタンス側の起点として、src側の(ow,oh)の範囲で転送する。
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の新しい画像インスタンス
+    def or(src, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      self.render_to(dst)
+      raise MiyakoError, "illegal range!" unless Bitmap.blit_or(src, dst, &block)
+      return dst
+    end
+
+    #===２つの画像のorを破壊的に行う
+    #重ね合わせの式は、"src or self -> self"で表される。
+    #範囲は、インスタンス側とsrc側との(ow,oh)の小さい方の範囲で転送する。
+    #src側の(x,y)をインスタンス側の起点として、src側の(ow,oh)の範囲で転送する。
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の自分自身を返す
+    def or!(src, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.blit_or(src, self, &block)
+      return self
+    end
+
+    #===２つの画像のxorを取り、別の画像へ転送する
+    #重ね合わせの式は、"src xor self -> dst"で表される。自分自身と転送先画像は同じ大きさとなる。
+    #範囲は、インスタンス側とsrc側との(ow,oh)の小さい方の範囲で転送する。
+    #src側の(x,y)をインスタンス側の起点として、src側の(ow,oh)の範囲で転送する。
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の新しい画像インスタンス
+    def xor(src, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      self.render_to(dst)
+      raise MiyakoError, "illegal range!" unless Bitmap.blit_xor(src, dst, &block)
+      return dst
+    end
+
+    #===２つの画像のxorを破壊的に行う
+    #重ね合わせの式は、"src xor self -> self"で表される。
+    #範囲は、インスタンス側とsrc側との(ow,oh)の小さい方の範囲で転送する。
+    #src側の(x,y)をインスタンス側の起点として、src側の(ow,oh)の範囲で転送する。
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の自分自身を返す
+    def xor!(src, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.blit_xor(src, self, &block)
+      return self
+    end
+
+    #===画像のαチャネルの値を一定の割合で変化させて転送する
+    #degreeの値が1.0に近づけば近づくほど透明に近づき、
+    #degreeの値が-1.0に近づけば近づくほど不透明に近づく(値が-1.0のときは完全不透明、値が0.0のときは変化なし、1.0のときは完全に透明になる)
+    #但し、元々αの値がゼロの時は変化しない
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_degree_:: 減少率。-1.0<=degree<=1.0までの実数
+    #返却値:: 変更後の新しい画像インスタンス
+    def dec_alpha(degree, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      raise MiyakoError, "illegal range!" unless Bitmap.dec_alpha(self, dst, degree, &block)
+      return dst
+    end
+
+    #===画像のαチャネルの値を一定の割合で破壊的に変化させる
+    #degreeの値が1.0に近づけば近づくほど透明に近づき、
+    #degreeの値が-1.0に近づけば近づくほど不透明に近づく
+    #(値が-1.0のときは完全不透明、値が0.0のときは変化なし、1.0のときは完全に透明になる)
+    #但し、元々αの値がゼロの時は変化しない
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_degree_:: 減少率。-1.0<=degree<=1.0までの実数
+    #返却値:: 変更後の自分自身を返す
+    def dec_alpha!(degree, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.dec_alpha!(self, degree, &block)
+      return self
+    end
+
+    #===画像の色を一定の割合で黒に近づける(ブラックアウト)
+    #赤・青・緑・αの各要素を一定の割合で下げ、黒色に近づける。
+    #degreeの値が1.0に近づけば近づくほど黒色に近づく(値が0.0のときは変化なし、1.0のときは真っ黒になる)
+    #αの値が0のときは変わらないことに注意！
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_degree_:: 変化率。0.0<=degree<=1.0までの実数
+    #返却値:: 変更後の新しい画像インスタンス
+    def black_out(degree, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      raise MiyakoError, "illegal range!" unless Bitmap.black_out(self, dst, degree, &block)
+      return dst
+    end
+
+    #===画像の色を一定の割合で黒に近づける(ブラックアウト)
+    #赤・青・緑・αの各要素を一定の割合で下げ、黒色に近づける。
+    #degreeの値が1.0に近づけば近づくほど黒色に近づく(値が0.0のときは変化なし、1.0のときは真っ黒になる)
+    #αの値が0のときは変わらないことに注意！
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_degree_:: 変化率。0.0<=degree<=1.0までの実数
+    #返却値:: 変更後の自分自身を返す
+    def black_out!(degree, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.black_out!(self, degree, &block)
+      return self
+    end
+
+    #===画像の色を一定の割合で白に近づける(ホワイトアウト)
+    #赤・青・緑・αの各要素を一定の割合で上げ、白色に近づける。
+    #degreeの値が1.0に近づけば近づくほど白色に近づく(値が0.0のときは変化なし、1.0のときは真っ白になる)
+    #αの値が0のときは変わらないことに注意！
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_degree_:: 変化率。0.0<=degree<=1.0までの実数
+    #返却値:: 変更後の新しい画像インスタンス
+    def white_out(degree, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      raise MiyakoError, "illegal range!" unless Bitmap.white_out(self, dst, degree, &block)
+      return dst
+    end
+
+    #===画像の色を一定の割合で白に近づける(ホワイトアウト)
+    #赤・青・緑・αの各要素を一定の割合で上げ、白色に近づける。
+    #degreeの値が1.0に近づけば近づくほど白色に近づく(値が0.0のときは変化なし、1.0のときは真っ白になる)
+    #αの値が0のときは変わらないことに注意！
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_degree_:: 変化率。0.0<=degree<=1.0までの実数
+    #返却値:: 変更後の自分自身を返す
+    def white_out!(degree, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.white_out!(self, degree, &block)
+      return self
+    end
+
+    #===画像のRGB値を反転させる
+    #αチャネルの値は変更しない
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #返却値:: 変更後の新しい画像インスタンス
+    def inverse(&block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      raise MiyakoError, "illegal range!" unless Bitmap.inverse(self, dst, &block)
+      return dst
+    end
+
+    #===画像のRGB値を反転させる
+    #αチャネルの値は変更しない
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #返却値:: 変更後の自分自身を返す
+    def inverse!(&block)
+      raise MiyakoError, "illegal range!" unless Bitmap.inverse!(self, &block)
+      return self
+    end
+
+    #===2枚の画像の加算合成を行う
+    #範囲は、src側の(ow,oh)の範囲で転送する。転送先の描画開始位置は、src側の(x,y)を左上とする。
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の新しい画像インスタンス
+    def additive(src, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      self.render_to(dst)
+      raise MiyakoError, "illegal range!" unless Bitmap.additive(src, dst, &block)
+      return dst
+    end
+
+    #===2枚の画像の加算合成を行う
+    #範囲は、src側の(ow,oh)の範囲で転送する。転送先の描画開始位置は、src側の(x,y)を左上とする。
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の自分自身を返す
+    def additive!(src, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.additive(src, self, &block)
+      return self
+    end
+
+    #===2枚の画像の減算合成を行う
+    #範囲は、src側の(ow,oh)の範囲で転送する。転送先の描画開始位置は、src側の(x,y)を左上とする。
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の新しい画像インスタンス
+    def subtraction(src, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      self.render_to(dst)
+      raise MiyakoError, "illegal range!" unless Bitmap.subtraction(src, dst, &block)
+      return dst
+    end
+
+    #===2枚の画像の減算合成を行う
+    #範囲は、src側の(ow,oh)の範囲で転送する。転送先の描画開始位置は、src側の(x,y)を左上とする。
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_src_:: 転送元ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 変更後の自分自身を返す
+    def subtraction!(src, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.subtraction(src, self, &block)
+      return self
+    end
+
+    #===画像の色相を変更する
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_degree_:: 色相の変更量。単位は度(実数)。範囲は、-360.0<degree<360.0
+    #返却値:: 変更後の新しい画像インスタンス
+    def hue(degree, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      raise MiyakoError, "illegal range!" unless Bitmap.hue(self, dst, degree, &block)
+      return dst
+    end
+
+    #===画像の色相を変更する
+    #_degree_:: 色相の変更量。単位は度(実数)。範囲は、-360.0<degree<360.0
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #返却値:: 変更後の画像インスタンス
+    #返却値:: 変更後の自分自身を返す
+    def hue!(degree, &block)
+			puts "start"
+      raise MiyakoError, "illegal range!" unless Bitmap.hue!(self, degree, &block)
+			puts "finish"
+      return self
+    end
+
+    #===画像の彩度を変更する
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_saturation_:: 彩度の変更量。範囲は0.0〜1.0の実数
+    #返却値:: 変更後の新しい画像インスタンス
+    def saturation(saturation, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      raise MiyakoError, "illegal range!" unless Bitmap.saturation(self, dst, saturation, &block)
+      return dst
+    end
+
+    #===画像の彩度を変更する
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_saturation_:: 彩度の変更量。範囲は0.0〜1.0の実数
+    #返却値:: 変更後の自分自身を返す
+    def saturation!(saturation, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.saturation!(self, saturation, &block)
+      return self
+    end
+
+    #===画像の明度を変更する
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_value_:: 明度の変更量。範囲は0.0〜1.0の実数
+    #返却値:: 変更後の新しい画像インスタンス
+    def value(value, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      raise MiyakoError, "illegal range!" unless Bitmap.value(self, dst, value, &block)
+      return dst
+    end
+
+    #===画像の明度を変更する
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_value_:: 明度の変更量。範囲は0.0〜1.0の実数
+    #返却値:: 変更後の画像インスタンス
+    def value!(value, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.value!(self, value, &block)
+      return self
+    end
+
+    #===画像の色相・彩度・明度を変更する
+    #ブロックを渡すと、src,dst側のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|src側SpriteUnit,dst側SpriteUnit|となる。
+    #_degree_:: 色相の変更量。単位は度(実数)。範囲は、-360.0<degree<360.0
+    #_saturation_:: 彩度の変更量。範囲は0.0〜1.0の実数
+    #_value_:: 明度の変更量。範囲は0.0〜1.0の実数
+    #返却値:: 変更後の新しい画像インスタンス
+    def hsv(degree, saturation, value, &block)
+      dst = Sprite.new(:size=>self.size, :type=>:ac)
+      raise MiyakoError, "illegal range!" unless Bitmap.hsv(self, dst, degree, saturation, value, &block)
+      return dst
+    end
+
+    #===画像の色相・彩度・明度を変更する
+    #ブロックを渡すと、自分自身のSpriteUnitを更新して、それを実際の転送に反映させることが出来る
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|SpriteUnit|となる。
+    #_degree_:: 色相の変更量。単位は度(実数)。範囲は、-360.0<degree<360.0
+    #_saturation_:: 彩度の変更量。範囲は0.0〜1.0の実数
+    #_value_:: 明度の変更量。範囲は0.0〜1.0の実数
+    #返却値:: 変更後の画像インスタンス
+    def hsv!(degree, saturation, value, &block)
+      raise MiyakoError, "illegal range!" unless Bitmap.hsv!(self, degree, saturation, value, &block)
+      return self
     end
   end
 end