ruby-miyako 2.1.1 → 2.1.2

data/README

@@ -1,8 +1,8 @@
 *******************************************************************************
 【   作者名   】　サイロス誠
 【  ソフト名  】　Interactive Media Authoring System "Miyako"
-【 バージョン 】　2.1.1
-【   作成日   】　2009/10/16
+【 バージョン 】　2.1.2
+【   作成日   】　2009/10/25
 【    種別    】　フリーウェア
 【  開発言語  】　Ruby 1.9.1
 【 ランタイム 】　Ruby 1.9.1～,Ruby/SDL 2.1～,SDL
@@ -1343,7 +1343,7 @@ v2.1.0(2009.10.9)
 ・Segments#max_x
 ・Segments#max_y
 
-v2.1.0.1(2009.10.16)
+v2.1.1(2009.10.16)
 <バグ修正>
 ・InitiativeYuki#commandメソッドで、選択不可の選択肢を選んだときにメソッド処理が終了するバグを修正
 ・Font#draw_textメソッドで、文字を転送先画像の外で描画するとSEGVを起こす問題を修正
@@ -1366,5 +1366,37 @@ v2.1.0.1(2009.10.16)
 ・WaitCounter#stop_callback_inner
 <インスタンスメソッド廃止>
 
+v2.1.2(2009.10.25)
+<バグ修正>
+・Plane#render,render_toメソッドで、画面より小さいスプライトを描画しようとしても何も描画されないバグを修正
+・Plane#move!,move_to!メソッドで、描画時に画面の左上が描画されない時があるバグを修正
+・Plane#move,move_toメソッドが、move!、move_to!と全く同じ動作をするバグを修正
+<機能改善>
+・各種render_toメソッドでの内部処理の安全性を高めた
+<仕様変更>
+・Sprite#part_move!,move_to!,resize!,resize_to!などのメソッドで、部分矩形の大きさを自動的に補正する処理を廃止
+・Sprite#ox=,oh=,ow=,oh=で、画像の範囲外の値を設定すると例外が発生する処理を廃止
+<ファイル追加>
+<ファイル削除>
+<グローバル変数追加>
+<定数追加>
+<定数削除>
+<構造体追加>
+<クラス追加>
+<モジュール追加>
+<mixin>
+<クラス・モジュールメソッド追加>
+<クラス・モジュールメソッド廃止>
+<インスタンスメソッド追加>
+・Sprite#render_rect
+・Sprite#render_rect_to
+・Sprite#render_rect2
+・Sprite#render_rect2_to
+・Sprite#render_rect_xy
+・Sprite#render_rect_xy_to
+・Sprite#render_rect2_xy
+・Sprite#render_rect2_xy_to
+<インスタンスメソッド廃止>
+
 *******************************************************************************
 このReadMeファイルは「れ～どめ～えじた～」によって作成されました。

data/lib/Miyako/API/plane.rb

@@ -69,6 +69,14 @@ module Miyako
       return @pos.y
     end
 
+    def adjust_pos(pos) #:nodocs:
+      pos.x %= @sprite.ow if pos.x >= @sprite.ow || pos.x <= -@sprite.ow
+      pos.y %= @sprite.oh if pos.y >= @sprite.oh || pos.y <= -@sprite.oh
+      return pos
+    end
+
+    private :adjust_pos
+
     #===プレーンの表示位置を移動させる
     #画像スクロールと同じ効果を得る
     #_dx_:: 移動量(x 座標)
@@ -76,8 +84,7 @@ module Miyako
     #返却値:: 自分自身を返す
     def move!(dx, dy)
       @pos.move!(dx, dy)
-      @pos.x %= @sprite.ow if @pos.x >= @sprite.ow || @pos.x <= -@sprite.ow
-      @pos.y %= @sprite.oh if @pos.y >= @sprite.oh || @pos.y <= -@sprite.oh
+      @pos = adjust_pos(@pos)
       return self
     end
 
@@ -88,8 +95,7 @@ module Miyako
     #返却値:: 自分自身を返す
     def move_to!(x, y)
       @pos.move_to!(x, y)
-      @pos.x %= @screen.ow if @pos.x >= @sprite.ow || @pos.x <= -@sprite.ow
-      @pos.y %= @screen.oh if @pos.y >= @sprite.oh || @pos.y <= -@sprite.oh
+      @pos = adjust_pos(@pos)
       return self
     end
 
@@ -99,11 +105,8 @@ module Miyako
     #_dx_:: 移動量(x 座標)
     #_dy_:: 移動量(y 座標)
     #返却値:: 変更したPosition構造体を返す
-    def move!(dx, dy)
-      @pos.move!(dx, dy)
-      @pos.x %= @sprite.ow if @pos.x >= @sprite.ow || @pos.x <= -@sprite.ow
-      @pos.y %= @sprite.oh if @pos.y >= @sprite.oh || @pos.y <= -@sprite.oh
-      return self
+    def move(dx, dy)
+      return adjust_pos(@pos.move(dx, dy))
     end
 
     #===プレーンの表示位置を移動させたときの位置を求める(移動位置指定)
@@ -112,11 +115,8 @@ module Miyako
     #_x_:: 移動先の位置(x 座標)
     #_y_:: 移動先の位置(y 座標)
     #返却値:: 変更したPosition構造体を返す
-    def move_to!(x, y)
-      @pos.move_to!(x, y)
-      @pos.x %= @screen.ow if @pos.x >= @sprite.ow || @pos.x <= -@sprite.ow
-      @pos.y %= @screen.oh if @pos.y >= @sprite.oh || @pos.y <= -@sprite.oh
-      return self
+    def move_to(x, y)
+      return adjust_pos(@pos.move_to(x, y))
     end
 
     #===画像の表示矩形を取得する
@@ -138,23 +138,6 @@ module Miyako
       @sprite.dispose
     end
 
-    #===画面に描画を指示する
-    #現在表示できるプレーンを、現在の状態で描画するよう指示する
-    #--
-    #(但し、実際に描画されるのはScreen.renderメソッドが呼び出された時)
-    #++
-    #返却値:: 自分自身を返す
-    def render
-      @size.h.times{|y|
-        @size.w.times{|x|
-          u = @sprite.to_unit
-          u.move_to!(x * @sprite.ow + @pos.x, y * @sprite.oh + @pos.y)
-          Screen.render_screen(u) if u.x >= 0 && u.y >= 0 && u.x + u.ow <= Screen.bitmap.w && u.y + u.oh <= Screen.bitmap.h
-        }
-      }
-      return self
-    end
-
     #===描画の素になるスプライトのアニメーションを更新する
     #返却値:: 更新した結果、パターンが変わった・アニメーションが終了したときはtrue、それ以外はfalseを返す
     def update_animation
@@ -190,6 +173,12 @@ module Miyako
     #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に、タイリングを行いながら貼り付ける。
     #visibleメソッドの値がfalseのときは描画されない。
     def render
+      @size.h.times{|y|
+        @size.w.times{|x|
+          @sprite.render_xy(x * @sprite.ow + @pos.x, y * @sprite.oh + @pos.y)
+        }
+      }
+      return self
     end
 
     #===プレーンを画像に描画する
