lolengine
/
lol
peilaus alkaen https://github.com/lolengine/lol
1
0
Fork 0
Koodi Ongelmat 0 Julkaisut 0 Wiki Toiminta
Selaa lähdekoodia

Lolua small simplification 

getter default params are better now
legacy
touky 9 vuotta sitten
vanhempi
0cdeb424d9
commit
eb943fc5e3
6 muutettua tiedostoa jossa 166 lisäystä ja 68 poistoa
Jaettu näkymä
Diff Options
Show Stats Download Patch File Download Diff File
  1. +10
    -0
      doc/samples/meshviewer/imgui.ini
  2. +23
    -6
      doc/tutorial/14_lol_lua.cpp
  3. +1
    -1
      doc/tutorial/14_lol_lua.lua
  4. +1
    -1
      src/easymesh/easymeshlua.cpp
  5. +39
    -37
      src/easymesh/easymeshlua.h
  6. +92
    -23
      src/lolua/baselua.h

+ 10
- 0
doc/samples/meshviewer/imgui.ini Näytä tiedosto

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

[Camera Setup]
Pos=60,60
Size=307,314
Collapsed=0


+ 23
- 6
doc/tutorial/14_lol_lua.cpp Näytä tiedosto

@@ -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();


+ 1
- 1
doc/tutorial/14_lol_lua.lua Näytä tiedosto

@@ -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);

+ 1
- 1
src/easymesh/easymeshlua.cpp Näytä tiedosto

@@ -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);
}



+ 39
- 37
src/easymesh/easymeshlua.h Näytä tiedosto

@@ -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();
}


+ 92
- 23
src/lolua/baselua.h Näytä tiedosto

@@ -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



Kirjoita Esikatselu
Ladataan…
Peruuta
Tallenna