Lolua small simplification

getter default params are better now

doc/samples/meshviewer/imgui.ini

@@ -0,0 +1,10 @@
+[Debug]
+Pos=60,60
+Size=400,400
+Collapsed=0
+
+[Camera Setup]
+Pos=60,60
+Size=307,314
+Collapsed=0
+

doc/tutorial/14_lol_lua.cpp

@@ -43,20 +43,24 @@ public:
 
         return (stack << i).End();
     }
-
-    static int AddTenInstance(lua_State* l)
+    
+    LOLUA_DECLARE_RETURN_METHOD(AddTenInstance, GetPtr<DemoObject>(), AddTenMethod, Get<float>(), Get<int32_t>(), Get<int32_t>());
+    static int _AddTenInstance(lua_State* l)
     {
         auto stack = LuaStack::Begin(l);
         DemoObject* obj = stack.GetPtr<DemoObject>();
-		float f = stack.Get<float>();
+        float f = stack.Get<float>();
+        int32_t i = stack.Get<int32_t>();
+        int32_t i2 = stack.Get<int32_t>();
 
-        f = obj->AddTenMethod(f);
+        f = obj->AddTenMethod(f, i, i2);
 
         return (stack << f).End();
     }
 
-    float AddTenMethod(float f)
+    float AddTenMethod(float f, int32_t i, int32_t i2)
     {
+        UNUSED(i, i2);
         return (f + 10);
     }
 
@@ -71,7 +75,8 @@ public:
         return (stack << i).End();
     }
 
-    static int SetX(lua_State* l)
+    LOLUA_DECLARE_VOID_METHOD(SetX, GetPtr<DemoObject>(), SetXMethod, Get<int32_t>());
+    static int _SetX(lua_State* l)
     {
         auto stack = LuaStack::Begin(l);
         DemoObject* obj = stack.GetPtr<DemoObject>();
@@ -82,6 +87,12 @@ public:
         return stack.End();
     }
 
+    void SetXMethod(int32_t i)
+    {
+        m_x = i;
+    }
+
+
     //-------------------------------------------------------------------------
     static const LuaObjectLibrary* GetLib()
     {
@@ -190,6 +201,12 @@ public:
             function_return: %s, loluademo_return: %i, loluademo_inst_return: %.f, loluademo_getx: %i, loluademo_inst->m_x: %i.\n",
             function_return.C(), loluademo_return, loluademo_inst_return, loluademo_getx, loluademo_inst->m_x);
 
+#define /***/ _LOLUA_ARG_1(a00) (float)a00
+#define /***/ _LOLUA_ARG_2(a00, a01) _LOLUA_ARG_1(a00), _LOLUA_ARG_1(a01)
+#define /***/ _LOLUA_ARG_3(a00, a01, a02) _LOLUA_ARG_1(a00), _LOLUA_ARG_2(a01, a02)
+#define /***/ _LOLUA_ARG_4(a00, a01, a02, a03) _LOLUA_ARG_1(a00), _LOLUA_ARG_3(a01, a02, a03)
+        msg::info("_LOLUA_ARG_1: %f, %f, %f, %f\n", _LOLUA_ARG_4(0, 1, 2, 3));
+
         delete demo_loader;
 
         Ticker::Shutdown();

doc/tutorial/14_lol_lua.lua

@@ -13,4 +13,4 @@ loluademo_return = LoluaDemo.AddFive(1);
 loluademo_inst = LoluaDemo.New();
 loluademo_inst:SetX(10);
 loluademo_getx = loluademo_inst:GetX();
-loluademo_inst_return = loluademo_inst:AddTenInstance(2.0);
+loluademo_inst_return = loluademo_inst:AddTenInstance(2.5, 4, 6);

src/easymesh/easymeshlua.cpp

@@ -82,7 +82,7 @@ EasyMeshLuaObject* EasyMeshLuaObject::New(lua_State* l, int arg_nb)
     UNUSED(l);
     UNUSED(arg_nb);
     LuaStack s = LuaStack::Begin(l);
-    String str = s.Get("", true);
+    String str = s.Get<String>("");
     return new EasyMeshLuaObject(str);
 }
 

src/easymesh/easymeshlua.h

@@ -38,12 +38,13 @@ public:
         auto h = s.Get<float>();
         auto d1 = s.Get<float>();
         auto d2 = s.Get<float>();
