ruby-miyako 2.1.0 → 2.1.1

data/miyako_transform.c

@@ -60,9 +60,9 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
 
 	size.w = dst.rect.w;
 	size.h = dst.rect.h;
-  
+
 	if(src.surface == dst.surface){ return Qnil; }
-	
+
   if(dst.rect.w >= 32768 || dst.rect.h >= 32768){ return Qnil; }
 
   double rad = NUM2DBL(radian) * -1.0;
@@ -77,6 +77,8 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
 	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);
@@ -92,50 +94,50 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
       int ny = (x*isin+y*icos) >> 12;
       if(ny < py || ny >= pb){ tp++; continue; }
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-      dst.color.r = (*tp >> 16) & 0xff;
-      dst.color.g = (*tp >>  8) & 0xff;
-      dst.color.b = (*tp      ) & 0xff;
-      dst.color.a = (*tp >> 24) & 0xff | dst.a255;
-			Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
-      src.color.a = (*psrc >> 24) & 0xff | src.a255;
-      if(src.color.a == 0){ tp++; continue; }
-      if(dst.color.a == 0 || src.color.a == 255)
+      da = (*tp >> 24) | dst.a255;
+      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)
       {
         *tp = *psrc;
         tp++;
         continue;
       }
-      int a1 = src.color.a + 1;
-      int a2 = 256 - src.color.a;
-      src.color.r = (*psrc >> 16) & 0xff;
-      src.color.g = (*psrc >>  8) & 0xff;
-      src.color.b = (*psrc      ) & 0xff;
-			*tp = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
-            ((src.color.g * a1 + dst.color.g * a2) >> 8) <<  8 |
-						((src.color.b * a1 + dst.color.b * a2) >> 8)       |
-						0xff                                         << 24;
+      int a1 = sa + 1;
+      int a2 = 256 - sa;
+      dr = *tp & 0xff0000;
+      dg = *tp & 0xff00;
+      db = *tp & 0xff;
+      sr = *psrc & 0xff0000;
+      sg = *psrc & 0xff00;
+      sb = *psrc & 0xff;
+      *tp = ((sr * a1 + dr * a2) & 0xff000000 |
+             (sg * a1 + dg * a2) & 0xff0000   |
+             (sb * a1 + db * a2)) >> 8        |
+            0xff000000;
 #else
-      dst.color.r = (*tp & dst.fmt->Rmask) >> dst.fmt->Rshift;
-      dst.color.g = (*tp & dst.fmt->Gmask) >> dst.fmt->Gshift;
-      dst.color.b = (*tp & dst.fmt->Bmask) >> dst.fmt->Bshift;
-      dst.color.a = (*tp & dst.fmt->Amask) | dst.a255;
+      dr = (*tp & dst.fmt->Rmask) >> dst.fmt->Rshift;
+      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;
-      src.color.a = (*psrc & src.fmt->Amask) | src.a255;
-      if(src.color.a == 0){ tp++; continue; }
-      if(dst.color.a == 0 || src.color.a == 255)
+      sa = (*psrc & src.fmt->Amask) | src.a255;
+      if(sa == 0){ tp++; continue; }
+      if(da == 0 || sa == 255)
       {
         *tp = *psrc;
         tp++;
         continue;
       }
-      int a1 = src.color.a + 1;
-      int a2 = 256 - src.color.a;
-      src.color.r = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
-      src.color.g = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
-      src.color.b = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
-      *tp = (((src.color.r * a1 + dst.color.r * a2) >> 8)) << dst.fmt->Rshift |
-            (((src.color.g * a1 + dst.color.g * a2) >> 8)) << dst.fmt->Gshift |
-            (((src.color.b * a1 + dst.color.b * a2) >> 8)) << dst.fmt->Bshift |
+      int a1 = sa + 1;
+      int a2 = 256 - sa;
+      sr = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
+      sg = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
+      sb = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
+      *tp = (((sr * a1 + dr * a2) >> 8)) << dst.fmt->Rshift |
+            (((sg * a1 + dg * a2) >> 8)) << dst.fmt->Gshift |
+            (((sb * a1 + db * a2) >> 8)) << dst.fmt->Bshift |
             0xff;
 #endif
       tp++;
