From 8222295f3b33a34b91a1ff89e068937d54e0d03e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Benjamin=20=E2=80=98Touky=E2=80=99=20Huet?= Date: Wed, 11 Mar 2015 05:04:59 +0000 Subject: [PATCH] 2nd pass on Lua integration. First pass on EzMesh integration (doesn't work yet) --- doc/tutorial/14_lol_lua.cpp | 65 +-- src/easymesh/easymesh.h | 10 +- src/easymesh/easymeshlua.cpp | 104 ++++- src/easymesh/easymeshlua.h | 723 +++++++++++++++++++++++++---- src/easymesh/easymeshtransform.cpp | 8 + src/image/color/color.cpp | 30 ++ src/lol/extras.h | 1 + src/lol/image/color.h | 13 +- src/lolua/baselua.cpp | 12 +- src/lolua/baselua.h | 448 +++++++++++++++--- src/world.cpp | 2 +- src/world.h | 2 +- 12 files changed, 1213 insertions(+), 205 deletions(-) diff --git a/doc/tutorial/14_lol_lua.cpp b/doc/tutorial/14_lol_lua.cpp index 5f67413d..cd312894 100644 --- a/doc/tutorial/14_lol_lua.cpp +++ b/doc/tutorial/14_lol_lua.cpp @@ -19,12 +19,13 @@ using namespace lol; //----------------------------------------------------------------------------- -class DemoObject : public Lolua::ObjectDef +class DemoObject : public LuaObjectDef { + typedef Lolua::VarPtr LuaDemoObjectPtr; public: - DemoObject() : Lolua::ObjectDef() {} + DemoObject() : LuaObjectDef() {} virtual ~DemoObject() {} - static DemoObject* New(Lolua::State* l, int arg_nb) + static DemoObject* New(LuaState* l, int arg_nb) { UNUSED(l); UNUSED(arg_nb); @@ -32,17 +33,19 @@ public: } //------------------------------------------------------------------------- - static int AddFive(Lolua::State* l) + static int AddFive(LuaState* l) { - Lolua::Var i(l, 1); + LuaInt32 i; i.Get(l, 1); i += 5; return i.Return(l); } - static int AddTenInstance(Lolua::State* l) + static int AddTenInstance(LuaState* l) { - Lolua::VarPtr obj(l, 1); - Lolua::Var f(l, 2); - f = obj.V()->AddTenMethod(f.V()); + LuaStack stack(l); + LuaDemoObjectPtr obj; + LuaFloat f; + stack >> obj >> f; + f = obj->AddTenMethod(f); return f.Return(l); } float AddTenMethod(float f) @@ -50,25 +53,29 @@ public: return (f + 10); } - static int GetX(Lolua::State* l) + static int GetX(LuaState* l) { - Lolua::VarPtr obj(l, 1); - Lolua::Var i; - i = obj.V()->m_x; - return i.Return(l); + LuaStack stack(l); + LuaDemoObjectPtr obj; + LuaInt32 i; + stack >> obj; + i = obj->m_x; + return stack << i; } - static int SetX(Lolua::State* l) + static int SetX(LuaState* l) { - Lolua::VarPtr obj(l, 1); - Lolua::Var i(l, 2); - obj.V()->m_x = i.V(); + LuaStack stack(l); + LuaDemoObjectPtr obj; + LuaInt32 i; + stack >> obj >> i; + obj->m_x = i; return 0; } //------------------------------------------------------------------------- - static const Lolua::ObjectLib* GetLib() + static const LuaObjectLib* GetLib() { - static const Lolua::ObjectLib lib = Lolua::ObjectLib( + static const LuaObjectLib lib = LuaObjectLib( "LoluaDemo", { { "AddFive", &DemoObject::AddFive } }, { { "AddTenInstance", &DemoObject::AddTenInstance } }, @@ -80,26 +87,26 @@ public: }; //----------------------------------------------------------------------------- -static int GlobalAddString(Lolua::State* l) +static int GlobalAddString(LuaState* l) { - Lolua::Var s(l, 1); - s += "_added"; + LuaString s; s.Get(l, 1); + s() += "_added"; return s.Return(l); } //----------------------------------------------------------------------------- -class LoluaDemoLoader : public Lolua::Loader +class LoluaDemoLoader : public LuaLoader { public: - LoluaDemoLoader() : Lolua::Loader() + LoluaDemoLoader() : LuaLoader() { - Lolua::State* l = GetLuaState(); + LuaState* l = GetLuaState(); //Registering demo object - Lolua::Object::Register(l); + LuaObject::Register(l); //Registering function - Lolua::Function add_string(l, "GlobalAddString", &GlobalAddString); + LuaFunction add_string(l, "GlobalAddString", &GlobalAddString); } virtual ~LoluaDemoLoader() { @@ -107,7 +114,7 @@ public: } void TestStuff() { - Lolua::State* l = GetLuaState(); + LuaState* l = GetLuaState(); /* //create property diff --git a/src/easymesh/easymesh.h b/src/easymesh/easymesh.h index 94fdad8d..2a0c57c7 100644 --- a/src/easymesh/easymesh.h +++ b/src/easymesh/easymesh.h @@ -16,7 +16,6 @@ #include "commandstack.h" #include "easymeshrender.h" #include "easymeshbuild.h" -#include "easymeshlua.h" namespace lol { @@ -181,6 +180,12 @@ public: //------------------------------------------------------------------------- //Mesh transform operations //------------------------------------------------------------------------- + /* See Translate */ + void TranslateX(float t); + /* See Translate */ + void TranslateY(float t); + /* See Translate */ + void TranslateZ(float t); /* [cmd:t/tx/ty/tz] Translate vertices - v : Translation quantity. */ @@ -263,6 +268,9 @@ public: - s : scale quantity. */ void Scale(float s); + void ScaleX(float s); + void ScaleY(float s); + void ScaleZ(float s); void Scale(vec3 const &s); /* [cmd:m*] Mirror vertices through *-plane Acts as an OpenBrace diff --git a/src/easymesh/easymeshlua.cpp b/src/easymesh/easymeshlua.cpp index 8f277785..19b7b1cc 100644 --- a/src/easymesh/easymeshlua.cpp +++ b/src/easymesh/easymeshlua.cpp @@ -22,12 +22,12 @@ using namespace lol; //----------------------------------------------------------------------------- -EasyMeshLuaLoader::EasyMeshLuaLoader() : Lolua::Loader() +EasyMeshLuaLoader::EasyMeshLuaLoader() : LuaLoader() { - Lolua::State* l = GetLuaState(); + LuaState* l = GetLuaState(); //Registering demo object - Lolua::Object::Register(l); + LuaObject::Register(l); } //----------------------------------------------------------------------------- @@ -37,7 +37,7 @@ EasyMeshLuaLoader::~EasyMeshLuaLoader() } //----------------------------------------------------------------------------- -EasyMeshLuaObject::EasyMeshLuaObject() : Lolua::ObjectDef() +EasyMeshLuaObject::EasyMeshLuaObject() : LuaObjectDef() { } @@ -47,20 +47,104 @@ EasyMeshLuaObject::~EasyMeshLuaObject() } //----------------------------------------------------------------------------- -EasyMeshLuaObject* EasyMeshLuaObject::New(Lolua::State* l, int arg_nb) +EasyMeshLuaObject* EasyMeshLuaObject::New(LuaState* l, int arg_nb) { UNUSED(l); UNUSED(arg_nb); return new EasyMeshLuaObject(); } -//------------------------------------------------------------------------- -const Lolua::ObjectLib* EasyMeshLuaObject::GetLib() +//----------------------------------------------------------------------------- +const LuaObjectLib* EasyMeshLuaObject::GetLib() { - static const Lolua::ObjectLib lib = Lolua::ObjectLib( + static const LuaObjectLib lib = LuaObjectLib( "EasyMesh", - { { nullptr, nullptr } }, - { { nullptr, nullptr } }, + //Statics + { /*{ nullptr, nullptr }*/ }, + //Methods + { + //----------------------------------------------------------------- + { "AddCylinder", &AppendCylinder }, { "ac", &AppendCylinder }, + { "AddSphere", &AppendSphere }, { "asph", &AppendSphere }, + { "AddCapsule", &AppendCapsule }, { "acap", &AppendCapsule }, + { "AddTorus", &AppendTorus }, { "ato", &AppendTorus }, + { "AddBox", &AppendBox }, { "ab", &AppendBox }, + { "AddStar", &AppendStar }, { "as", &AppendStar }, + { "AddExpandedStar", &AppendExpandedStar }, { "aes", &AppendExpandedStar }, + { "AddDisc", &AppendDisc }, { "ad", &AppendDisc }, + { "AddTriangle", &AppendSimpleTriangle }, { "at", &AppendSimpleTriangle }, + { "AddQuad", &AppendSimpleQuad }, { "aq", &AppendSimpleQuad }, + { "AddCog", &AppendCog }, { "acog", &AppendCog }, + //----------------------------------------------------------------- + { "setcolor", &SetCurColor }, { "sc", &SetCurColor }, + { "setcolora", &SetCurColorA }, { "sca", &SetCurColorA }, + { "setcolorb", &SetCurColorB }, { "scb", &SetCurColorB }, + { "setcolorv", &SetVertColor }, { "scv", &SetVertColor }, + //----------------------------------------------------------------- + { "TranslateX", &TranslateX }, { "tx", &TranslateX }, + { "TranslateY", &TranslateY }, { "ty", &TranslateY }, + { "TranslateZ", &TranslateZ }, { "tz", &TranslateZ }, + { "Translate", &Translate }, { "t", &Translate }, + //----------------------------------------------------------------- + { "RotateX", &RotateX }, { "rx", &RotateX }, + { "RotateY", &RotateY }, { "ry", &RotateY }, + { "RotateZ", &RotateZ }, { "rz", &RotateZ }, + { "Rotate", &Rotate }, { "r", &Rotate }, + //----------------------------------------------------------------- + { "ScaleX", &ScaleX }, { "sx", &ScaleX }, + { "ScaleY", &ScaleY }, { "sy", &ScaleY }, + { "ScaleZ", &ScaleZ }, { "sz", &ScaleZ }, + { "Scale", &Scale }, { "s", &Scale }, + //----------------------------------------------------------------- + { "RadialJitter", &RadialJitter }, { "rj", &RadialJitter }, + //----------------------------------------------------------------- + { "TaperX", &TaperX }, { "tax", &TaperX }, + { "TaperY", &TaperY }, { "tay", &TaperY }, + { "TaperZ", &TaperZ }, { "taz", &TaperZ }, + //----------------------------------------------------------------- + { "TwistX", &TwistX }, { "twx", &TwistX }, + { "TwistY", &TwistY }, { "twy", &TwistY }, + { "TwistZ", &TwistZ }, { "twz", &TwistZ }, + //----------------------------------------------------------------- + { "ShearX", &ShearX }, { "shx", &ShearX }, + { "ShearY", &ShearY }, { "shy", &ShearY }, + { "ShearZ", &ShearZ }, { "shz", &ShearZ }, + //----------------------------------------------------------------- + { "StretchX", &StretchX }, { "stx", &StretchX }, + { "StretchY", &StretchY }, { "sty", &StretchY }, + { "StretchZ", &StretchZ }, { "stz", &StretchZ }, + //----------------------------------------------------------------- + { "BendXY", &BendXY }, { "bdxy", &BendXY }, + { "BendXZ", &BendXZ }, { "bdxz", &BendXZ }, + { "BendYX", &BendYX }, { "bdyx", &BendYX }, + { "BendYZ", &BendYZ }, { "bdyz", &BendYZ }, + { "BendZX", &BendZX }, { "bdzx", &BendZX }, + { "BendZY", &BendZY }, { "bdzy", &BendZY }, + //----------------------------------------------------------------- + { "MirrorX", &MirrorX }, { "mx", &MirrorX }, + { "MirrorY", &MirrorY }, { "my", &MirrorY }, + { "MirrorZ", &MirrorZ }, { "mz", &MirrorZ }, + //----------------------------------------------------------------- + { "Loop", &LoopStart }, { "lp", &LoopStart }, + { "LoopDo", &LoopEnd }, { "ld", &LoopEnd }, + { "BraceOpen", &OpenBrace }, { "bop", &OpenBrace }, + { "BraceClose", &CloseBrace }, { "bcl", &CloseBrace }, + //----------------------------------------------------------------- + { "VerticeMerge", &VerticesMerge }, { "vm", &VerticesMerge }, + { "VerticeSeparate", &VerticesSeparate }, { "vs", &VerticesSeparate }, + //----------------------------------------------------------------- + { "Duplicate", &Duplicate }, { "dup", &Duplicate }, + { "Smooth", &Smooth }, { "smth", &Smooth }, + { "SplitTriangles", &SplitTriangles }, { "splt", &SplitTriangles }, + { "Chamfer", &Chamfer }, { "cf", &Chamfer }, + //----------------------------------------------------------------- + { "ToggleScaleWinding", &ToggleScaleWinding }, { "tsw", &ToggleScaleWinding }, + { "ToggleQuadWeighting", &ToggleQuadWeighting }, { "tqw", &ToggleQuadWeighting }, + { "TogglePostBuildNormal", &TogglePostBuildNormal }, { "tpbn", &TogglePostBuildNormal }, + { "ToggleVerticeNoCleanup", &ToggleVerticeNoCleanup }, { "tvnc", &ToggleVerticeNoCleanup }, + //----------------------------------------------------------------- + }, + //Variables { { nullptr, nullptr, nullptr } }); return &lib; } diff --git a/src/easymesh/easymeshlua.h b/src/easymesh/easymeshlua.h index 8ec23454..3a14af80 100644 --- a/src/easymesh/easymeshlua.h +++ b/src/easymesh/easymeshlua.h @@ -16,7 +16,7 @@ namespace lol { //----------------------------------------------------------------------------- -class EasyMeshLuaLoader : public Lolua::Loader +class EasyMeshLuaLoader : public LuaLoader { public: EasyMeshLuaLoader(); @@ -24,120 +24,645 @@ public: }; //----------------------------------------------------------------------------- -class EasyMeshLuaObject : public Lolua::ObjectDef +class EasyMeshLuaObject : public LuaObjectDef { + typedef Lolua::VarPtr EzMeshPtr; + EasyMesh m_instance; public: //------------------------------------------------------------------------- EasyMeshLuaObject(); virtual ~EasyMeshLuaObject(); //------------------------------------------------------------------------- - static EasyMeshLuaObject* New(Lolua::State* l, int arg_nb); - static const Lolua::ObjectLib* GetLib(); + static EasyMeshLuaObject* New(LuaState* l, int arg_nb); + static const LuaObjectLib* GetLib(); //------------------------------------------------------------------------- + static int AppendCylinder(LuaState* 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; + m->m_instance.AppendCylinder(nsides, h, d1, d2, dualside, smooth, close); + return 0; + } + static int AppendSphere(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaInt32 ndivisions; + LuaFloat d; + s >> m >> ndivisions >> d; + m->m_instance.AppendSphere(ndivisions, d); + return 0; + } + static int AppendCapsule(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaInt32 ndivisions; + LuaFloat h, d; + s >> m >> ndivisions >> h >> d; + m->m_instance.AppendCapsule(ndivisions, h, d); + return 0; + } + static int AppendTorus(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaInt32 ndivisions; + LuaFloat d1, d2; + s >> m >> ndivisions >> d1 >> d2; + m->m_instance.AppendTorus(ndivisions, d1, d2); + return 0; + } + static int AppendBox(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaVec3 size; + LuaFloat chamf(0.f, true); + LuaBool smooth(false, true); + s >> m >> size >> chamf >> smooth; + m->m_instance.AppendBox(size, chamf, smooth); + return 0; + } + static int AppendStar(LuaState* 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; + m->m_instance.AppendStar(nbranches, d1, d2, fade, fade2); + return 0; + } + static int AppendExpandedStar(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaInt32 nbranches; + LuaFloat d1, d2, extrad(0.f, true); + s >> m >> nbranches >> d1 >> d2 >> extrad; + m->m_instance.AppendExpandedStar(nbranches, d1, d2, extrad); + return 0; + } + static int AppendDisc(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaInt32 nsides; + LuaFloat d; + LuaBool fade(false, true); + s >> m >> nsides >> d >> fade; + m->m_instance.AppendDisc(nsides, d, fade); + return 0; + } + static int AppendSimpleTriangle(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat d; + LuaBool fade(false, true); + s >> m >> d >> fade; + m->m_instance.AppendSimpleTriangle(d, fade); + return 0; + } + static int AppendSimpleQuad(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat size; + LuaBool fade(false, true); + s >> m >> size >> fade; + m->m_instance.AppendSimpleQuad(size, fade); + return 0; + } + static int AppendCog(LuaState* 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; + } + //------------------------------------------------------------------------- + static int TranslateX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat f; + s >> m >> f; + m->m_instance.TranslateX(f); + return 0; + } + static int TranslateY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat f; + s >> m >> f; + m->m_instance.TranslateY(f); + return 0; + } + static int TranslateZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat f; + s >> m >> f; + m->m_instance.TranslateZ(f); + return 0; + } + static int Translate(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaVec3 v; + s >> m >> v; + m->m_instance.Translate(v); + return 0; + } + //------------------------------------------------------------------------- + static int RotateX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat a; + s >> m >> a; + m->m_instance.RotateX(a); + return 0; + } + static int RotateY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat a; + s >> m >> a; + m->m_instance.RotateY(a); + return 0; + } + static int RotateZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat a; + s >> m >> a; + m->m_instance.RotateZ(a); + return 0; + } + static int Rotate(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat a; + LuaVec3 v; + s >> m >> a >> v; + m->m_instance.Rotate(a, v); + return 0; + } + //------------------------------------------------------------------------- + static int ScaleX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat x; + s >> m >> x; + m->m_instance.ScaleX(x); + return 0; + } + static int ScaleY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat y; + s >> m >> y; + m->m_instance.ScaleY(y); + return 0; + } + static int ScaleZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat z; + s >> m >> z; + m->m_instance.ScaleZ(z); + return 0; + } + static int Scale(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaVec3 v; + s >> m >> v; + m->m_instance.Scale(v); + return 0; + } + //------------------------------------------------------------------------- + static int RadialJitter(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat f; + s >> m >> f; + m->m_instance.RadialJitter(f); + return 0; + } + //------------------------------------------------------------------------- + static int TaperX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat y, z, xoff(0.f, true); + LuaBool abs(true, true); + s >> m >> y >> z >> xoff >> abs; + m->m_instance.TaperX(y, z, xoff, abs); + return 0; + } + static int TaperY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat x, z, yoff(0.f, true); + LuaBool abs(true, true); + s >> m >> x >> z >> yoff >> abs; + m->m_instance.TaperY(x, z, yoff, abs); + return 0; + } + static int TaperZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat x, y, zoff(0.f, true); + LuaBool abs(true, true); + s >> m >> x >> y >> zoff >> abs; + m->m_instance.TaperZ(x, y, zoff, abs); + return 0; + } + //------------------------------------------------------------------------- + static int TwistX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.TwistX(t, toff); + return 0; + } + static int TwistY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.TwistY(t, toff); + return 0; + } + static int TwistZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.TwistZ(t, toff); + return 0; + } + //------------------------------------------------------------------------- + static int ShearX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat y, z, xoff(0.f, true); + LuaBool abs(true, true); + s >> m >> y >> z >> xoff >> abs; + m->m_instance.ShearX(y, z, xoff, abs); + return 0; + } + static int ShearY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat x, z, yoff(0.f, true); + LuaBool abs(true, true); + s >> m >> x >> z >> yoff >> abs; + m->m_instance.ShearY(x, z, yoff, abs); + return 0; + } + static int ShearZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat x, y, zoff(0.f, true); + LuaBool abs(true, true); + s >> m >> x >> y >> zoff >> abs; + m->m_instance.ShearZ(x, y, zoff, abs); + return 0; + } + //------------------------------------------------------------------------- + static int StretchX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat y, z, xoff(0.f, true); + s >> m >> y >> z >> xoff; + m->m_instance.StretchX(y, z, xoff); + return 0; + } + static int StretchY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat x, z, yoff(0.f, true); + s >> m >> x >> z >> yoff; + m->m_instance.StretchY(x, z, yoff); + return 0; + } + static int StretchZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat x, y, zoff(0.f, true); + s >> m >> x >> y >> zoff; + m->m_instance.StretchZ(x, y, zoff); + return 0; + } + //------------------------------------------------------------------------- + static int BendXY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.BendXY(t, toff); + return 0; + } + static int BendXZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.BendXZ(t, toff); + return 0; + } + static int BendYX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.BendYX(t, toff); + return 0; + } + static int BendYZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.BendYZ(t, toff); + return 0; + } + static int BendZX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.BendZX(t, toff); + return 0; + } + static int BendZY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat t, toff(0.f, true); + s >> m >> t >> toff; + m->m_instance.BendZY(t, toff); + return 0; + } + //------------------------------------------------------------------------- + static int MirrorX(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.MirrorX(); + return 0; + } + static int MirrorY(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.MirrorY(); + return 0; + } + static int MirrorZ(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.MirrorZ(); + return 0; + } + //------------------------------------------------------------------------- + static int LoopStart(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaInt32 loopnb; + s >> m >> loopnb; + m->m_instance.LoopStart(loopnb); + return 0; + } + static int LoopEnd(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.LoopEnd(); + return 0; + } + static int OpenBrace(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.OpenBrace(); + return 0; + } + static int CloseBrace(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.CloseBrace(); + return 0; + } + //------------------------------------------------------------------------- + static int ToggleScaleWinding(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.ToggleScaleWinding(); + return 0; + } + static int ToggleQuadWeighting(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.ToggleQuadWeighting(); + return 0; + } + static int TogglePostBuildNormal(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.TogglePostBuildNormal(); + return 0; + } + static int ToggleVerticeNoCleanup(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.ToggleVerticeNoCleanup(); + return 0; + } + //------------------------------------------------------------------------- + static int VerticesMerge(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.VerticesMerge(); + return 0; + } + static int VerticesSeparate(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + m->m_instance.VerticesSeparate(); + return 0; + } + //------------------------------------------------------------------------- + static int Duplicate(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaVec3 ds(vec3(1.f)); + s >> m >> ds; + m->m_instance.DupAndScale(ds, true); + return 0; + } + static int Smooth(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaInt32 pass, split_per_pass, smooth_per_pass; + s >> m >> pass >> split_per_pass >> smooth_per_pass; + m->m_instance.SmoothMesh(pass, split_per_pass, smooth_per_pass); + return 0; + } + static int SplitTriangles(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaInt32 pass; + s >> m >> pass; + m->m_instance.SplitTriangles(pass); + return 0; + } + static int Chamfer(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + LuaFloat f; + s >> m >> f; + m->m_instance.Chamfer(f); + return 0; + } + //------------------------------------------------------------------------- + static int SetCurColor(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + LuaVec4 c; + if (s.GetArgs() == 1 && !c.IsValid(l, 2)) + { + LuaString str; + s >> str; + c = Color::C8BppHexString(str); + } + m->m_instance.SetCurColor(c); + return 0; + } + static int SetCurColorA(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + LuaVec4 c; + if (s.GetArgs() == 1 && !c.IsValid(l, 2)) + { + LuaString str; + s >> str; + c = Color::C8BppHexString(str); + } + m->m_instance.SetCurColorA(c); + return 0; + } + static int SetCurColorB(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + LuaVec4 c; + if (s.GetArgs() == 1 && !c.IsValid(l, 2)) + { + LuaString str; + s >> str; + c = Color::C8BppHexString(str); + } + m->m_instance.SetCurColorB(c); + return 0; + } + static int SetVertColor(LuaState* l) + { + LuaStack s(l); + EzMeshPtr m; + s >> m; + LuaVec4 c; + if (s.GetArgs() == 1 && !c.IsValid(l, 2)) + { + LuaString str; + s >> str; + c = Color::C8BppHexString(str); + } + m->m_instance.SetVertColor(c); + return 0; + } /* - (csgu|csgunion) { return token::T_CSGUNION; } (csgs|CsgSub) { return token::T_CSGSUBSTRACT; } (csgsl|CsgSubL) { return token::T_CSGSUBSTRACTLOSS; } (csga|csgand) { return token::T_CSGAND; } (csgx|csgxor) { return token::T_CSGXOR; } - - (lp|loop) { return token::T_LOOP; } - (sc|setcolor) { return token::T_COLOR; } - (sca|setcolora) { return token::T_ACOLOR; } - (scb|setcolorb) { return token::T_BCOLOR; } - (scv|setcolorv) { return token::T_VCOLOR; } - - (tsw|tglscalewind) { return token::T_TOGGLESCALEWINDING; } - (tqw|tglquadweight) { return token::T_TOGGLEQUADWEIGHTING; } - (tpbn|tglpstbuildnormal) { return token::T_TOGGLEPOSTBUILDNORMAL; } - (tvnc|tglvertnocleanup) { return token::T_TOGGLEVERTNOCLEANUP; } - - (vm|vertmerge) { return token::T_VERTMERGE; } - (vs|vertseparate) { return token::T_VERTSEPARATE; } - - (tx|translatex) { return token::T_TRANSLATEX; } - (ty|translatey) { return token::T_TRANSLATEY; } - (tz|translatez) { return token::T_TRANSLATEZ; } - (t|translate) { return token::T_TRANSLATE; } - (rx|rotatex) { return token::T_ROTATEX; } - (ry|rotatey) { return token::T_ROTATEY; } - (rz|rotatez) { return token::T_ROTATEZ; } - (r|rotate) { return token::T_ROTATE; } - (rj|radialjitter) { return token::T_RADIALJITTER; } - (tax|taperx) { return token::T_TAPERX; } - (tay|tapery) { return token::T_TAPERY; } - (taz|taperz) { return token::T_TAPERZ; } - (twx|twistx) { return token::T_TWISTX; } - (twy|twisty) { return token::T_TWISTY; } - (twz|twistz) { return token::T_TWISTZ; } - (shx|shearx) { return token::T_SHEARX; } - (shy|sheary) { return token::T_SHEARY; } - (shz|shearz) { return token::T_SHEARZ; } - (stx|stretchx) { return token::T_STRETCHX; } - (sty|stretchy) { return token::T_STRETCHY; } - (stz|stretchz) { return token::T_STRETCHZ; } - (bdxy|bendxy) { return token::T_BENDXY; } - (bdxz|bendxz) { return token::T_BENDXZ; } - (bdyx|bendyx) { return token::T_BENDYX; } - (bdyz|bendyz) { return token::T_BENDYZ; } - (bdzx|bendzx) { return token::T_BENDZX; } - (bdzy|bendzy) { return token::T_BENDZY; } - (sx|scalex) { return token::T_SCALEX; } - (sy|scaley) { return token::T_SCALEY; } - (sz|scalez) { return token::T_SCALEZ; } - (s|scale) { return token::T_SCALE; } - (mx|mirrorx) { return token::T_MIRRORX; } - (my|mirrory) { return token::T_MIRRORY; } - (mz|mirrorz) { return token::T_MIRRORZ; } - (ch|chamfer) { return token::T_CHAMFER; } - (splt|splittriangle) { return token::T_SPLITTRIANGLE; } - (smth|smooth) { return token::T_SMOOTHMESH; } - (dup|duplicate) { return token::T_DUPLICATE; } - - (ac|addcylinder) { return token::T_CYLINDER; } - (asph|addsphere) { return token::T_SPHERE; } - (acap|addcapsule) { return token::T_CAPSULE; } - (ato|addtorus) { return token::T_TORUS; } - (ab|addbox) { return token::T_BOX; } - (ascb|addsmoothchamfbox) { return token::T_SMOOTHCHAMFBOX; } - (afcb|addflatchamfbox) { return token::T_FLATCHAMFBOX; } - (as|addstar) { return token::T_STAR; } - (aes|addexpandedstar) { return token::T_EXPANDEDSTAR; } - (ad|adddisc) { return token::T_DISC; } - (at|addtriangle) { return token::T_TRIANGLE; } - (aq|addquad) { return token::T_QUAD; } - (acg|addcog) { return token::T_COG; } */ - /* - - %{ *//* ======= BASE COLOR TYPES ========================================= *//* % -} -%{ *//* COLOR *//* %} -#[0-9a-fA-F]{3} { -uint32_t tmp = std::strtol(yytext + 1, nullptr, 16); -yylval->u32val = 0x11000000u * (tmp >> 8) -| 0x00110000u * ((tmp >> 4) & 0xf) -| 0x00001100u * (tmp & 0xf) -| 0x000000ffu; -return token::COLOR; } -#[0-9a-fA-F]{4} { -uint32_t tmp = std::strtol(yytext + 1, nullptr, 16); -yylval->u32val = 0x11000000u * (tmp >> 12) -| 0x00110000u * ((tmp >> 8) & 0xf) -| 0x00001100u * ((tmp >> 4) & 0xf) -| 0x00000011u * (tmp & 0xf); -return token::COLOR; } -#[0-9a-fA-F]{6} { -yylval->u32val = 0xffu -| 0x100u * (uint32_t)std::strtol(yytext + 1, nullptr, 16); -return token::COLOR; } -#[0-9a-fA-F]{8} { -yylval->u32val = (uint32_t)std::strtol(yytext + 1, nullptr, 16); -return token::COLOR; } -*/ }; diff --git a/src/easymesh/easymeshtransform.cpp b/src/easymesh/easymeshtransform.cpp index 7e7a8333..fc1f4887 100644 --- a/src/easymesh/easymeshtransform.cpp +++ b/src/easymesh/easymeshtransform.cpp @@ -15,6 +15,11 @@ namespace lol { +//----------------------------------------------------------------------------- +void EasyMesh::TranslateX(float t) { Translate(vec3(t, 0.f, 0.f)); } +void EasyMesh::TranslateY(float t) { Translate(vec3(0.f, t, 0.f)); } +void EasyMesh::TranslateZ(float t) { Translate(vec3(0.f, 0.f, t)); } + //----------------------------------------------------------------------------- void EasyMesh::Translate(vec3 const &v) { @@ -188,6 +193,9 @@ void EasyMesh::DoMeshTransform(MeshTransform ct, Axis axis0, Axis axis1, float n //----------------------------------------------------------------------------- void EasyMesh::Scale(float s) { Scale(vec3(s)); } +void EasyMesh::ScaleX(float s) { Scale(vec3(s, 0.f, 0.f)); } +void EasyMesh::ScaleY(float s) { Scale(vec3(0.f, s, 0.f)); } +void EasyMesh::ScaleZ(float s) { Scale(vec3(0.f, 0.f, s)); } void EasyMesh::Scale(vec3 const &s) { if (BD()->IsEnabled(MeshBuildOperation::CommandRecording)) diff --git a/src/image/color/color.cpp b/src/image/color/color.cpp index afe52ebd..16f9bcef 100644 --- a/src/image/color/color.cpp +++ b/src/image/color/color.cpp @@ -55,5 +55,35 @@ String Color::HexString8Bpp(vec4 c) return String::Printf("%02x%2x%02x%02x", c2.r, c2.g, c2.b, c2.a); } +/* +* Conversion from colours to hexadecimal +*/ +vec4 Color::C8BppHexString(String s) +{ + String c = s[0] == '#' ? &s[1] : s; + uint32_t tmp = std::strtol(c.C(), nullptr, 16); + if (c.Count() == 3) + { + tmp = 0x11000000u * (tmp >> 8) + | 0x00110000u * ((tmp >> 4) & 0xf) + | 0x00001100u * (tmp & 0xf) + | 0x000000ffu; + } + else if (c.Count() == 4) + { + tmp = 0x11000000u * (tmp >> 12) + | 0x00110000u * ((tmp >> 8) & 0xf) + | 0x00001100u * ((tmp >> 4) & 0xf) + | 0x00000011u * (tmp & 0xf); + } + else if (c.Count() == 6) + { + tmp = 0xffu | 0x100u * tmp; + } + vec4 color(0.f); + ivec4 v(tmp >> 24, (tmp >> 16) & 0xff, (tmp >> 8) & 0xff, tmp & 0xff); + return vec4(v) * (1.f / 255.f); +} + } /* namespace lol */ diff --git a/src/lol/extras.h b/src/lol/extras.h index 55f2bb63..e59a16fd 100644 --- a/src/lol/extras.h +++ b/src/lol/extras.h @@ -53,6 +53,7 @@ #include #include #include +#include // Managers #include diff --git a/src/lol/image/color.h b/src/lol/image/color.h index 1a00124a..9982c946 100644 --- a/src/lol/image/color.h +++ b/src/lol/image/color.h @@ -21,7 +21,7 @@ namespace lol { -class Color +class Color : public vec4 { public: /* @@ -317,15 +317,20 @@ public: static vec3 WavelengthToCIExyY(float nm); /* - * Convert colors to hex strings. - */ + * Convert colors to hex strings. + */ static String HexString4Bpp(vec3 c); static String HexString4Bpp(vec4 c); static String HexString8Bpp(vec3 c); static String HexString8Bpp(vec4 c); /* - * Some predefined colours + * Convert hex strings to colors. + */ + static vec4 C8BppHexString(String c); + + /* + * Some predefined colours */ static const vec4 black, red, green, yellow, blue, magenta, cyan, white, gray_dark, gray, gray_light; }; diff --git a/src/lolua/baselua.cpp b/src/lolua/baselua.cpp index ebffd242..3bda66b3 100644 --- a/src/lolua/baselua.cpp +++ b/src/lolua/baselua.cpp @@ -25,7 +25,7 @@ class LuaBaseData { friend class Lolua::Loader; - static int LuaPanic(Lolua::State* L) + static int LuaPanic(LuaState* L) { char const *message = lua_tostring(L, -1); Log::Error("%s\n", message); @@ -33,13 +33,13 @@ class LuaBaseData return 0; } - static int LuaDoFile(Lolua::State *L) + static int LuaDoFile(LuaState *L) { if (lua_isnoneornil(L, 1)) return LUA_ERRFILE; - Lolua::Var var(L, 1); - char const *filename = var.V();// lua_tostring(L, 1); + LuaCharPtr var; var.Get(L, 1); + char const *filename = var;// lua_tostring(L, 1); int status = LUA_ERRFILE; array pathlist = System::GetPathList(filename); @@ -78,7 +78,7 @@ Loader::Loader() luaL_openlibs(m_lua_state); /* Override dofile() */ - Lolua::Function do_file(m_lua_state, "dofile", LuaBaseData::LuaDoFile); + LuaFunction do_file(m_lua_state, "dofile", LuaBaseData::LuaDoFile); } //----------------------------------------------------------------------------- @@ -96,7 +96,7 @@ bool Loader::ExecLua(String const &lua) } //----------------------------------------------------------------------------- -Lolua::State* Loader::GetLuaState() +LuaState* Loader::GetLuaState() { return m_lua_state; } diff --git a/src/lolua/baselua.h b/src/lolua/baselua.h index 879abe01..496bbd0a 100644 --- a/src/lolua/baselua.h +++ b/src/lolua/baselua.h @@ -19,6 +19,8 @@ namespace lol { +typedef lua_State LuaState; + //----------------------------------------------------------------------------- namespace Lolua { @@ -31,7 +33,6 @@ typedef struct ClassVar lua_CFunction get; lua_CFunction set; } ClassVar; -typedef lua_State State; //----------------------------------------------------------------------------- struct ObjectLib @@ -100,7 +101,7 @@ class ObjectDef public: ObjectDef() { } virtual ~ObjectDef() { } - static ObjectDef* New(State* l, int arg_nb) + static ObjectDef* New(LuaState* l, int arg_nb) { UNUSED(l); UNUSED(arg_nb); @@ -122,7 +123,7 @@ public: //------------------------------------------------------------------------- template - static void Register(State *l) + static void Register(LuaState *l) { //Default statics static const luaL_Reg default_statics[] @@ -208,7 +209,7 @@ public: protected: //------------------------------------------------------------------------- template - static int New(State* l) + static int New(LuaState* l) { //Number of arguments int n_args = lua_gettop(l); @@ -227,11 +228,11 @@ protected: //------------------------------------------------------------------------- template - static int Del(State * l) + static int Del(LuaState * l) { - VarPtr obj(l, 1); - ASSERT(obj.V()); - delete obj.V(); + VarPtr obj; obj.Get(l, 1); + ASSERT(obj()); + delete obj(); return 0; } }; @@ -240,7 +241,7 @@ protected: class Function { public: - Function(State* l, const char* name, int(*function)(State*)) + Function(LuaState* l, const char* name, int(*function)(LuaState*)) { lua_pushcfunction(l, function); lua_setglobal(l, name); @@ -253,22 +254,60 @@ class VarPtr { protected: T* m_value = nullptr; + bool m_optional = false; public: - VarPtr() { } - VarPtr(T* value) { m_value = value; } - VarPtr(State* l, int index) { InnerGet(l, index); } - inline T* V() { return m_value; } - inline T* operator=(T* value) { m_value = value; } - inline int Return(State* l) { InnerPush(l); return 1; } + VarPtr() { } + VarPtr(T* value, bool optional = false) + { + m_value = value; + m_optional = optional; + } + VarPtr(LuaState* l, int& index, bool optional = false) + { + m_optional = 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 bool IsValid(LuaState* l, int index) + { + return InnerValid(l, index); + } +private: + inline void GetInc(LuaState* 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(LuaState* l, int index) + { + int idx = index; + GetInc(l, idx); + } + inline int Return(LuaState* l) + { + InnerPush(l); + return 1; + } protected: - virtual void InnerGet(State* l, int index) + virtual bool InnerIsValid(LuaState* l, int index) + { + return !!lua_isuserdata(l, index); + } + virtual void InnerGet(LuaState* l, int& index) { - T** obj = static_cast(luaL_checkudata(l, index, Object::GetMethodName())); + T** obj = static_cast(luaL_checkudata(l, index++, Object::GetMethodName())); m_value = obj ? *obj : nullptr; } - void InnerPush(State* l) + void InnerPush(LuaState* l) { T** data = (T**)lua_newuserdata(l, sizeof(T*)); *data = m_value; @@ -280,12 +319,12 @@ class VarPtrLight { public: VarPtrLight() : VarPtr() { } - VarPtrLight(T* value) : VarPtr(T* value) { } - VarPtrLight(State* l, int index) : VarPtr(State* l, int index) { } + VarPtrLight(T* value, bool optional = false) : VarPtr(value, optional) { } + VarPtrLight(LuaState* l, int& index, bool optional = false) : VarPtr(l, index, optional) { } protected: - virtual void InnerGet(State* l, int index) + virtual void InnerGet(LuaState* l, int& index) { - T** obj = static_cast(luaL_testudata(l, index, Object::GetMethodName())); + T** obj = static_cast(luaL_testudata(l, index++, Object::GetMethodName())); m_value = obj ? *obj : nullptr; } }; @@ -295,14 +334,51 @@ template class Var { private: + bool m_optional = false; T m_value; public: - Var() { InnerInit(); } - Var(T value) { m_value = value; } - Var(State* l, int index) { InnerGet(l, index); } - inline T& V() { return m_value; } - inline int Return(State* l) { InnerPush(l); return 1; } + Var(bool optional = false) + { + m_optional = optional; + InnerInit(); + } + Var(T value, bool optional = false) + { + m_optional = optional; + m_value = value; + } + Var(LuaState* l, int& index, bool optional = false) + { + m_optional = optional; + GetInc(l, index); + } + inline operator T() { return m_value; } + inline T& operator ()() { return m_value; } + inline bool IsValid(LuaState* l, int index) + { + return InnerIsValid(l, index); + } +private: + void GetInc(LuaState* 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(LuaState* l, int index) + { + int idx = index; + GetInc(l, idx); + } + inline int Return(LuaState* l) + { + return InnerPush(l); + } inline Var& operator-(const T& value) { m_value - value; return *this; } inline Var& operator+(const T& value) { m_value + value; return *this; } inline Var& operator*(const T& value) { m_value * value; return *this; } @@ -323,32 +399,277 @@ public: inline Var& operator/=(const Var& 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& o) { return m_value == o.m_value; } - inline bool operator!=(const Var& o) { return m_value != o.m_value; } + inline bool operator==(const Var& o) { return m_value == o.m_value; } + inline bool operator!=(const Var& o) { return m_value != o.m_value; } private: - void InnerInit() { m_value = T(0); } - void InnerGet(State* l, int index) { ASSERT(false); } - void InnerPush(State* l) { ASSERT(false); } + void InnerInit() { m_value = T(0); } + bool InnerIsValid(LuaState* l, int index) { UNUSED(l); UNUSED(index); ASSERT(false); return false; } + void InnerGet(LuaState* l, int& index) { UNUSED(l); UNUSED(index); ASSERT(false); } + int InnerPush(LuaState* l) { UNUSED(l); ASSERT(false); return 0; } }; //----------------------------------------------------------------------------- -template<> inline void Var ::InnerInit() { m_value = String(); } -template<> inline void Var ::InnerGet(State* l, int index) { m_value = lua_tostring(l, index); } -template<> inline void Var::InnerGet(State* l, int index) { m_value = lua_tostring(l, index); } -template<> inline void Var ::InnerGet(State* l, int index) { m_value = lua_tonumber(l, index); } -template<> inline void Var ::InnerGet(State* l, int index) { m_value = (float)lua_tonumber(l, index); } -template<> inline void Var ::InnerGet(State* l, int index) { m_value = (int32_t)lua_tointeger(l, index); } -template<> inline void Var ::InnerGet(State* l, int index) { m_value = lua_tointeger(l, index); } -template<> inline void Var ::InnerGet(State* l, int index) { m_value = lua_tounsigned(l, index); } - -template<> inline void Var ::InnerPush(State* l) { lua_pushstring(l, m_value.C()); } -template<> inline void Var::InnerPush(State* l) { lua_pushstring(l, m_value); } -template<> inline void Var ::InnerPush(State* l) { lua_pushnumber(l, m_value); } -template<> inline void Var ::InnerPush(State* l) { lua_pushnumber(l, m_value); } -template<> inline void Var ::InnerPush(State* l) { lua_pushinteger(l, m_value); } -template<> inline void Var ::InnerPush(State* l) { lua_pushinteger(l, m_value); } -template<> inline void Var ::InnerPush(State* l) { lua_pushunsigned(l, m_value); } +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + return lua_isboolean(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + m_value = !!lua_toboolean(l, index++); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + lua_pushboolean(l, m_value); + return 1; +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + return !!lua_isstring(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + m_value = lua_tostring(l, index++); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + lua_pushstring(l, m_value); + return 1; +} +//----------------------------------------------------------------------------- +template<> inline void Var::InnerInit() +{ + m_value = String(); +} +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + Var v; + return v.IsValid(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + Var v(l, index); + m_value = v(); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + Var v; + v = m_value.C(); + return v.Return(l); +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + return !!lua_isnumber(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + m_value = lua_tonumber(l, index++); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + lua_pushnumber(l, m_value); + return 1; +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + Var v; + return v.IsValid(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + Var v(l, index); + m_value = (float)v(); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + Var v = (double)m_value; + return v.Return(l); +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + return !!lua_isnumber(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + m_value = lua_tointeger(l, index++); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + lua_pushinteger(l, m_value); + return 1; +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + Var v; + return v.IsValid(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + Var v(l, index); + m_value = (int32_t)v(); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + Var v = (int64_t)m_value; + return v.Return(l); +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + return !!lua_isnumber(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + m_value = lua_tounsigned(l, index++); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + lua_pushunsigned(l, m_value); + return 1; +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + Var v; + return v.IsValid(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + Var v(l, index); + m_value = (uint64_t)v(); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + Var v = (uint32_t)m_value; + return v.Return(l); +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + Var x; + return x.IsValid(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + Var x(l, index); + Var y(x(), true); y.Get(l, index); + m_value = vec2(x, y); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + Var x = m_value.x; + Var y = m_value.y; + return (x.Return(l) + y.Return(l)); +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + Var x; + return x.IsValid(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + Var x(l, index); + Var y(x(), true); y.Get(l, index); + Var z(x(), true); z.Get(l, index); + m_value = vec3(x, y, z); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + Var x = m_value.x; + Var y = m_value.y; + Var z = m_value.z; + return (x.Return(l) + y.Return(l) + z.Return(l)); +} +//----------------------------------------------------------------------------- +template<> inline bool Var::InnerIsValid(LuaState* l, int index) +{ + Var x; + return x.IsValid(l, index); +} +template<> inline void Var::InnerGet(LuaState* l, int& index) +{ + Var x(l, index); + Var y(x(), true); y.Get(l, index); + Var z(x(), true); z.Get(l, index); + Var w(x(), true); w.Get(l, index); + m_value = vec4(x, y, z, w); +} +template<> inline int Var::InnerPush(LuaState* l) +{ + Var x = m_value.x; + Var y = m_value.y; + Var z = m_value.z; + Var w = m_value.w; + return (x.Return(l) + y.Return(l) + z.Return(l) + w.Return(l)); +} + +//----------------------------------------------------------------------------- +class Stack +{ +public: + Stack(LuaState* l, int32_t start_index = 1) + { + m_state = l; + m_index = start_index; + } + virtual ~Stack() { } + inline operator int32_t() { return m_result; } + int32_t GetArgs() + { + return lua_gettop(m_state); + } + + //------------------------------------------------------------------------- + template + Stack& operator>>(Var& var) + { + var = Var(m_state, m_index); + return *this; + } + template + Stack& operator>>(VarPtr& var) + { + var = VarPtr(m_state, m_index); + return *this; + } + template + Stack& operator>>(VarPtrLight& var) + { + var = VarPtrLight(m_state, m_index); + return *this; + } + + //------------------------------------------------------------------------- + template + Stack& operator<<(Var& var) + { + m_result += var.Return(m_state); + return *this; + } + template + Stack& operator<<(VarPtr& var) + { + m_result += var.Return(m_state); + return *this; + } + template + Stack& operator<<(VarPtrLight& var) + { + m_result += var.Return(m_state); + return *this; + } + +private: + LuaState* m_state = nullptr; + int32_t m_index = 1; + int32_t m_result = 0; +}; //----------------------------------------------------------------------------- class Loader @@ -363,26 +684,45 @@ public: T GetVar(String const &name) { lua_getglobal(m_lua_state, name.C()); - Var var(m_lua_state, -1); + Var var; var.Get(m_lua_state, -1); lua_pop(m_lua_state, 1); - return var.V(); + return var; } template T* GetPtr(String const &name) { lua_getglobal(m_lua_state, name.C()); - VarPtr var(m_lua_state, -1); + VarPtr var; var.Get(m_lua_state, -1); lua_pop(m_lua_state, 1); - return var.V(); + return var(); } protected: - Lolua::State* GetLuaState(); + LuaState* GetLuaState(); private: - Lolua::State* m_lua_state; + LuaState* m_lua_state; }; } /* namespace Lolua */ +typedef Lolua::Function LuaFunction; +typedef Lolua::Object LuaObject; +typedef Lolua::ObjectDef LuaObjectDef; +typedef Lolua::ObjectLib LuaObjectLib; +typedef Lolua::Loader LuaLoader; +typedef Lolua::Var LuaBool; +typedef Lolua::Var LuaCharPtr; +typedef Lolua::Var LuaString; +typedef Lolua::Var LuaDouble; +typedef Lolua::Var LuaFloat; +typedef Lolua::Var LuaInt64; +typedef Lolua::Var LuaInt32; +typedef Lolua::Var LuaUInt32; +typedef Lolua::Var LuaUInt64; +typedef Lolua::Var LuaVec2; +typedef Lolua::Var LuaVec3; +typedef Lolua::Var LuaVec4; +typedef Lolua::Stack LuaStack; + } /* namespace lol */ diff --git a/src/world.cpp b/src/world.cpp index 0075694b..65d146a9 100644 --- a/src/world.cpp +++ b/src/world.cpp @@ -35,7 +35,7 @@ World g_world; */ World::World() - : Lolua::Loader() + : LuaLoader() { g_world_data.m_lua_state = GetLuaState(); } diff --git a/src/world.h b/src/world.h index 541a9ffc..3ea00c6f 100644 --- a/src/world.h +++ b/src/world.h @@ -18,7 +18,7 @@ namespace lol { -class World : public Lolua::Loader +class World : public LuaLoader { public: World();