diff --git a/stepmania/src/Actor.cpp b/stepmania/src/Actor.cpp
index 48f158b1e7..2ecf0b9435 100644
--- a/stepmania/src/Actor.cpp
+++ b/stepmania/src/Actor.cpp
@@ -979,10 +979,6 @@ void Actor::PlayCommand( const CString &sCommandName )
 	RunCommands( *it->second );
 }
 
-void Actor::PushSelf( lua_State *L )
-{
-	Luna<Actor,LuaActor>::Push( L, this );
-}
 
 /*
  * (c) 2001-2004 Chris Danford
diff --git a/stepmania/src/Actor.h b/stepmania/src/Actor.h
index 08099ca12d..873b3c7e70 100644
--- a/stepmania/src/Actor.h
+++ b/stepmania/src/Actor.h
@@ -9,13 +9,19 @@
 #include <map>
 struct XNode;
 struct lua_State;
+#include "LuaBinding.h"
+
 
 #define DRAW_ORDER_BEFORE_EVERYTHING	-100
 #define DRAW_ORDER_TRANSITIONS			100
 #define DRAW_ORDER_AFTER_EVERYTHING		200
 
+template<class T>
+class LunaActor : public Luna<T>
+{
+public:
+	LunaActor() { LUA->Register( Register ); }
 
-#define LUA_Actor_METHODS( T ) \
 	static int sleep( T* p, lua_State *L )			{ p->Sleep(FArg(1)); return 0; } \
 	static int linear( T* p, lua_State *L )			{ p->BeginTweening(FArg(1),Actor::TWEEN_LINEAR); return 0; } \
 	static int accelerate( T* p, lua_State *L )		{ p->BeginTweening(FArg(1),Actor::TWEEN_ACCELERATE); return 0; } \
@@ -105,96 +111,98 @@ struct lua_State;
 	static int playcommand( T* p, lua_State *L )		{ p->PlayCommand(SArg(1)); return 0; } \
 	static int queuecommand( T* p, lua_State *L )		{ p->QueueCommand(SArg(1)); return 0; } \
 
-#define LUA_Actor_METHODS_MAP( T ) \
-	LUA_METHOD_MAP( T, sleep ) \
-	LUA_METHOD_MAP( T, linear ) \
-	LUA_METHOD_MAP( T, accelerate ) \
-	LUA_METHOD_MAP( T, decelerate ) \
-	LUA_METHOD_MAP( T, bouncebegin ) \
-	LUA_METHOD_MAP( T, bounceend ) \
-	LUA_METHOD_MAP( T, spring ) \
-	LUA_METHOD_MAP( T, stoptweening ) \
-	LUA_METHOD_MAP( T, finishtweening ) \
-	LUA_METHOD_MAP( T, hurrytweening ) \
-	LUA_METHOD_MAP( T, x ) \
-	LUA_METHOD_MAP( T, y ) \
-	LUA_METHOD_MAP( T, z ) \
-	LUA_METHOD_MAP( T, addx ) \
-	LUA_METHOD_MAP( T, addy ) \
-	LUA_METHOD_MAP( T, addz ) \
-	LUA_METHOD_MAP( T, zoom ) \
-	LUA_METHOD_MAP( T, zoomx ) \
-	LUA_METHOD_MAP( T, zoomy ) \
-	LUA_METHOD_MAP( T, zoomz ) \
-	LUA_METHOD_MAP( T, zoomtowidth ) \
-	LUA_METHOD_MAP( T, zoomtoheight ) \
-	LUA_METHOD_MAP( T, stretchto ) \
-	LUA_METHOD_MAP( T, cropleft ) \
-	LUA_METHOD_MAP( T, croptop ) \
-	LUA_METHOD_MAP( T, cropright ) \
-	LUA_METHOD_MAP( T, cropbottom ) \
-	LUA_METHOD_MAP( T, fadeleft ) \
-	LUA_METHOD_MAP( T, fadetop ) \
-	LUA_METHOD_MAP( T, faderight ) \
-	LUA_METHOD_MAP( T, fadebottom ) \
-	LUA_METHOD_MAP( T, diffuse ) \
-	LUA_METHOD_MAP( T, diffuseleftedge ) \
-	LUA_METHOD_MAP( T, diffuserightedge ) \
-	LUA_METHOD_MAP( T, diffusetopedge ) \
-	LUA_METHOD_MAP( T, diffusebottomedge ) \
-	LUA_METHOD_MAP( T, diffusealpha ) \
-	LUA_METHOD_MAP( T, diffusecolor ) \
-	LUA_METHOD_MAP( T, glow ) \
-	LUA_METHOD_MAP( T, rotationx ) \
-	LUA_METHOD_MAP( T, rotationy ) \
-	LUA_METHOD_MAP( T, rotationz ) \
-	LUA_METHOD_MAP( T, heading ) \
-	LUA_METHOD_MAP( T, pitch ) \
-	LUA_METHOD_MAP( T, roll ) \
-	LUA_METHOD_MAP( T, shadowlength ) \
-	LUA_METHOD_MAP( T, horizalign ) \
-	LUA_METHOD_MAP( T, vertalign ) \
-	LUA_METHOD_MAP( T, diffuseblink ) \
-	LUA_METHOD_MAP( T, diffuseshift ) \
-	LUA_METHOD_MAP( T, glowblink ) \
-	LUA_METHOD_MAP( T, glowshift ) \
-	LUA_METHOD_MAP( T, rainbow ) \
-	LUA_METHOD_MAP( T, wag ) \
-	LUA_METHOD_MAP( T, bounce ) \
-	LUA_METHOD_MAP( T, bob ) \
-	LUA_METHOD_MAP( T, pulse ) \
-	LUA_METHOD_MAP( T, spin ) \
-	LUA_METHOD_MAP( T, vibrate ) \
-	LUA_METHOD_MAP( T, stopeffect ) \
-	LUA_METHOD_MAP( T, effectcolor1 ) \
-	LUA_METHOD_MAP( T, effectcolor2 ) \
-	LUA_METHOD_MAP( T, effectperiod ) \
-	LUA_METHOD_MAP( T, effectoffset ) \
-	LUA_METHOD_MAP( T, effectdelay ) \
-	LUA_METHOD_MAP( T, effectclock ) \
-	LUA_METHOD_MAP( T, effectmagnitude ) \
-	LUA_METHOD_MAP( T, scaletocover ) \
-	LUA_METHOD_MAP( T, scaletofit ) \
-	LUA_METHOD_MAP( T, animate ) \
-	LUA_METHOD_MAP( T, play ) \
-	LUA_METHOD_MAP( T, pause ) \
-	LUA_METHOD_MAP( T, setstate ) \
-	LUA_METHOD_MAP( T, texturewrapping ) \
-	LUA_METHOD_MAP( T, additiveblend ) \
-	LUA_METHOD_MAP( T, blend ) \
-	LUA_METHOD_MAP( T, zbuffer ) \
-	LUA_METHOD_MAP( T, ztest ) \
-	LUA_METHOD_MAP( T, ztestmode ) \
-	LUA_METHOD_MAP( T, zwrite ) \
-	LUA_METHOD_MAP( T, clearzbuffer ) \
-	LUA_METHOD_MAP( T, backfacecull ) \
-	LUA_METHOD_MAP( T, cullmode ) \
-	LUA_METHOD_MAP( T, hidden ) \
-	LUA_METHOD_MAP( T, hibernate ) \
-	LUA_METHOD_MAP( T, draworder ) \
-	LUA_METHOD_MAP( T, playcommand ) \
-	LUA_METHOD_MAP( T, queuecommand ) \
-
+	static void Register(lua_State *L) {
+  		ADD_METHOD( sleep ) \
+		ADD_METHOD( linear ) \
+		ADD_METHOD( accelerate ) \
+		ADD_METHOD( decelerate ) \
+		ADD_METHOD( bouncebegin ) \
+		ADD_METHOD( bounceend ) \
+		ADD_METHOD( spring ) \
+		ADD_METHOD( stoptweening ) \
+		ADD_METHOD( finishtweening ) \
+		ADD_METHOD( hurrytweening ) \
+		ADD_METHOD( x ) \
+		ADD_METHOD( y ) \
+		ADD_METHOD( z ) \
+		ADD_METHOD( addx ) \
+		ADD_METHOD( addy ) \
+		ADD_METHOD( addz ) \
+		ADD_METHOD( zoom ) \
+		ADD_METHOD( zoomx ) \
+		ADD_METHOD( zoomy ) \
+		ADD_METHOD( zoomz ) \
+		ADD_METHOD( zoomtowidth ) \
+		ADD_METHOD( zoomtoheight ) \
+		ADD_METHOD( stretchto ) \
+		ADD_METHOD( cropleft ) \
+		ADD_METHOD( croptop ) \
+		ADD_METHOD( cropright ) \
+		ADD_METHOD( cropbottom ) \
+		ADD_METHOD( fadeleft ) \
+		ADD_METHOD( fadetop ) \
+		ADD_METHOD( faderight ) \
+		ADD_METHOD( fadebottom ) \
+		ADD_METHOD( diffuse ) \
+		ADD_METHOD( diffuseleftedge ) \
+		ADD_METHOD( diffuserightedge ) \
+		ADD_METHOD( diffusetopedge ) \
+		ADD_METHOD( diffusebottomedge ) \
+		ADD_METHOD( diffusealpha ) \
+		ADD_METHOD( diffusecolor ) \
+		ADD_METHOD( glow ) \
+		ADD_METHOD( rotationx ) \
+		ADD_METHOD( rotationy ) \
+		ADD_METHOD( rotationz ) \
+		ADD_METHOD( heading ) \
+		ADD_METHOD( pitch ) \
+		ADD_METHOD( roll ) \
+		ADD_METHOD( shadowlength ) \
+		ADD_METHOD( horizalign ) \
+		ADD_METHOD( vertalign ) \
+		ADD_METHOD( diffuseblink ) \
+		ADD_METHOD( diffuseshift ) \
+		ADD_METHOD( glowblink ) \
+		ADD_METHOD( glowshift ) \
+		ADD_METHOD( rainbow ) \
+		ADD_METHOD( wag ) \
+		ADD_METHOD( bounce ) \
+		ADD_METHOD( bob ) \
+		ADD_METHOD( pulse ) \
+		ADD_METHOD( spin ) \
+		ADD_METHOD( vibrate ) \
+		ADD_METHOD( stopeffect ) \
+		ADD_METHOD( effectcolor1 ) \
+		ADD_METHOD( effectcolor2 ) \
+		ADD_METHOD( effectperiod ) \
+		ADD_METHOD( effectoffset ) \
+		ADD_METHOD( effectdelay ) \
+		ADD_METHOD( effectclock ) \
+		ADD_METHOD( effectmagnitude ) \
+		ADD_METHOD( scaletocover ) \
+		ADD_METHOD( scaletofit ) \
+		ADD_METHOD( animate ) \
+		ADD_METHOD( play ) \
+		ADD_METHOD( pause ) \
+		ADD_METHOD( setstate ) \
+		ADD_METHOD( texturewrapping ) \
+		ADD_METHOD( additiveblend ) \
+		ADD_METHOD( blend ) \
+		ADD_METHOD( zbuffer ) \
+		ADD_METHOD( ztest ) \
+		ADD_METHOD( ztestmode ) \
+		ADD_METHOD( zwrite ) \
+		ADD_METHOD( clearzbuffer ) \
+		ADD_METHOD( backfacecull ) \
+		ADD_METHOD( cullmode ) \
+		ADD_METHOD( hidden ) \
+		ADD_METHOD( hibernate ) \
+		ADD_METHOD( draworder ) \
+		ADD_METHOD( playcommand ) \
+		ADD_METHOD( queuecommand ) \
+		Luna<T>::Register( L );
+	}
+};
 
 class Actor
 {
diff --git a/stepmania/src/ActorFrame.cpp b/stepmania/src/ActorFrame.cpp
index 57415ea42d..f894fa3045 100644
--- a/stepmania/src/ActorFrame.cpp
+++ b/stepmania/src/ActorFrame.cpp
@@ -254,11 +254,6 @@ void ActorFrame::PlayCommand( const CString &sCommandName )
 	}
 }
 
-void ActorFrame::PushSelf( lua_State *L )
-{
-	Luna<ActorFrame,LuaActorFrame>::Push( L, this );
-}
-
 /*
  * (c) 2001-2004 Chris Danford
  * All rights reserved.
diff --git a/stepmania/src/ActorFrame.h b/stepmania/src/ActorFrame.h
index 00ff79847b..e908c98943 100644
--- a/stepmania/src/ActorFrame.h
+++ b/stepmania/src/ActorFrame.h
@@ -5,13 +5,20 @@
 
 #include "Actor.h"
 
-#define LUA_ActorFrame_METHODS( T ) \
-	LUA_Actor_METHODS( T ) \
+template<class T>
+class LunaActorFrame : public LunaActor<T>
+{
+public:
+	LunaActorFrame() { LUA->Register( Register ); }
+
 	static int propagate( T* p, lua_State *L )	{ p->SetPropagateCommands( BArg(1) ); return 0; } \
 
-#define LUA_ActorFrame_METHODS_MAP( T ) \
-	LUA_Actor_METHODS_MAP( T ) \
-	LUA_METHOD_MAP( T, propagate ) \
+	static void Register(lua_State *L) 
+	{
+		ADD_METHOD( propagate ) \
+		LunaActor<T>::Register( L );
+	}
+};
 
 class ActorFrame : public Actor
 {
diff --git a/stepmania/src/BitmapText.cpp b/stepmania/src/BitmapText.cpp
index ae65bd8d0e..bd77966a52 100644
--- a/stepmania/src/BitmapText.cpp
+++ b/stepmania/src/BitmapText.cpp
@@ -551,11 +551,6 @@ void BitmapText::SetWrapWidthPixels( int iWrapWidthPixels )
 	SetText( m_sText, "", iWrapWidthPixels );
 }
 
-void BitmapText::PushSelf( lua_State *L )
-{
-	Luna<BitmapText,LuaBitmapText>::Push( L, this );
-}
-
 /*
  * (c) 2003-2004 Chris Danford
  * All rights reserved.
diff --git a/stepmania/src/BitmapText.h b/stepmania/src/BitmapText.h
index 5c6fb33ee3..5126d5ca40 100644
--- a/stepmania/src/BitmapText.h
+++ b/stepmania/src/BitmapText.h
@@ -6,15 +6,22 @@
 #include "Actor.h"
 class RageTexture;
 
-#define LUA_BitmapText_METHODS( T ) \
-	LUA_Actor_METHODS( T ) \
+template<class T>
+class LunaBitmapText : public LunaActor<T>
+{
+public:
+	LunaBitmapText() { LUA->Register( Register ); }
+
 	static int wrapwidthpixels( T* p, lua_State *L )	{ p->SetWrapWidthPixels( IArg(1) ); return 0; } \
 	static int maxwidth( T* p, lua_State *L )			{ p->SetMaxWidth( FArg(1) ); return 0; } \
 
-#define LUA_BitmapText_METHODS_MAP( T ) \
-	LUA_Actor_METHODS_MAP( T ) \
-	LUA_METHOD_MAP( T, wrapwidthpixels ) \
-	LUA_METHOD_MAP( T, maxwidth ) \
+	static void Register(lua_State *L) 
+	{
+		ADD_METHOD( wrapwidthpixels ) \
+		ADD_METHOD( maxwidth ) \
+		LunaActor<T>::Register( L );
+	}
+};
 
 
 class Font;
diff --git a/stepmania/src/LuaBinding.h b/stepmania/src/LuaBinding.h
index a868bba3e2..4c39e0a33a 100644
--- a/stepmania/src/LuaBinding.h
+++ b/stepmania/src/LuaBinding.h
@@ -2,6 +2,9 @@
  * Modified by Chris.
  */
 