-        auto dualside = s.Get<bool>(false, true);
-        auto smooth = s.Get<bool>(false, true);
-        auto close = s.Get<bool>(false, true);
+        auto dualside = s.Get<bool>(false);
+        auto smooth = s.Get<bool>(false);
+        auto close = s.Get<bool>(false);
         m->m_instance.AppendCylinder(nsides, h, d1, d2, dualside, smooth, close);
         return s.End();
     }
+    //LOLUA_DECLARE_VOID_METHOD(AppendSphere, GetPtr<EasyMeshLuaObject>(), m_instance.AppendSphere, Get<int32_t>(), Get<float>());
     static int AppendSphere(lua_State* l)
     {
         auto s = LuaStack::Begin(l);
@@ -53,6 +54,7 @@ public:
         m->m_instance.AppendSphere(ndivisions, d);
         return s.End();
     }
+
     static int AppendCapsule(lua_State* l)
     {
         auto s = LuaStack::Begin(l);
@@ -78,8 +80,8 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto size = s.Get<vec3>();
-        auto chamf = s.Get<float>(0.f, true);
-        auto smooth = s.Get<bool>(false, true);
+        auto chamf = s.Get<float>(0.f);
+        auto smooth = s.Get<bool>(false);
         m->m_instance.AppendBox(size, chamf, smooth);
         return s.End();
     }
@@ -90,8 +92,8 @@ public:
         auto nbranches = s.Get<int32_t>();
         auto d1 = s.Get<float>();
         auto d2 = s.Get<float>();
-        auto fade = s.Get<bool>(false, true);
-        auto fade2 = s.Get<bool>(false, true);
+        auto fade = s.Get<bool>(false);
+        auto fade2 = s.Get<bool>(false);
         m->m_instance.AppendStar(nbranches, d1, d2, fade, fade2);
         return s.End();
     }
@@ -102,7 +104,7 @@ public:
         auto nbranches = s.Get<int32_t>();
         auto d1 = s.Get<float>();
         auto d2 = s.Get<float>();
-        auto extrad = s.Get<float>(0.f, true);
+        auto extrad = s.Get<float>(0.f);
         m->m_instance.AppendExpandedStar(nbranches, d1, d2, extrad);
         return s.End();
     }
@@ -112,7 +114,7 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto nsides = s.Get<int32_t>();
         auto d = s.Get<float>();
-        auto fade = s.Get<bool>(false, true);
+        auto fade = s.Get<bool>(false);
         m->m_instance.AppendDisc(nsides, d, fade);
         return s.End();
     }
@@ -121,7 +123,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto d = s.Get<float>();
-        auto fade = s.Get<bool>(false, true);
+        auto fade = s.Get<bool>(false);
         m->m_instance.AppendSimpleTriangle(d, fade);
         return s.End();
     }
@@ -130,7 +132,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto size = s.Get<float>();
-        auto fade = s.Get<bool>(false, true);
+        auto fade = s.Get<bool>(false);
         m->m_instance.AppendSimpleQuad(size, fade);
         return s.End();
     }
@@ -140,11 +142,11 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto nbsides = s.Get<int32_t>();
         auto h = s.Get<float>();
-        auto sidemul = s.Get<float>(0.f, true);
+        auto sidemul = s.Get<float>(0.f);
         auto d0 = s.Get<vec2>();
         auto d1 = s.Get<vec2>();
         auto d2 = s.Get<vec2>();
-        auto offset = s.Get<bool>(false, true);
+        auto offset = s.Get<bool>(false);
         m->m_instance.AppendCog(nbsides, h, d0.x, d0.y, d1.x, d1.y, d2.x, d2.y, sidemul, offset);
         return s.End();
     }
@@ -264,8 +266,8 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto y = s.Get<float>();
         auto z = s.Get<float>();
-        auto xoff = s.Get<float>(0.f, true);
-        auto abs = s.Get<bool>(true, true);
+        auto xoff = s.Get<float>(0.f);
+        auto abs = s.Get<bool>(true);
         m->m_instance.TaperX(y, z, xoff, abs);
         return s.End();
     }
@@ -275,8 +277,8 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto x = s.Get<float>();
         auto z = s.Get<float>();
-        auto yoff = s.Get<float>(0.f, true);
-        auto abs = s.Get<bool>(true, true);
+        auto yoff = s.Get<float>(0.f);
+        auto abs = s.Get<bool>(true);
         m->m_instance.TaperY(x, z, yoff, abs);
         return s.End();
     }
@@ -286,8 +288,8 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto x = s.Get<float>();
         auto y = s.Get<float>();