@@ -144,7 +146,7 @@ static VALUE bitmap_miyako_rotate(VALUE self, VALUE vsrc, VALUE vdst, VALUE radi
 
   SDL_UnlockSurface(src.surface);
   SDL_UnlockSurface(dst.surface);
-	
+
   return vdst;
 }
 
@@ -156,13 +158,15 @@ 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;
+  Uint32 sr, sg, sb, sa;
+  Uint32 dr, dg, db, da;
 
   _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
 
   if(_miyako_init_rect(&src, &dst, &size) == 0) return Qnil;
-  
+
 	if(src.surface == dst.surface){ return Qnil; }
-	
+
   if(dst.rect.w >= 32768 || dst.rect.h >= 32768){ return Qnil; }
 
   double tscx = NUM2DBL(xscale);
@@ -199,50 +203,50 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
       int ny = (y*scy) >> 12 - off_y;
       if(ny < py || ny >= pb){ tp++; continue; }
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-      dst.color.r = (*tp >> 16) & 0xff;
-      dst.color.g = (*tp >>  8) & 0xff;
-      dst.color.b = (*tp      ) & 0xff;
-      dst.color.a = (*tp >> 24) & 0xff | dst.a255;
+      da = (*tp >> 24) | dst.a255;
 			Uint32 *psrc = src.ptr + (src.rect.x + ny - py) * src.surface->w + src.rect.x + nx - px;
-      src.color.a = (*psrc >> 24) & 0xff | src.a255;
-      if(src.color.a == 0){ tp++; continue; }
-      if(dst.color.a == 0 || src.color.a == 255)
+      sa = (*psrc >> 24) | src.a255;
+      if(sa == 0){ tp++; continue; }
+      if(da == 0 || sa == 255)
       {
         *tp = *psrc;
         tp++;
         continue;
       }
-      int a1 = src.color.a + 1;
-      int a2 = 256 - src.color.a;
-      src.color.r = (*psrc >> 16) & 0xff;
-      src.color.g = (*psrc >>  8) & 0xff;
-      src.color.b = (*psrc      ) & 0xff;
-			*tp = ((src.color.r * a1 + dst.color.r * a2) >> 8) << 16 |
-            ((src.color.g * a1 + dst.color.g * a2) >> 8) <<  8 |
-            ((src.color.b * a1 + dst.color.b * a2) >> 8)       |
-            0xff                                         << 24;
+      int a1 = sa + 1;
+      int a2 = 256 - sa;
+      dr = *tp & 0xff0000;
+      dg = *tp & 0xff00;
+      db = *tp & 0xff;
+      sr = *psrc & 0xff0000;
+      sg = *psrc & 0xff00;
+      sb = *psrc & 0xff;
+      *tp = ((sr * a1 + dr * a2) & 0xff000000 |
+             (sg * a1 + dg * a2) & 0xff0000   |
+             (sb * a1 + db * a2)) >> 8        |
+            0xff000000;
 #else
-      dst.color.r = (*tp & dst.fmt->Rmask) >> dst.fmt->Rshift;
-      dst.color.g = (*tp & dst.fmt->Gmask) >> dst.fmt->Gshift;
-      dst.color.b = (*tp & dst.fmt->Bmask) >> dst.fmt->Bshift;
-      dst.color.a = (*tp & dst.fmt->Amask) | dst.a255;
+      dr = (*tp & dst.fmt->Rmask) >> dst.fmt->Rshift;
+      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;
-      src.color.a = (*psrc & src.fmt->Amask) | src.a255;
-      if(src.color.a == 0){ tp++; continue; }
-      if(dst.color.a == 0 || src.color.a == 255)
+      sa = (*psrc & src.fmt->Amask) | src.a255;
+      if(sa == 0){ tp++; continue; }
+      if(da == 0 || sa == 255)
       {
         *tp = *psrc;
         tp++;
         continue;
       }