@@ -198,6 +187,12 @@ module Miyako
     #visibleメソッドの値がfalseのときは描画されない。
     #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
     def render_to(dst)
+      @size.h.times{|y|
+        @size.w.times{|x|
+          @sprite.render_xy_to(dst, x * @sprite.ow + @pos.x, y * @sprite.oh + @pos.y)
+        }
+      }
+      return self
     end
 
     def_delegators(:sprite)

data/lib/Miyako/API/sprite.rb

@@ -248,7 +248,6 @@ module Miyako
     #値が画像の幅の範囲外(値がマイナス、画像の幅を超える値)のときは例外が発生する
     #_v_:: 表示開始位置。整数で指定
     def ox=(v)
-      raise MiyakoValueError, "Illegal ox parameter! : #{v} (range: 0..#{@w-@unit.ow})" if (v < 0 || (v+@unit.ow) > @w)
       @unit.ox = v
     end
 
@@ -257,7 +256,6 @@ module Miyako
     #値が画像の高さの範囲外(値がマイナス、画像の高さを超える値)のときは例外が発生する
     #_v_:: 表示開始位置。整数で指定
     def oy=(v)
-      raise MiyakoValueError, "Illegal oy parameter! : #{v} (range: 0..#{@h-@unit.oh})" if (v < 0 || (v+@unit.oh) > @h)
       @unit.oy = v
     end
 
@@ -266,7 +264,6 @@ module Miyako
     #値が画像の幅の範囲外(値がマイナス、画像の幅を超える値)のときは例外が発生する
     #_v_:: 表示幅。整数で指定
     def ow=(v)
-      raise MiyakoValueError, "Illegal ox parameter! : #{v} (range: 0..#{@w-@unit.ox})" if (v < 0 || (@unit.ox+v) > @w)
       @unit.ow = v
       set_layout_size(v, @unit.oh)
     end
@@ -276,7 +273,6 @@ module Miyako
     #値が画像の高さの範囲外(値がマイナス、画像の高さを超える値)のときは例外が発生する
     #_v_:: 表示高。整数で指定
     def oh=(v)
-      raise MiyakoValueError, "Illegal ox parameter! : #{v} (range: 0..#{@h-@unit.oy})" if (v < 0 || (@unit.oy+v) > @h)
       @unit.oh = v
       set_layout_size(@unit.ow, v)
     end
@@ -288,30 +284,30 @@ module Miyako
     end
 
     def adjust_part(ox, oy, ow, oh)
-      if ox < 0
-        ow += ox
-        ox = 0
-      end
-      if oy < 0
-        oh += oy
-        oy = 0
-      end
-      ow = 1 if ow <= 0
-      oh = 1 if oh <= 0
-      if ox + ow > w
-        ow = w - ox
-        if ow == 0
-          ox -= 1
-          ow = 1
-        end
-      end
-      if oy + oh > h
-        oh = h - oy
-        if oh == 0
-          oy -= 1
-          oh = 1
-        end
-      end
+#      if ox < 0
+#        ow += ox
+#        ox = 0
+#      end
+#      if oy < 0
+#        oh += oy
+#        oy = 0
+#     end
+#     ow = 1 if ow <= 0
+#     oh = 1 if oh <= 0
+#      if ox + ow > w
+#        ow = w - ox
+#        if ow == 0
+#          ox -= 1
+#          ow = 1
+#        end
+#      end
+#      if oy + oh > h
+#        oh = h - oy
+#        if oh == 0
+#          oy -= 1
+#          oh = 1
+#        end
+#      end
       Rect.new(ox,oy,ow,oh)
     end
 
@@ -562,29 +558,24 @@ module Miyako
     def render_to(dst)
     end
 
-    #===インスタンスの内容を画面に描画する
-    #現在の画像を、現在の状態で描画するよう指示する
-    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
-    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
-    #ブロックの引数は、|インスタンスのSpriteUnit, 画面のSpriteUnit|となる。
+    #===インスタンスの内容を画面の指定の位置に描画する
+    #画像を画面の[x,y]の位置を開始点として描画する
+    #このメソッドでは、あらかじめ持っている描画開始位置を無視して描画する
     #visibleメソッドの値がfalseのときは描画されない。
     #返却値:: 自分自身を返す
     def render_xy(x,y)
     end
 
-    #===インスタンスの内容を別のインスタンスに描画する
-    #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。
-    #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に設定にする。
-    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
-    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
-    #ブロックの引数は、|インスタンスのSpriteUnit,転送先のSpriteUnit|となる。
+    #===インスタンスの内容を別のインスタンスの指定の位置に描画する
+    #画像を大正の画像の[x,y]位置を開始点として描画する
+    #このメソッドでは、あらかじめ持っている描画開始位置を無視して描画する
     #visibleメソッドの値がfalseのときは描画されない。
     #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
     #返却値:: 自分自身を返す
     def render_xy_to(dst,x,y)
     end
 
-    #===インスタンスの内容を画面に描画する
+    #===部分矩形の一部分を画面に描画する
     #現在の画像を、現在の状態で描画するよう指示する
     #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
     #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
@@ -594,7 +585,7 @@ module Miyako
     def render_rect(rect)
     end
 
-    #===インスタンスの内容を別のインスタンスに描画する
+    #===部分矩形の一部分を別のインスタンスに描画する
     #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。
     #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に設定にする。
     #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
@@ -606,50 +597,71 @@ module Miyako
     def render_rect_to(dst,rect)
     end
 
-    #===インスタンスの内容を画面に描画する
-    #現在の画像を、現在の状態で描画するよう指示する
-    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
-    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
-    #ブロックの引数は、|インスタンスのSpriteUnit, 画面のSpriteUnit|となる。
+    #===画像の一部分を画面に描画する
+    #画像の一部分（rect構造体で示した矩形）を画面に描画する
+    #このメソッドでは、部分矩形を無視して描画する
     #visibleメソッドの値がfalseのときは描画されない。
+    #_rect_:: Rect構造体
     #返却値:: 自分自身を返す
     def render_rect2(rect)
     end
 
-    #===インスタンスの内容を別のインスタンスに描画する
-    #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。
-    #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に設定にする。
-    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
-    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
-    #ブロックの引数は、|インスタンスのSpriteUnit,転送先のSpriteUnit|となる。
+    #===画像の一部分を別のインスタンスに描画する
+    #画像の一部分（rect構造体で示した矩形）を別のスプライトに描画する
+    #このメソッドでは、部分矩形を無視して描画する
     #visibleメソッドの値がfalseのときは描画されない。
     #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #_rect_:: Rect構造体
     #返却値:: 自分自身を返す
     def render_rect2_to(dst,rect)
     end
 
-    #===インスタンスの内容を画面に描画する
-    #現在の画像を、現在の状態で描画するよう指示する
-    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
-    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
-    #ブロックの引数は、|インスタンスのSpriteUnit, 画面のSpriteUnit|となる。
+    #===部分矩形の一部分を画面の指定の位置に描画する
+    #画像の一部分（rect構造体で示した矩形）を画面の[x,y]の位置を開始点として描画する
+    #このメソッドでは、あらかじめ持っている描画開始位置を無視して描画する
     #visibleメソッドの値がfalseのときは描画されない。