-        auto zoff = s.Get<float>(0.f, true);
-        auto abs = s.Get<bool>(true, true);
+        auto zoff = s.Get<float>(0.f);
+        auto abs = s.Get<bool>(true);
         m->m_instance.TaperZ(x, y, zoff, abs);
         return s.End();
     }
@@ -297,7 +299,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.TwistX(t, toff);
         return s.End();
     }
@@ -306,7 +308,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.TwistY(t, toff);
         return s.End();
     }
@@ -315,7 +317,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.TwistZ(t, toff);
         return s.End();
     }
@@ -326,8 +328,8 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto y = s.Get<float>();
         auto z = s.Get<float>();
-        auto xoff = s.Get<float>(0.f, true);
-        auto abs = s.Get<bool>(true, true);
+        auto xoff = s.Get<float>(0.f);
+        auto abs = s.Get<bool>(true);
         m->m_instance.ShearX(y, z, xoff, abs);
         return s.End();
     }
@@ -337,8 +339,8 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto x = s.Get<float>();
         auto z = s.Get<float>();
-        auto yoff = s.Get<float>(0.f, true);
-        auto abs = s.Get<bool>(true, true);
+        auto yoff = s.Get<float>(0.f);
+        auto abs = s.Get<bool>(true);
         m->m_instance.ShearY(x, z, yoff, abs);
         return s.End();
     }
@@ -348,8 +350,8 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto x = s.Get<float>();
         auto y = s.Get<float>();
-        auto zoff = s.Get<float>(0.f, true);
-        auto abs = s.Get<bool>(true, true);
+        auto zoff = s.Get<float>(0.f);
+        auto abs = s.Get<bool>(true);
         m->m_instance.ShearZ(x, y, zoff, abs);
         return s.End();
     }
@@ -360,7 +362,7 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto y = s.Get<float>();
         auto z = s.Get<float>();
-        auto xoff = s.Get<float>(0.f, true);
+        auto xoff = s.Get<float>(0.f);
         m->m_instance.StretchX(y, z, xoff);
         return s.End();
     }
@@ -370,7 +372,7 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto x = s.Get<float>();
         auto z = s.Get<float>();
-        auto yoff = s.Get<float>(0.f, true);
+        auto yoff = s.Get<float>(0.f);
         m->m_instance.StretchY(x, z, yoff);
         return s.End();
     }
@@ -380,7 +382,7 @@ public:
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto x = s.Get<float>();
         auto y = s.Get<float>();
-        auto zoff = s.Get<float>(0.f, true);
+        auto zoff = s.Get<float>(0.f);
         m->m_instance.StretchZ(x, y, zoff);
         return s.End();
     }
@@ -390,7 +392,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.BendXY(t, toff);
         return s.End();
     }
@@ -399,7 +401,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.BendXZ(t, toff);
         return s.End();
     }
@@ -408,7 +410,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.BendYX(t, toff);
         return s.End();
     }
@@ -417,7 +419,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.BendYZ(t, toff);
         return s.End();
     }
@@ -426,7 +428,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.BendZX(t, toff);
         return s.End();
     }
@@ -435,7 +437,7 @@ public:
         auto s = LuaStack::Begin(l);
         auto m = s.GetPtr<EasyMeshLuaObject>();
         auto t = s.Get<float>();
-        auto toff = s.Get<float>(0.f, true);
+        auto toff = s.Get<float>(0.f);
         m->m_instance.BendZY(t, toff);
         return s.End();
     }

src/lolua/baselua.h

@@ -321,37 +321,56 @@ public:
         inline Ptr<T>& operator=(T const*& value) { m_value = value; return *this; }
     };
 
+private:
+    bool AllowGet(bool is_optional, bool value_validity)
+    {
+        bool is_nil = lua_isnil(m_state, m_index);
+        if (!is_optional || (!is_nil && value_validity))
+        {
+            ASSERT(!is_nil); /* touky: should it assert, though ? */
+            return true;
+        }
+        return false;
+    }
+
+public:
 	//-------------------------------------------------------------------------
-    template<typename T> T Get(bool isOptional = false) { return Get(InnerDefault<T>(), isOptional); }
-    template<typename E> SafeEnum<E> GetEnum(bool isOptional = false) { return GetEnum(InnerDefaultSafeEnum<E>(), isOptional); }
-    template<typename P> Ptr<P> GetPtr(bool isOptional = false) { return GetPtr(InnerDefaultPtr<P>(), isOptional); }
+    template<typename T> T Get() { return Get(InnerDefault<T>(), false); }
+    template<typename T> T Get(T default_value) { return Get(default_value, true); }
+    template<typename E> SafeEnum<E> GetEnum() { return GetEnum(InnerDefaultSafeEnum<E>(), false); }
+    template<typename E> SafeEnum<E> GetEnum(SafeEnum<E> default_value) { return GetEnum(default_value, true); }
+    template<typename P> Ptr<P> GetPtr() { return GetPtr(InnerDefaultPtr<P>(), false); }
+    template<typename P> Ptr<P> GetPtr(Ptr<P> default_value) { return GetPtr(default_value, true); }
 