-      int a1 = src.color.a + 1;
-      int a2 = 256 - src.color.a;
-      src.color.r = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
-      src.color.g = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
-      src.color.b = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
-      *tp = ((src.color.r * a1 + dst.color.r * a2) >> 8) << dst.fmt->Rshift |
-            ((src.color.g * a1 + dst.color.g * a2) >> 8) << dst.fmt->Gshift |
-            ((src.color.b * a1 + dst.color.b * a2) >> 8) << dst.fmt->Bshift |
+      int a1 = sa + 1;
+      int a2 = 256 - sa;
+      sr = (*psrc & src.fmt->Rmask) >> src.fmt->Rshift;
+      sg = (*psrc & src.fmt->Gmask) >> src.fmt->Gshift;
+      sb = (*psrc & src.fmt->Bmask) >> src.fmt->Bshift;
+      *tp = ((sr * a1 + dr * a2) >> 8) << dst.fmt->Rshift |
+            ((sg * a1 + dg * a2) >> 8) << dst.fmt->Gshift |
+            ((sb * a1 + db * a2) >> 8) << dst.fmt->Bshift |
             0xff;
 #endif
       tp++;
@@ -251,7 +255,7 @@ static VALUE bitmap_miyako_scale(VALUE self, VALUE vsrc, VALUE vdst, VALUE xscal
 
   SDL_UnlockSurface(src.surface);
   SDL_UnlockSurface(dst.surface);
-	
+
   return vdst;
 }
 
@@ -265,7 +269,7 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
   MiyakoSize   size;
 
   if(_miyako_init_rect(src, dst, &size) == 0) return;
-  
+
   double rad = NUM2DBL(radian) * -1.0;
   long isin = (long)(sin(rad)*4096.0);
   long icos = (long)(cos(rad)*4096.0);
@@ -289,6 +293,8 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
 	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);
@@ -304,50 +310,50 @@ static void transform_inner(MiyakoBitmap *src, MiyakoBitmap *dst, VALUE radian,
       int ny = (((x*isin+y*icos) >> 12) * scy) >> 12 - off_y;
       if(ny < py || ny >= pb){ tp++; continue; }
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-      dst->color.r = (*tp >> 16) & 0xff;
-      dst->color.g = (*tp >>  8) & 0xff;
-      dst->color.b = (*tp      ) & 0xff;
-      dst->color.a = (*tp >> 24) & 0xff | dst->a255;
-			Uint32 *psrc = src->ptr + (src->rect.x + ny - py) * src->surface->w + src->rect.x + nx - px;
-      src->color.a = (*psrc >> 24) & 0xff | src->a255;
-      if(src->color.a == 0){ tp++; continue; }
-      if(dst->color.a == 0 || src->color.a == 255)
+      da = (*tp >> 24) | dst->a255;
+      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)
       {
         *tp = *psrc;
         tp++;
         continue;
       }
-      int a1 = src->color.a + 1;
-      int a2 = 256 - src->color.a;
-      src->color.r = (*psrc >> 16) & 0xff;
-      src->color.g = (*psrc >>  8) & 0xff;
-      src->color.b = (*psrc      ) & 0xff;
-			*tp = ((src->color.r * a1 + dst->color.r * a2) >> 8) << 16 |
-            ((src->color.g * a1 + dst->color.g * a2) >> 8) <<  8 |
-            ((src->color.b * a1 + dst->color.b * a2) >> 8)       |
-						0xff                                           << 24;
+      int a1 = sa + 1;
+      int a2 = 256 - sa;
+      dr = *tp & 0xff0000;
+      dg = *tp & 0xff00;
+      db = *tp & 0xff;
+      sr = *psrc & 0xff0000;
+      sg = *psrc & 0xff00;
+      sb = *psrc & 0xff;
+      *tp = ((sr * a1 + dr * a2) & 0xff000000 |
+             (sg * a1 + dg * a2) & 0xff0000   |
+             (sb * a1 + db * a2)) >> 8        |
+            0xff000000;
 #else
-      dst->color.r = (*tp & dst->fmt->Rmask) >> dst->fmt->Rshift;
-      dst->color.g = (*tp & dst->fmt->Gmask) >> dst->fmt->Gshift;
-      dst->color.b = (*tp & dst->fmt->Bmask) >> dst->fmt->Bshift;
-      dst->color.a = (*tp & dst->fmt->Amask) | dst->a255;
+      dr = (*tp & dst->fmt->Rmask) >> dst->fmt->Rshift;
+      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;
-      src->color.a = (*psrc & src->fmt->Amask) | src->a255;
-      if(src->color.a == 0){ tp++; continue; }
-      if(dst->color.a == 0 || src->color.a == 255)
+      sa = (*psrc & src->fmt->Amask) | src->a255;
+      if(sa == 0){ tp++; continue; }
+      if(da == 0 || sa == 255)
       {
         *tp = *psrc;
         tp++;
         continue;
       }