+    #_rect_:: Rect構造体
+    #_x_:: 描画開始位置（x座標）
+    #_y_:: 描画開始位置（y座標）
     #返却値:: 自分自身を返す
     def render_rect_xy(rect,x,y)
     end
 
-    #===インスタンスの内容を別のインスタンスに描画する
-    #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。
-    #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に設定にする。
-    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
-    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
-    #ブロックの引数は、|インスタンスのSpriteUnit,転送先のSpriteUnit|となる。
+    #===部分矩形の一部分を別のインスタンスの指定の位置にに描画する
+    #画像の一部分（rect構造体で示した矩形）をスプライトの[x,y]の位置を開始点として描画する
+    #このメソッドでは、あらかじめ持っている描画開始位置を無視して描画する
     #visibleメソッドの値がfalseのときは描画されない。
     #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #_rect_:: Rect構造体
+    #_x_:: 描画開始位置（x座標）
+    #_y_:: 描画開始位置（y座標）
     #返却値:: 自分自身を返す
     def render_rect_xy_to(dst,rect,x,y)
     end
 
+    #===画像の一部分を画面の指定の位置に描画する
+    #画像の一部分（rect構造体で示した矩形）を画面の[x,y]の位置を開始点として描画する
+    #このメソッドでは、あらかじめ持っている描画開始位置と部分矩形を無視して描画する
+    #visibleメソッドの値がfalseのときは描画されない。
+    #_rect_:: Rect構造体
+    #_x_:: 描画開始位置（x座標）
+    #_y_:: 描画開始位置（y座標）
+    #返却値:: 自分自身を返す
+    def render_rect2_xy(rect,x,y)
+    end
+
+    #===画像の一部分を別のインスタンスの指定の位置にに描画する
+    #画像の一部分（rect構造体で示した矩形）をスプライトの[x,y]の位置を開始点として描画する
+    #このメソッドでは、あらかじめ持っている描画開始位置と部分矩形を無視して描画する
+    #visibleメソッドの値がfalseのときは描画されない。
+    #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #_rect_:: Rect構造体
+    #_x_:: 描画開始位置（x座標）
+    #_y_:: 描画開始位置（y座標）
+    #返却値:: 自分自身を返す
+    def render_rect2_xy_to(dst,rect,x,y)
+    end
+
     #===インスタンスの内容を画面に描画する(回転/拡大/縮小/鏡像付き)
     #転送元の描画範囲は、src側SpriteUnitの(ox,oy)を起点に、src側(ow,oh)の範囲で転送する。回転の中心はsrc側(ox,oy)を起点に、src側(cx,cy)が中心になるように設定する。
     #画面の描画範囲は、src側SpriteUnitの(x,y)を起点に、画面側SpriteUnitの(cx,cy)が中心になるように設定にする。

data/lib/Miyako/miyako.rb

@@ -60,7 +60,7 @@ Thread.abort_on_exception = true
 
 #==Miyako基幹モジュール
 module Miyako
-  VERSION = "2.1.1"
+  VERSION = "2.1.2"
 
   #===アプリケーション実行中に演奏する音楽のサンプリングレートを指定する
   #単位はHz(周波数)

data/miyako_no_katana.c

@@ -37,6 +37,7 @@ static VALUE mInput = Qnil;
 static VALUE mSpriteBase = Qnil;
 static VALUE mAnimation = Qnil;
 static VALUE mDiagram = Qnil;
+static VALUE eMiyakoError = Qnil;
 static VALUE cSurface = Qnil;
 static VALUE cGL = Qnil;
 static VALUE cFont = Qnil;
