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

2nd pass on Lua integration. 

First pass on EzMesh integration (doesn't work yet)
undefined
Benjamin ‘Touky’ Huet Sam Hocevar <sam@hocevar.net> 10 years ago
parent
6155ee02e6
commit
8222295f3b
12 changed files with 1213 additions and 205 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +36
    -29
      doc/tutorial/14_lol_lua.cpp
  2. +9
    -1
      src/easymesh/easymesh.h
  3. +94
    -10
      src/easymesh/easymeshlua.cpp
  4. +624
    -99
      src/easymesh/easymeshlua.h
  5. +8
    -0
      src/easymesh/easymeshtransform.cpp
  6. +30
    -0
      src/image/color/color.cpp
  7. +1
    -0
      src/lol/extras.h
  8. +9
    -4
      src/lol/image/color.h
  9. +6
    -6
      src/lolua/baselua.cpp
  10. +394
    -54
      src/lolua/baselua.h
  11. +1
    -1
      src/world.cpp
  12. +1
    -1
      src/world.h

+ 36
- 29
doc/tutorial/14_lol_lua.cpp View File

@@ -19,12 +19,13 @@
using namespace lol;

//-----------------------------------------------------------------------------
class DemoObject : public Lolua::ObjectDef
class DemoObject : public LuaObjectDef
{
typedef Lolua::VarPtr<DemoObject> 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<int> 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<DemoObject> obj(l, 1);
Lolua::Var<float> 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<DemoObject> obj(l, 1);
Lolua::Var<int32_t> 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<DemoObject> obj(l, 1);
Lolua::Var<int32_t> 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<String> 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<DemoObject>(l);
LuaObject::Register<DemoObject>(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


+ 9
- 1
src/easymesh/easymesh.h View File

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


+ 94
- 10
src/easymesh/easymeshlua.cpp View File

@@ -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<EasyMeshLuaObject>(l);
LuaObject::Register<EasyMeshLuaObject>(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;
}


+ 624
- 99
src/easymesh/easymeshlua.h View File

@@ -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<EasyMeshLuaObject> 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; }
*/

};



+ 8
- 0
src/easymesh/easymeshtransform.cpp View File

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


+ 30
- 0
src/image/color/color.cpp View File

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


+ 1
- 0
src/lol/extras.h View File

@@ -53,6 +53,7 @@
#include <lol/../application/application.h>
#include <lol/../easymesh/csgbsp.h>
#include <lol/../easymesh/easymesh.h>
#include <lol/../easymesh/easymeshlua.h>

// Managers
#include <lol/../ticker.h>


+ 9
- 4
src/lol/image/color.h View File

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


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

@@ -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<char const*> 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<String> 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;
}


+ 394
- 54
src/lolua/baselua.h View File

@@ -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 <typename TLuaClass>
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 <typename TLuaClass>
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 <typename TLuaClass>
static int Del(State * l)
static int Del(LuaState * l)
{
VarPtr<TLuaClass> obj(l, 1);
ASSERT(obj.V());
delete obj.V();
VarPtr<TLuaClass> 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<T**>(luaL_checkudata(l, index, Object::GetMethodName<T>()));
T** obj = static_cast<T**>(luaL_checkudata(l, index++, Object::GetMethodName<T>()));
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<T**>(luaL_testudata(l, index, Object::GetMethodName<T>()));
T** obj = static_cast<T**>(luaL_testudata(l, index++, Object::GetMethodName<T>()));
m_value = obj ? *obj : nullptr;
}
};
@@ -295,14 +334,51 @@ template<typename T>
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<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; }
@@ -323,32 +399,277 @@ public:
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; }
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; }

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<String> ::InnerInit() { m_value = String(); }
template<> inline void Var<String> ::InnerGet(State* l, int index) { m_value = lua_tostring(l, index); }
template<> inline void Var<char const*>::InnerGet(State* l, int index) { m_value = lua_tostring(l, index); }
template<> inline void Var<double> ::InnerGet(State* l, int index) { m_value = lua_tonumber(l, index); }
template<> inline void Var<float> ::InnerGet(State* l, int index) { m_value = (float)lua_tonumber(l, index); }
template<> inline void Var<int32_t> ::InnerGet(State* l, int index) { m_value = (int32_t)lua_tointeger(l, index); }
template<> inline void Var<int64_t> ::InnerGet(State* l, int index) { m_value = lua_tointeger(l, index); }
template<> inline void Var<uint32_t> ::InnerGet(State* l, int index) { m_value = lua_tounsigned(l, index); }

