@@ -159,86 +159,76 @@ SceneSetupLuaObject::~SceneSetupLuaObject() | |||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
SceneSetupLuaObject* SceneSetupLuaObject::New(lua_State* l, int arg_nb) | SceneSetupLuaObject* SceneSetupLuaObject::New(lua_State* l, int arg_nb) | ||||
{ | { | ||||
UNUSED(l); | |||||
UNUSED(arg_nb); | 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 ------------------------------------------------------------ | //-- Setup command ------------------------------------------------------------ | ||||
int SceneSetupLuaObject::AddLight(lua_State* l) | 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) | 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(); | o->m_setup->SetupScene(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//-- main funcs --------------------------------------------------------------- | //-- main funcs --------------------------------------------------------------- | ||||
int SceneSetupLuaObject::SetPosition(lua_State* l) | 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); | o->m_setup->SetPosition(c); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
int SceneSetupLuaObject::SetLookAt(lua_State* l) | 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); | o->m_setup->SetLookAt(c); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
int SceneSetupLuaObject::SetColor(lua_State* l) | 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); | o->m_setup->SetColor(c); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
int SceneSetupLuaObject::Show(lua_State* l) | 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); | o->m_setup->Show(e); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
int SceneSetupLuaObject::Hide(lua_State* l) | 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); | o->m_setup->Hide(e); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
int SceneSetupLuaObject::Toggle(lua_State* l) | 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); | o->m_setup->Toggle(e); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
@@ -264,7 +254,7 @@ const LuaObjectLibrary* SceneSetupLuaObject::GetLib() | |||||
}, | }, | ||||
//Variables | //Variables | ||||
{ { nullptr, nullptr, nullptr } }); | { { nullptr, nullptr, nullptr } }); | ||||
return &lib; | |||||
return &lib; | |||||
} | } | ||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
@@ -103,12 +103,10 @@ public: | |||||
bool m_show_gizmo; | bool m_show_gizmo; | ||||
bool m_show_lights; | bool m_show_lights; | ||||
}; | }; | ||||
typedef Lolua::VarEnum<SceneSetup::DisplayBase> LuaDisplay; | |||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
class SceneSetupLuaObject : public LuaObject | class SceneSetupLuaObject : public LuaObject | ||||
{ | { | ||||
typedef Lolua::VarPtr<SceneSetupLuaObject> LuaSSetupPtr; | |||||
public: | public: | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
SceneSetupLuaObject(String& name); | SceneSetupLuaObject(String& name); | ||||
@@ -23,7 +23,6 @@ using namespace lol; | |||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
class DemoObject : public LuaObject | class DemoObject : public LuaObject | ||||
{ | { | ||||
typedef Lolua::VarPtr<DemoObject> LuaDemoObjectPtr; | |||||
public: | public: | ||||
DemoObject() : LuaObject() {} | DemoObject() : LuaObject() {} | ||||
virtual ~DemoObject() {} | virtual ~DemoObject() {} | ||||
@@ -81,10 +81,9 @@ EasyMeshLuaObject* EasyMeshLuaObject::New(lua_State* l, int arg_nb) | |||||
{ | { | ||||
UNUSED(l); | UNUSED(l); | ||||
UNUSED(arg_nb); | 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); | |||||
} | } | ||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
@@ -18,7 +18,6 @@ namespace lol | |||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
class EasyMeshLuaObject : public LuaObject | class EasyMeshLuaObject : public LuaObject | ||||
{ | { | ||||
typedef Lolua::VarPtr<EasyMeshLuaObject> EzMeshPtr; | |||||
EasyMesh m_instance; | EasyMesh m_instance; | ||||
public: | public: | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
@@ -33,604 +32,583 @@ public: | |||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int AppendCylinder(lua_State* l) | 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); | m->m_instance.AppendCylinder(nsides, h, d1, d2, dualside, smooth, close); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendSphere(lua_State* l) | 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); | m->m_instance.AppendSphere(ndivisions, d); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendCapsule(lua_State* l) | 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); | m->m_instance.AppendCapsule(ndivisions, h, d); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendTorus(lua_State* l) | 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); | m->m_instance.AppendTorus(ndivisions, d1, d2); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendBox(lua_State* l) | 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); | m->m_instance.AppendBox(size, chamf, smooth); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendStar(lua_State* l) | 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); | m->m_instance.AppendStar(nbranches, d1, d2, fade, fade2); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendExpandedStar(lua_State* l) | 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); | m->m_instance.AppendExpandedStar(nbranches, d1, d2, extrad); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendDisc(lua_State* l) | 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); | m->m_instance.AppendDisc(nsides, d, fade); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendSimpleTriangle(lua_State* l) | 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); | m->m_instance.AppendSimpleTriangle(d, fade); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendSimpleQuad(lua_State* l) | 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); | m->m_instance.AppendSimpleQuad(size, fade); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int AppendCog(lua_State* l) | 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) | 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); | m->m_instance.TranslateX(f); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int TranslateY(lua_State* l) | 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); | m->m_instance.TranslateY(f); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int TranslateZ(lua_State* l) | 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); | m->m_instance.TranslateZ(f); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int Translate(lua_State* l) | 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); | m->m_instance.Translate(v); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int RotateX(lua_State* l) | 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); | m->m_instance.RotateX(a); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int RotateY(lua_State* l) | 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); | m->m_instance.RotateY(a); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int RotateZ(lua_State* l) | 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); | m->m_instance.RotateZ(a); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int Rotate(lua_State* l) | 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); | m->m_instance.Rotate(a, v); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int ScaleX(lua_State* l) | 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); | m->m_instance.ScaleX(x); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int ScaleY(lua_State* l) | 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); | m->m_instance.ScaleY(y); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int ScaleZ(lua_State* l) | 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); | m->m_instance.ScaleZ(z); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int Scale(lua_State* l) | 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); | m->m_instance.Scale(v); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int RadialJitter(lua_State* l) | 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); | m->m_instance.RadialJitter(f); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int TaperX(lua_State* l) | 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); | m->m_instance.TaperX(y, z, xoff, abs); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int TaperY(lua_State* l) | 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); | m->m_instance.TaperY(x, z, yoff, abs); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int TaperZ(lua_State* l) | 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); | m->m_instance.TaperZ(x, y, zoff, abs); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int TwistX(lua_State* l) | 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); | m->m_instance.TwistX(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int TwistY(lua_State* l) | 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); | m->m_instance.TwistY(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int TwistZ(lua_State* l) | 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); | m->m_instance.TwistZ(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int ShearX(lua_State* l) | 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); | m->m_instance.ShearX(y, z, xoff, abs); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int ShearY(lua_State* l) | 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); | m->m_instance.ShearY(x, z, yoff, abs); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int ShearZ(lua_State* l) | 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); | m->m_instance.ShearZ(x, y, zoff, abs); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int StretchX(lua_State* l) | 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); | m->m_instance.StretchX(y, z, xoff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int StretchY(lua_State* l) | 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); | m->m_instance.StretchY(x, z, yoff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int StretchZ(lua_State* l) | 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); | m->m_instance.StretchZ(x, y, zoff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int BendXY(lua_State* l) | 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); | m->m_instance.BendXY(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int BendXZ(lua_State* l) | 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); | m->m_instance.BendXZ(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int BendYX(lua_State* l) | 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); | m->m_instance.BendYX(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int BendYZ(lua_State* l) | 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); | m->m_instance.BendYZ(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int BendZX(lua_State* l) | 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); | m->m_instance.BendZX(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int BendZY(lua_State* l) | 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); | m->m_instance.BendZY(t, toff); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int MirrorX(lua_State* l) | 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(); | m->m_instance.MirrorX(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int MirrorY(lua_State* l) | 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(); | m->m_instance.MirrorY(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int MirrorZ(lua_State* l) | 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(); | m->m_instance.MirrorZ(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int LoopStart(lua_State* l) | 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); | m->m_instance.LoopStart(loopnb); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int LoopEnd(lua_State* l) | 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(); | m->m_instance.LoopEnd(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int OpenBrace(lua_State* l) | 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(); | m->m_instance.OpenBrace(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int CloseBrace(lua_State* l) | 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(); | m->m_instance.CloseBrace(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int ToggleScaleWinding(lua_State* l) | 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(); | m->m_instance.ToggleScaleWinding(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int ToggleQuadWeighting(lua_State* l) | 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(); | m->m_instance.ToggleQuadWeighting(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int TogglePostBuildNormal(lua_State* l) | 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(); | m->m_instance.TogglePostBuildNormal(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int ToggleVerticeNoCleanup(lua_State* l) | 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(); | m->m_instance.ToggleVerticeNoCleanup(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int VerticesMerge(lua_State* l) | 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(); | m->m_instance.VerticesMerge(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int VerticesSeparate(lua_State* l) | 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(); | m->m_instance.VerticesSeparate(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int VerticesCleanup(lua_State* l) | 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(); | m->m_instance.VerticesCleanup(); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int Duplicate(lua_State* l) | 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); | m->m_instance.DupAndScale(ds, true); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int Smooth(lua_State* l) | 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); | m->m_instance.SmoothMesh(pass, split_per_pass, smooth_per_pass); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int SplitTriangles(lua_State* l) | 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); | m->m_instance.SplitTriangles(pass); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int Chamfer(lua_State* l) | 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); | m->m_instance.Chamfer(f); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
static int SetCurColor(lua_State* l) | 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); | m->m_instance.SetCurColor(c); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int SetCurColorA(lua_State* l) | 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); | m->m_instance.SetCurColorA(c); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int SetCurColorB(lua_State* l) | 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); | m->m_instance.SetCurColorB(c); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
static int SetVertColor(lua_State* l) | 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); | m->m_instance.SetVertColor(c); | ||||
return 0; | |||||
return s.End(); | |||||
} | } | ||||
/* | /* | ||||
(csgu|csgunion) { return token::T_CSGUNION; } | (csgu|csgunion) { return token::T_CSGUNION; } | ||||
@@ -40,8 +40,9 @@ class LuaBaseData | |||||
int status = luaL_dostring(l, s.C()); | int status = luaL_dostring(l, s.C()); | ||||
if (status == 1) | 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); | lua_pop(l, 1); | ||||
} | } | ||||
return status; | return status; | ||||
@@ -53,8 +54,8 @@ class LuaBaseData | |||||
if (lua_isnoneornil(l, 1)) | if (lua_isnoneornil(l, 1)) | ||||
return LUA_ERRFILE; | 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; | int status = LUA_ERRFILE; | ||||
File f; | File f; | ||||
@@ -76,8 +77,9 @@ class LuaBaseData | |||||
msg::error("could not find Lua file %s\n", filename); | msg::error("could not find Lua file %s\n", filename); | ||||
else if (status == 1) | 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); | lua_pop(l, 1); | ||||
} | } | ||||
@@ -16,9 +16,6 @@ | |||||
#pragma once | #pragma once | ||||
#define OLD_VAR_SYSTEM true | |||||
#define NEW_VAR_SYSTEM true | |||||
namespace lol | namespace lol | ||||
{ | { | ||||
@@ -134,20 +131,19 @@ public: | |||||
{ "New", New<TLuaClass> }, | { "New", New<TLuaClass> }, | ||||
{ "Store", Store<TLuaClass> }, | { "Store", Store<TLuaClass> }, | ||||
{ "__gc", Del<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 } | { 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 | //Create Static metatable | ||||
luaL_newmetatable(l, GetStaticName<TLuaClass>()); | luaL_newmetatable(l, GetStaticName<TLuaClass>()); | ||||
@@ -235,6 +231,18 @@ protected: | |||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
template <typename TLuaClass> static int Store(lua_State * l); | template <typename TLuaClass> static int Store(lua_State * l); | ||||
template <typename TLuaClass> static int Del(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 ----------------------------- | // Stack: Main class that encapsulates everything ----------------------------- | ||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
class Stack | class Stack | ||||
{ | { | ||||
public: | |||||
#if NEW_VAR_SYSTEM | |||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
public: | |||||
static Stack Begin(lua_State* state, int32_t start_index = 1) | static Stack Begin(lua_State* state, int32_t start_index = 1) | ||||
{ | { | ||||
return Stack(state, start_index); | return Stack(state, start_index); | ||||
} | } | ||||
//------------------------------------------------------------------------- | |||||
void SetIndex(int32_t index) | |||||
{ | |||||
m_index = index; | |||||
} | |||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
int32_t End() | int32_t End() | ||||
{ | { | ||||
return m_result; | return m_result; | ||||
} | } | ||||
#if !OLD_VAR_SYSTEM | |||||
//------------------------------------------------------------------------- | |||||
protected: | protected: | ||||
#endif //!OLD_VAR_SYSTEM | |||||
#endif //NEW_VAR_SYSTEM | |||||
Stack(lua_State* l, int32_t start_index = 1) | Stack(lua_State* l, int32_t start_index = 1) | ||||
{ | { | ||||
m_state = l; | m_state = l; | ||||
m_index = start_index; | m_index = start_index; | ||||
} | } | ||||
public: | |||||
virtual ~Stack() { } | virtual ~Stack() { } | ||||
protected: | |||||
int32_t GetArgs() | int32_t GetArgs() | ||||
{ | { | ||||
return lua_gettop(m_state); | return lua_gettop(m_state); | ||||
} | } | ||||
#if NEW_VAR_SYSTEM | |||||
public: | public: | ||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
//The encapsulating struct for pointers | //The encapsulating struct for pointers | ||||
@@ -945,6 +317,7 @@ public: | |||||
} | } | ||||
Ptr(const T*& value) { m_value = value; } | Ptr(const T*& value) { m_value = value; } | ||||
inline operator T*() { return m_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; } | 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> 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; } | 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 | #ifndef INNER_SAFE_ENUM | ||||
template<typename E> SafeEnum<E> InnerDefaultSafeEnum() { return SafeEnum<E>(); } | template<typename E> SafeEnum<E> InnerDefaultSafeEnum() { return SafeEnum<E>(); } | ||||
template<typename E> bool InnerIsValidSafeEnum() { return InnerIsValid<String>(); } | template<typename E> bool InnerIsValidSafeEnum() { return InnerIsValid<String>(); } | ||||
@@ -1016,35 +382,7 @@ protected: | |||||
} | } | ||||
#endif //STACK_STRING | #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: | private: | ||||
lua_State* m_state = nullptr; | lua_State* m_state = nullptr; | ||||
int32_t m_index = 1; | int32_t m_index = 1; | ||||
@@ -1052,22 +390,8 @@ private: | |||||
}; | }; | ||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
#if NEW_VAR_SYSTEM | |||||
#ifndef REGION_STACK_VAR | #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 | #ifndef STACK_BOOL | ||||
template<> inline bool Stack::InnerIsValid<bool>() { return lua_isboolean(m_state, m_index); } | 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++); } | 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 | #endif //STACK_FLOAT | ||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
//DO NOT REMOVE: IT IS THE BASIS FOR INT 32 | |||||
#ifndef STACK_INT64 | #ifndef STACK_INT64 | ||||
template<> inline bool Stack::InnerIsValid<int64_t>() { return !!lua_isnumber(m_state, m_index); } | 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++); } | 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)); } | 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 | #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 //REGION_STACK_VAR | ||||
#endif //NEW_VAR_SYSTEM | |||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
class Loader | class Loader | ||||
{ | { | ||||
@@ -1194,7 +489,6 @@ public: | |||||
bool ExecLuaFile(String const &lua); | bool ExecLuaFile(String const &lua); | ||||
bool ExecLuaCode(String const &lua); | bool ExecLuaCode(String const &lua); | ||||
#if NEW_VAR_SYSTEM | |||||
//------------------------------------------------------------------------- | //------------------------------------------------------------------------- | ||||
#define DECLARE_LOADER_GET(T0, T1, GET_NAME) \ | #define DECLARE_LOADER_GET(T0, T1, GET_NAME) \ | ||||
template<typename T0> \ | template<typename T0> \ | ||||
@@ -1213,27 +507,6 @@ public: | |||||
#undef DECLARE_LOADER_GET | #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: | protected: | ||||
lua_State* GetLuaState(); | lua_State* GetLuaState(); | ||||
static void Store(lua_State* l, Loader* loader); | static void Store(lua_State* l, Loader* loader); | ||||
@@ -1249,12 +522,11 @@ private: | |||||
//----------------------------------------------------------------------------- | //----------------------------------------------------------------------------- | ||||
// ObjectHelper member implementations that require VarPtr | // ObjectHelper member implementations that require VarPtr | ||||
#if NEW_VAR_SYSTEM | |||||
template <typename TLuaClass> | template <typename TLuaClass> | ||||
int ObjectHelper::Store(lua_State * l) | int ObjectHelper::Store(lua_State * l) | ||||
{ | { | ||||
auto stack = LuaStack::Begin(l); | auto stack = LuaStack::Begin(l); | ||||
auto obj = stack.Get<Stack::Ptr<TLuaClass> >(); | |||||
TLuaClass* obj = stack.GetPtr<TLuaClass>(); | |||||
ASSERT(obj); | ASSERT(obj); | ||||
Loader::StoreObject(l, obj); | Loader::StoreObject(l, obj); | ||||
return 0; | return 0; | ||||
@@ -1264,37 +536,12 @@ template <typename TLuaClass> | |||||
int ObjectHelper::Del(lua_State * l) | int ObjectHelper::Del(lua_State * l) | ||||
{ | { | ||||
auto stack = LuaStack::Begin(l); | auto stack = LuaStack::Begin(l); | ||||
auto obj = stack.Get<Stack::Ptr<TLuaClass> >(); | |||||
TLuaClass* obj = stack.GetPtr<TLuaClass>(); | |||||
ASSERT(obj); | ASSERT(obj); | ||||
delete obj; | delete obj; | ||||
return 0; | 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 */ | } /* namespace Lolua */ | ||||
//TYPEDEFS | //TYPEDEFS | ||||
@@ -1305,22 +552,5 @@ typedef Lolua::Object::Library LuaObjectLibrary; | |||||
typedef Lolua::Loader LuaLoader; | typedef Lolua::Loader LuaLoader; | ||||
typedef Lolua::Stack LuaStack; | typedef Lolua::Stack LuaStack; | ||||
template <typename P> using LuaPtr = Lolua::Stack::Ptr<P>; | 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 */ | } /* namespace lol */ |