@@ -119,34 +120,77 @@ static VALUE miyako_main_loop(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+/*
+:nodoc:
+*/
+static VALUE sprite_get_rect(VALUE src, int *dst)
+{
+  int i;
+  VALUE *tmp;
+  switch(TYPE(src))
+  {
+  case T_ARRAY:
+    if(RARRAY_LEN(src) < 4)
+      rb_raise(eMiyakoError, "rect needs 4 or much elements!");
+    tmp = RARRAY_PTR(src);
+    for(i=0; i<4; i++){ *dst++ = NUM2INT(*tmp++); }
+    break;
+  case T_STRUCT:
+    if(RSTRUCT_LEN(src) < 4)
+      rb_raise(eMiyakoError, "rect needs 4 or much members!");
+    tmp = RSTRUCT_PTR(src);
+    for(i=0; i<4; i++){ *dst++ = NUM2INT(*tmp++); }
+    break;
+  default:
+    *(dst+0) = NUM2INT(rb_funcall(src, rb_intern("x"), 0));
+    *(dst+1) = NUM2INT(rb_funcall(src, rb_intern("y"), 0));
+    *(dst+2) = NUM2INT(rb_funcall(src, rb_intern("w"), 0));
+    *(dst+3) = NUM2INT(rb_funcall(src, rb_intern("h"), 0));
+    break;
+  }
+  return Qnil;
+}
+
 /*
 ===内部用レンダメソッド
 */
 static void render_to_inner(MiyakoBitmap *sb, MiyakoBitmap *db)
 {
-	if(sb->ptr == db->ptr){ return; }
+  if(sb->ptr == db->ptr){ return; }
 
-	MiyakoSize size;
+  MiyakoSize size;
   if(_miyako_init_rect(sb, db, &size) == 0) return;
 
-	SDL_LockSurface(sb->surface);
-	SDL_LockSurface(db->surface);
+  SDL_LockSurface(sb->surface);
+  SDL_LockSurface(db->surface);
+
+  int x, y;
+  for(y = 0; y < size.h; y++)
+  {
+    Uint32 src_y = (sb->rect.y         + y);
+    Uint32 dst_y = (db->rect.y + sb->y + y);
+    Uint32 src_x = sb->rect.x;
+    Uint32 dst_x = db->rect.x + sb->x;
+
+    if(src_y < 0 || dst_y < 0){ continue; }
+    if(src_y >= sb->surface->h || dst_y >= db->surface->h){ break; }
 
-	int x, y;
-	for(y = 0; y < size.h; y++)
-	{
-    Uint32 *psrc = sb->ptr + (sb->rect.y         + y) * sb->surface->w + sb->rect.x;
-    Uint32 *pdst = db->ptr + (db->rect.y + sb->y + y) * db->surface->w + db->rect.x + sb->x;
-		for(x = 0; x < size.w; x++)
-		{
+    Uint32 *psrc = sb->ptr + src_y * sb->surface->w + src_x;
+    Uint32 *pdst = db->ptr + dst_y * db->surface->w + dst_x;
+    for(x = 0; x < size.w; x++)
+    {
+      if(src_x < 0 || dst_x < 0){  psrc++; pdst++; src_x++; dst_x++; continue; }
+      if(src_x >= sb->surface->w || dst_x >= db->surface->w){ break; }
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
       sb->color.a = (*psrc >> 24) & 0xff | sb->a255;
-      if(sb->color.a == 0){ psrc++; pdst++; continue; }
+      if(sb->color.a == 0){ psrc++; pdst++; src_x++; dst_x++; continue; }
       db->color.a = (*pdst >> 24) & 0xff | db->a255;
       if(db->color.a == 0 || sb->color.a == 255){
         *pdst = *psrc | (sb->a255 << 24);
         psrc++;
         pdst++;
+        src_x++;
+        dst_x++;
         continue;
       }
       int a1 = sb->color.a + 1;
@@ -157,18 +201,20 @@ static void render_to_inner(MiyakoBitmap *sb, MiyakoBitmap *db)
       db->color.r = (*pdst >> 16) & 0xff;
       db->color.g = (*pdst >>  8) & 0xff;
       db->color.b = (*pdst      ) & 0xff;
-			*pdst = ((sb->color.r * a1 + db->color.r * a2) >> 8) << 16 |
-						  ((sb->color.g * a1 + db->color.g * a2) >> 8) <<  8 |
-							((sb->color.b * a1 + db->color.b * a2) >> 8)       |
-							0xff << 24;
+      *pdst = ((sb->color.r * a1 + db->color.r * a2) >> 8) << 16 |
+              ((sb->color.g * a1 + db->color.g * a2) >> 8) <<  8 |
+              ((sb->color.b * a1 + db->color.b * a2) >> 8)       |
+              0xff << 24;
 #else
       sb->color.a = (*psrc & sb->fmt->Amask) | sb->a255;
-      if(sb->color.a == 0){ psrc++; pdst++; continue; }
+      if(sb->color.a == 0){ psrc++; pdst++; src_x++; dst_x++; continue; }
       db->color.a = (*pdst & db->fmt->Amask) | db->a255;
       if(db->color.a == 0 || sb->color.a == 255){
         *pdst = *psrc | sb->a255;
         psrc++;
         pdst++;
+        src_x++;
+        dst_x++;
         continue;
       }
       int a1 = sb->color.a + 1;
@@ -179,18 +225,20 @@ static void render_to_inner(MiyakoBitmap *sb, MiyakoBitmap *db)
       db->color.r = (*pdst & db->fmt->Rmask) >> db->fmt->Rshift;
       db->color.g = (*pdst & db->fmt->Gmask) >> db->fmt->Gshift;
       db->color.b = (*pdst & db->fmt->Bmask) >> db->fmt->Bshift;
-			*pdst = ((sb->color.r * a1 + db->color.r * a2) >> 8) << db->fmt->Rshift |
-						  ((sb->color.g * a1 + db->color.g * a2) >> 8) << db->fmt->Gshift |
-							((sb->color.b * a1 + db->color.b * a2) >> 8) << db->fmt->Bshift |
-							0xff;
+      *pdst = ((sb->color.r * a1 + db->color.r * a2) >> 8) << db->fmt->Rshift |
+              ((sb->color.g * a1 + db->color.g * a2) >> 8) << db->fmt->Gshift |
+              ((sb->color.b * a1 + db->color.b * a2) >> 8) << db->fmt->Bshift |
+              0xff;
 #endif
       psrc++;
       pdst++;
+      src_x++;
+      dst_x++;
     }
   }
 
-	SDL_UnlockSurface(sb->surface);
-	SDL_UnlockSurface(db->surface);
+  SDL_UnlockSurface(sb->surface);
+  SDL_UnlockSurface(db->surface);
 }
 
 /*
@@ -198,8 +246,8 @@ static void render_to_inner(MiyakoBitmap *sb, MiyakoBitmap *db)
 */
 static void render_inner(MiyakoBitmap *sb, MiyakoBitmap *db)
 {
-	db->rect.x += sb->x;
-	db->rect.y += sb->y;
+  db->rect.x += sb->x;
+  db->rect.y += sb->y;
   SDL_BlitSurface(sb->surface, &(sb->rect), db->surface, &(db->rect));
 }
 
@@ -299,8 +347,8 @@ VALUE _miyako_sprite_render(VALUE sprite)
 static VALUE sprite_render_to_sprite(VALUE self, VALUE vdst)
 {
   if(rb_iv_get(self, str_visible) == Qfalse) return self;
-	MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit_2(self, vdst, scr, &src, &dst, Qnil, Qnil, 1);
   render_to_inner(&src, &dst);
   return self;
@@ -349,8 +397,8 @@ static VALUE sprite_render_xy_to_sprite(VALUE self, VALUE vdst, VALUE vx, VALUE
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit_2(self, vdst, scr, &src, &dst, Qnil, Qnil, 1);
   src.x = NUM2INT(vx);
   src.y = NUM2INT(vy);
@@ -358,6 +406,224 @@ static VALUE sprite_render_xy_to_sprite(VALUE self, VALUE vdst, VALUE vx, VALUE
   return self;
 }
 
+/*
+インスタンスの内容を画面に描画する
+*/
+static VALUE sprite_render_rect(VALUE self, VALUE vrect)
+{
+  if(rb_iv_get(self, str_visible) == Qfalse) return self;
+
+  int rect[4];
+  sprite_get_rect(vrect, &(rect[0]));
+
+  VALUE src_unit = rb_iv_get(self, "@unit");
+  VALUE dst_unit = rb_iv_get(mScreen, "@@unit");
+
+  SDL_Surface  *src = GetSurface(*(RSTRUCT_PTR(src_unit)+0))->surface;
+  SDL_Surface  *dst = GetSurface(*(RSTRUCT_PTR(dst_unit)+0))->surface;
+
+  SDL_Rect srect, drect;
+
+  VALUE *s_p = RSTRUCT_PTR(src_unit);
+  srect.x = NUM2INT(*(s_p + 1)) + rect[0];
+  srect.y = NUM2INT(*(s_p + 2)) + rect[1];
+  srect.w = rect[2];
+  srect.h = rect[3];
+
+  VALUE *d_p = RSTRUCT_PTR(dst_unit);
+  drect.x = NUM2INT(*(d_p + 1));
+  drect.y = NUM2INT(*(d_p + 2));
+  drect.w = NUM2INT(*(d_p + 3));
+  drect.h = NUM2INT(*(d_p + 4));
+
+  SDL_BlitSurface(src, &srect, dst, &drect);
+  return self;
+}
+
+/*
+インスタンスの内容を別のインスタンスに描画する
+*/
+static VALUE sprite_render_rect_to_sprite(VALUE self, VALUE vdst, VALUE vrect)
+{
+  VALUE visible = rb_iv_get(self, str_visible);
+  if(visible == Qfalse) return self;
+  int rect[4];
+  sprite_get_rect(vrect, &(rect[0]));
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  _miyako_setup_unit_2(self, vdst, scr, &src, &dst, Qnil, Qnil, 1);
+  src.rect.x += rect[0];
+  src.rect.y += rect[1];
+  src.rect.w = rect[2];
+  src.rect.h = rect[3];
+  render_to_inner(&src, &dst);
+  return self;
+}
+
+/*
+インスタンスの内容を画面に描画する
+*/
+static VALUE sprite_render_rect2(VALUE self, VALUE vrect)
+{
+  if(rb_iv_get(self, str_visible) == Qfalse) return self;
+
+  int rect[4];
+  sprite_get_rect(vrect, &(rect[0]));
+
+  VALUE src_unit = rb_iv_get(self, "@unit");
+  VALUE dst_unit = rb_iv_get(mScreen, "@@unit");
+
+  SDL_Surface  *src = GetSurface(*(RSTRUCT_PTR(src_unit)+0))->surface;
+  SDL_Surface  *dst = GetSurface(*(RSTRUCT_PTR(dst_unit)+0))->surface;
+
+  SDL_Rect srect, drect;
+
+  srect.x = rect[0];
+  srect.y = rect[1];
+  srect.w = rect[2];
+  srect.h = rect[3];
+
+  VALUE *d_p = RSTRUCT_PTR(dst_unit);
+  drect.x = NUM2INT(*(d_p + 1));
+  drect.y = NUM2INT(*(d_p + 2));
+  drect.w = NUM2INT(*(d_p + 3));
+  drect.h = NUM2INT(*(d_p + 4));
+
+  SDL_BlitSurface(src, &srect, dst, &drect);
+  return self;
+}
+
+/*
+インスタンスの内容を別のインスタンスに描画する
+*/
+static VALUE sprite_render_rect2_to_sprite(VALUE self, VALUE vdst, VALUE vrect)
+{
+  VALUE visible = rb_iv_get(self, str_visible);
+  if(visible == Qfalse) return self;
+  int rect[4];
+  sprite_get_rect(vrect, &(rect[0]));
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  _miyako_setup_unit_2(self, vdst, scr, &src, &dst, Qnil, Qnil, 1);
+  src.rect.x = rect[0];
+  src.rect.y = rect[1];
+  src.rect.w = rect[2];
+  src.rect.h = rect[3];
+  render_to_inner(&src, &dst);
+  return self;
+}
+
+/*
+インスタンスの内容を画面に描画する
+*/
+static VALUE sprite_render_rect_xy(VALUE self, VALUE vrect, VALUE vx, VALUE vy)
+{
+  if(rb_iv_get(self, str_visible) == Qfalse) return self;
+
+  int rect[4];
+  sprite_get_rect(vrect, &(rect[0]));
+
+  VALUE src_unit = rb_iv_get(self, "@unit");
+  VALUE dst_unit = rb_iv_get(mScreen, "@@unit");
+
+  SDL_Surface  *src = GetSurface(*(RSTRUCT_PTR(src_unit)+0))->surface;
+  SDL_Surface  *dst = GetSurface(*(RSTRUCT_PTR(dst_unit)+0))->surface;
+
+  SDL_Rect srect, drect;
+
+  VALUE *s_p = RSTRUCT_PTR(src_unit);
+  srect.x = NUM2INT(*(s_p + 1)) + rect[0];
+  srect.y = NUM2INT(*(s_p + 2)) + rect[1];
+  srect.w = rect[2];
+  srect.h = rect[3];
+
+  VALUE *d_p = RSTRUCT_PTR(dst_unit);
+  drect.x = NUM2INT(*(d_p + 1)) + NUM2INT(vx);
+  drect.y = NUM2INT(*(d_p + 2)) + NUM2INT(vy);
+  drect.w = NUM2INT(*(d_p + 3));
+  drect.h = NUM2INT(*(d_p + 4));
+
+  SDL_BlitSurface(src, &srect, dst, &drect);
+  return self;
+}
+
+/*
+インスタンスの内容を別のインスタンスに描画する
+*/
+static VALUE sprite_render_rect_xy_to_sprite(VALUE self, VALUE vdst, VALUE vrect, VALUE vx, VALUE vy)
+{
+  VALUE visible = rb_iv_get(self, str_visible);
+  if(visible == Qfalse) return self;
+  int rect[4];
+  sprite_get_rect(vrect, &(rect[0]));
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  _miyako_setup_unit_2(self, vdst, scr, &src, &dst, Qnil, Qnil, 1);
+  src.rect.x += rect[0];
+  src.rect.y += rect[1];
+  src.rect.w = rect[2];
+  src.rect.h = rect[3];
+  src.x = NUM2INT(vx);
+  src.y = NUM2INT(vy);
+  render_to_inner(&src, &dst);
+  return self;
+}
+
+/*
+インスタンスの内容を画面に描画する
+*/
+static VALUE sprite_render_rect2_xy(VALUE self, VALUE vrect, VALUE vx, VALUE vy)
+{
+  if(rb_iv_get(self, str_visible) == Qfalse) return self;
+
+  int rect[4];
+  sprite_get_rect(vrect, &(rect[0]));
+
+  VALUE src_unit = rb_iv_get(self, "@unit");
+  VALUE dst_unit = rb_iv_get(mScreen, "@@unit");
+
+  SDL_Surface  *src = GetSurface(*(RSTRUCT_PTR(src_unit)+0))->surface;
+  SDL_Surface  *dst = GetSurface(*(RSTRUCT_PTR(dst_unit)+0))->surface;
+
+  SDL_Rect srect, drect;
+
+  srect.x = rect[0];
+  srect.y = rect[1];
+  srect.w = rect[2];
+  srect.h = rect[3];
+
+  VALUE *d_p = RSTRUCT_PTR(dst_unit);
+  drect.x = NUM2INT(*(d_p + 1)) + NUM2INT(vx);
+  drect.y = NUM2INT(*(d_p + 2)) + NUM2INT(vy);
+  drect.w = NUM2INT(*(d_p + 3));
+  drect.h = NUM2INT(*(d_p + 4));
+
+  SDL_BlitSurface(src, &srect, dst, &drect);
+  return self;
+}
+
+/*
+インスタンスの内容を別のインスタンスに描画する
+*/
+static VALUE sprite_render_rect2_xy_to_sprite(VALUE self, VALUE vdst, VALUE vrect, VALUE vx, VALUE vy)
+{
+  VALUE visible = rb_iv_get(self, str_visible);
+  if(visible == Qfalse) return self;
+  int rect[4];
+  sprite_get_rect(vrect, &(rect[0]));
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  _miyako_setup_unit_2(self, vdst, scr, &src, &dst, Qnil, Qnil, 1);
+  src.rect.x = rect[0];
+  src.rect.y = rect[1];
+  src.rect.w = rect[2];
+  src.rect.h = rect[3];
+  src.x = NUM2INT(vx);
+  src.y = NUM2INT(vy);
+  render_to_inner(&src, &dst);
+  return self;
+}
+
 /*
 :nodoc:
 */
@@ -404,7 +670,7 @@ void _miyako_screen_pre_render()
 static VALUE screen_render(VALUE self)
 {
   VALUE dst = rb_iv_get(mScreen, "@@unit");
-	SDL_Surface *pdst = GetSurface(*(RSTRUCT_PTR(dst)))->surface;
+  SDL_Surface *pdst = GetSurface(*(RSTRUCT_PTR(dst)))->surface;
   VALUE fps_view = rb_iv_get(mScreen, "@@fpsView");
 
   _miyako_sprite_list_render(rb_iv_get(cSprite, "@@sprites"));
@@ -449,8 +715,8 @@ void _miyako_screen_render()
 */
 static VALUE screen_render_screen(VALUE self, VALUE vsrc)
 {
-	MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit_2(vsrc, mScreen, scr, &src, &dst, Qnil, Qnil, 1);
   render_inner(&src, &dst);
   return self;
@@ -566,7 +832,7 @@ static void maplayer_render_inner(VALUE self, MiyakoBitmap *dst)
   int my = pos_y % mc_chip_size_h;
 
   MiyakoBitmap src;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
 
   int bx = dst->rect.x;
   int by = dst->rect.y;
@@ -580,7 +846,7 @@ static void maplayer_render_inner(VALUE self, MiyakoBitmap *dst)
       int code = NUM2INT(*(RARRAY_PTR(mapdat2) + idx2));
       if(code == -1){ continue; }
       _miyako_setup_unit(
-			  rb_funcall(*(RARRAY_PTR(munits) + code),
+        rb_funcall(*(RARRAY_PTR(munits) + code),
                    rb_intern("to_unit"), 0),
         scr, &src,
         INT2NUM(x * ow - mx), INT2NUM(y * oh - my), 0);
@@ -613,7 +879,7 @@ static void fixedmaplayer_render_inner(VALUE self, MiyakoBitmap *dst)
   VALUE mapdat = rb_iv_get(self, "@mapdat");
 
   MiyakoBitmap src;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
 
   int bx = dst->rect.x;
   int by = dst->rect.y;
@@ -676,7 +942,7 @@ static void maplayer_render_to_inner(VALUE self, MiyakoBitmap *dst)
   int my = pos_y % mc_chip_size_h;
 
   MiyakoBitmap src;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
 
   int bx = dst->rect.x;
   int by = dst->rect.y;
@@ -720,7 +986,7 @@ static void fixedmaplayer_render_to_inner(VALUE self, MiyakoBitmap *dst)
   VALUE mapdat = rb_iv_get(self, "@mapdat");
 
   MiyakoBitmap src;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
 
   int bx = dst->rect.x;
   int by = dst->rect.y;
@@ -749,8 +1015,8 @@ static VALUE maplayer_render(VALUE self)
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit(mScreen, scr, &dst, Qnil, Qnil, 1);
   maplayer_render_inner(self, &dst);
   return self;
@@ -763,8 +1029,8 @@ static VALUE fixedmaplayer_render(VALUE self)
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit(mScreen, scr, &dst, Qnil, Qnil, 1);
   fixedmaplayer_render_inner(self, &dst);
   return self;
@@ -777,8 +1043,8 @@ static VALUE maplayer_render_to_sprite(VALUE self, VALUE vdst)
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
   maplayer_render_to_inner(self, &dst);
   return self;
@@ -791,8 +1057,8 @@ static VALUE fixedmaplayer_render_to_sprite(VALUE self, VALUE vdst)
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
   maplayer_render_inner(self, &dst);
   return self;
@@ -805,8 +1071,8 @@ static VALUE map_render(VALUE self)
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit(mScreen, scr, &dst, Qnil, Qnil, 1);
   VALUE map_layers = rb_iv_get(self, "@map_layers");
   int i;
@@ -824,8 +1090,8 @@ static VALUE fixedmap_render(VALUE self)
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit(mScreen, scr, &dst, Qnil, Qnil, 1);
   VALUE map_layers = rb_iv_get(self, "@map_layers");
   int i;
@@ -843,8 +1109,8 @@ static VALUE map_render_to_sprite(VALUE self, VALUE vdst)
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
 
   VALUE map_layers = rb_iv_get(self, "@map_layers");
@@ -863,8 +1129,8 @@ static VALUE fixedmap_render_to_sprite(VALUE self, VALUE vdst)
 {
   VALUE visible = rb_iv_get(self, str_visible);
   if(visible == Qfalse) return self;
-	MiyakoBitmap dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit(vdst, scr, &dst, Qnil, Qnil, 1);
 
   VALUE map_layers = rb_iv_get(self, "@map_layers");
@@ -1001,8 +1267,8 @@ static VALUE sa_render(VALUE self)
   *(runit + 5) = INT2NUM(NUM2INT(tmp_x) + NUM2INT(*(move_off+0)));
   *(runit + 6) = INT2NUM(NUM2INT(tmp_y) + NUM2INT(*(move_off+1)));
 
-	MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit_2(vsrc, mScreen, scr, &src, &dst, Qnil, Qnil, 1);
   render_inner(&src, &dst);
 
@@ -1042,8 +1308,8 @@ static VALUE sa_render_to_sprite(VALUE self, VALUE vdst)
   *(runit + 5) = INT2NUM(NUM2INT(tmp_x) + NUM2INT(rb_funcall(move_off, id_kakko, 1, nZero)));
   *(runit + 6) = INT2NUM(NUM2INT(tmp_y) + NUM2INT(rb_funcall(move_off, id_kakko, 1, nOne )));
 
-	MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  MiyakoBitmap src, dst;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
   render_to_inner(&src, &dst);
 
@@ -1063,32 +1329,24 @@ static VALUE plane_render(VALUE self)
   if(visible == Qfalse) return self;
   VALUE sprite = rb_iv_get(self, "@sprite");
 
-  VALUE ssize = rb_iv_get(mScreen, "@@size");
-  int ssw = NUM2INT(*(RSTRUCT_PTR(ssize) + 0));
-  int ssh = NUM2INT(*(RSTRUCT_PTR(ssize) + 1));
   VALUE pos = rb_iv_get(self, "@pos");
   VALUE size = rb_iv_get(self, "@size");
+  VALUE osize = rb_funcall(sprite, rb_intern("layout_size"), 0);
   int w = NUM2INT(*(RSTRUCT_PTR(size) + 0));
   int h = NUM2INT(*(RSTRUCT_PTR(size) + 1));
   int pos_x = NUM2INT(*(RSTRUCT_PTR(pos) + 0));
   int pos_y = NUM2INT(*(RSTRUCT_PTR(pos) + 1));
-
-	MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
-	_miyako_setup_unit_2(sprite, mScreen, scr, &src, &dst, Qnil, Qnil, 1);
-
-  int sw = src.rect.w;
-  int sh = src.rect.h;
+  int ow = NUM2INT(*(RSTRUCT_PTR(osize) + 0));
+  int oh = NUM2INT(*(RSTRUCT_PTR(osize) + 1));
 
   int x, y;
   for(y = 0; y < h; y++){
     for(x = 0; x < w; x++){
-      src.x = (x-1) * sw + pos_x;
-      src.y = (y-1) * sh + pos_y;
-      if(src.x > 0 || src.y > 0
-      || (src.x+sw) <= ssw || (src.y+sh) <= ssh){
-				render_inner(&src, &dst);
-      }
+      if(pos_x > 0) pos_x -= ow;
+      if(pos_y > 0) pos_y -= oh;
+      VALUE vx = INT2NUM(pos_x + x * ow);
+      VALUE vy = INT2NUM(pos_y + y * oh);
+      rb_funcall(sprite, rb_intern("render_xy"), 2, vx, vy);
     }
   }
 
@@ -1104,32 +1362,24 @@ static VALUE plane_render_to_sprite(VALUE self, VALUE vdst)
   if(visible == Qfalse) return self;
   VALUE sprite = rb_iv_get(self, "@sprite");
 
-  VALUE ssize = rb_iv_get(mScreen, "@@size");
-  int ssw = NUM2INT(*(RSTRUCT_PTR(ssize) + 0));
-  int ssh = NUM2INT(*(RSTRUCT_PTR(ssize) + 1));
   VALUE pos = rb_iv_get(self, "@pos");
   VALUE size = rb_iv_get(self, "@size");
+  VALUE osize = rb_funcall(sprite, rb_intern("layout_size"), 0);
   int w = NUM2INT(*(RSTRUCT_PTR(size) + 0));
   int h = NUM2INT(*(RSTRUCT_PTR(size) + 1));
   int pos_x = NUM2INT(*(RSTRUCT_PTR(pos) + 0));
   int pos_y = NUM2INT(*(RSTRUCT_PTR(pos) + 1));
-
-	MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
-	_miyako_setup_unit_2(sprite, vdst, scr, &src, &dst, Qnil, Qnil, 1);
-
-  int sw = src.rect.w;
-  int sh = src.rect.h;
+  int ow = NUM2INT(*(RSTRUCT_PTR(osize) + 0));
+  int oh = NUM2INT(*(RSTRUCT_PTR(osize) + 1));
 
   int x, y;
   for(y = 0; y < h; y++){
     for(x = 0; x < w; x++){
-      src.x = (x-1) * sw + pos_x;
-      src.y = (y-1) * sh + pos_y;
-      if(src.x > 0 || src.y > 0
-      || (src.x+sw) <= ssw || (src.y+sh) <= ssh){
-        render_to_inner(&src, &dst);
-      }
+      if(pos_x > 0) pos_x -= ow;
+      if(pos_y > 0) pos_y -= oh;
+      VALUE vx = INT2NUM(pos_x + x * ow);
+      VALUE vy = INT2NUM(pos_y + y * oh);
+      rb_funcall(sprite, rb_intern("render_xy_to"), 3, vdst, vx, vy);
     }
   }
 
@@ -1205,6 +1455,7 @@ void Init_miyako_no_katana()
   mSpriteBase = rb_define_module_under(mMiyako, "SpriteBase");
   mAnimation = rb_define_module_under(mMiyako, "Animation");
   mDiagram = rb_define_module_under(mMiyako, "Diagram");
+  eMiyakoError  = rb_define_class_under(mMiyako, "MiyakoError", rb_eException);
   cSurface = rb_define_class_under(mSDL, "Surface", rb_cObject);
   cGL  = rb_define_module_under(mSDL, "GL");
   cFont  = rb_define_class_under(mMiyako, "Font", rb_cObject);
@@ -1279,6 +1530,14 @@ void Init_miyako_no_katana()
   rb_define_method(cSprite, "render_to", sprite_render_to_sprite, 1);
   rb_define_method(cSprite, "render_xy", sprite_render_xy, 2);
   rb_define_method(cSprite, "render_xy_to", sprite_render_xy_to_sprite, 3);
+  rb_define_method(cSprite, "render_rect", sprite_render_rect, 1);
+  rb_define_method(cSprite, "render_rect_to", sprite_render_rect_to_sprite, 2);
+  rb_define_method(cSprite, "render_rect2", sprite_render_rect2, 1);
+  rb_define_method(cSprite, "render_rect2_to", sprite_render_rect2_to_sprite, 2);
+  rb_define_method(cSprite, "render_rect_xy", sprite_render_rect_xy, 3);
+  rb_define_method(cSprite, "render_rect_xy_to", sprite_render_rect_xy_to_sprite, 4);
+  rb_define_method(cSprite, "render_rect2_xy", sprite_render_rect2_xy, 3);
+  rb_define_method(cSprite, "render_rect2_xy_to", sprite_render_rect2_xy_to_sprite, 4);
 
   rb_define_method(cPlane, "render", plane_render, 0);
   rb_define_method(cPlane, "render_to", plane_render_to_sprite, 1);

data/miyako_transform.c

@@ -54,14 +54,14 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
 {
   MiyakoBitmap src, dst;
   MiyakoSize   size;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
 
   _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
 
-	size.w = dst.rect.w;
-	size.h = dst.rect.h;
+  size.w = dst.rect.w;
+  size.h = dst.rect.h;
 
-	if(src.surface == dst.surface){ return Qnil; }
+  if(src.surface == dst.surface){ return Qnil; }
 
   if(dst.rect.w >= 32768 || dst.rect.h >= 32768){ return Qnil; }
 
@@ -69,19 +69,19 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
   long isin = (long)(sin(rad)*4096.0);
   long icos = (long)(cos(rad)*4096.0);
 
-	int px = -(NUM2INT(*(RSTRUCT_PTR(src.unit)+7)));
-	int py = -(NUM2INT(*(RSTRUCT_PTR(src.unit)+8)));
-	int pr = src.rect.w + px;
-	int pb = src.rect.h + py;
-	int qx = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+7)));
-	int qy = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+8)));
-	int qr = dst.rect.w + qx;
-	int qb = dst.rect.h + qy;
+  int px = -(NUM2INT(*(RSTRUCT_PTR(src.unit)+7)));
+  int py = -(NUM2INT(*(RSTRUCT_PTR(src.unit)+8)));
+  int pr = src.rect.w + px;
+  int pb = src.rect.h + py;
+  int qx = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+7)));
+  int qy = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+8)));
+  int qr = dst.rect.w + qx;
+  int qb = dst.rect.h + qy;
   Uint32 sr, sg, sb, sa;
   Uint32 dr, dg, db, da;
 