-      int a1 = src->color.a + 1;
-      int a2 = 256 - src->color.a;
-      src->color.r = (*psrc & src->fmt->Rmask) >> src->fmt->Rshift;
-      src->color.g = (*psrc & src->fmt->Gmask) >> src->fmt->Gshift;
-      src->color.b = (*psrc & src->fmt->Bmask) >> src->fmt->Bshift;
-      *tp = ((src->color.r * a1 + dst->color.r * a2) >> 8) << dst->fmt->Rshift |
-            ((src->color.g * a1 + dst->color.g * a2) >> 8) << dst->fmt->Gshift |
-            ((src->color.b * a1 + dst->color.b * a2) >> 8) << dst->fmt->Bshift |
+      int a1 = sa + 1;
+      int a2 = 256 - sa;
+      sr = (*psrc & src->fmt->Rmask) >> src->fmt->Rshift;
+      sg = (*psrc & src->fmt->Gmask) >> src->fmt->Gshift;
+      sb = (*psrc & src->fmt->Bmask) >> src->fmt->Bshift;
+      *tp = ((sr * a1 + dr * a2) >> 8) << dst->fmt->Rshift |
+            ((sg * a1 + dg * a2) >> 8) << dst->fmt->Gshift |
+            ((sb * a1 + db * a2) >> 8) << dst->fmt->Bshift |
             0xff;
 #endif
       tp++;
@@ -369,7 +375,7 @@ static VALUE bitmap_miyako_transform(VALUE self, VALUE vsrc, VALUE vdst, VALUE r
   _miyako_setup_unit_2(vsrc, vdst, scr, &src, &dst, Qnil, Qnil, 1);
 
 	if(src.surface == dst.surface){ return Qnil; }
-	
+
   transform_inner(&src, &dst, radian, xscale, yscale);
   return vdst;
 }
@@ -387,7 +393,7 @@ static VALUE sprite_render_transform(VALUE self, VALUE radian, VALUE xscale, VAL
   _miyako_setup_unit_2(self, mScreen, scr, &src, &dst, Qnil, Qnil, 1);
 
 	if(src.surface == dst.surface){ return Qnil; }
-	
+
   transform_inner(&src, &dst, radian, xscale, yscale);
   return self;
 }
@@ -403,9 +409,9 @@ static VALUE sprite_render_to_sprite_transform(VALUE self, VALUE vdst, VALUE rad
 	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; }
-	
+
   transform_inner(&src, &dst, radian, xscale, yscale);
   return self;
 }
@@ -421,7 +427,7 @@ void Init_miyako_transform()
 
   rb_define_method(cSprite, "render_transform", sprite_render_transform, 3);
   rb_define_method(cSprite, "render_to_transform", sprite_render_to_sprite_transform, 4);
-  
+
   id_update = rb_intern("update");
   id_kakko  = rb_intern("[]");
   id_render = rb_intern("render");

data/miyako_utility.c

@@ -37,22 +37,7 @@ static VALUE sSpriteUnit = Qnil;
 // from rubysdl_video.c
 static GLOBAL_DEFINE_GET_STRUCT(Surface, GetSurface, cSurface, "SDL::Surface");
 