+private:
     //-------------------------------------------------------------------------
-#define DECLARE_STACK_GET(T0, T1, GET_NAME, INNER_IS_VALID, INNER_GET) \
-    template<typename T0> \
-    T1 GET_NAME(T1 value, bool isOptional = false) \
-    { \
-        bool is_nil = lua_isnil(m_state, m_index); \
-        if (!isOptional || (!is_nil && INNER_IS_VALID<T0>())) \
-        { \
-            ASSERT(!is_nil); /* touky: should assert, though ? */ \
-            return INNER_GET<T0>(value); \
-        } \
-        return value; \
+    template<typename T> T Get(T default_value, bool is_optional)
+    {
+        if (AllowGet(is_optional, InnerIsValid<T>()))
+            return InnerGet(default_value);
+        return default_value;
+    }
+    template<typename E> SafeEnum<E> GetEnum(SafeEnum<E> default_value, bool is_optional)
+    {
+        if (AllowGet(is_optional, InnerIsValidSafeEnum<E>()))
+            return InnerGetSafeEnum(default_value);
+        return default_value;
+    }
+    template<typename P> Ptr<P> GetPtr(Ptr<P> default_value, bool is_optional)
+    {
+        if (AllowGet(is_optional, InnerIsValidPtr<P>()))
+            return InnerGetPtr(default_value);
+        return default_value;
     }
 
-    DECLARE_STACK_GET(T, T, Get, InnerIsValid, InnerGet);
-    DECLARE_STACK_GET(E, SafeEnum<E>, GetEnum, InnerIsValidSafeEnum, InnerGetSafeEnum);
-    DECLARE_STACK_GET(P, Ptr<P>, GetPtr, InnerIsValidPtr, InnerGetPtr);
-
-#undef DECLARE_STACK_GET
-
+public:
     //-------------------------------------------------------------------------
-    template<typename T> Stack& operator<<(T& value) { m_result += InnerPush<T>(value); return *this; }
-    template<typename E> Stack& operator<<(SafeEnum<E>& value) { m_result += InnerPushSafeEnum<E>(value); return *this; }
-    template<typename P> Stack& operator<<(Ptr<P>& value) { m_result += InnerPushPtr<P>(value); return *this; }
+    template<typename T> Stack& operator<<(T value) { m_result += InnerPush<T>(value); return *this; }
+    template<typename E> Stack& operator<<(SafeEnum<E> value) { m_result += InnerPushSafeEnum<E>(value); return *this; }
+    template<typename P> Stack& operator<<(Ptr<P> value) { m_result += InnerPushPtr<P>(value); return *this; }
 
 protected:
+    //-------------------------------------------------------------------------
     #define INNER_ERROR "Your type is not implemented. For pointers, use LuaPtr<MyType>()"
     template<typename T> T InnerDefault() { return T(0); }
 	template<typename T> bool InnerIsValid() { ASSERT(false, INNER_ERROR); return false; }
@@ -389,6 +408,56 @@ private:
     int32_t m_result = 0;
 };
 