-	SDL_LockSurface(src.surface);
-	SDL_LockSurface(dst.surface);
+  SDL_LockSurface(src.surface);
+  SDL_LockSurface(dst.surface);
 
   int x, y;
   for(y = qy; y < qb; y++)
@@ -121,7 +121,7 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
       dg = (*tp & dst.fmt->Gmask) >> dst.fmt->Gshift;
       db = (*tp & dst.fmt->Bmask) >> dst.fmt->Bshift;
       da = (*tp & dst.fmt->Amask) | dst.a255;
-			Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
+      Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
       sa = (*psrc & src.fmt->Amask) | src.a255;
       if(sa == 0){ tp++; continue; }
       if(da == 0 || sa == 255)
@@ -157,7 +157,7 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
 {
   MiyakoBitmap src, dst;
   MiyakoSize   size;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
   Uint32 sr, sg, sb, sa;
   Uint32 dr, dg, db, da;
 
@@ -165,7 +165,7 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
 
   if(_miyako_init_rect(&src, &dst, &size) == 0) return Qnil;
 
-	if(src.surface == dst.surface){ return Qnil; }
+  if(src.surface == dst.surface){ return Qnil; }
 
   if(dst.rect.w >= 32768 || dst.rect.h >= 32768){ return Qnil; }
 
@@ -180,17 +180,17 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
   int off_x = scx < 0 ? 1 : 0;
   int off_y = scy < 0 ? 1 : 0;
 
-	int px = -(NUM2INT(*(RSTRUCT_PTR(src.unit)+7)));
-	int py = -(NUM2INT(*(RSTRUCT_PTR(src.unit)+8)));
-	int pr = src.rect.w + px;
-	int pb = src.rect.h + py;
-	int qx = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+7)));
-	int qy = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+8)));
-	int qr = dst.rect.w + qx;
-	int qb = dst.rect.h + qy;
+  int px = -(NUM2INT(*(RSTRUCT_PTR(src.unit)+7)));
+  int py = -(NUM2INT(*(RSTRUCT_PTR(src.unit)+8)));
+  int pr = src.rect.w + px;
+  int pb = src.rect.h + py;
+  int qx = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+7)));
+  int qy = -(NUM2INT(*(RSTRUCT_PTR(dst.unit)+8)));
+  int qr = dst.rect.w + qx;
+  int qb = dst.rect.h + qy;
 