-void _miyako_yield_unit_1(MiyakoBitmap *src)
-{
-  if(rb_block_given_p() == Qtrue){ src->unit = rb_obj_dup(src->unit); rb_yield(src->unit); }
-}
-
-void _miyako_yield_unit_2(MiyakoBitmap *src, MiyakoBitmap *dst)
-{
-  if(rb_block_given_p() == Qtrue)
-  {
-    src->unit = rb_obj_dup(src->unit);
-    dst->unit = rb_obj_dup(dst->unit);
-    rb_yield_values(2, src->unit, dst->unit);
-  }
-}
-
-void _miyako_setup_unit(VALUE unit, SDL_Surface *screen, MiyakoBitmap *mb, VALUE x, VALUE y, int use_yield)
+void _miyako_setup_unit(VALUE unit, SDL_Surface *screen, MiyakoBitmap *mb, VALUE x, VALUE y)
 {
   mb->unit = unit;
   if(rb_obj_is_kind_of(mb->unit, sSpriteUnit) == Qfalse){
@@ -60,13 +45,13 @@ void _miyako_setup_unit(VALUE unit, SDL_Surface *screen, MiyakoBitmap *mb, VALUE
     if(mb->unit == Qnil){ rb_raise(eMiyakoError, "Source instance has not SpriteUnit!"); }
   }
 
-  if(use_yield) _miyako_yield_unit_1(mb);
+  VALUE *mb_p = RSTRUCT_PTR(mb->unit);
+
+  mb->rect.x = NUM2INT(*(mb_p + 1));
+  mb->rect.y = NUM2INT(*(mb_p + 2));
+  mb->rect.w = NUM2INT(*(mb_p + 3));
+  mb->rect.h = NUM2INT(*(mb_p + 4));
 
-  mb->rect.x = NUM2INT(*(RSTRUCT_PTR(mb->unit) + 1));
-  mb->rect.y = NUM2INT(*(RSTRUCT_PTR(mb->unit) + 2));
-  mb->rect.w = NUM2INT(*(RSTRUCT_PTR(mb->unit) + 3));
-  mb->rect.h = NUM2INT(*(RSTRUCT_PTR(mb->unit) + 4));
-  
 	mb->surface = GetSurface(*(RSTRUCT_PTR(mb->unit)))->surface;
 	mb->ptr = (Uint32 *)(mb->surface->pixels);
 	mb->fmt = mb->surface->format;
@@ -92,17 +77,17 @@ void _miyako_setup_unit(VALUE unit, SDL_Surface *screen, MiyakoBitmap *mb, VALUE
     if(mb->rect.y + mb->rect.h > mb->surface->h)
       mb->rect.h = mb->surface->h - mb->rect.y;
   }
-  
+
   mb->a255 = (mb->surface == screen) ? 0xff : 0;
-  
-  mb->x = (x == Qnil ? NUM2INT(*(RSTRUCT_PTR(mb->unit) + 5)) : NUM2INT(x));
-  mb->y = (y == Qnil ? NUM2INT(*(RSTRUCT_PTR(mb->unit) + 6)) : NUM2INT(y));
+
+  mb->x = (x == Qnil ? NUM2INT(*(mb_p + 5)) : NUM2INT(x));
+  mb->y = (y == Qnil ? NUM2INT(*(mb_p+ 6)) : NUM2INT(y));
 }
 
-void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d, 
+void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
                          SDL_Surface *screen,
                          MiyakoBitmap *mb_s, MiyakoBitmap *mb_d,
-                         VALUE x, VALUE y, int use_yield)
+                         VALUE x, VALUE y)
 {
   mb_s->unit = unit_s;
   if(rb_obj_is_kind_of(mb_s->unit, sSpriteUnit) == Qfalse){
@@ -116,16 +101,17 @@ void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
     if(mb_d->unit == Qnil){ rb_raise(eMiyakoError, "Source instance has not SpriteUnit!"); }
   }
 
-  if(use_yield) _miyako_yield_unit_2(mb_s, mb_d);
-
 	mb_s->surface = GetSurface(*(RSTRUCT_PTR(mb_s->unit)))->surface;
 	mb_s->ptr = (Uint32 *)(mb_s->surface->pixels);
 	mb_s->fmt = mb_s->surface->format;
 
-  mb_s->rect.x = NUM2INT(*(RSTRUCT_PTR(mb_s->unit) + 1));
-  mb_s->rect.y = NUM2INT(*(RSTRUCT_PTR(mb_s->unit) + 2));
-  mb_s->rect.w = NUM2INT(*(RSTRUCT_PTR(mb_s->unit) + 3));
-  mb_s->rect.h = NUM2INT(*(RSTRUCT_PTR(mb_s->unit) + 4));
+  VALUE *ms_p = RSTRUCT_PTR(mb_s->unit);
+  VALUE *md_p = RSTRUCT_PTR(mb_d->unit);
+
+  mb_s->rect.x = NUM2INT(*(ms_p + 1));
+  mb_s->rect.y = NUM2INT(*(ms_p + 2));
+  mb_s->rect.w = NUM2INT(*(ms_p + 3));
+  mb_s->rect.h = NUM2INT(*(ms_p + 4));
 
   // adjust clip_rect
   if(mb_s->surface == screen)
@@ -150,18 +136,18 @@ void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
   }
 
   mb_s->a255 = (mb_s->surface == screen) ? 0xff : 0;