+#ifndef LuaBinding_H
+#define LuaBinding_H
+
 extern "C"
 {
 #include <lua.h>
@@ -9,6 +12,7 @@ extern "C"
 }
 
 #include "LuaManager.h"
+#include <vector>
 
 
 #define SArg(n) (luaL_checkstring(L,n))
@@ -17,27 +21,10 @@ extern "C"
 #define FArg(n) ((float) luaL_checknumber(L,n))
 
 
-#define LUA_REGISTER_CLASS( T ) \
-class Lua##T { \
-public: \
-	Lua##T() { LUA->Register( Register ); } \
-	static const char className[]; \
-	static Luna<T,Lua##T>::RegType methods[]; \
-	static void Register( lua_State* L ) { \
-		Luna<T,Lua##T>::Register(L); \
-	} \
-	LUA_##T##_METHODS( T ) \
-}; \
-static Lua##T registera; \
-const char Lua##T::className[] = #T; \
-Luna<T,Lua##T>::RegType Lua##T::methods[] = { \
-	LUA_##T##_METHODS_MAP( T ) \
-	{0,0} \
-};
-#define LUA_METHOD_MAP( T, Method ) 	{ #Method, Lua##T::Method },
 
-
-template <typename T, typename TInfo> class Luna {
+template <typename T>
+class Luna 
+{
   typedef struct { T *pT; } userdataType;
 public:
   typedef int (*mfp)(T *p, lua_State *L);
@@ -47,12 +34,12 @@ public:
     lua_newtable(L);
     int methods = lua_gettop(L);
 
-    luaL_newmetatable(L, TInfo::className);
+    luaL_newmetatable(L, s_className);
     int metatable = lua_gettop(L);
 
     // store method table in globals so that
     // scripts can add functions written in Lua.
-    lua_pushstring(L, TInfo::className);
+    lua_pushstring(L, s_className);
     lua_pushvalue(L, methods);
     lua_settable(L, LUA_GLOBALSINDEX);
 
@@ -69,7 +56,8 @@ public:
     lua_settable(L, metatable);
 
     // fill method table with methods from class T
-    for (RegType *l = TInfo::methods; l->name; l++) {
+    for (vector<RegType>::const_iterator i = s_pvMethods->begin(); i != s_pvMethods->end(); i++) {
+		const RegType *l = &(*i);
       lua_pushstring(L, l->name);
       lua_pushlightuserdata(L, (void*)l);
       lua_pushcclosure(L, thunk, 1);
@@ -82,13 +70,12 @@ public:
   // get userdata from Lua stack and return pointer to T object
   static T *check(lua_State *L, int narg) {
     userdataType *ud =
-      static_cast<userdataType*>(luaL_checkudata(L, narg, TInfo::className));
-    if(!ud) luaL_typerror(L, narg, TInfo::className);
+      static_cast<userdataType*>(luaL_checkudata(L, narg, s_className));
+    if(!ud) luaL_typerror(L, narg, s_className);
     return ud->pT;  // pointer to T object
   }
 
 private:
-  Luna();  // hide default constructor
 
   // member function dispatcher
   static int thunk(lua_State *L) {
@@ -106,23 +93,39 @@ public:
   static int Push(lua_State *L, T* p ) {
     userdataType *ud = static_cast<userdataType*>(lua_newuserdata(L, sizeof(userdataType)));
     ud->pT = p;  // store pointer to object in userdata
-    luaL_getmetatable(L, TInfo::className);  // lookup metatable in Lua registry
+    luaL_getmetatable(L, s_className);  // lookup metatable in Lua registry
     lua_setmetatable(L, -2);
     return 1;  // userdata containing pointer to T object
   }
 
+	typedef vector<RegType> RegTypeVector;
+	static RegTypeVector *s_pvMethods;
 private:
+	static const char s_className[];
 
   static int tostring_T (lua_State *L) {
     char buff[32];
     userdataType *ud = static_cast<userdataType*>(lua_touserdata(L, 1));
     T *obj = ud->pT;
     sprintf(buff, "%p", obj);
-    lua_pushfstring(L, "%s (%s)", TInfo::className, buff);
+    lua_pushfstring(L, "%s (%s)", s_className, buff);
     return 1;
   }
 };
 
+
+#define LUA_REGISTER_CLASS( T ) \
+const char Luna##T<T>::s_className[] = #T; \
+Luna##T<T>::RegTypeVector* Luna##T<T>::s_pvMethods = NULL; \
+static Luna##T<T> registera; \
+void T::PushSelf( lua_State *L ) { Luna##T<T>::Push( L, this ); }
+
+#define ADD_METHOD( method_name ) \
+	{ if(s_pvMethods==NULL) s_pvMethods = new RegTypeVector; RegType r = {#method_name,method_name}; s_pvMethods->push_back(r); }
+
+
+#endif
+
 /*
  * (c) 2001-2005 lua-users.org, Chris Danford
  * All rights reserved.
diff --git a/stepmania/src/Model.cpp b/stepmania/src/Model.cpp
index 4b4960491e..3aeb624bfd 100644
--- a/stepmania/src/Model.cpp
+++ b/stepmania/src/Model.cpp
@@ -785,11 +785,6 @@ bool Model::MaterialsNeedNormals() const
 	return false;
 }
 
-void Model::PushSelf( lua_State *L )
-{
-	Luna<Model,LuaModel>::Push( L, this );
-}
-
 /*
  * (c) 2003-2004 Chris Danford
  * All rights reserved.
diff --git a/stepmania/src/Model.h b/stepmania/src/Model.h
index a8e500f564..8e46e39430 100644
--- a/stepmania/src/Model.h
+++ b/stepmania/src/Model.h
@@ -10,13 +10,20 @@
 #include <map>
 #include "RageModelGeometry.h"
 
-#define LUA_Model_METHODS( T ) \
-	LUA_Actor_METHODS( T ) \
+template<class T>
+class LunaModel : public LunaActor<T>
+{
+public:
+	LunaModel() { LUA->Register( Register ); }
+
 	static int playanimation( T* p, lua_State *L )	{ p->PlayAnimation(SArg(1),FArg(2)); return 0; } \
 
-#define LUA_Model_METHODS_MAP( T ) \
-	LUA_Actor_METHODS_MAP( T ) \
-	LUA_METHOD_MAP( T, playanimation ) \
+	static void Register(lua_State *L) 
+	{
+		ADD_METHOD( playanimation ) \
+		LunaActor<T>::Register( L );
+	}
+};
 
 class Model : public Actor
 {
diff --git a/stepmania/src/Sprite.cpp b/stepmania/src/Sprite.cpp
index a23c3ef5d1..e26d03514e 100644
--- a/stepmania/src/Sprite.cpp
+++ b/stepmania/src/Sprite.cpp
@@ -976,12 +976,6 @@ void Sprite::LoseFocus()
 	Actor::LoseFocus();
 }
 
-void Sprite::PushSelf( lua_State *L )
-{
-	Luna<Sprite,LuaSprite>::Push( L, this );
-}
-
-
 /*
  * (c) 2001-2004 Chris Danford
  * All rights reserved.
diff --git a/stepmania/src/Sprite.h b/stepmania/src/Sprite.h
index 133c6cb404..51a2765b30 100644
--- a/stepmania/src/Sprite.h
+++ b/stepmania/src/Sprite.h
@@ -8,9 +8,12 @@
 
 class RageTexture;
 
+template<class T>
+class LunaSprite : public LunaActor<T>
+{
+public:
+	LunaSprite() { LUA->Register( Register ); }
 
-#define LUA_Sprite_METHODS( T ) \
-	LUA_Actor_METHODS( T ) \
 	/* Commands that go in the tweening queue: 
 	 * Commands that take effect immediately (ignoring the tweening queue): */ \
 	static int customtexturerect( T* p, lua_State *L )	{ p->SetCustomTextureRect( RectF(FArg(1),FArg(2),FArg(3),FArg(4)) ); return 0; } \
@@ -25,15 +28,17 @@ class RageTexture;
 	static int loop( T* p, lua_State *L )				{ p->SetLooping(BArg(1)); return 0; } \
 	static int rate( T* p, lua_State *L )				{ p->SetPlaybackRate(FArg(1)); return 0; } \
 
-#define LUA_Sprite_METHODS_MAP( T ) \
-	LUA_Actor_METHODS_MAP( T ) \
-	LUA_METHOD_MAP( T, customtexturerect ) \
-	LUA_METHOD_MAP( T, texcoordvelocity ) \
-	LUA_METHOD_MAP( T, scaletoclipped ) \
-	LUA_METHOD_MAP( T, stretchtexcoords ) \
-	LUA_METHOD_MAP( T, position ) \
-	LUA_METHOD_MAP( T, loop ) \
-	LUA_METHOD_MAP( T, rate ) \
+	static void Register(lua_State *L) {
+		ADD_METHOD( customtexturerect ) \
+		ADD_METHOD( texcoordvelocity ) \
+		ADD_METHOD( scaletoclipped ) \
+		ADD_METHOD( stretchtexcoords ) \
+		ADD_METHOD( position ) \
+		ADD_METHOD( loop ) \
+		ADD_METHOD( rate ) \
+		LunaActor<T>::Register( L );
+	}
+};
 
 
 class Sprite: public Actor