template<> inline void Var<String> ::InnerPush(State* l) { lua_pushstring(l, m_value.C()); }
template<> inline void Var<char const*>::InnerPush(State* l) { lua_pushstring(l, m_value); }
template<> inline void Var<double> ::InnerPush(State* l) { lua_pushnumber(l, m_value); }
template<> inline void Var<float> ::InnerPush(State* l) { lua_pushnumber(l, m_value); }
template<> inline void Var<int32_t> ::InnerPush(State* l) { lua_pushinteger(l, m_value); }
template<> inline void Var<int64_t> ::InnerPush(State* l) { lua_pushinteger(l, m_value); }
template<> inline void Var<uint32_t> ::InnerPush(State* l) { lua_pushunsigned(l, m_value); }
template<> inline bool Var<bool>::InnerIsValid(LuaState* l, int index)
{
return lua_isboolean(l, index);
}
template<> inline void Var<bool>::InnerGet(LuaState* l, int& index)
{
m_value = !!lua_toboolean(l, index++);
}
template<> inline int Var<bool>::InnerPush(LuaState* l)
{
lua_pushboolean(l, m_value);
return 1;
}
//-----------------------------------------------------------------------------
template<> inline bool Var<char const*>::InnerIsValid(LuaState* l, int index)
{
return !!lua_isstring(l, index);
}
template<> inline void Var<char const*>::InnerGet(LuaState* l, int& index)
{
m_value = lua_tostring(l, index++);
}
template<> inline int Var<char const*>::InnerPush(LuaState* l)
{
lua_pushstring(l, m_value);
return 1;
}
//-----------------------------------------------------------------------------
template<> inline void Var<String>::InnerInit()
{
m_value = String();
}
template<> inline bool Var<String>::InnerIsValid(LuaState* l, int index)
{
Var<char const*> v;
return v.IsValid(l, index);
}
template<> inline void Var<String>::InnerGet(LuaState* l, int& index)
{
Var<char const*> v(l, index);
m_value = v();
}
template<> inline int Var<String>::InnerPush(LuaState* l)
{
Var<char const*> v;
v = m_value.C();
return v.Return(l);
}
//-----------------------------------------------------------------------------
template<> inline bool Var<double>::InnerIsValid(LuaState* l, int index)
{
return !!lua_isnumber(l, index);
}
template<> inline void Var<double>::InnerGet(LuaState* l, int& index)
{
m_value = lua_tonumber(l, index++);
}
template<> inline int Var<double>::InnerPush(LuaState* l)
{
lua_pushnumber(l, m_value);
return 1;
}
//-----------------------------------------------------------------------------
template<> inline bool Var<float>::InnerIsValid(LuaState* l, int index)
{
Var<double> v;
return v.IsValid(l, index);
}
template<> inline void Var<float>::InnerGet(LuaState* l, int& index)
{
Var<double> v(l, index);
m_value = (float)v();
}
template<> inline int Var<float>::InnerPush(LuaState* l)
{
Var<double> v = (double)m_value;
return v.Return(l);
}
//-----------------------------------------------------------------------------
template<> inline bool Var<int64_t>::InnerIsValid(LuaState* l, int index)
{
return !!lua_isnumber(l, index);
}
template<> inline void Var<int64_t>::InnerGet(LuaState* l, int& index)
{
m_value = lua_tointeger(l, index++);
}
template<> inline int Var<int64_t>::InnerPush(LuaState* l)
{
lua_pushinteger(l, m_value);
return 1;
}
//-----------------------------------------------------------------------------
template<> inline bool Var<int32_t>::InnerIsValid(LuaState* l, int index)
{
Var<int64_t> v;
return v.IsValid(l, index);
}
template<> inline void Var<int32_t>::InnerGet(LuaState* l, int& index)
{
Var<int64_t> v(l, index);
m_value = (int32_t)v();
}
template<> inline int Var<int32_t>::InnerPush(LuaState* l)
{
Var<int64_t> v = (int64_t)m_value;
return v.Return(l);
}
//-----------------------------------------------------------------------------
template<> inline bool Var<uint32_t>::InnerIsValid(LuaState* l, int index)
{
return !!lua_isnumber(l, index);
}
template<> inline void Var<uint32_t>::InnerGet(LuaState* l, int& index)
{
m_value = lua_tounsigned(l, index++);
}
template<> inline int Var<uint32_t>::InnerPush(LuaState* l)
{
lua_pushunsigned(l, m_value);
return 1;
}
//-----------------------------------------------------------------------------
template<> inline bool Var<uint64_t>::InnerIsValid(LuaState* l, int index)
{
Var<uint32_t> v;
return v.IsValid(l, index);
}
template<> inline void Var<uint64_t>::InnerGet(LuaState* l, int& index)
{
Var<uint32_t> v(l, index);
m_value = (uint64_t)v();
}
template<> inline int Var<uint64_t>::InnerPush(LuaState* l)
{
Var<uint32_t> v = (uint32_t)m_value;
return v.Return(l);
}
//-----------------------------------------------------------------------------
template<> inline bool Var<vec2>::InnerIsValid(LuaState* l, int index)
{
Var<float> x;
return x.IsValid(l, index);
}
template<> inline void Var<vec2>::InnerGet(LuaState* l, int& index)
{
Var<float> x(l, index);
Var<float> y(x(), true); y.Get(l, index);
m_value = vec2(x, y);
}
template<> inline int Var<vec2>::InnerPush(LuaState* 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(LuaState* l, int index)
{
Var<float> x;
return x.IsValid(l, index);
}
template<> inline void Var<vec3>::InnerGet(LuaState* l, int& index)
{
Var<float> x(l, index);
Var<float> y(x(), true); y.Get(l, index);
Var<float> z(x(), true); z.Get(l, index);
m_value = vec3(x, y, z);
}
template<> inline int Var<vec3>::InnerPush(LuaState* 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(LuaState* l, int index)
{
Var<float> x;
return x.IsValid(l, index);
}
template<> inline void Var<vec4>::InnerGet(LuaState* l, int& index)
{
Var<float> x(l, index);
Var<float> y(x(), true); y.Get(l, index);
Var<float> z(x(), true); z.Get(l, index);
Var<float> w(x(), true); w.Get(l, index);
m_value = vec4(x, y, z, w);
}
template<> inline int Var<vec4>::InnerPush(LuaState* 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));
}