-  
-  mb_s->x = (x == Qnil ? NUM2INT(*(RSTRUCT_PTR(mb_s->unit) + 5)) : NUM2INT(x));
-  mb_s->y = (y == Qnil ? NUM2INT(*(RSTRUCT_PTR(mb_s->unit) + 6)) : NUM2INT(y));
+
+  mb_s->x = (x == Qnil ? NUM2INT(*(ms_p + 5)) : NUM2INT(x));
+  mb_s->y = (y == Qnil ? NUM2INT(*(ms_p + 6)) : NUM2INT(y));
 
 	mb_d->surface = GetSurface(*(RSTRUCT_PTR(mb_d->unit)))->surface;
 	mb_d->ptr = (Uint32 *)(mb_d->surface->pixels);
 	mb_d->fmt = mb_d->surface->format;
 
-  mb_d->rect.x = NUM2INT(*(RSTRUCT_PTR(mb_d->unit) + 1));
-  mb_d->rect.y = NUM2INT(*(RSTRUCT_PTR(mb_d->unit) + 2));
-  mb_d->rect.w = NUM2INT(*(RSTRUCT_PTR(mb_d->unit) + 3));
-  mb_d->rect.h = NUM2INT(*(RSTRUCT_PTR(mb_d->unit) + 4));
+  mb_d->rect.x = NUM2INT(*(md_p + 1));
+  mb_d->rect.y = NUM2INT(*(md_p + 2));
+  mb_d->rect.w = NUM2INT(*(md_p + 3));
+  mb_d->rect.h = NUM2INT(*(md_p + 4));
 
   // adjust clip_rect
   if(mb_d->surface == screen)
@@ -186,7 +172,7 @@ void _miyako_setup_unit_2(VALUE unit_s, VALUE unit_d,
   }
 
   mb_d->a255 = (mb_d->surface == screen) ? 0xff : 0;
-  
+
   mb_d->x = NUM2INT(*(RSTRUCT_PTR(mb_d->unit) + 5));
   mb_d->y = NUM2INT(*(RSTRUCT_PTR(mb_d->unit) + 6));
 }
@@ -199,13 +185,13 @@ int _miyako_init_rect(MiyakoBitmap *src, MiyakoBitmap *dst, MiyakoSize *size)
   int dh = dst->rect.h;
 
   // ox(oy)が画像のw(h)以上の時は転送不可
-  
+
   if(src->rect.x >= src->surface->w || src->rect.y >= src->surface->h) return 0;
   if(dst->rect.x >= dst->surface->w || dst->rect.y >= dst->surface->h) return 0;
 
   // ox(oy)がマイナスの時は、ow(oh)を減らしておいて、ox, oyをゼロにしておく
   // 0以下になったら転送不可
-  
+
   if(src->rect.x < 0){
     sw += src->rect.x;
     src->rect.x = 0;
@@ -229,7 +215,7 @@ int _miyako_init_rect(MiyakoBitmap *src, MiyakoBitmap *dst, MiyakoSize *size)
 
   // ox(oy)+ow(oh)が、w(h)を越える場合は、ow(oh)を減らしておく
   // 0以下になったら転送不可
-  
+
   if(src->rect.x + sw > src->surface->w)
   {
     sw += (src->surface->w - src->rect.x - sw);
@@ -252,13 +238,13 @@ int _miyako_init_rect(MiyakoBitmap *src, MiyakoBitmap *dst, MiyakoSize *size)
   }
 
   // ox(oy)が画像のw(h)以上、-w(-h)以下の時は転送不可
-  
+
   if(src->x >= dw || src->x <= -dw) return 0;
   if(src->y >= dh || src->y <= -dh) return 0;
 
   // x(y)がマイナスの時は、ow(oh)を減らしておいて、x, yをゼロにしておく
   // 0以下になったら転送不可
-  
+
   if(src->x < 0){
     dw += src->x;
     src->x = 0;
@@ -274,7 +260,7 @@ int _miyako_init_rect(MiyakoBitmap *src, MiyakoBitmap *dst, MiyakoSize *size)
 
   size->w = (dw > sw ? sw : dw);
   size->h = (dh > sh ? sh : dh);
-  
+
   return 1;
 }