-	SDL_LockSurface(src.surface);
-	SDL_LockSurface(dst.surface);
+  SDL_LockSurface(src.surface);
+  SDL_LockSurface(dst.surface);
 
   int x, y;
   for(y = qy; y < qb; y++)
@@ -204,7 +204,7 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
       if(ny < py || ny >= pb){ tp++; continue; }
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
       da = (*tp >> 24) | dst.a255;
-			Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
+      Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
       sa = (*psrc >> 24) | src.a255;
       if(sa == 0){ tp++; continue; }
       if(da == 0 || sa == 255)
@@ -230,7 +230,7 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
       dg = (*tp & dst.fmt->Gmask) >> dst.fmt->Gshift;
       db = (*tp & dst.fmt->Bmask) >> dst.fmt->Bshift;
       da = (*tp & dst.fmt->Amask) | dst.a255;
-			Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
+      Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
       sa = (*psrc & src.fmt->Amask) | src.a255;
       if(sa == 0){ tp++; continue; }
       if(da == 0 || sa == 255)
@@ -285,19 +285,19 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
   int off_x = scx < 0 ? 1 : 0;
   int off_y = scy < 0 ? 1 : 0;
 
-	int px = -(NUM2INT(*(RSTRUCT_PTR(src->unit)+7)));
-	int py = -(NUM2INT(*(RSTRUCT_PTR(src->unit)+8)));
-	int pr = src->rect.w + px;
-	int pb = src->rect.h + py;
-	int qx = -(NUM2INT(*(RSTRUCT_PTR(dst->unit)+7)));
-	int qy = -(NUM2INT(*(RSTRUCT_PTR(dst->unit)+8)));
-	int qr = dst->rect.w + qx;
-	int qb = dst->rect.h + qy;
+  int px = -(NUM2INT(*(RSTRUCT_PTR(src->unit)+7)));
+  int py = -(NUM2INT(*(RSTRUCT_PTR(src->unit)+8)));
+  int pr = src->rect.w + px;
+  int pb = src->rect.h + py;
+  int qx = -(NUM2INT(*(RSTRUCT_PTR(dst->unit)+7)));
+  int qy = -(NUM2INT(*(RSTRUCT_PTR(dst->unit)+8)));
+  int qr = dst->rect.w + qx;
+  int qb = dst->rect.h + qy;
   Uint32 sr, sg, sb, sa;
   Uint32 dr, dg, db, da;
 