+//-----------------------------------------------------------------------------
+#define /***/ LOLUA_VAR_1(a00) auto v00 = s.a00;
+#define /***/ LOLUA_VAR_2(a00, a01) LOLUA_VAR_1(a00) auto v01 = s.a01;
+#define /***/ LOLUA_VAR_3(a00, a01, a02) LOLUA_VAR_2(a00, a01) auto v02 = s.a02;
+#define /***/ LOLUA_VAR_4(a00, a01, a02, a03) LOLUA_VAR_3(a00, a01, a02) auto v03 = s.a03;
+#define /***/ LOLUA_VAR_5(a00, a01, a02, a03, a04) LOLUA_VAR_4(a00, a01, a02, a03) auto v04 = s.a04;
+#define /***/ LOLUA_VAR_6(a00, a01, a02, a03, a04, a05) LOLUA_VAR_5(a00, a01, a02, a03, a04) auto v05 = s.a05;
+#define /***/ LOLUA_VAR_7(a00, a01, a02, a03, a04, a05, a06) LOLUA_VAR_6(a00, a01, a02, a03, a04, a05) auto v06 = s.a06;
+#define /***/ LOLUA_VAR_8(a00, a01, a02, a03, a04, a05, a06, a07) LOLUA_VAR_7(a00, a01, a02, a03, a04, a05, a06) auto v07 = s.a07;
+#define /***/ LOLUA_VAR_9(a00, a01, a02, a03, a04, a05, a06, a07, a08) LOLUA_VAR_8(a00, a01, a02, a03, a04, a05, a06, a07) auto v08 = s.a08;
+#define /**/ LOLUA_VAR_10(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09) LOLUA_VAR_9(a00, a01, a02, a03, a04, a05, a06, a07, a08) auto v09 = s.a09;
+#define /**/ LOLUA_VAR_11(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09, a10) LOLUA_VAR_10(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09) auto v10 = s.a10;
+#define /**/ LOLUA_VAR_12(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09, a10, a11) LOLUA_VAR_11(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09) auto v11 = s.a11;
+//-----------------------------------------------------------------------------
+#define /***/ LOLUA_ARG_1(a00) v00
+#define /***/ LOLUA_ARG_2(a00, a01) LOLUA_ARG_1(a00), v01
+#define /***/ LOLUA_ARG_3(a00, a01, a02) LOLUA_ARG_2(a00, a01), v02
+#define /***/ LOLUA_ARG_4(a00, a01, a02, a03) LOLUA_ARG_3(a00, a01, a02), v03
+#define /***/ LOLUA_ARG_5(a00, a01, a02, a03, a04) LOLUA_ARG_4(a00, a01, a02, a03), v04
+#define /***/ LOLUA_ARG_6(a00, a01, a02, a03, a04, a05) LOLUA_ARG_5(a00, a01, a02, a03, a04), v05
+#define /***/ LOLUA_ARG_7(a00, a01, a02, a03, a04, a05, a06) LOLUA_ARG_6(a00, a01, a02, a03, a04, a05), v06
+#define /***/ LOLUA_ARG_8(a00, a01, a02, a03, a04, a05, a06, a07) LOLUA_ARG_7(a00, a01, a02, a03, a04, a05, a06), v07
+#define /***/ LOLUA_ARG_9(a00, a01, a02, a03, a04, a05, a06, a07, a08) LOLUA_ARG_8(a00, a01, a02, a03, a04, a05, a06, a07), v08
+#define /**/ LOLUA_ARG_10(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09) LOLUA_ARG_9(a00, a01, a02, a03, a04, a05, a06, a07, a08), v09
+#define /**/ LOLUA_ARG_11(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09, a10) LOLUA_ARG_10(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09), v10
+#define /**/ LOLUA_ARG_12(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09, a10, a11) LOLUA_ARG_11(a00, a01, a02, a03, a04, a05, a06, a07, a08, a09), v11
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+#define LOLUA_DECLARE_VOID_METHOD(LUA_FUNC_NAME, INSTANCE_GET, INSTANCE_CALL, ...) \
+    static int LUA_FUNC_NAME(lua_State* l) \
+    { \
+        auto s = LuaStack::Begin(l); \
+        auto o = s.INSTANCE_GET; \
+        LOL_CALL(LOL_CAT(LOLUA_VAR_, LOL_CALL(LOL_COUNT_TO_12, (__VA_ARGS__))), (__VA_ARGS__)) \
+        o->INSTANCE_CALL(LOL_CALL(LOL_CAT(LOLUA_ARG_, LOL_CALL(LOL_COUNT_TO_12, (__VA_ARGS__))), (__VA_ARGS__))); \
+        return s.End(); \
+    }
+
+//-----------------------------------------------------------------------------
+#define LOLUA_DECLARE_RETURN_METHOD(LUA_FUNC_NAME, INSTANCE_GET, INSTANCE_CALL, ...) \
+    static int LUA_FUNC_NAME(lua_State* l) \
+    { \
+        auto s = LuaStack::Begin(l); \
+        auto o = s.INSTANCE_GET; \
+        LOL_CALL(LOL_CAT(LOLUA_VAR_, LOL_CALL(LOL_COUNT_TO_12, (__VA_ARGS__))), (__VA_ARGS__)) \
+        s << o->INSTANCE_CALL(LOL_CALL(LOL_CAT(LOLUA_ARG_, LOL_CALL(LOL_COUNT_TO_12, (__VA_ARGS__))), (__VA_ARGS__))); \
+        return s.End(); \
+    }
+
 //-----------------------------------------------------------------------------
 #ifndef REGION_STACK_VAR