lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
Browse Source

2nd pass, removed all old code, and fixed all the wrong usages

legacy
touky 8 years ago
parent
4d78d62a70
commit
0cdeb424d9
7 changed files with 394 additions and 1198 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +36
    -46
      doc/samples/meshviewer/scenesetup.cpp
  2. +0
    -2
      doc/samples/meshviewer/scenesetup.h
  3. +0
    -1
      doc/tutorial/14_lol_lua.cpp
  4. +3
    -4
      src/easymesh/easymeshlua.cpp
  5. +310
    -332
      src/easymesh/easymeshlua.h
  6. +8
    -6
      src/lolua/baselua.cpp
  7. +37
    -807
      src/lolua/baselua.h

+ 36
- 46
doc/samples/meshviewer/scenesetup.cpp View File

@@ -159,86 +159,76 @@ SceneSetupLuaObject::~SceneSetupLuaObject()
//-----------------------------------------------------------------------------
SceneSetupLuaObject* SceneSetupLuaObject::New(lua_State* l, int arg_nb)
{
UNUSED(l);
UNUSED(arg_nb);
LuaStack s(l);
LuaString n;
s >> n;
return new SceneSetupLuaObject(n());
auto s = LuaStack::Begin(l);
auto n = s.Get<String>();
return new SceneSetupLuaObject(n);
}

//-- Setup command ------------------------------------------------------------
int SceneSetupLuaObject::AddLight(lua_State* l)
{
LuaStack s(l);
LuaSSetupPtr o;
LuaString t;
s >> o >> t;
o->m_setup->AddLight(FindValue<LightType>(t().C()));
return 0;
auto s = LuaStack::Begin(l);
auto o = s.GetPtr<SceneSetupLuaObject>();
auto t = s.Get<String>();
o->m_setup->AddLight(FindValue<LightType>(t.C()));
return s.End();
}
int SceneSetupLuaObject::SetupScene(lua_State* l)
{
LuaStack s(l);
LuaSSetupPtr o;
s >> o;
auto s = LuaStack::Begin(l);
auto o = s.GetPtr<SceneSetupLuaObject>();
o->m_setup->SetupScene();
return 0;
return s.End();
}
//-- main funcs ---------------------------------------------------------------
int SceneSetupLuaObject::SetPosition(lua_State* l)
{
LuaStack s(l);
LuaSSetupPtr o;
LuaVec3 c;
s >> o >> c;
auto s = LuaStack::Begin(l);
auto o = s.GetPtr<SceneSetupLuaObject>();
auto c = s.Get<vec3>();
o->m_setup->SetPosition(c);
return 0;
return s.End();
}
int SceneSetupLuaObject::SetLookAt(lua_State* l)
{
LuaStack s(l);
LuaSSetupPtr o;
LuaVec3 c;
s >> o >> c;
auto s = LuaStack::Begin(l);
auto o = s.GetPtr<SceneSetupLuaObject>();
auto c = s.Get<vec3>();
o->m_setup->SetLookAt(c);
return 0;
return s.End();
}
int SceneSetupLuaObject::SetColor(lua_State* l)
{
LuaStack s(l);
LuaSSetupPtr o;
LuaColor c;
s >> o >> c;
auto s = LuaStack::Begin(l);
auto o = s.GetPtr<SceneSetupLuaObject>();
auto c = s.Get<vec4>();
o->m_setup->SetColor(c);
return 0;
return s.End();
}
int SceneSetupLuaObject::Show(lua_State* l)
{
LuaStack s(l);
LuaSSetupPtr o;
LuaDisplay e;
s >> o >> e;
auto s = LuaStack::Begin(l);
auto o = s.GetPtr<SceneSetupLuaObject>();
auto e = s.GetEnum<SceneSetup::DisplayBase>();
o->m_setup->Show(e);
return 0;
return s.End();
}
int SceneSetupLuaObject::Hide(lua_State* l)
{
LuaStack s(l);
LuaSSetupPtr o;
LuaDisplay e;
s >> o >> e;
auto s = LuaStack::Begin(l);
auto o = s.GetPtr<SceneSetupLuaObject>();
auto e = s.GetEnum<SceneSetup::DisplayBase>();
o->m_setup->Hide(e);
return 0;
return s.End();
}
int SceneSetupLuaObject::Toggle(lua_State* l)
{
LuaStack s(l);
LuaSSetupPtr o;
LuaDisplay e;
s >> o >> e;
auto s = LuaStack::Begin(l);
auto o = s.GetPtr<SceneSetupLuaObject>();
auto e = s.GetEnum<SceneSetup::DisplayBase>();
o->m_setup->Toggle(e);
return 0;
return s.End();
}

//-----------------------------------------------------------------------------
@@ -264,7 +254,7 @@ const LuaObjectLibrary* SceneSetupLuaObject::GetLib()
},
//Variables
{ { nullptr, nullptr, nullptr } });
return &lib;
return &lib;
}

//-----------------------------------------------------------------------------


+ 0
- 2
doc/samples/meshviewer/scenesetup.h View File

@@ -103,12 +103,10 @@ public:
bool m_show_gizmo;
bool m_show_lights;
};
typedef Lolua::VarEnum<SceneSetup::DisplayBase> LuaDisplay;

