ruby-miyako 2.1.0 → 2.1.1

data/miyako_font.c

@@ -63,7 +63,7 @@ static VALUE font_draw_text(VALUE self, VALUE vdst, VALUE str, VALUE vx, VALUE v
   StringValue(str);
 
   str = rb_funcall(str, id_encode, 1, rb_const_get(cEncoding, id_utf8));
-  
+
   TTF_Font *font = Get_TTFont(rb_iv_get(self, "@font"))->font;
 
   VALUE *p_font_color = RARRAY_PTR(rb_iv_get(self, "@color"));
@@ -88,8 +88,9 @@ static VALUE font_draw_text(VALUE self, VALUE vdst, VALUE str, VALUE vx, VALUE v
   int hspace = NUM2INT(rb_iv_get(self, "@hspace"));
 
   SDL_Surface *scr = GetSurface(rb_iv_get(mScreen, "@@screen"))->surface;
+  SDL_Rect drect;
 
-	MiyakoBitmap src, dst;
+  MiyakoBitmap src, dst;
   _miyako_setup_unit(vdst, scr, &dst, vx, vy, 0);
 
   char *sptr = RSTRING_PTR(str);
@@ -97,7 +98,9 @@ static VALUE font_draw_text(VALUE self, VALUE vdst, VALUE str, VALUE vx, VALUE v
   src.x = dst.x;
   src.y = dst.y;
 
-	int x, y;
+  int x, y;
+  Uint32 sr, sg, sb, sa;
+  Uint32 dr, dg, db, da;
 
   if(use_shadow == Qtrue)
   {
@@ -105,77 +108,140 @@ static VALUE font_draw_text(VALUE self, VALUE vdst, VALUE str, VALUE vx, VALUE v
 
     if(ssrc2 == NULL) return INT2NUM(src.x);
     Uint32 *psrc2 = (Uint32 *)(ssrc2->pixels);
-	
+
     src.x += shadow_margin_x;
     src.y += shadow_margin_y;
-    
-		MiyakoSize size2;
-		size2.w = dst.rect.w - (src.x < 0 ? -(src.x) : src.x);
-		size2.h = dst.rect.h - (src.y < 0 ? -(src.y) : src.y);
-		if(size2.w > ssrc2->w){ size2.w = ssrc2->w; }
-		if(size2.h > ssrc2->h){ size2.h = ssrc2->h; }
-
-    SDL_LockSurface(ssrc2);
-    SDL_LockSurface(dst.surface);
-  
-    for(y = 0; y < size2.h; y++)
+
+    if(dst.surface == scr)
     {
-      Uint32 *ppsrc2 = psrc2 + y * ssrc2->w;
-      Uint32 *ppdst = dst.ptr + (src.y + y) * dst.surface->w + src.x;
-      for(x = 0; x < size2.w; x++)
+      drect.x = src.x;
+      drect.y = src.y;
+      SDL_BlitSurface(ssrc2, NULL, dst.surface, &(drect));
+    }
+    else
+    {
+      MiyakoSize size2;
+      size2.w = dst.rect.w - (src.x < 0 ? 0 : src.x);
+      if(size2.w <= 0)
       {
-#if SDL_BYTEORDER == SDL_LIL_ENDIAN
-				dst.color.a = (Uint32)(((*ppdst) >> 24) << dst.fmt->Aloss) & 0xff | dst.a255;
-	      src.color.a = (Uint32)(((*ppsrc2) >> 24) << ssrc2->format->Aloss) & 0xff;
-        if(src.color.a == 0){ ppsrc2++; ppdst++; continue; }
-        if(dst.color.a == 0 || src.color.a == 255){
-          *ppdst = *ppsrc2;
-          ppsrc2++;
-          ppdst++;
-          continue;
+        SDL_FreeSurface(ssrc2);
+        return INT2NUM(dst.x);
+      }
+      if(size2.w > ssrc2->w){ size2.w = ssrc2->w; }
+
+      int margin_x = 0;
+      if(src.x < 0)
+      {
+        int tmp_w = ssrc2->w + src.x;
+        if(tmp_w < size2.w) size2.w += src.x;
+        if(size2.w <= 0)
+        {
+          SDL_FreeSurface(ssrc2);
+          return INT2NUM(dst.x);
         }
-				dst.color.r = (Uint32)(((*ppdst) >> 16)) & 0xff;
-				dst.color.g = (Uint32)(((*ppdst) >> 8)) & 0xff;
-				dst.color.b = (Uint32)(((*ppdst))) & 0xff;
-	      src.color.r = (Uint32)(((*ppsrc2) >> 16)) & 0xff;
-	      src.color.g = (Uint32)(((*ppsrc2) >> 8)) & 0xff;
-	      src.color.b = (Uint32)(((*ppsrc2))) & 0xff;
-        int a1 = src.color.a + 1;
-        int a2 = 256 - src.color.a;
-        *ppdst = (((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)) |
-                 (255 >> dst.fmt->Aloss) << 24;
-#else
-				dst.color.a = (Uint32)(((*ppdst & dst.fmt->Amask)) << dst.fmt->Aloss) | dst.a255;
-	      src.color.a = (Uint32)(((*ppsrc2 & ssrc2->format->Amask)) << ssrc2->format->Aloss);
-        if(src.color.a == 0){ ppsrc2++; ppdst++; continue; }
-        if(dst.color.a == 0 || src.color.a == 255){
-          *ppdst = *ppsrc2;
+        margin_x = -src.x;
+        src.x = 0;
+      }
+
+      size2.h = dst.rect.h - (src.y < 0 ? 0 : src.y);
+      if(size2.h <= 0)
+      {
+        SDL_FreeSurface(ssrc2);
+        return INT2NUM(dst.x);
+      }
+      if(size2.h > ssrc2->h){ size2.h = ssrc2->h; }
+
+      int margin_y = 0;
+      if(src.y < 0)
+      {
+        int tmp_h = ssrc2->h + src.y;
+        if(tmp_h < size2.h) size2.h += src.y;
+        if(size2.h <= 0)
+        {
+          SDL_FreeSurface(ssrc2);
+          return INT2NUM(dst.x);
+        }
+        margin_y = -src.y;
+        src.y = 0;
+      }
+
+      SDL_LockSurface(ssrc2);
+      SDL_LockSurface(dst.surface);
+
+      for(y = 0; y < size2.h; y++)
+      {
+        Uint32 *ppsrc2 = psrc2 + (y+margin_y) * ssrc2->w + margin_x;
+        Uint32 *ppdst = dst.ptr + (src.y + y) * dst.surface->w + src.x;
+        for(x = 0; x < size2.w; x++)
+        {
+  #if SDL_BYTEORDER == SDL_LIL_ENDIAN
+          da = (*ppdst >> 24) | dst.a255;
+          sa = *ppsrc2 >> 24;
+          if(sa == 0){ ppsrc2++; ppdst++; continue; }
+          if(da == 0 || sa == 255){
+            *ppdst = *ppsrc2;
+            ppsrc2++;
+            ppdst++;
+            continue;
+          }
+  #if 0
+          dr = (Uint32)((*ppdst >> 16)) & 0xff;
+          dg = (Uint32)((*ppdst >> 8)) & 0xff;
+          db = (Uint32)((*ppdst)) & 0xff;
+          sr = (Uint32)((*ppsrc2 >> 16)) & 0xff;
+          sg = (Uint32)((*ppsrc2 >> 8)) & 0xff;
+          sb = (Uint32)((*ppsrc2)) & 0xff;
+          int a1 = sa + 1;
+          int a2 = 256 - sa;
+          *ppdst = (((sr * a1 + dr * a2) >> 8)) << 16 |
+                   (((sg * a1 + dg * a2) >> 8)) << 8 |
+                   (((sb * a1 + db * a2) >> 8)) |
+                   0xff000000;
+  #else
+          dr = *ppdst & 0xff0000;
+          dg = *ppdst & 0xff00;
+          db = *ppdst & 0xff;
+          sr = *ppsrc2 & 0xff0000;
+          sg = *ppsrc2 & 0xff00;
+          sb = *ppsrc2 & 0xff;
+          int a1 = sa + 1;
+          int a2 = 256 - sa;
+          *ppdst = ((sr * a1 + dr * a2) & 0xff000000 |
+                    (sg * a1 + dg * a2) & 0xff0000   |
+                    (sb * a1 + db * a2)) >> 8        |
+                   0xff000000;
+  #endif
+  #else
+          da = (Uint32)(((*ppdst & dst.fmt->Amask) | dst.a255;
+          sa = (Uint32)(((*ppsrc2 & ssrc2->format->Amask)));
+          if(sa == 0){ ppsrc2++; ppdst++; continue; }
+          if(da == 0 || sa == 255){
+            *ppdst = *ppsrc2;
+            ppsrc2++;
+            ppdst++;
+            continue;
+          }
+          dr = (Uint32)(((*ppdst & dst.fmt->Rmask) >> dst.fmt->Rshift));
+          dg = (Uint32)(((*ppdst & dst.fmt->Gmask) >> dst.fmt->Gshift));
+          db = (Uint32)(((*ppdst & dst.fmt->Bmask) >> dst.fmt->Bshift));
+          sr = (Uint32)(((*ppsrc2 & ssrc2->format->Rmask) >> ssrc2->format->Rshift));
+          sg = (Uint32)(((*ppsrc2 & ssrc2->format->Gmask) >> ssrc2->format->Gshift));
+          sb = (Uint32)(((*ppsrc2 & ssrc2->format->Bmask) >> ssrc2->format->Bshift));
+          int a1 = sa + 1;
+          int a2 = 256 - sa;
+          *ppdst = (((sr * a1 + dr * a2) >> 8)) << dst.fmt->Rshift |
+                   (((sg * a1 + dg * a2) >> 8)) << dst.fmt->Gshift |
+                   (((sb * a1 + db * a2) >> 8)) << dst.fmt->Bshift |
+                   (255 >> dst.fmt->Aloss);
+  #endif
           ppsrc2++;
           ppdst++;
-          continue;
         }
-				dst.color.r = (Uint32)(((*ppdst & dst.fmt->Rmask) >> dst.fmt->Rshift));
-				dst.color.g = (Uint32)(((*ppdst & dst.fmt->Gmask) >> dst.fmt->Gshift));
-				dst.color.b = (Uint32)(((*ppdst & dst.fmt->Bmask) >> dst.fmt->Bshift));
-	      src.color.r = (Uint32)(((*ppsrc2 & ssrc2->format->Rmask) >> ssrc2->format->Rshift));
-	      src.color.g = (Uint32)(((*ppsrc2 & ssrc2->format->Gmask) >> ssrc2->format->Gshift));
-	      src.color.b = (Uint32)(((*ppsrc2 & ssrc2->format->Bmask) >> ssrc2->format->Bshift));
-        int a1 = src.color.a + 1;
-        int a2 = 256 - src.color.a;
-        *ppdst = (((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 |
-                 (255 >> dst.fmt->Aloss);
-#endif
-        ppsrc2++;
-        ppdst++;
       }
-    }
 
-    SDL_UnlockSurface(ssrc2);
-    SDL_UnlockSurface(dst.surface);
+      SDL_UnlockSurface(ssrc2);
+      SDL_UnlockSurface(dst.surface);
+    }
 
     SDL_FreeSurface(ssrc2);
 
@@ -187,75 +253,139 @@ static VALUE font_draw_text(VALUE self, VALUE vdst, VALUE str, VALUE vx, VALUE v
 
   if(ssrc == NULL) return INT2NUM(src.x);
 
-  Uint32 *psrc = (Uint32 *)(ssrc->pixels);
-
-	MiyakoSize size;
-	size.w = dst.rect.w - (src.x < 0 ? -(src.x) : src.x);
-	size.h = dst.rect.h - (src.y < 0 ? -(src.y) : src.y);
-	if(size.w > ssrc->w){ size.w = ssrc->w; }
-	if(size.h > ssrc->h){ size.h = ssrc->h; }
-
-  SDL_LockSurface(ssrc);
-  SDL_LockSurface(dst.surface);
-  
-	for(y = 0; y < size.h; y++)
-	{
-		Uint32 *ppsrc = psrc + y * ssrc->w;
-		Uint32 *ppdst = dst.ptr + (src.y + y) * dst.surface->w + src.x;
-		for(x = 0; x < size.w; x++)
-		{
+  if(dst.surface == scr)
+  {
+    drect.x = src.x;
+    drect.y = src.y;
+    SDL_BlitSurface(ssrc, NULL, dst.surface, &(drect));
+  }
+  else
+  {
+    Uint32 *psrc = (Uint32 *)(ssrc->pixels);
+
+    MiyakoSize size;
+
+    size.w = dst.rect.w - (src.x < 0 ? 0 : src.x);
+    if(size.w <= 0)
+    {
+      SDL_FreeSurface(ssrc);
+      return INT2NUM(dst.x);
+    }
+    if(size.w > ssrc->w){ size.w = ssrc->w; }
+
+    int margin_x = 0;
+    if(src.x < 0)
+    {
+      int tmp_w = ssrc->w + src.x;
+      if(tmp_w < size.w) size.w += src.x;
+      if(size.w <= 0)
+      {
+        SDL_FreeSurface(ssrc);
+        return INT2NUM(dst.x);
+      }
+      margin_x = -src.x;
+      src.x = 0;
+    }
+
+    size.h = dst.rect.h - (src.y < 0 ? 0 : src.y);
+    if(size.h <= 0)
+    {
+      SDL_FreeSurface(ssrc);
+      return INT2NUM(dst.x);
+    }
+    if(size.h > ssrc->h){ size.h = ssrc->h; }
+
+    int margin_y = 0;
+    if(src.y < 0)
+    {
+      int tmp_h = ssrc->h + src.y;
+      if(tmp_h < size.h) size.h += src.y;
+      if(size.h <= 0)
+      {
+        SDL_FreeSurface(ssrc);
+        return INT2NUM(dst.x);
+      }
+      margin_y = -src.y;
+      src.y = 0;
+    }
+
+    SDL_LockSurface(ssrc);
+    SDL_LockSurface(dst.surface);
+
+    for(y = 0; y < size.h; y++)
+    {
+      Uint32 *ppsrc = psrc + (y+margin_y) * ssrc->w + margin_x;
+      Uint32 *ppdst = dst.ptr + (src.y + y) * dst.surface->w + src.x;
+      for(x = 0; x < size.w; x++)
+      {
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
-			dst.color.a = (Uint32)(((*ppdst) >> 24) << dst.fmt->Aloss) & 0xff | dst.a255;
-			src.color.a = (Uint32)(((*ppsrc) >> 24) << ssrc->format->Aloss) & 0xff;
-			if(src.color.a == 0){ ppsrc++; ppdst++; continue; }
-			if(dst.color.a == 0 || src.color.a == 255){
-				*ppdst = *ppsrc;
-				ppsrc++;
-				ppdst++;
-				continue;
-			}
-			dst.color.r = (Uint32)(((*ppdst) >> 16)) & 0xff;
-			dst.color.g = (Uint32)(((*ppdst) >> 8)) & 0xff;
-			dst.color.b = (Uint32)(((*ppdst))) & 0xff;
-			src.color.r = (Uint32)(((*ppsrc) >> 16)) & 0xff;
-			src.color.g = (Uint32)(((*ppsrc) >> 8)) & 0xff;
-			src.color.b = (Uint32)(((*ppsrc))) & 0xff;
-			int a1 = src.color.a + 1;
-			int a2 = 256 - src.color.a;
-			*ppdst = (((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)) |
-							 (255 >> dst.fmt->Aloss) << 24;
+        da = (*ppdst >> 24) | dst.a255;
+        sa = *ppsrc >> 24;
+        if(sa == 0){ ppsrc++; ppdst++; continue; }
+        if(da == 0 || sa == 255){
+          *ppdst = *ppsrc;
+          ppsrc++;
+          ppdst++;
+          continue;
+        }
+#if 0
+        dr = (Uint32)(((*ppdst) >> 16)) & 0xff;
+        dg = (Uint32)(((*ppdst) >> 8)) & 0xff;
+        db = (Uint32)(((*ppdst))) & 0xff;
+        sr = (Uint32)(((*ppsrc) >> 16)) & 0xff;
+        sg = (Uint32)(((*ppsrc) >> 8)) & 0xff;
+        sb = (Uint32)(((*ppsrc))) & 0xff;
+        int a1 = sa + 1;
+        int a2 = 256 - sa;
+        *ppdst = (((sr * a1 + dr * a2) >> 8)) << 16 |
+                 (((sg * a1 + dg * a2) >> 8)) << 8 |
+                 (((sb * a1 + db * a2) >> 8)) |
+                 0xff000000;
+#else
+        dr = *ppdst & 0xff0000;
+        dg = *ppdst & 0xff00;
+        db = *ppdst & 0xff;
+        sr = *ppsrc & 0xff0000;
+        sg = *ppsrc & 0xff00;
+        sb = *ppsrc & 0xff;
+        int a1 = sa + 1;
+        int a2 = 256 - sa;
+        *ppdst = ((sr * a1 + dr * a2) & 0xff000000 |
+                  (sg * a1 + dg * a2) & 0xff0000   |
+                  (sb * a1 + db * a2)) >> 8        |
+                 0xff000000;
+#endif
 #else
-			dst.color.a = (Uint32)(((*ppdst & dst.fmt->Amask)) << dst.fmt->Aloss) | dst.a255;
-			src.color.a = (Uint32)(((*ppsrc & ssrc->format->Amask)) << ssrc->format->Aloss);
-			if(src.color.a == 0){ ppsrc++; ppdst++; continue; }
-			if(dst.color.a == 0 || src.color.a == 255){
-				*ppdst = *ppsrc;
-				ppsrc++;
-				ppdst++;
-				continue;
-			}
-			dst.color.r = (Uint32)(((*ppdst & dst.fmt->Rmask) >> dst.fmt->Rshift));
-			dst.color.g = (Uint32)(((*ppdst & dst.fmt->Gmask) >> dst.fmt->Gshift));
-			dst.color.b = (Uint32)(((*ppdst & dst.fmt->Bmask) >> dst.fmt->Bshift));
-			src.color.r = (Uint32)(((*ppsrc & ssrc->format->Rmask) >> ssrc->format->Rshift));
-			src.color.g = (Uint32)(((*ppsrc & ssrc->format->Gmask) >> ssrc->format->Gshift));
-			src.color.b = (Uint32)(((*ppsrc & ssrc->format->Bmask) >> ssrc->format->Bshift));
-			int a1 = src.color.a + 1;
-			int a2 = 256 - src.color.a;
-			*ppdst = (((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 |
-							 (255 >> dst.fmt->Aloss);
+        da = (Uint32)(((*ppdst & dst.fmt->Amask)) << dst.fmt->Aloss) | dst.a255;
+        sa = (Uint32)(((*ppsrc & ssrc->format->Amask)) << ssrc->format->Aloss);
+        if(sa == 0){ ppsrc++; ppdst++; continue; }
+        if(da == 0 || sa == 255){
+          *ppdst = *ppsrc;
+          ppsrc++;
+          ppdst++;
+          continue;
+        }
+        dr = (Uint32)(((*ppdst & dst.fmt->Rmask) >> dst.fmt->Rshift));
+        dg = (Uint32)(((*ppdst & dst.fmt->Gmask) >> dst.fmt->Gshift));
+        db = (Uint32)(((*ppdst & dst.fmt->Bmask) >> dst.fmt->Bshift));
+        sr = (Uint32)(((*ppsrc & ssrc->format->Rmask) >> ssrc->format->Rshift));
+        sg = (Uint32)(((*ppsrc & ssrc->format->Gmask) >> ssrc->format->Gshift));
+        sb = (Uint32)(((*ppsrc & ssrc->format->Bmask) >> ssrc->format->Bshift));
+        int a1 = sa + 1;
+        int a2 = 256 - sa;
+        *ppdst = (((sr * a1 + dr * a2) >> 8)) << dst.fmt->Rshift |
+                 (((sg * a1 + dg * a2) >> 8)) << dst.fmt->Gshift |
+                 (((sb * a1 + db * a2) >> 8)) << dst.fmt->Bshift |
+                 (255 >> dst.fmt->Aloss);
 #endif
-      ppsrc++;
-			ppdst++;
-		}
-	}
+        ppsrc++;
+        ppdst++;
+      }
+    }
 
-  SDL_UnlockSurface(ssrc);
-  SDL_UnlockSurface(dst.surface);
+    SDL_UnlockSurface(ssrc);
+    SDL_UnlockSurface(dst.surface);
+  }
   SDL_FreeSurface(ssrc);
 
   int i, n;

data/miyako_input_audio.c

@@ -72,19 +72,19 @@ static VALUE input_update(VALUE self)
   int i;
   VALUE *ptr;
 
-  VALUE btn = rb_iv_get(self, "@@btn");    
-  VALUE mouse = rb_iv_get(self, "@@mouse");    
-  VALUE process = rb_iv_get(self, "@@process");    
-  VALUE toggle = rb_iv_get(self, "@@toggle_screen_mode");    
+  VALUE btn = rb_iv_get(self, "@@btn");
+  VALUE mouse = rb_iv_get(self, "@@mouse");
+  VALUE process = rb_iv_get(self, "@@process");
+  VALUE toggle = rb_iv_get(self, "@@toggle_screen_mode");
 
   VALUE trigger = rb_hash_lookup(btn, sy_trigger);
   VALUE pushed  = rb_hash_lookup(btn, sy_pushed);
   VALUE click   = rb_hash_lookup(mouse, sy_click);
   VALUE drop    = rb_hash_lookup(mouse, sy_drop);
   VALUE pos     = rb_hash_lookup(mouse, sy_pos);
-  
+
   rb_funcall(cJoystick, id_update_all, 0);
-  
+
   VALUE keys = rb_funcall(pushed, rb_intern("keys"), 0);
   ptr = RARRAY_PTR(keys);
   for(i=0; i<RARRAY_LEN(keys); i++)
@@ -100,7 +100,7 @@ static VALUE input_update(VALUE self)
   rb_hash_aset(drop, sy_left, Qfalse);
   rb_hash_aset(drop, sy_middle, Qfalse);
   rb_hash_aset(drop, sy_right, Qfalse);
-  
+
   VALUE e_list = rb_ary_new();
   VALUE e = rb_funcall(cEvent, id_poll, 0);
   while(e != Qnil)
@@ -125,10 +125,15 @@ static VALUE input_update(VALUE self)
       rb_hash_aset(pushed, sy_ent, nZero);
     }
   }
-  
+
   return Qnil;
 }
 
+void _miyako_input_update()
+{
+  input_update(mInput);
+}
+
 /*
 :nodoc:
 */
@@ -136,7 +141,7 @@ static VALUE bgm_update(VALUE self)
 {
   VALUE nua = rb_gv_get("$not_use_audio");
   if(nua == Qfalse) return Qnil;
-  
+
   VALUE pb = rb_iv_get(self, "@@playin_bgm");
   if(pb == Qnil) return Qnil;
 
@@ -167,14 +172,14 @@ static VALUE se_update(VALUE self)
 {
   VALUE nua = rb_gv_get("$not_use_audio");
   if(nua == Qfalse) return Qnil;
-  
+
   VALUE playings = rb_iv_get(self, "@@playings");
   VALUE *ptr = RARRAY_PTR(playings);
   int i;
   for(i=0; i<RARRAY_LEN(playings); i++)
   {
     VALUE pl = *(ptr+i);
-    
+
   if(rb_funcall(pl, id_is_playing_wo_loop, 0) == Qfalse &&
        rb_funcall(pl, id_in_the_loop, 0) == Qtrue)
     {
@@ -192,7 +197,7 @@ static VALUE se_update(VALUE self)
       rb_funcall(pl, id_allow_countup, 0);
     }
   }
-  
+
   return Qnil;
 }
 
@@ -206,6 +211,11 @@ static VALUE audio_update(VALUE self)
   return self;
 }
 
+void _miyako_audio_update()
+{
+  audio_update(mAudio);
+}
+
 void Init_miyako_input_audio()
 {
   mSDL = rb_define_module("SDL");
@@ -247,8 +257,8 @@ void Init_miyako_input_audio()
   one = 1;
   nOne = INT2NUM(one);
 
-  rb_define_module_function(mInput, "update", input_update, 0);
-  rb_define_module_function(mAudio, "update", audio_update, 0);
+  rb_define_singleton_method(mInput, "update", input_update, 0);
+  rb_define_singleton_method(mAudio, "update", audio_update, 0);
   rb_define_singleton_method(cBGM, "update", bgm_update, 0);
   rb_define_singleton_method(cSE, "update", se_update, 0);
 }