-	SDL_LockSurface(src->surface);
-	SDL_LockSurface(dst->surface);
+  SDL_LockSurface(src->surface);
+  SDL_LockSurface(dst->surface);
 
   int x, y;
   for(y = qy; y < qb; y++)
@@ -337,7 +337,7 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
       dg = (*tp & dst->fmt->Gmask) >> dst->fmt->Gshift;
       db = (*tp & dst->fmt->Bmask) >> dst->fmt->Bshift;
       da = (*tp & dst->fmt->Amask) | dst->a255;
-			Uint32 *psrc = src->ptr + (src->rect.x + ny - py) * src->surface->w + src->rect.x + nx - px;
+      Uint32 *psrc = src->ptr + (src->rect.x + ny - py) * src->surface->w + src->rect.x + nx - px;
       sa = (*psrc & src->fmt->Amask) | src->a255;
       if(sa == 0){ tp++; continue; }
       if(da == 0 || sa == 255)
@@ -370,11 +370,11 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
 static VALUE bitmap_miyako_transform(VALUE self, VALUE vsrc, VALUE vdst, VALUE radian, VALUE xscale, VALUE yscale)
 {
   MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
 
   _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
 
-	if(src.surface == dst.surface){ return Qnil; }
+  if(src.surface == dst.surface){ return Qnil; }
 
   transform_inner(&src, &dst, radian, xscale, yscale);
   return vdst;
@@ -388,11 +388,11 @@ static VALUE sprite_render_transform(VALUE self, VALUE radian, VALUE xscale, VAL
   VALUE visible = rb_iv_get(self, "@visible");
   if(visible == Qfalse) return self;
   MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
 
   _miyako_setup_unit_2(self, mScreen, scr, &src, &dst, Qnil, Qnil, 1);
 
-	if(src.surface == dst.surface){ return Qnil; }
+  if(src.surface == dst.surface){ return Qnil; }
 
   transform_inner(&src, &dst, radian, xscale, yscale);
   return self;
@@ -406,11 +406,11 @@ static VALUE sprite_render_to_sprite_transform(VALUE self, VALUE vdst, VALUE rad
   VALUE visible = rb_iv_get(self, "@visible");
   if(visible == Qfalse) return self;
   MiyakoBitmap src, dst;
-	SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Surface  *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
 
   _miyako_setup_unit_2(self, vdst, scr, &src, &dst, Qnil, Qnil, 1);
 
-	if(src.surface == dst.surface){ return Qnil; }
+  if(src.surface == dst.surface){ return Qnil; }
 
   transform_inner(&src, &dst, radian, xscale, yscale);
   return self;
@@ -438,7 +438,7 @@ void Init_miyako_transform()
   one = 1;
   nOne = INT2NUM(one);
 
-	rb_define_singleton_method(cBitmap, "rotate", bitmap_miyako_rotate, 3);
-	rb_define_singleton_method(cBitmap, "scale", bitmap_miyako_scale, 4);
-	rb_define_singleton_method(cBitmap, "transform", bitmap_miyako_transform, 5);
+  rb_define_singleton_method(cBitmap, "rotate", bitmap_miyako_rotate, 3);
+  rb_define_singleton_method(cBitmap, "scale", bitmap_miyako_scale, 4);
+  rb_define_singleton_method(cBitmap, "transform", bitmap_miyako_transform, 5);
 }

data/sample/Animation2/lex.rb

@@ -29,7 +29,7 @@ mode = 0
 len_body = Sprite.new({:file=>sprintf("lex_body.png"), :type=>:ck})
 len_body.move_to!(425, 219)
 
-len_anim_param = { 
+len_anim_param = {
   :sprite => len_body,
   :wait => 0.1,
   :move_offset => [[0,0], [0,-1], [0,0], [0,1]]
@@ -40,7 +40,7 @@ len_anim.start
 road_roller = Sprite.new({:file=>sprintf("lex_roadroller.png"), :type=>:ck})
 road_roller.move_to!(310, 180)
 
-rr_anim_param = { 
+rr_anim_param = {
   :sprite => road_roller,
   :wait => 0.1,
   :move_offset => [[0,0], [0,1], [0,0], [0,-1]]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-miyako
 version: !ruby/object:Gem::Version 
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors: 
 - Cyross Makoto
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-16 00:00:00 +09:00
+date: 2009-10-25 00:00:00 +09:00
 default_executable: 
 dependencies: []