//-----------------------------------------------------------------------------
class SceneSetupLuaObject : public LuaObject
{
typedef Lolua::VarPtr<SceneSetupLuaObject> LuaSSetupPtr;
public:
//-------------------------------------------------------------------------
SceneSetupLuaObject(String& name);


+ 0
- 1
doc/tutorial/14_lol_lua.cpp View File

@@ -23,7 +23,6 @@ using namespace lol;
//-----------------------------------------------------------------------------
class DemoObject : public LuaObject
{
typedef Lolua::VarPtr<DemoObject> LuaDemoObjectPtr;
public:
DemoObject() : LuaObject() {}
virtual ~DemoObject() {}


+ 3
- 4
src/easymesh/easymeshlua.cpp View File

@@ -81,10 +81,9 @@ EasyMeshLuaObject* EasyMeshLuaObject::New(lua_State* l, int arg_nb)
{
UNUSED(l);
UNUSED(arg_nb);
LuaStack s(l);
LuaString n("", true);
s >> n;
return new EasyMeshLuaObject(n());
LuaStack s = LuaStack::Begin(l);
String str = s.Get("", true);
return new EasyMeshLuaObject(str);
}

//-----------------------------------------------------------------------------


+ 310
- 332
src/easymesh/easymeshlua.h View File

@@ -18,7 +18,6 @@ namespace lol
//-----------------------------------------------------------------------------
class EasyMeshLuaObject : public LuaObject
{
typedef Lolua::VarPtr<EasyMeshLuaObject> EzMeshPtr;
EasyMesh m_instance;
public:
//-------------------------------------------------------------------------
@@ -33,604 +32,583 @@ public:
//-------------------------------------------------------------------------
static int AppendCylinder(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 nsides;
LuaFloat h, d1, d2;
LuaBool dualside(false, true), smooth(false, true), close(false, true);
s >> m >> nsides >> h >> d1 >> d2 >> dualside >> smooth >> close;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto nsides = s.Get<int32_t>();
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);
m->m_instance.AppendCylinder(nsides, h, d1, d2, dualside, smooth, close);
return 0;
return s.End();
}
static int AppendSphere(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 ndivisions;
LuaFloat d;
s >> m >> ndivisions >> d;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto ndivisions = s.Get<int32_t>();
auto d = s.Get<float>();
m->m_instance.AppendSphere(ndivisions, d);
return 0;
return s.End();
}
static int AppendCapsule(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 ndivisions;
LuaFloat h, d;
s >> m >> ndivisions >> h >> d;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto ndivisions = s.Get<int32_t>();
auto h = s.Get<float>();
auto d = s.Get<float>();
m->m_instance.AppendCapsule(ndivisions, h, d);
return 0;
return s.End();
}
static int AppendTorus(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 ndivisions;
LuaFloat d1, d2;
s >> m >> ndivisions >> d1 >> d2;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto ndivisions = s.Get<int32_t>();
auto d1 = s.Get<float>();
auto d2 = s.Get<float>();
m->m_instance.AppendTorus(ndivisions, d1, d2);
return 0;
return s.End();
}
static int AppendBox(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaVec3 size;
LuaFloat chamf(0.f, true);
LuaBool smooth(false, true);
s >> m >> size >> chamf >> smooth;
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);
m->m_instance.AppendBox(size, chamf, smooth);
return 0;
return s.End();
}
static int AppendStar(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 nbranches;
LuaFloat d1, d2;
LuaBool fade(false, true), fade2(false, true);
s >> m >> nbranches >> d1 >> d2 >> fade >> fade2;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
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);
m->m_instance.AppendStar(nbranches, d1, d2, fade, fade2);
return 0;
return s.End();
}
static int AppendExpandedStar(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 nbranches;
LuaFloat d1, d2, extrad(0.f, true);
s >> m >> nbranches >> d1 >> d2 >> extrad;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto nbranches = s.Get<int32_t>();
auto d1 = s.Get<float>();
auto d2 = s.Get<float>();
auto extrad = s.Get<float>(0.f, true);
m->m_instance.AppendExpandedStar(nbranches, d1, d2, extrad);
return 0;
return s.End();
}
static int AppendDisc(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 nsides;
LuaFloat d;
LuaBool fade(false, true);
s >> m >> nsides >> d >> fade;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto nsides = s.Get<int32_t>();
auto d = s.Get<float>();
auto fade = s.Get<bool>(false, true);
m->m_instance.AppendDisc(nsides, d, fade);
return 0;
return s.End();
}
static int AppendSimpleTriangle(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat d;
LuaBool fade(false, true);
s >> m >> d >> fade;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto d = s.Get<float>();
auto fade = s.Get<bool>(false, true);
m->m_instance.AppendSimpleTriangle(d, fade);
return 0;
return s.End();
}
static int AppendSimpleQuad(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat size;
LuaBool fade(false, true);
s >> m >> size >> fade;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto size = s.Get<float>();
auto fade = s.Get<bool>(false, true);
m->m_instance.AppendSimpleQuad(size, fade);
return 0;
return s.End();
}
static int AppendCog(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 nbsides;
LuaFloat h, sidemul(0.f, true);
LuaVec2 d0, d1, d2;
LuaBool offset(false, true);
s >> m >> nbsides >> h >> d0 >> d1 >> d2 >> sidemul >> offset;
m->m_instance.AppendCog(nbsides, h, d0().x, d0().y, d1().x, d1().y, d2().x, d2().y, sidemul, offset);
return 0;
auto s = LuaStack::Begin(l);
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 d0 = s.Get<vec2>();
auto d1 = s.Get<vec2>();
auto d2 = s.Get<vec2>();
auto offset = s.Get<bool>(false, true);
m->m_instance.AppendCog(nbsides, h, d0.x, d0.y, d1.x, d1.y, d2.x, d2.y, sidemul, offset);
return s.End();
}
//-------------------------------------------------------------------------
static int TranslateX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat f;
s >> m >> f;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto f = s.Get<float>();
m->m_instance.TranslateX(f);
return 0;
return s.End();
}
static int TranslateY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat f;
s >> m >> f;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto f = s.Get<float>();
m->m_instance.TranslateY(f);
return 0;
return s.End();
}
static int TranslateZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat f;
s >> m >> f;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto f = s.Get<float>();
m->m_instance.TranslateZ(f);
return 0;
return s.End();
}
static int Translate(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaVec3 v;
s >> m >> v;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto v = s.Get<vec3>();
m->m_instance.Translate(v);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int RotateX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat a;
s >> m >> a;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto a = s.Get<float>();
m->m_instance.RotateX(a);
return 0;
return s.End();
}
static int RotateY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat a;
s >> m >> a;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto a = s.Get<float>();
m->m_instance.RotateY(a);
return 0;
return s.End();
}
static int RotateZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat a;
s >> m >> a;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto a = s.Get<float>();
m->m_instance.RotateZ(a);
return 0;
return s.End();
}
static int Rotate(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat a;
LuaVec3 v;
s >> m >> a >> v;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto a = s.Get<float>();
auto v = s.Get<vec3>();
m->m_instance.Rotate(a, v);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int ScaleX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat x;
s >> m >> x;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto x = s.Get<float>();
m->m_instance.ScaleX(x);
return 0;
return s.End();
}
static int ScaleY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat y;
s >> m >> y;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto y = s.Get<float>();
m->m_instance.ScaleY(y);
return 0;
return s.End();
}
static int ScaleZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat z;
s >> m >> z;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto z = s.Get<float>();
m->m_instance.ScaleZ(z);
return 0;
return s.End();
}
static int Scale(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaVec3 v;
s >> m >> v;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto v = s.Get<vec3>();
m->m_instance.Scale(v);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int RadialJitter(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat f;
s >> m >> f;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto f = s.Get<float>();
m->m_instance.RadialJitter(f);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int TaperX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat y, z, xoff(0.f, true);
LuaBool abs(true, true);
s >> m >> y >> z >> xoff >> abs;
auto s = LuaStack::Begin(l);
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);
m->m_instance.TaperX(y, z, xoff, abs);
return 0;
return s.End();
}
static int TaperY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat x, z, yoff(0.f, true);
LuaBool abs(true, true);
s >> m >> x >> z >> yoff >> abs;
auto s = LuaStack::Begin(l);
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);
m->m_instance.TaperY(x, z, yoff, abs);
return 0;
return s.End();
}
static int TaperZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat x, y, zoff(0.f, true);
LuaBool abs(true, true);
s >> m >> x >> y >> zoff >> abs;
auto s = LuaStack::Begin(l);
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);
m->m_instance.TaperZ(x, y, zoff, abs);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int TwistX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.TwistX(t, toff);
return 0;
return s.End();
}
static int TwistY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.TwistY(t, toff);
return 0;
return s.End();
}
static int TwistZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.TwistZ(t, toff);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int ShearX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat y, z, xoff(0.f, true);
LuaBool abs(true, true);
s >> m >> y >> z >> xoff >> abs;
auto s = LuaStack::Begin(l);
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);
m->m_instance.ShearX(y, z, xoff, abs);
return 0;
return s.End();
}
static int ShearY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat x, z, yoff(0.f, true);
LuaBool abs(true, true);
s >> m >> x >> z >> yoff >> abs;
auto s = LuaStack::Begin(l);
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);
m->m_instance.ShearY(x, z, yoff, abs);
return 0;
return s.End();
}
static int ShearZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat x, y, zoff(0.f, true);
LuaBool abs(true, true);
s >> m >> x >> y >> zoff >> abs;
auto s = LuaStack::Begin(l);
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);
m->m_instance.ShearZ(x, y, zoff, abs);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int StretchX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat y, z, xoff(0.f, true);
s >> m >> y >> z >> xoff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto y = s.Get<float>();
auto z = s.Get<float>();
auto xoff = s.Get<float>(0.f, true);
m->m_instance.StretchX(y, z, xoff);
return 0;
return s.End();
}
static int StretchY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat x, z, yoff(0.f, true);
s >> m >> x >> z >> yoff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto x = s.Get<float>();
auto z = s.Get<float>();
auto yoff = s.Get<float>(0.f, true);
m->m_instance.StretchY(x, z, yoff);
return 0;
return s.End();
}
static int StretchZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat x, y, zoff(0.f, true);
s >> m >> x >> y >> zoff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto x = s.Get<float>();
auto y = s.Get<float>();
auto zoff = s.Get<float>(0.f, true);
m->m_instance.StretchZ(x, y, zoff);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int BendXY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.BendXY(t, toff);
return 0;
return s.End();
}
static int BendXZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.BendXZ(t, toff);
return 0;
return s.End();
}
static int BendYX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.BendYX(t, toff);
return 0;
return s.End();
}
static int BendYZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.BendYZ(t, toff);
return 0;
return s.End();
}
static int BendZX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.BendZX(t, toff);
return 0;
return s.End();
}
static int BendZY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat t, toff(0.f, true);
s >> m >> t >> toff;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto t = s.Get<float>();
auto toff = s.Get<float>(0.f, true);
m->m_instance.BendZY(t, toff);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int MirrorX(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.MirrorX();
return 0;
return s.End();
}
static int MirrorY(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.MirrorY();
return 0;
return s.End();
}
static int MirrorZ(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.MirrorZ();
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int LoopStart(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 loopnb;
s >> m >> loopnb;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto loopnb = s.Get<int32_t>();
m->m_instance.LoopStart(loopnb);
return 0;
return s.End();
}
static int LoopEnd(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.LoopEnd();
return 0;
return s.End();
}
static int OpenBrace(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.OpenBrace();
return 0;
return s.End();
}
static int CloseBrace(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.CloseBrace();
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int ToggleScaleWinding(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.ToggleScaleWinding();
return 0;
return s.End();
}
static int ToggleQuadWeighting(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.ToggleQuadWeighting();
return 0;
return s.End();
}
static int TogglePostBuildNormal(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.TogglePostBuildNormal();
return 0;
return s.End();
}
static int ToggleVerticeNoCleanup(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.ToggleVerticeNoCleanup();
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int VerticesMerge(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.VerticesMerge();
return 0;
return s.End();
}
static int VerticesSeparate(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.VerticesSeparate();
return 0;
return s.End();
}
static int VerticesCleanup(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
s >> m;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
m->m_instance.VerticesCleanup();
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int Duplicate(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaVec3 ds(vec3(1.f));
s >> m >> ds;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto ds = s.Get<vec3>(vec3(1.f));
m->m_instance.DupAndScale(ds, true);
return 0;
return s.End();
}
static int Smooth(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 pass, split_per_pass, smooth_per_pass;
s >> m >> pass >> split_per_pass >> smooth_per_pass;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto pass = s.Get<int32_t>();
auto split_per_pass = s.Get<int32_t>();
auto smooth_per_pass = s.Get<int32_t>();
m->m_instance.SmoothMesh(pass, split_per_pass, smooth_per_pass);
return 0;
return s.End();
}
static int SplitTriangles(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaInt32 pass;
s >> m >> pass;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto pass = s.Get<int32_t>();
m->m_instance.SplitTriangles(pass);
return 0;
return s.End();
}
static int Chamfer(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaFloat f;
s >> m >> f;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto f = s.Get<float>();
m->m_instance.Chamfer(f);
return 0;
return s.End();
}
//-------------------------------------------------------------------------
static int SetCurColor(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaColor c;
s >> m >> c;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto c = s.Get<vec4>();
m->m_instance.SetCurColor(c);
return 0;
return s.End();
}
static int SetCurColorA(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaColor c;
s >> m >> c;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto c = s.Get<vec4>();
m->m_instance.SetCurColorA(c);
return 0;
return s.End();
}
static int SetCurColorB(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaColor c;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto c = s.Get<vec4>();
m->m_instance.SetCurColorB(c);
return 0;
return s.End();
}
static int SetVertColor(lua_State* l)
{
LuaStack s(l);
EzMeshPtr m;
LuaColor c;
s >> m >> c;
auto s = LuaStack::Begin(l);
auto m = s.GetPtr<EasyMeshLuaObject>();
auto c = s.Get<vec4>();
m->m_instance.SetVertColor(c);
return 0;
return s.End();
}
/*
(csgu|csgunion) { return token::T_CSGUNION; }


+ 8
- 6
src/lolua/baselua.cpp View File

@@ -40,8 +40,9 @@ class LuaBaseData
int status = luaL_dostring(l, s.C());
if (status == 1)
{
LuaString error; error.Get(l, -1);
msg::error("Lua error %s\n", error().C());
auto stack = LuaStack::Begin(l, -1);
auto error = stack.Get<String>();
msg::error("Lua error %s\n", error.C());
lua_pop(l, 1);
}
return status;
@@ -53,8 +54,8 @@ class LuaBaseData
if (lua_isnoneornil(l, 1))
return LUA_ERRFILE;

LuaCharPtr var; var.Get(l, 1);
char const *filename = var;// lua_tostring(l, 1);
auto stack = LuaStack::Begin(l);
char const *filename = stack.Get<char const*>();
int status = LUA_ERRFILE;

File f;
@@ -76,8 +77,9 @@ class LuaBaseData
msg::error("could not find Lua file %s\n", filename);
else if (status == 1)
{
LuaString error; error.Get(l, -1);
msg::error("Lua error %s\n", error().C());
stack.SetIndex(-1);
auto error = stack.Get<String>();
msg::error("Lua error %s\n", error.C());
lua_pop(l, 1);
}



+ 37
- 807
src/lolua/baselua.h View File

@@ -16,9 +16,6 @@

#pragma once

#define OLD_VAR_SYSTEM true
#define NEW_VAR_SYSTEM true

namespace lol
{

@@ -134,20 +131,19 @@ public:
{ "New", New<TLuaClass> },
{ "Store", Store<TLuaClass> },
{ "__gc", Del<TLuaClass> },
{ "__tostring", ToString<TLuaClass> },
{ "__add", OpAdd<TLuaClass> },
{ "__sub", OpSubstract<TLuaClass> },
{ "__mul", OpMultiply<TLuaClass> },
{ "__div", OpDivide<TLuaClass> },
{ "__mod", OpModulo<TLuaClass> },
{ "__unm", OpUnaryNeg<TLuaClass> },
{ "__concat", OpConcat<TLuaClass> },
{ "__eq", CmpEqual<TLuaClass> },
{ "__lt", CmpLessThan<TLuaClass> },
{ "__le", CmpLessEqual<TLuaClass> },
{ NULL, NULL }
};
//TODO: Touky: Implement that
//__tostring : ToString
//__add : Addition(+)
//__sub : Subtraction(-)
//__mul : Multiplication(*)
//__div : Division(/ )
//__mod : Modulos(%)
//__unm : Unary - , used for negation on numbers
//__concat : Concatenation(..)
//__eq : Equality(== )
//__lt : Less than(<)
//__le : Less than or equal to(<= )

//Create Static metatable
luaL_newmetatable(l, GetStaticName<TLuaClass>());
@@ -235,6 +231,18 @@ protected:
//-------------------------------------------------------------------------
template <typename TLuaClass> static int Store(lua_State * l);
template <typename TLuaClass> static int Del(lua_State * l);
//-------------------------------------------------------------------------
template <typename TLuaClass> static int ToString(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int OpAdd(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int OpSubstract(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int OpMultiply(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int OpDivide(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int OpModulo(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int OpUnaryNeg(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int OpConcat(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int CmpEqual(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int CmpLessThan(lua_State* l) { ASSERT(false); return 0; }
template <typename TLuaClass> static int CmpLessEqual(lua_State* l) { ASSERT(false); return 0; }
};

//-----------------------------------------------------------------------------
@@ -248,683 +256,47 @@ public:
}
};

//-----------------------------------------------------------------------------
#if OLD_VAR_SYSTEM

//-----------------------------------------------------------------------------
template<typename T>
class VarPtr
{
protected:
T* m_value = nullptr;
bool m_optional = false;

public:
VarPtr(bool optional = false)
{
m_optional = optional;
}
VarPtr(T* value, bool optional = false)
: VarPtr(optional)
{
m_value = value;
}
VarPtr(lua_State* l, int& index, bool optional = false)
: VarPtr(optional)
{
GetInc(l, index);
}
VarPtr(T* value, lua_State* l, int& index, bool optional = false)
: VarPtr(value, optional)
{
GetInc(l, index);
}

inline T* operator ()() { return m_value; }
inline T* operator ->() { return m_value; }
inline T* operator=(T* value) { m_value = value; }
inline T* GetValue() { return m_value; }
inline bool IsValid(lua_State* l, int index)
{
return InnerIsValid(l, index);
}
inline bool IsOptional()
{
return m_optional;
}
private:
inline void GetInc(lua_State* l, int& index)
{
bool is_nil = lua_isnil(l, index);
if (!m_optional || (!is_nil && InnerIsValid(l, index)))
{
ASSERT(!is_nil);
InnerGet(l, index);
}
}
public:
inline void Get(lua_State* l, int index)
{
int idx = index;
GetInc(l, idx);
}
inline int Return(lua_State* l)
{
InnerPush(l);
return 1;
}

protected:
virtual bool InnerIsValid(lua_State* l, int index)
{
return !!lua_isuserdata(l, index);
}
virtual void InnerGet(lua_State* l, int& index)
{
T** obj = static_cast<T**>(luaL_checkudata(l, index++, ObjectHelper::GetMethodName<T>()));
m_value = obj ? *obj : nullptr;
}
void InnerPush(lua_State* l)
{
T** data = (T**)lua_newuserdata(l, sizeof(T*));
*data = m_value;
}
};

//-----------------------------------------------------------------------------
/* TODO: FIX THAT TOUKY !!
template<typename T>
class VarPtrLight
{
public:
VarPtrLight(bool optional = false) : VarPtr(optional) { }
VarPtrLight(T* value, bool optional = false) : VarPtr(value, optional) { }
VarPtrLight(lua_State* l, int& index, bool optional = false) : VarPtr(l, index, optional) { }
VarPtrLight(T* value, lua_State* l, int& index, bool optional = false) : VarPtr(value, l, index, optional) { }
protected:
virtual void InnerGet(lua_State* l, int& index)
{
T** obj = static_cast<T**>(luaL_testudata(l, index++, ObjectDef::GetMethodName<T>()));
m_value = obj ? *obj : nullptr;
}
};
*/

//-----------------------------------------------------------------------------
template<typename T>
class Var
{
protected:
bool m_optional = false;
T m_value;

public:
Var(bool optional = false)
{
m_optional = optional;
InnerInit();
}
Var(T value, bool optional = false)
{
m_optional = optional;
m_value = value;
}
Var(lua_State* l, int& index, bool optional = false)
{
m_optional = optional;
GetInc(l, index);
}
Var(T value, lua_State* l, int& index, bool optional = false)
{
m_optional = optional;
m_value = value;
GetInc(l, index);
}
inline operator T() { return m_value; }
inline T& operator ()() { return m_value; }
inline T& GetValue() { return m_value; }
inline bool IsValid(lua_State* l, int index)
{
return InnerIsValid(l, index);
}
inline bool IsOptional()
{
return m_optional;
}
private:
void GetInc(lua_State* l, int& index)
{
bool is_nil = lua_isnil(l, index);
if (!m_optional || (!is_nil && InnerIsValid(l, index)))
{
ASSERT(!is_nil);
InnerGet(l, index);
}
}
public:
inline void Get(lua_State* l, int index)
{
int idx = index;
GetInc(l, idx);
}
inline int Return(lua_State* l)
{
return InnerPush(l);
}
inline Var<T>& operator-(const T& value) { m_value - value; return *this; }
inline Var<T>& operator+(const T& value) { m_value + value; return *this; }
inline Var<T>& operator*(const T& value) { m_value * value; return *this; }
inline Var<T>& operator/(const T& value) { m_value / value; return *this; }
inline Var<T>& operator=(const T& value) { m_value = value; return *this; }
inline Var<T>& operator-=(const T& value) { m_value -= value; return *this; }
inline Var<T>& operator+=(const T& value) { m_value += value; return *this; }
inline Var<T>& operator*=(const T& value) { m_value *= value; return *this; }
inline Var<T>& operator/=(const T& value) { m_value /= value; return *this; }
inline Var<T>& operator-(const Var<T>& o) { m_value - o.m_value; return *this; }
inline Var<T>& operator+(const Var<T>& o) { m_value + o.m_value; return *this; }
inline Var<T>& operator*(const Var<T>& o) { m_value * o.m_value; return *this; }
inline Var<T>& operator/(const Var<T>& o) { m_value / o.m_value; return *this; }
inline Var<T>& operator=(const Var<T>& o) { m_value = o.m_value; return *this; }
inline Var<T>& operator-=(const Var<T>& o) { m_value -= o.m_value; return *this; }
inline Var<T>& operator+=(const Var<T>& o) { m_value += o.m_value; return *this; }
inline Var<T>& operator*=(const Var<T>& o) { m_value *= o.m_value; return *this; }
inline Var<T>& operator/=(const Var<T>& o) { m_value /= o.m_value; return *this; }
inline bool operator==(const T& value) { return m_value == value; }
inline bool operator!=(const T& value) { return m_value != value; }
inline bool operator==(const Var<T>& o) { return m_value == o.m_value; }
inline bool operator!=(const Var<T>& o) { return m_value != o.m_value; }

protected:
void InnerInit() { m_value = T(0); }
bool InnerIsValid(lua_State* l, int index) { UNUSED(l); UNUSED(index); ASSERT(false); return false; }
void InnerGet(lua_State* l, int& index) { UNUSED(l); UNUSED(index); ASSERT(false); }
int InnerPush(lua_State* l) { UNUSED(l); ASSERT(false); return 0; }
};

//-----------------------------------------------------------------------------
#ifndef BASE_TYPES
template<> inline bool Var<bool>::InnerIsValid(lua_State* l, int index)
{
return lua_isboolean(l, index);
}
template<> inline void Var<bool>::InnerGet(lua_State* l, int& index)
{
m_value = !!lua_toboolean(l, index++);
}
template<> inline int Var<bool>::InnerPush(lua_State* l)
{
lua_pushboolean(l, m_value);
return 1;
}
//-----------------------------------------------------------------------------
template<> inline bool Var<char const*>::InnerIsValid(lua_State* l, int index)
{
return !!lua_isstring(l, index);
}
template<> inline void Var<char const*>::InnerGet(lua_State* l, int& index)
{
m_value = lua_tostring(l, index++);
}
template<> inline int Var<char const*>::InnerPush(lua_State* l)
{
lua_pushstring(l, m_value);
return 1;
}
//-----------------------------------------------------------------------------
template<> inline void Var<String>::InnerInit()
{
m_value = String();
}
template<> inline bool Var<String>::InnerIsValid(lua_State* l, int index)
{
Var<char const*> v;
return v.IsValid(l, index);
}
template<> inline void Var<String>::InnerGet(lua_State* l, int& index)
{
Var<char const*> v(l, index);
m_value = v();
}
template<> inline int Var<String>::InnerPush(lua_State* l)
{
Var<char const*> v;
v = m_value.C();
return v.Return(l);
}
//-----------------------------------------------------------------------------
template<> inline bool Var<double>::InnerIsValid(lua_State* l, int index)
{
return !!lua_isnumber(l, index);
}
template<> inline void Var<double>::InnerGet(lua_State* l, int& index)
{
m_value = lua_tonumber(l, index++);
}
template<> inline int Var<double>::InnerPush(lua_State* l)
{
lua_pushnumber(l, m_value);
return 1;
}
//-----------------------------------------------------------------------------
template<> inline bool Var<float>::InnerIsValid(lua_State* l, int index)
{
Var<double> v;
return v.IsValid(l, index);
}
template<> inline void Var<float>::InnerGet(lua_State* l, int& index)
{
Var<double> v(l, index);
m_value = (float)v();
}
template<> inline int Var<float>::InnerPush(lua_State* l)
{
Var<double> v = (double)m_value;
return v.Return(l);
}

#if 0
//-----------------------------------------------------------------------------
template<> inline bool Var<int64_t>::InnerIsValid(lua_State* l, int index)
{
return !!lua_isnumber(l, index);
}
template<> inline void Var<int64_t>::InnerGet(lua_State* l, int& index)
{
m_value = lua_tointeger(l, index++);
}
template<> inline int Var<int64_t>::InnerPush(lua_State* l)
{
lua_pushinteger(l, m_value);
return 1;
}
#endif

//-----------------------------------------------------------------------------
template<> inline bool Var<int32_t>::InnerIsValid(lua_State* l, int index)
{
Var<int64_t> v;
return v.IsValid(l, index);
}
template<> inline void Var<int32_t>::InnerGet(lua_State* l, int& index)
{
Var<int64_t> v(l, index);
m_value = (int32_t)v();
}
template<> inline int Var<int32_t>::InnerPush(lua_State* l)
{
Var<int64_t> v = (int64_t)m_value;
return v.Return(l);
}

//-----------------------------------------------------------------------------
template<> inline bool Var<uint32_t>::InnerIsValid(lua_State* l, int index)
{
return !!lua_isnumber(l, index);
}
template<> inline void Var<uint32_t>::InnerGet(lua_State* l, int& index)
{
m_value = (uint32_t)(lua_Unsigned)lua_tointeger(l, index++);
}
template<> inline int Var<uint32_t>::InnerPush(lua_State* l)
{
lua_pushinteger(l, (lua_Integer)m_value);
return 1;
}

#if 0
//-----------------------------------------------------------------------------
template<> inline bool Var<uint64_t>::InnerIsValid(lua_State* l, int index)
{
Var<uint32_t> v;
return v.IsValid(l, index);
}
template<> inline void Var<uint64_t>::InnerGet(lua_State* l, int& index)
{
Var<uint32_t> v(l, index);
m_value = (uint64_t)v();
}
template<> inline int Var<uint64_t>::InnerPush(lua_State* l)
{
Var<uint32_t> v = (uint32_t)m_value;
return v.Return(l);
}
#endif

//-----------------------------------------------------------------------------
template<> inline bool Var<vec2>::InnerIsValid(lua_State* l, int index)
{
Var<float> x;
return x.IsValid(l, index);
}
template<> inline void Var<vec2>::InnerGet(lua_State* l, int& index)
{
Var<float> x(l, index);
Var<float> y(x(), l, index, true);
m_value = vec2(x, y);
}
template<> inline int Var<vec2>::InnerPush(lua_State* l)
{
Var<float> x = m_value.x;
Var<float> y = m_value.y;
return (x.Return(l) + y.Return(l));
}
//-----------------------------------------------------------------------------
template<> inline bool Var<vec3>::InnerIsValid(lua_State* l, int index)
{
Var<float> x;
return x.IsValid(l, index);
}
template<> inline void Var<vec3>::InnerGet(lua_State* l, int& index)
{
Var<float> x(l, index);
Var<float> y(x(), l, index, true);
Var<float> z(x(), l, index, true);
m_value = vec3(x, y, z);
}
template<> inline int Var<vec3>::InnerPush(lua_State* l)
{
Var<float> x = m_value.x;
Var<float> y = m_value.y;
Var<float> z = m_value.z;
return (x.Return(l) + y.Return(l) + z.Return(l));
}
//-----------------------------------------------------------------------------
template<> inline bool Var<vec4>::InnerIsValid(lua_State* l, int index)
{
Var<float> x;
return x.IsValid(l, index);
}
template<> inline void Var<vec4>::InnerGet(lua_State* l, int& index)
{
Var<float> x(l, index);
Var<float> y(x(), l, index, true);
Var<float> z(x(), l, index, true);
Var<float> w(x(), l, index, true);
m_value = vec4(x, y, z, w);
}
template<> inline int Var<vec4>::InnerPush(lua_State* l)
{
Var<float> x = m_value.x;
Var<float> y = m_value.y;
Var<float> z = m_value.z;
Var<float> w = m_value.w;
return (x.Return(l) + y.Return(l) + z.Return(l) + w.Return(l));
}
#endif //BASE_TYPES

//-----------------------------------------------------------------------------
#ifndef CUSTOM_TYPES
class VarColor
{
protected:
Var<vec4> m_value;

public:
VarColor(bool optional = false)
{
m_value = Var<vec4>(optional);
InnerInit();
}
VarColor(vec4 value, bool optional = false)
{
m_value = Var<vec4>(value, optional);
}
VarColor(lua_State* l, int& index, bool optional = false)
: VarColor(optional)
{
GetInc(l, index);
}
VarColor(vec4 value, lua_State* l, int& index, bool optional = false)
: VarColor(value, optional)
{
GetInc(l, index);
}

inline operator vec4() { return m_value; }
inline vec4& operator ()() { return m_value(); }
inline vec4& GetValue() { return m_value.GetValue(); }
inline bool IsValid(lua_State* l, int index)
{
return InnerIsValid(l, index);
}
inline bool IsOptional()
{
return m_value.IsOptional();
}
private:
void GetInc(lua_State* l, int& index)
{
bool is_nil = lua_isnil(l, index);
if (!m_value.IsOptional() || (!is_nil && InnerIsValid(l, index)))
{
ASSERT(!is_nil);
InnerGet(l, index);
}
}
public:
inline void Get(lua_State* l, int index)
{
int idx = index;
GetInc(l, idx);
}
inline int Return(lua_State* l)
{
return InnerPush(l);
}
inline VarColor& operator-(const vec4& value) { m_value - value; return *this; }
inline VarColor& operator+(const vec4& value) { m_value + value; return *this; }
inline VarColor& operator*(const vec4& value) { m_value * value; return *this; }
inline VarColor& operator/(const vec4& value) { m_value / value; return *this; }
inline VarColor& operator=(const vec4& value) { m_value = value; return *this; }
inline VarColor& operator-=(const vec4& value) { m_value -= value; return *this; }
inline VarColor& operator+=(const vec4& value) { m_value += value; return *this; }
inline VarColor& operator*=(const vec4& value) { m_value *= value; return *this; }
inline VarColor& operator/=(const vec4& value) { m_value /= value; return *this; }
inline VarColor& operator-(const Var<vec4>& o) { m_value - o; return *this; }
inline VarColor& operator+(const Var<vec4>& o) { m_value + o; return *this; }
inline VarColor& operator*(const Var<vec4>& o) { m_value * o; return *this; }
inline VarColor& operator/(const Var<vec4>& o) { m_value / o; return *this; }
inline VarColor& operator=(const Var<vec4>& o) { m_value = o; return *this; }
inline VarColor& operator-=(const Var<vec4>& o) { m_value -= o; return *this; }
inline VarColor& operator+=(const Var<vec4>& o) { m_value += o; return *this; }
inline VarColor& operator*=(const Var<vec4>& o) { m_value *= o; return *this; }
inline VarColor& operator/=(const Var<vec4>& o) { m_value /= o; return *this; }
inline bool operator==(const vec4& value) { return m_value == value; }
inline bool operator!=(const vec4& value) { return m_value != value; }
inline bool operator==(const Var<vec4>& o) { return m_value == o; }
inline bool operator!=(const Var<vec4>& o) { return m_value != o; }
inline VarColor& operator-(const VarColor& v) { m_value - v.m_value; return *this; }
inline VarColor& operator+(const VarColor& v) { m_value + v.m_value; return *this; }
inline VarColor& operator*(const VarColor& v) { m_value * v.m_value; return *this; }
inline VarColor& operator/(const VarColor& v) { m_value / v.m_value; return *this; }
inline VarColor& operator=(const VarColor& v) { m_value = v.m_value; return *this; }
inline VarColor& operator-=(const VarColor& v) { m_value -= v.m_value; return *this; }
inline VarColor& operator+=(const VarColor& v) { m_value += v.m_value; return *this; }
inline VarColor& operator*=(const VarColor& v) { m_value *= v.m_value; return *this; }
inline VarColor& operator/=(const VarColor& v) { m_value /= v.m_value; return *this; }
inline bool operator==(const VarColor& v) { return m_value == v.m_value; }
inline bool operator!=(const VarColor& v) { return m_value != v.m_value; }

protected:
void InnerInit()
{
m_value = vec4::zero;
}
bool InnerIsValid(lua_State* l, int index)
{
Var<String> s;
return m_value.IsValid(l, index) || s.IsValid(l, index);
}
void InnerGet(lua_State* l, int& index)
{
//Try vec4 first
if (m_value.IsValid(l, index))
{
m_value.Get(l, index);
}
else
{
Var<String> c(l, index);
*this = Color::C8BppHexString(c);
}
}
int InnerPush(lua_State* l)
{
Var<String> c = Color::HexString8Bpp(m_value);
return c.Return(l);
}
};

//-----------------------------------------------------------------------------
template<typename E>
class VarEnum
{
protected:
SafeEnum<E> m_value;
bool m_optional = false;

public:
VarEnum(bool optional = false)
{
m_optional = optional;
InnerInit();
}
VarEnum(SafeEnum<E> value, bool optional = false)
: VarEnum(optional)
{
m_value = value;
}
VarEnum(lua_State* l, int& index, bool optional = false)
: VarEnum(optional)
{
GetInc(l, index);
}
VarEnum(SafeEnum<E> value, lua_State* l, int& index, bool optional = false)
: VarEnum(value, optional)
{
GetInc(l, index);
}

inline operator SafeEnum<E>() { return m_value; }
inline SafeEnum<E>& operator ()() { return m_value; }
inline SafeEnum<E>& GetValue() { return m_value; }
inline bool IsValid(lua_State* l, int index)
{
return InnerIsValid(l, index);
}
inline bool IsOptional()
{
return m_optional;
}
private:
void GetInc(lua_State* l, int& index)
{
bool is_nil = lua_isnil(l, index);
if (!m_optional || (!is_nil && InnerIsValid(l, index)))
{
ASSERT(!is_nil);
InnerGet(l, index);
}
}
public:
inline void Get(lua_State* l, int index)
{
int idx = index;
GetInc(l, idx);
}
inline int Return(lua_State* l)
{
return InnerPush(l);
}
inline VarEnum<E>& operator-(const SafeEnum<E>& value) { m_value - value; return *this; }
inline VarEnum<E>& operator+(const SafeEnum<E>& value) { m_value + value; return *this; }
inline VarEnum<E>& operator*(const SafeEnum<E>& value) { m_value * value; return *this; }
inline VarEnum<E>& operator/(const SafeEnum<E>& value) { m_value / value; return *this; }
inline VarEnum<E>& operator=(const SafeEnum<E>& value) { m_value = value; return *this; }
inline VarEnum<E>& operator-=(const SafeEnum<E>& value) { m_value -= value; return *this; }
inline VarEnum<E>& operator+=(const SafeEnum<E>& value) { m_value += value; return *this; }
inline VarEnum<E>& operator*=(const SafeEnum<E>& value) { m_value *= value; return *this; }
inline VarEnum<E>& operator/=(const SafeEnum<E>& value) { m_value /= value; return *this; }
inline bool operator==(const SafeEnum<E>& value) { return m_value == value; }
inline bool operator!=(const SafeEnum<E>& value) { return m_value != value; }
inline VarEnum<E>& operator-(const VarEnum<E>& v) { m_value - v.m_value; return *this; }
inline VarEnum<E>& operator+(const VarEnum<E>& v) { m_value + v.m_value; return *this; }
inline VarEnum<E>& operator*(const VarEnum<E>& v) { m_value * v.m_value; return *this; }
inline VarEnum<E>& operator/(const VarEnum<E>& v) { m_value / v.m_value; return *this; }
inline VarEnum<E>& operator=(const VarEnum<E>& v) { m_value = v.m_value; return *this; }
inline VarEnum<E>& operator-=(const VarEnum<E>& v) { m_value -= v.m_value; return *this; }
inline VarEnum<E>& operator+=(const VarEnum<E>& v) { m_value += v.m_value; return *this; }
inline VarEnum<E>& operator*=(const VarEnum<E>& v) { m_value *= v.m_value; return *this; }
inline VarEnum<E>& operator/=(const VarEnum<E>& v) { m_value /= v.m_value; return *this; }
inline bool operator==(const VarEnum<E>& v) { return m_value == v.m_value; }
inline bool operator!=(const VarEnum<E>& v) { return m_value != v.m_value; }

protected:
void InnerInit()
{
m_value = SafeEnum<E>(0);
}
bool InnerIsValid(lua_State* l, int index)
{
Var<String> s;
return s.IsValid(l, index);
}
void InnerGet(lua_State* l, int& index)
{
Var<String> c(l, index);
*this = FindValue<SafeEnum<E> >(c);
}
int InnerPush(lua_State* l)
{
Var<String> s = this->GetValue().ToString();
return s.Return(l);
}
};
#endif //CUSTOM_TYPES

#endif //OLD_VAR_SYSTEM

//-----------------------------------------------------------------------------
// Stack: Main class that encapsulates everything -----------------------------
//-----------------------------------------------------------------------------
class Stack
{
public:

#if NEW_VAR_SYSTEM

//-------------------------------------------------------------------------
public:
static Stack Begin(lua_State* state, int32_t start_index = 1)
{
return Stack(state, start_index);
}

//-------------------------------------------------------------------------
void SetIndex(int32_t index)
{
m_index = index;
}

//-------------------------------------------------------------------------
int32_t End()
{
return m_result;
}

#if !OLD_VAR_SYSTEM
//-------------------------------------------------------------------------
protected:
#endif //!OLD_VAR_SYSTEM

#endif //NEW_VAR_SYSTEM
Stack(lua_State* l, int32_t start_index = 1)
{
m_state = l;
m_index = start_index;
}

public:
virtual ~Stack() { }

protected:
int32_t GetArgs()
{
return lua_gettop(m_state);
}

#if NEW_VAR_SYSTEM

public:
//-------------------------------------------------------------------------
//The encapsulating struct for pointers
@@ -945,6 +317,7 @@ public:
}
Ptr(const T*& value) { m_value = value; }
inline operator T*() { return m_value; }
inline T* operator ->() { return m_value; }
inline Ptr<T>& operator=(T const*& value) { m_value = value; return *this; }
};

@@ -985,13 +358,6 @@ protected:
template<typename T> T InnerGet(T value) { UNUSED(value); ASSERT(false, INNER_ERROR); return InnerDefault<T>(); }
template<typename T> int InnerPush(T value) { UNUSED(value); ASSERT(false, INNER_ERROR); return 0; }

#ifndef INNER_T_T
//template<typename T, template <typename> class C> C<T> InnerDefault() { return C<E>(); }
//template<typename E> bool InnerIsValid() { return InnerIsValid<String>(); }
//template<typename E> SafeEnum<E> InnerGet(SafeEnum<E> value) { return FindValue<SafeEnum<E> >(InnerGet<char const*>(value.ToString().C())); }
//template<typename E> int InnerPush(SafeEnum<E> value) { return InnerPush<char const*>(value.ToString.C()); }
#endif //STACK_STRING

#ifndef INNER_SAFE_ENUM
template<typename E> SafeEnum<E> InnerDefaultSafeEnum() { return SafeEnum<E>(); }
template<typename E> bool InnerIsValidSafeEnum() { return InnerIsValid<String>(); }
@@ -1016,35 +382,7 @@ protected:
}
#endif //STACK_STRING

#endif //NEW_VAR_SYSTEM

//-------------------------------------------------------------------------
#if OLD_VAR_SYSTEM
public:
inline operator int32_t() { return m_result; }
//-------------------------------------------------------------------------

template<typename T>
Stack& operator>>(T& var)
{
var = T(var.GetValue(), m_state, m_index, var.IsOptional());
return *this;
}

#if !NEW_VAR_SYSTEM

//-------------------------------------------------------------------------
template<typename T>
Stack& operator<<(T& var)
{
m_result += var.Return(m_state);
return *this;
}

#endif //NEW_VAR_SYSTEM

#endif //OLD_VAR_SYSTEM

private:
lua_State* m_state = nullptr;
int32_t m_index = 1;
@@ -1052,22 +390,8 @@ private:
};

//-----------------------------------------------------------------------------
#if NEW_VAR_SYSTEM

#ifndef REGION_STACK_VAR

//#if OLD_VAR_SYSTEM && NEW_VAR_SYSTEM
//
////-------------------------------------------------------------------------
//template<typename T, typename V>
//Stack& Stack::operator<<(Var<T>& var)
//{
// m_result += var.Return(m_state);
// return *this;
//}
//
//#endif //OLD_VAR_SYSTEM && NEW_VAR_SYSTEM

#ifndef STACK_BOOL
template<> inline bool Stack::InnerIsValid<bool>() { return lua_isboolean(m_state, m_index); }
template<> inline bool Stack::InnerGet<bool>(bool value) { UNUSED(value); return !!lua_toboolean(m_state, m_index++); }
@@ -1104,7 +428,6 @@ template<> inline int Stack::InnerPush<float>(float value) { return InnerPush<d
#endif //STACK_FLOAT

//-----------------------------------------------------------------------------
//DO NOT REMOVE: IT IS THE BASIS FOR INT 32
#ifndef STACK_INT64
template<> inline bool Stack::InnerIsValid<int64_t>() { return !!lua_isnumber(m_state, m_index); }
template<> inline int64_t Stack::InnerGet<int64_t>(int64_t value) { UNUSED(value); return lua_tointeger(m_state, m_index++); }
@@ -1153,36 +476,8 @@ template<> inline vec4 Stack::InnerGet<vec4>(vec4 value) { return vec4(InnerGet<
template<> inline int Stack::InnerPush<vec4>(vec4 value) { return (InnerPush<float>(value.x) + InnerPush<float>(value.y) + InnerPush<float>(value.z) + InnerPush<float>(value.w)); }
#endif STACK_VEC4

//-----------------------------------------------------------------------------
#ifndef STACK_SAFE_ENUM
//template<typename E> inline SafeEnum<E> Stack::InnerDefault<SafeEnum, E>() { return SafeEnum<E>(); }
//template<typename E> inline bool Stack::InnerIsValid<SafeEnum<E> >() { return InnerIsValid<String>(); }
//template<typename E> inline SafeEnum<E> Stack::InnerGet<SafeEnum<E> >(SafeEnum<E> value) { return FindValue<SafeEnum<E> >(InnerGet<char const*>(value.ToString().C())); }
//template<typename E> inline int Stack::InnerPush<SafeEnum<E> >(SafeEnum<E> value) { return InnerPush<char const*>(value.ToString.C()); }
#endif //STACK_STRING

//-----------------------------------------------------------------------------
#ifndef STACK_PTR
//template<typename P> inline Stack::Ptr<P> Stack::InnerDefault<Stack::Ptr<P> >() { return Stack::Ptr<P>(nullptr); }
//template<typename P> inline bool Stack::InnerIsValid<Stack::Ptr<P> >() { return !!lua_isuserdata(m_state, m_index); }
//template<typename P> inline Stack::Ptr<P> Stack::InnerGet<Stack::Ptr<P> >(Stack::Ptr<P> value)
//{
// P** obj = static_cast<P**>(value.m_throw_error
// ? luaL_checkudata(m_state, m_index++, ObjectHelper::GetMethodName<P>())
// : luaL_testudata(m_state, m_index++, ObjectHelper::GetMethodName<P>()) );
// return Stack::Ptr<P>(obj ? *obj : value.m_value);
//}
//template<typename P> inline int Stack::InnerPush<Stack::Ptr<P> >(Stack::Ptr<P> value)
//{
// P** data = (P**)lua_newuserdata(m_state, sizeof(P*));
// *data = value.m_value;
//}
#endif //STACK_STRING

#endif //REGION_STACK_VAR

#endif //NEW_VAR_SYSTEM

//-----------------------------------------------------------------------------
class Loader
{
@@ -1194,7 +489,6 @@ public:
bool ExecLuaFile(String const &lua);
bool ExecLuaCode(String const &lua);

#if NEW_VAR_SYSTEM
//-------------------------------------------------------------------------
#define DECLARE_LOADER_GET(T0, T1, GET_NAME) \
template<typename T0> \
@@ -1213,27 +507,6 @@ public:

#undef DECLARE_LOADER_GET

#else //OLD_VAR_SYSTEM

template<typename T>
T GetVar(String const &name)
{
lua_getglobal(m_lua_state, name.C());
Var<T> var; var.Get(m_lua_state, -1);
lua_pop(m_lua_state, 1);
return var;
}
template<typename T>
T* GetPtr(String const &name)
{
lua_getglobal(m_lua_state, name.C());
VarPtr<T> var; var.Get(m_lua_state, -1);
lua_pop(m_lua_state, 1);
return var();
}

#endif //OLD_VAR_SYSTEM

protected:
lua_State* GetLuaState();
static void Store(lua_State* l, Loader* loader);
@@ -1249,12 +522,11 @@ private:
//-----------------------------------------------------------------------------
// ObjectHelper member implementations that require VarPtr

#if NEW_VAR_SYSTEM
template <typename TLuaClass>
int ObjectHelper::Store(lua_State * l)
{
auto stack = LuaStack::Begin(l);
auto obj = stack.Get<Stack::Ptr<TLuaClass> >();
TLuaClass* obj = stack.GetPtr<TLuaClass>();
ASSERT(obj);
Loader::StoreObject(l, obj);
return 0;
@@ -1264,37 +536,12 @@ template <typename TLuaClass>
int ObjectHelper::Del(lua_State * l)
{
auto stack = LuaStack::Begin(l);
auto obj = stack.Get<Stack::Ptr<TLuaClass> >();
TLuaClass* obj = stack.GetPtr<TLuaClass>();
ASSERT(obj);
delete obj;
return 0;
}

#else //OLD_VAR_SYSTEM

template <typename TLuaClass>
int ObjectHelper::Store(lua_State * l)
{
VarPtr<TLuaClass> obj;
obj.Get(l, 1);
ASSERT(obj());
Loader::StoreObject(l, obj());
return 0;
}

template <typename TLuaClass>
int ObjectHelper::Del(lua_State * l)
{
VarPtr<TLuaClass> obj;
obj.Get(l, 1);
ASSERT(obj());
delete obj();
return 0;
}

#endif //OLD_VAR_SYSTEM


} /* namespace Lolua */

//TYPEDEFS
@@ -1305,22 +552,5 @@ typedef Lolua::Object::Library LuaObjectLibrary;
typedef Lolua::Loader LuaLoader;
typedef Lolua::Stack LuaStack;
template <typename P> using LuaPtr = Lolua::Stack::Ptr<P>;
//template <typename P>
//typedef Lolua::Stack::Ptr<P> LuaPtr<P>;
#if OLD_VAR_SYSTEM
typedef Lolua::Var<bool> LuaBool;
typedef Lolua::Var<char const*> LuaCharPtr;
typedef Lolua::Var<String> LuaString;
typedef Lolua::Var<double> LuaDouble;
typedef Lolua::Var<float> LuaFloat;
typedef Lolua::Var<int64_t> LuaInt64;
typedef Lolua::Var<int32_t> LuaInt32;
typedef Lolua::Var<uint32_t> LuaUInt32;
typedef Lolua::Var<uint64_t> LuaUInt64;
typedef Lolua::Var<vec2> LuaVec2;
typedef Lolua::Var<vec3> LuaVec3;
typedef Lolua::Var<vec4> LuaVec4;
typedef Lolua::VarColor LuaColor;
#endif //OLD_VAR_SYSTEM

} /* namespace lol */

Write Preview
Loading…
Cancel
Save