//-----------------------------------------------------------------------------
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<typename T>
Stack& operator>>(Var<T>& var)
{
var = Var<T>(m_state, m_index);
return *this;
}
template<typename T>
Stack& operator>>(VarPtr<T>& var)
{
var = VarPtr<T>(m_state, m_index);
return *this;
}
template<typename T>
Stack& operator>>(VarPtrLight<T>& var)
{
var = VarPtrLight<T>(m_state, m_index);
return *this;
}

//-------------------------------------------------------------------------
template<typename T>
Stack& operator<<(Var<T>& var)
{
m_result += var.Return(m_state);
return *this;
}
template<typename T>
Stack& operator<<(VarPtr<T>& var)
{
m_result += var.Return(m_state);
return *this;
}
template<typename T>
Stack& operator<<(VarPtrLight<T>& 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<T> var(m_lua_state, -1);
Var<T> var; var.Get(m_lua_state, -1);
lua_pop(m_lua_state, 1);
return var.V();
return var;
}
template<typename T>
T* GetPtr(String const &name)
{
lua_getglobal(m_lua_state, name.C());
VarPtr<T> var(m_lua_state, -1);
VarPtr<T> 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<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::Stack LuaStack;

} /* namespace lol */

+ 1
- 1
src/world.cpp View File

@@ -35,7 +35,7 @@ World g_world;
*/

World::World()
: Lolua::Loader()
: LuaLoader()
{
g_world_data.m_lua_state = GetLuaState();
}


+ 1
- 1
src/world.h View File

@@ -18,7 +18,7 @@
namespace lol
{

class World : public Lolua::Loader
class World : public LuaLoader
{
public:
World();


Write Preview
Loading…
Cancel
Save