Changeset 3863


Ignore:
Timestamp:
Mar 11, 2015, 6:04:59 AM (7 years ago)
Author:
touky
Message:

2nd pass on Lua integration.
First pass on EzMesh integration (doesn't work yet)

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/doc/tutorial/14_lol_lua.cpp

    r3860 r3863  
    2020
    2121//-----------------------------------------------------------------------------
    22 class DemoObject : public Lolua::ObjectDef
    23 {
     22class DemoObject : public LuaObjectDef
     23{
     24    typedef Lolua::VarPtr<DemoObject> LuaDemoObjectPtr;
    2425public:
    25     DemoObject() : Lolua::ObjectDef() {}
     26    DemoObject() : LuaObjectDef() {}
    2627    virtual ~DemoObject() {}
    27     static DemoObject* New(Lolua::State* l, int arg_nb)
     28    static DemoObject* New(LuaState* l, int arg_nb)
    2829    {
    2930        UNUSED(l);
     
    3334
    3435    //-------------------------------------------------------------------------
    35     static int AddFive(Lolua::State* l)
    36     {
    37         Lolua::Var<int> i(l, 1);
     36    static int AddFive(LuaState* l)
     37    {
     38        LuaInt32 i; i.Get(l, 1);
    3839        i += 5;
    3940        return i.Return(l);
    4041    }
    41     static int AddTenInstance(Lolua::State* l)
    42     {
    43         Lolua::VarPtr<DemoObject> obj(l, 1);
    44         Lolua::Var<float> f(l, 2);
    45         f = obj.V()->AddTenMethod(f.V());
     42    static int AddTenInstance(LuaState* l)
     43    {
     44        LuaStack stack(l);
     45        LuaDemoObjectPtr obj;
     46        LuaFloat f;
     47        stack >> obj >> f;
     48        f = obj->AddTenMethod(f);
    4649        return f.Return(l);
    4750    }
     
    5154    }
    5255
    53     static int GetX(Lolua::State* l)
    54     {
    55         Lolua::VarPtr<DemoObject> obj(l, 1);
    56         Lolua::Var<int32_t> i;
    57         i = obj.V()->m_x;
    58         return i.Return(l);
    59     }
    60     static int SetX(Lolua::State* l)
    61     {
    62         Lolua::VarPtr<DemoObject> obj(l, 1);
    63         Lolua::Var<int32_t> i(l, 2);
    64         obj.V()->m_x = i.V();
     56    static int GetX(LuaState* l)
     57    {
     58        LuaStack stack(l);
     59        LuaDemoObjectPtr obj;
     60        LuaInt32 i;
     61        stack >> obj;
     62        i = obj->m_x;
     63        return stack << i;
     64    }
     65    static int SetX(LuaState* l)
     66    {
     67        LuaStack stack(l);
     68        LuaDemoObjectPtr obj;
     69        LuaInt32 i;
     70        stack >> obj >> i;
     71        obj->m_x = i;
    6572        return 0;
    6673    }
    6774
    6875    //-------------------------------------------------------------------------
    69     static const Lolua::ObjectLib* GetLib()
    70     {
    71         static const Lolua::ObjectLib lib = Lolua::ObjectLib(
     76    static const LuaObjectLib* GetLib()
     77    {
     78        static const LuaObjectLib lib = LuaObjectLib(
    7279            "LoluaDemo",
    7380            { { "AddFive", &DemoObject::AddFive } },
     
    8188
    8289//-----------------------------------------------------------------------------
    83 static int GlobalAddString(Lolua::State* l)
    84 {
    85     Lolua::Var<String> s(l, 1);
    86     s += "_added";
     90static int GlobalAddString(LuaState* l)
     91{
     92    LuaString s; s.Get(l, 1);
     93    s() += "_added";
    8794    return s.Return(l);
    8895}
    8996
    9097//-----------------------------------------------------------------------------
    91 class LoluaDemoLoader : public Lolua::Loader
     98class LoluaDemoLoader : public LuaLoader
    9299{
    93100public:
    94     LoluaDemoLoader() : Lolua::Loader()
    95     {
    96         Lolua::State* l = GetLuaState();
     101    LoluaDemoLoader() : LuaLoader()
     102    {
     103        LuaState* l = GetLuaState();
    97104
    98105        //Registering demo object
    99         Lolua::Object::Register<DemoObject>(l);
     106        LuaObject::Register<DemoObject>(l);
    100107
    101108        //Registering function
    102         Lolua::Function add_string(l, "GlobalAddString", &GlobalAddString);
     109        LuaFunction add_string(l, "GlobalAddString", &GlobalAddString);
    103110    }
    104111    virtual ~LoluaDemoLoader()
     
    108115    void TestStuff()
    109116    {
    110         Lolua::State* l = GetLuaState();
     117        LuaState* l = GetLuaState();
    111118
    112119        /*
  • trunk/src/easymesh/easymesh.h

    r3860 r3863  
    1717#include "easymeshrender.h"
    1818#include "easymeshbuild.h"
    19 #include "easymeshlua.h"
    2019
    2120namespace lol
     
    182181    //Mesh transform operations
    183182    //-------------------------------------------------------------------------
     183    /* See Translate */
     184    void TranslateX(float t);
     185    /* See Translate */
     186    void TranslateY(float t);
     187    /* See Translate */
     188    void TranslateZ(float t);
    184189    /* [cmd:t/tx/ty/tz] Translate vertices
    185190        - v : Translation quantity.
     
    264269     */
    265270    void Scale(float s);
     271    void ScaleX(float s);
     272    void ScaleY(float s);
     273    void ScaleZ(float s);
    266274    void Scale(vec3 const &s);
    267275    /* [cmd:m*] Mirror vertices through *-plane
  • trunk/src/easymesh/easymeshlua.cpp

    r3860 r3863  
    2323
    2424//-----------------------------------------------------------------------------
    25 EasyMeshLuaLoader::EasyMeshLuaLoader() : Lolua::Loader()
    26 {
    27     Lolua::State* l = GetLuaState();
     25EasyMeshLuaLoader::EasyMeshLuaLoader() : LuaLoader()
     26{
     27    LuaState* l = GetLuaState();
    2828
    2929    //Registering demo object
    30     Lolua::Object::Register<EasyMeshLuaObject>(l);
     30    LuaObject::Register<EasyMeshLuaObject>(l);
    3131}
    3232
     
    3838
    3939//-----------------------------------------------------------------------------
    40 EasyMeshLuaObject::EasyMeshLuaObject() : Lolua::ObjectDef()
     40EasyMeshLuaObject::EasyMeshLuaObject() : LuaObjectDef()
    4141{
    4242}
     
    4848
    4949//-----------------------------------------------------------------------------
    50 EasyMeshLuaObject* EasyMeshLuaObject::New(Lolua::State* l, int arg_nb)
     50EasyMeshLuaObject* EasyMeshLuaObject::New(LuaState* l, int arg_nb)
    5151{
    5252    UNUSED(l);
     
    5555}
    5656
    57 //-------------------------------------------------------------------------
    58 const Lolua::ObjectLib* EasyMeshLuaObject::GetLib()
    59 {
    60     static const Lolua::ObjectLib lib = Lolua::ObjectLib(
     57//-----------------------------------------------------------------------------
     58const LuaObjectLib* EasyMeshLuaObject::GetLib()
     59{
     60    static const LuaObjectLib lib = LuaObjectLib(
    6161        "EasyMesh",
    62         { { nullptr, nullptr } },
    63         { { nullptr, nullptr } },
     62        //Statics
     63        { /*{ nullptr, nullptr }*/ },
     64        //Methods
     65        {
     66            //-----------------------------------------------------------------
     67            { "AddCylinder", &AppendCylinder }, { "ac", &AppendCylinder },
     68            { "AddSphere", &AppendSphere }, { "asph", &AppendSphere },
     69            { "AddCapsule", &AppendCapsule }, { "acap", &AppendCapsule },
     70            { "AddTorus", &AppendTorus }, { "ato", &AppendTorus },
     71            { "AddBox", &AppendBox }, { "ab", &AppendBox },
     72            { "AddStar", &AppendStar }, { "as", &AppendStar },
     73            { "AddExpandedStar", &AppendExpandedStar }, { "aes", &AppendExpandedStar },
     74            { "AddDisc", &AppendDisc }, { "ad", &AppendDisc },
     75            { "AddTriangle", &AppendSimpleTriangle }, { "at", &AppendSimpleTriangle },
     76            { "AddQuad", &AppendSimpleQuad }, { "aq", &AppendSimpleQuad },
     77            { "AddCog", &AppendCog }, { "acog", &AppendCog },
     78            //-----------------------------------------------------------------
     79            { "setcolor", &SetCurColor }, { "sc", &SetCurColor },
     80            { "setcolora", &SetCurColorA }, { "sca", &SetCurColorA },
     81            { "setcolorb", &SetCurColorB }, { "scb", &SetCurColorB },
     82            { "setcolorv", &SetVertColor }, { "scv", &SetVertColor },
     83            //-----------------------------------------------------------------
     84            { "TranslateX", &TranslateX }, { "tx", &TranslateX },
     85            { "TranslateY", &TranslateY }, { "ty", &TranslateY },
     86            { "TranslateZ", &TranslateZ }, { "tz", &TranslateZ },
     87            { "Translate",  &Translate },  { "t",  &Translate },
     88            //-----------------------------------------------------------------
     89            { "RotateX", &RotateX }, { "rx", &RotateX },
     90            { "RotateY", &RotateY }, { "ry", &RotateY },
     91            { "RotateZ", &RotateZ }, { "rz", &RotateZ },
     92            { "Rotate",  &Rotate },  { "r",  &Rotate },
     93            //-----------------------------------------------------------------
     94            { "ScaleX", &ScaleX }, { "sx", &ScaleX },
     95            { "ScaleY", &ScaleY }, { "sy", &ScaleY },
     96            { "ScaleZ", &ScaleZ }, { "sz", &ScaleZ },
     97            { "Scale", &Scale }, { "s", &Scale },
     98            //-----------------------------------------------------------------
     99            { "RadialJitter", &RadialJitter }, { "rj", &RadialJitter },
     100            //-----------------------------------------------------------------
     101            { "TaperX", &TaperX }, { "tax", &TaperX },
     102            { "TaperY", &TaperY }, { "tay", &TaperY },
     103            { "TaperZ", &TaperZ }, { "taz", &TaperZ },
     104            //-----------------------------------------------------------------
     105            { "TwistX", &TwistX }, { "twx", &TwistX },
     106            { "TwistY", &TwistY }, { "twy", &TwistY },
     107            { "TwistZ", &TwistZ }, { "twz", &TwistZ },
     108            //-----------------------------------------------------------------
     109            { "ShearX", &ShearX }, { "shx", &ShearX },
     110            { "ShearY", &ShearY }, { "shy", &ShearY },
     111            { "ShearZ", &ShearZ }, { "shz", &ShearZ },
     112            //-----------------------------------------------------------------
     113            { "StretchX", &StretchX }, { "stx", &StretchX },
     114            { "StretchY", &StretchY }, { "sty", &StretchY },
     115            { "StretchZ", &StretchZ }, { "stz", &StretchZ },
     116            //-----------------------------------------------------------------
     117            { "BendXY", &BendXY }, { "bdxy", &BendXY },
     118            { "BendXZ", &BendXZ }, { "bdxz", &BendXZ },
     119            { "BendYX", &BendYX }, { "bdyx", &BendYX },
     120            { "BendYZ", &BendYZ }, { "bdyz", &BendYZ },
     121            { "BendZX", &BendZX }, { "bdzx", &BendZX },
     122            { "BendZY", &BendZY }, { "bdzy", &BendZY },
     123            //-----------------------------------------------------------------
     124            { "MirrorX", &MirrorX }, { "mx", &MirrorX },
     125            { "MirrorY", &MirrorY }, { "my", &MirrorY },
     126            { "MirrorZ", &MirrorZ }, { "mz", &MirrorZ },
     127            //-----------------------------------------------------------------
     128            { "Loop", &LoopStart }, { "lp", &LoopStart },
     129            { "LoopDo", &LoopEnd }, { "ld", &LoopEnd },
     130            { "BraceOpen", &OpenBrace }, { "bop", &OpenBrace },
     131            { "BraceClose", &CloseBrace }, { "bcl", &CloseBrace },
     132            //-----------------------------------------------------------------
     133            { "VerticeMerge", &VerticesMerge }, { "vm", &VerticesMerge },
     134            { "VerticeSeparate", &VerticesSeparate }, { "vs", &VerticesSeparate },
     135            //-----------------------------------------------------------------
     136            { "Duplicate", &Duplicate }, { "dup", &Duplicate },
     137            { "Smooth", &Smooth }, { "smth", &Smooth },
     138            { "SplitTriangles", &SplitTriangles }, { "splt", &SplitTriangles },
     139            { "Chamfer", &Chamfer }, { "cf", &Chamfer },
     140            //-----------------------------------------------------------------
     141            { "ToggleScaleWinding", &ToggleScaleWinding }, { "tsw", &ToggleScaleWinding },
     142            { "ToggleQuadWeighting", &ToggleQuadWeighting }, { "tqw", &ToggleQuadWeighting },
     143            { "TogglePostBuildNormal", &TogglePostBuildNormal }, { "tpbn", &TogglePostBuildNormal },
     144            { "ToggleVerticeNoCleanup", &ToggleVerticeNoCleanup }, { "tvnc", &ToggleVerticeNoCleanup },
     145            //-----------------------------------------------------------------
     146        },
     147        //Variables
    64148        { { nullptr, nullptr, nullptr } });
    65149    return &lib;
  • trunk/src/easymesh/easymeshlua.h

    r3860 r3863  
    1717
    1818//-----------------------------------------------------------------------------
    19 class EasyMeshLuaLoader : public Lolua::Loader
     19class EasyMeshLuaLoader : public LuaLoader
    2020{
    2121public:
     
    2525   
    2626//-----------------------------------------------------------------------------
    27 class EasyMeshLuaObject : public Lolua::ObjectDef
     27class EasyMeshLuaObject : public LuaObjectDef
    2828{
     29    typedef Lolua::VarPtr<EasyMeshLuaObject> EzMeshPtr;
     30    EasyMesh m_instance;
    2931public:
    3032    //-------------------------------------------------------------------------
     
    3335
    3436    //-------------------------------------------------------------------------
    35     static EasyMeshLuaObject* New(Lolua::State* l, int arg_nb);
    36     static const Lolua::ObjectLib* GetLib();
     37    static EasyMeshLuaObject* New(LuaState* l, int arg_nb);
     38    static const LuaObjectLib* GetLib();
    3739
    3840    //-------------------------------------------------------------------------
     41    static int AppendCylinder(LuaState* l)
     42    {
     43        LuaStack s(l);
     44        EzMeshPtr m;
     45        LuaInt32 nsides;
     46        LuaFloat h, d1, d2;
     47        LuaBool dualside(false, true), smooth(false, true), close(false, true);
     48        s >> m >> nsides >> h >> d1 >> d2 >> dualside >> smooth >> close;
     49        m->m_instance.AppendCylinder(nsides, h, d1, d2, dualside, smooth, close);
     50        return 0;
     51    }
     52    static int AppendSphere(LuaState* l)
     53    {
     54        LuaStack s(l);
     55        EzMeshPtr m;
     56        LuaInt32 ndivisions;
     57        LuaFloat d;
     58        s >> m >> ndivisions >> d;
     59        m->m_instance.AppendSphere(ndivisions, d);
     60        return 0;
     61    }
     62    static int AppendCapsule(LuaState* l)
     63    {
     64        LuaStack s(l);
     65        EzMeshPtr m;
     66        LuaInt32 ndivisions;
     67        LuaFloat h, d;
     68        s >> m >> ndivisions >> h >> d;
     69        m->m_instance.AppendCapsule(ndivisions, h, d);
     70        return 0;
     71    }
     72    static int AppendTorus(LuaState* l)
     73    {
     74        LuaStack s(l);
     75        EzMeshPtr m;
     76        LuaInt32 ndivisions;
     77        LuaFloat d1, d2;
     78        s >> m >> ndivisions >> d1 >> d2;
     79        m->m_instance.AppendTorus(ndivisions, d1, d2);
     80        return 0;
     81    }
     82    static int AppendBox(LuaState* l)
     83    {
     84        LuaStack s(l);
     85        EzMeshPtr m;
     86        LuaVec3 size;
     87        LuaFloat chamf(0.f, true);
     88        LuaBool smooth(false, true);
     89        s >> m >> size >> chamf >> smooth;
     90        m->m_instance.AppendBox(size, chamf, smooth);
     91        return 0;
     92    }
     93    static int AppendStar(LuaState* l)
     94    {
     95        LuaStack s(l);
     96        EzMeshPtr m;
     97        LuaInt32 nbranches;
     98        LuaFloat d1, d2;
     99        LuaBool fade(false, true), fade2(false, true);
     100        s >> m >> nbranches >> d1 >> d2 >> fade >> fade2;
     101        m->m_instance.AppendStar(nbranches, d1, d2, fade, fade2);
     102        return 0;
     103    }
     104    static int AppendExpandedStar(LuaState* l)
     105    {
     106        LuaStack s(l);
     107        EzMeshPtr m;
     108        LuaInt32 nbranches;
     109        LuaFloat d1, d2, extrad(0.f, true);
     110        s >> m >> nbranches >> d1 >> d2 >> extrad;
     111        m->m_instance.AppendExpandedStar(nbranches, d1, d2, extrad);
     112        return 0;
     113    }
     114    static int AppendDisc(LuaState* l)
     115    {
     116        LuaStack s(l);
     117        EzMeshPtr m;
     118        LuaInt32 nsides;
     119        LuaFloat d;
     120        LuaBool fade(false, true);
     121        s >> m >> nsides >> d >> fade;
     122        m->m_instance.AppendDisc(nsides, d, fade);
     123        return 0;
     124    }
     125    static int AppendSimpleTriangle(LuaState* l)
     126    {
     127        LuaStack s(l);
     128        EzMeshPtr m;
     129        LuaFloat d;
     130        LuaBool fade(false, true);
     131        s >> m >> d >> fade;
     132        m->m_instance.AppendSimpleTriangle(d, fade);
     133        return 0;
     134    }
     135    static int AppendSimpleQuad(LuaState* l)
     136    {
     137        LuaStack s(l);
     138        EzMeshPtr m;
     139        LuaFloat size;
     140        LuaBool fade(false, true);
     141        s >> m >> size >> fade;
     142        m->m_instance.AppendSimpleQuad(size, fade);
     143        return 0;
     144    }
     145    static int AppendCog(LuaState* l)
     146    {
     147        LuaStack s(l);
     148        EzMeshPtr m;
     149        LuaInt32 nbsides;
     150        LuaFloat h, sidemul(0.f, true);
     151        LuaVec2 d0, d1, d2;
     152        LuaBool offset(false, true);
     153        s >> m >> nbsides >> h >> d0 >> d1 >> d2 >> sidemul >> offset;
     154        m->m_instance.AppendCog(nbsides, h, d0().x, d0().y, d1().x, d1().y, d2().x, d2().y, sidemul, offset);
     155        return 0;
     156    }
     157    //-------------------------------------------------------------------------
     158    static int TranslateX(LuaState* l)
     159    {
     160        LuaStack s(l);
     161        EzMeshPtr m;
     162        LuaFloat f;
     163        s >> m >> f;
     164        m->m_instance.TranslateX(f);
     165        return 0;
     166    }
     167    static int TranslateY(LuaState* l)
     168    {
     169        LuaStack s(l);
     170        EzMeshPtr m;
     171        LuaFloat f;
     172        s >> m >> f;
     173        m->m_instance.TranslateY(f);
     174        return 0;
     175    }
     176    static int TranslateZ(LuaState* l)
     177    {
     178        LuaStack s(l);
     179        EzMeshPtr m;
     180        LuaFloat f;
     181        s >> m >> f;
     182        m->m_instance.TranslateZ(f);
     183        return 0;
     184    }
     185    static int Translate(LuaState* l)
     186    {
     187        LuaStack s(l);
     188        EzMeshPtr m;
     189        LuaVec3 v;
     190        s >> m >> v;
     191        m->m_instance.Translate(v);
     192        return 0;
     193    }
     194    //-------------------------------------------------------------------------
     195    static int RotateX(LuaState* l)
     196    {
     197        LuaStack s(l);
     198        EzMeshPtr m;
     199        LuaFloat a;
     200        s >> m >> a;
     201        m->m_instance.RotateX(a);
     202        return 0;
     203    }
     204    static int RotateY(LuaState* l)
     205    {
     206        LuaStack s(l);
     207        EzMeshPtr m;
     208        LuaFloat a;
     209        s >> m >> a;
     210        m->m_instance.RotateY(a);
     211        return 0;
     212    }
     213    static int RotateZ(LuaState* l)
     214    {
     215        LuaStack s(l);
     216        EzMeshPtr m;
     217        LuaFloat a;
     218        s >> m >> a;
     219        m->m_instance.RotateZ(a);
     220        return 0;
     221    }
     222    static int Rotate(LuaState* l)
     223    {
     224        LuaStack s(l);
     225        EzMeshPtr m;
     226        LuaFloat a;
     227        LuaVec3 v;
     228        s >> m >> a >> v;
     229        m->m_instance.Rotate(a, v);
     230        return 0;
     231    }
     232    //-------------------------------------------------------------------------
     233    static int ScaleX(LuaState* l)
     234    {
     235        LuaStack s(l);
     236        EzMeshPtr m;
     237        LuaFloat x;
     238        s >> m >> x;
     239        m->m_instance.ScaleX(x);
     240        return 0;
     241    }
     242    static int ScaleY(LuaState* l)
     243    {
     244        LuaStack s(l);
     245        EzMeshPtr m;
     246        LuaFloat y;
     247        s >> m >> y;
     248        m->m_instance.ScaleY(y);
     249        return 0;
     250    }
     251    static int ScaleZ(LuaState* l)
     252    {
     253        LuaStack s(l);
     254        EzMeshPtr m;
     255        LuaFloat z;
     256        s >> m >> z;
     257        m->m_instance.ScaleZ(z);
     258        return 0;
     259    }
     260    static int Scale(LuaState* l)
     261    {
     262        LuaStack s(l);
     263        EzMeshPtr m;
     264        LuaVec3 v;
     265        s >> m >> v;
     266        m->m_instance.Scale(v);
     267        return 0;
     268    }
     269    //-------------------------------------------------------------------------
     270    static int RadialJitter(LuaState* l)
     271    {
     272        LuaStack s(l);
     273        EzMeshPtr m;
     274        LuaFloat f;
     275        s >> m >> f;
     276        m->m_instance.RadialJitter(f);
     277        return 0;
     278    }
     279    //-------------------------------------------------------------------------
     280    static int TaperX(LuaState* l)
     281    {
     282        LuaStack s(l);
     283        EzMeshPtr m;
     284        LuaFloat y, z, xoff(0.f, true);
     285        LuaBool abs(true, true);
     286        s >> m >> y >> z >> xoff >> abs;
     287        m->m_instance.TaperX(y, z, xoff, abs);
     288        return 0;
     289    }
     290    static int TaperY(LuaState* l)
     291    {
     292        LuaStack s(l);
     293        EzMeshPtr m;
     294        LuaFloat x, z, yoff(0.f, true);
     295        LuaBool abs(true, true);
     296        s >> m >> x >> z >> yoff >> abs;
     297        m->m_instance.TaperY(x, z, yoff, abs);
     298        return 0;
     299    }
     300    static int TaperZ(LuaState* l)
     301    {
     302        LuaStack s(l);
     303        EzMeshPtr m;
     304        LuaFloat x, y, zoff(0.f, true);
     305        LuaBool abs(true, true);
     306        s >> m >> x >> y >> zoff >> abs;
     307        m->m_instance.TaperZ(x, y, zoff, abs);
     308        return 0;
     309    }
     310    //-------------------------------------------------------------------------
     311    static int TwistX(LuaState* l)
     312    {
     313        LuaStack s(l);
     314        EzMeshPtr m;
     315        LuaFloat t, toff(0.f, true);
     316        s >> m >> t >> toff;
     317        m->m_instance.TwistX(t, toff);
     318        return 0;
     319    }
     320    static int TwistY(LuaState* l)
     321    {
     322        LuaStack s(l);
     323        EzMeshPtr m;
     324        LuaFloat t, toff(0.f, true);
     325        s >> m >> t >> toff;
     326        m->m_instance.TwistY(t, toff);
     327        return 0;
     328    }
     329    static int TwistZ(LuaState* l)
     330    {
     331        LuaStack s(l);
     332        EzMeshPtr m;
     333        LuaFloat t, toff(0.f, true);
     334        s >> m >> t >> toff;
     335        m->m_instance.TwistZ(t, toff);
     336        return 0;
     337    }
     338    //-------------------------------------------------------------------------
     339    static int ShearX(LuaState* l)
     340    {
     341        LuaStack s(l);
     342        EzMeshPtr m;
     343        LuaFloat y, z, xoff(0.f, true);
     344        LuaBool abs(true, true);
     345        s >> m >> y >> z >> xoff >> abs;
     346        m->m_instance.ShearX(y, z, xoff, abs);
     347        return 0;
     348    }
     349    static int ShearY(LuaState* l)
     350    {
     351        LuaStack s(l);
     352        EzMeshPtr m;
     353        LuaFloat x, z, yoff(0.f, true);
     354        LuaBool abs(true, true);
     355        s >> m >> x >> z >> yoff >> abs;
     356        m->m_instance.ShearY(x, z, yoff, abs);
     357        return 0;
     358    }
     359    static int ShearZ(LuaState* l)
     360    {
     361        LuaStack s(l);
     362        EzMeshPtr m;
     363        LuaFloat x, y, zoff(0.f, true);
     364        LuaBool abs(true, true);
     365        s >> m >> x >> y >> zoff >> abs;
     366        m->m_instance.ShearZ(x, y, zoff, abs);
     367        return 0;
     368    }
     369    //-------------------------------------------------------------------------
     370    static int StretchX(LuaState* l)
     371    {
     372        LuaStack s(l);
     373        EzMeshPtr m;
     374        LuaFloat y, z, xoff(0.f, true);
     375        s >> m >> y >> z >> xoff;
     376        m->m_instance.StretchX(y, z, xoff);
     377        return 0;
     378    }
     379    static int StretchY(LuaState* l)
     380    {
     381        LuaStack s(l);
     382        EzMeshPtr m;
     383        LuaFloat x, z, yoff(0.f, true);
     384        s >> m >> x >> z >> yoff;
     385        m->m_instance.StretchY(x, z, yoff);
     386        return 0;
     387    }
     388    static int StretchZ(LuaState* l)
     389    {
     390        LuaStack s(l);
     391        EzMeshPtr m;
     392        LuaFloat x, y, zoff(0.f, true);
     393        s >> m >> x >> y >> zoff;
     394        m->m_instance.StretchZ(x, y, zoff);
     395        return 0;
     396    }
     397    //-------------------------------------------------------------------------
     398    static int BendXY(LuaState* l)
     399    {
     400        LuaStack s(l);
     401        EzMeshPtr m;
     402        LuaFloat t, toff(0.f, true);
     403        s >> m >> t >> toff;
     404        m->m_instance.BendXY(t, toff);
     405        return 0;
     406    }
     407    static int BendXZ(LuaState* l)
     408    {
     409        LuaStack s(l);
     410        EzMeshPtr m;
     411        LuaFloat t, toff(0.f, true);
     412        s >> m >> t >> toff;
     413        m->m_instance.BendXZ(t, toff);
     414        return 0;
     415    }
     416    static int BendYX(LuaState* l)
     417    {
     418        LuaStack s(l);
     419        EzMeshPtr m;
     420        LuaFloat t, toff(0.f, true);
     421        s >> m >> t >> toff;
     422        m->m_instance.BendYX(t, toff);
     423        return 0;
     424    }
     425    static int BendYZ(LuaState* l)
     426    {
     427        LuaStack s(l);
     428        EzMeshPtr m;
     429        LuaFloat t, toff(0.f, true);
     430        s >> m >> t >> toff;
     431        m->m_instance.BendYZ(t, toff);
     432        return 0;
     433    }
     434    static int BendZX(LuaState* l)
     435    {
     436        LuaStack s(l);
     437        EzMeshPtr m;
     438        LuaFloat t, toff(0.f, true);
     439        s >> m >> t >> toff;
     440        m->m_instance.BendZX(t, toff);
     441        return 0;
     442    }
     443    static int BendZY(LuaState* l)
     444    {
     445        LuaStack s(l);
     446        EzMeshPtr m;
     447        LuaFloat t, toff(0.f, true);
     448        s >> m >> t >> toff;
     449        m->m_instance.BendZY(t, toff);
     450        return 0;
     451    }
     452    //-------------------------------------------------------------------------
     453    static int MirrorX(LuaState* l)
     454    {
     455        LuaStack s(l);
     456        EzMeshPtr m;
     457        s >> m;
     458        m->m_instance.MirrorX();
     459        return 0;
     460    }
     461    static int MirrorY(LuaState* l)
     462    {
     463        LuaStack s(l);
     464        EzMeshPtr m;
     465        s >> m;
     466        m->m_instance.MirrorY();
     467        return 0;
     468    }
     469    static int MirrorZ(LuaState* l)
     470    {
     471        LuaStack s(l);
     472        EzMeshPtr m;
     473        s >> m;
     474        m->m_instance.MirrorZ();
     475        return 0;
     476    }
     477    //-------------------------------------------------------------------------
     478    static int LoopStart(LuaState* l)
     479    {
     480        LuaStack s(l);
     481        EzMeshPtr m;
     482        LuaInt32 loopnb;
     483        s >> m >> loopnb;
     484        m->m_instance.LoopStart(loopnb);
     485        return 0;
     486    }
     487    static int LoopEnd(LuaState* l)
     488    {
     489        LuaStack s(l);
     490        EzMeshPtr m;
     491        s >> m;
     492        m->m_instance.LoopEnd();
     493        return 0;
     494    }
     495    static int OpenBrace(LuaState* l)
     496    {
     497        LuaStack s(l);
     498        EzMeshPtr m;
     499        s >> m;
     500        m->m_instance.OpenBrace();
     501        return 0;
     502    }
     503    static int CloseBrace(LuaState* l)
     504    {
     505        LuaStack s(l);
     506        EzMeshPtr m;
     507        s >> m;
     508        m->m_instance.CloseBrace();
     509        return 0;
     510    }
     511    //-------------------------------------------------------------------------
     512    static int ToggleScaleWinding(LuaState* l)
     513    {
     514        LuaStack s(l);
     515        EzMeshPtr m;
     516        s >> m;
     517        m->m_instance.ToggleScaleWinding();
     518        return 0;
     519    }
     520    static int ToggleQuadWeighting(LuaState* l)
     521    {
     522        LuaStack s(l);
     523        EzMeshPtr m;
     524        s >> m;
     525        m->m_instance.ToggleQuadWeighting();
     526        return 0;
     527    }
     528    static int TogglePostBuildNormal(LuaState* l)
     529    {
     530        LuaStack s(l);
     531        EzMeshPtr m;
     532        s >> m;
     533        m->m_instance.TogglePostBuildNormal();
     534        return 0;
     535    }
     536    static int ToggleVerticeNoCleanup(LuaState* l)
     537    {
     538        LuaStack s(l);
     539        EzMeshPtr m;
     540        s >> m;
     541        m->m_instance.ToggleVerticeNoCleanup();
     542        return 0;
     543    }
     544    //-------------------------------------------------------------------------
     545    static int VerticesMerge(LuaState* l)
     546    {
     547        LuaStack s(l);
     548        EzMeshPtr m;
     549        s >> m;
     550        m->m_instance.VerticesMerge();
     551        return 0;
     552    }
     553    static int VerticesSeparate(LuaState* l)
     554    {
     555        LuaStack s(l);
     556        EzMeshPtr m;
     557        s >> m;
     558        m->m_instance.VerticesSeparate();
     559        return 0;
     560    }
     561    //-------------------------------------------------------------------------
     562    static int Duplicate(LuaState* l)
     563    {
     564        LuaStack s(l);
     565        EzMeshPtr m;
     566        LuaVec3 ds(vec3(1.f));
     567        s >> m >> ds;
     568        m->m_instance.DupAndScale(ds, true);
     569        return 0;
     570    }
     571    static int Smooth(LuaState* l)
     572    {
     573        LuaStack s(l);
     574        EzMeshPtr m;
     575        LuaInt32 pass, split_per_pass, smooth_per_pass;
     576        s >> m >> pass >> split_per_pass >> smooth_per_pass;
     577        m->m_instance.SmoothMesh(pass, split_per_pass, smooth_per_pass);
     578        return 0;
     579    }
     580    static int SplitTriangles(LuaState* l)
     581    {
     582        LuaStack s(l);
     583        EzMeshPtr m;
     584        LuaInt32 pass;
     585        s >> m >> pass;
     586        m->m_instance.SplitTriangles(pass);
     587        return 0;
     588    }
     589    static int Chamfer(LuaState* l)
     590    {
     591        LuaStack s(l);
     592        EzMeshPtr m;
     593        LuaFloat f;
     594        s >> m >> f;
     595        m->m_instance.Chamfer(f);
     596        return 0;
     597    }
     598    //-------------------------------------------------------------------------
     599    static int SetCurColor(LuaState* l)
     600    {
     601        LuaStack s(l);
     602        EzMeshPtr m;
     603        s >> m;
     604        LuaVec4 c;
     605        if (s.GetArgs() == 1 && !c.IsValid(l, 2))
     606        {
     607            LuaString str;
     608            s >> str;
     609            c = Color::C8BppHexString(str);
     610        }
     611        m->m_instance.SetCurColor(c);
     612        return 0;
     613    }
     614    static int SetCurColorA(LuaState* l)
     615    {
     616        LuaStack s(l);
     617        EzMeshPtr m;
     618        s >> m;
     619        LuaVec4 c;
     620        if (s.GetArgs() == 1 && !c.IsValid(l, 2))
     621        {
     622            LuaString str;
     623            s >> str;
     624            c = Color::C8BppHexString(str);
     625        }
     626        m->m_instance.SetCurColorA(c);
     627        return 0;
     628    }
     629    static int SetCurColorB(LuaState* l)
     630    {
     631        LuaStack s(l);
     632        EzMeshPtr m;
     633        s >> m;
     634        LuaVec4 c;
     635        if (s.GetArgs() == 1 && !c.IsValid(l, 2))
     636        {
     637            LuaString str;
     638            s >> str;
     639            c = Color::C8BppHexString(str);
     640        }
     641        m->m_instance.SetCurColorB(c);
     642        return 0;
     643    }
     644    static int SetVertColor(LuaState* l)
     645    {
     646        LuaStack s(l);
     647        EzMeshPtr m;
     648        s >> m;
     649        LuaVec4 c;
     650        if (s.GetArgs() == 1 && !c.IsValid(l, 2))
     651        {
     652            LuaString str;
     653            s >> str;
     654            c = Color::C8BppHexString(str);
     655        }
     656        m->m_instance.SetVertColor(c);
     657        return 0;
     658    }
    39659    /*
    40 
    41660    (csgu|csgunion)          { return token::T_CSGUNION; }
    42661    (csgs|CsgSub)            { return token::T_CSGSUBSTRACT; }
     
    44663    (csga|csgand)            { return token::T_CSGAND; }
    45664    (csgx|csgxor)            { return token::T_CSGXOR; }
    46 
    47     (lp|loop)                { return token::T_LOOP; }
    48     (sc|setcolor)            { return token::T_COLOR; }
    49     (sca|setcolora)          { return token::T_ACOLOR; }
    50     (scb|setcolorb)          { return token::T_BCOLOR; }
    51     (scv|setcolorv)          { return token::T_VCOLOR; }
    52 
    53     (tsw|tglscalewind)       { return token::T_TOGGLESCALEWINDING; }
    54     (tqw|tglquadweight)      { return token::T_TOGGLEQUADWEIGHTING; }
    55     (tpbn|tglpstbuildnormal) { return token::T_TOGGLEPOSTBUILDNORMAL; }
    56     (tvnc|tglvertnocleanup)  { return token::T_TOGGLEVERTNOCLEANUP; }
    57 
    58     (vm|vertmerge)           { return token::T_VERTMERGE; }
    59     (vs|vertseparate)        { return token::T_VERTSEPARATE; }
    60 
    61     (tx|translatex)          { return token::T_TRANSLATEX; }
    62     (ty|translatey)          { return token::T_TRANSLATEY; }
    63     (tz|translatez)          { return token::T_TRANSLATEZ; }
    64     (t|translate)            { return token::T_TRANSLATE; }
    65     (rx|rotatex)             { return token::T_ROTATEX; }
    66     (ry|rotatey)             { return token::T_ROTATEY; }
    67     (rz|rotatez)             { return token::T_ROTATEZ; }
    68     (r|rotate)               { return token::T_ROTATE; }
    69     (rj|radialjitter)        { return token::T_RADIALJITTER; }
    70     (tax|taperx)             { return token::T_TAPERX; }
    71     (tay|tapery)             { return token::T_TAPERY; }
    72     (taz|taperz)             { return token::T_TAPERZ; }
    73     (twx|twistx)             { return token::T_TWISTX; }
    74     (twy|twisty)             { return token::T_TWISTY; }
    75     (twz|twistz)             { return token::T_TWISTZ; }
    76     (shx|shearx)             { return token::T_SHEARX; }
    77     (shy|sheary)             { return token::T_SHEARY; }
    78     (shz|shearz)             { return token::T_SHEARZ; }
    79     (stx|stretchx)           { return token::T_STRETCHX; }
    80     (sty|stretchy)           { return token::T_STRETCHY; }
    81     (stz|stretchz)           { return token::T_STRETCHZ; }
    82     (bdxy|bendxy)            { return token::T_BENDXY; }
    83     (bdxz|bendxz)            { return token::T_BENDXZ; }
    84     (bdyx|bendyx)            { return token::T_BENDYX; }
    85     (bdyz|bendyz)            { return token::T_BENDYZ; }
    86     (bdzx|bendzx)            { return token::T_BENDZX; }
    87     (bdzy|bendzy)            { return token::T_BENDZY; }
    88     (sx|scalex)              { return token::T_SCALEX; }
    89     (sy|scaley)              { return token::T_SCALEY; }
    90     (sz|scalez)              { return token::T_SCALEZ; }
    91     (s|scale)                { return token::T_SCALE; }
    92     (mx|mirrorx)             { return token::T_MIRRORX; }
    93     (my|mirrory)             { return token::T_MIRRORY; }
    94     (mz|mirrorz)             { return token::T_MIRRORZ; }
    95     (ch|chamfer)             { return token::T_CHAMFER; }
    96     (splt|splittriangle)     { return token::T_SPLITTRIANGLE; }
    97     (smth|smooth)            { return token::T_SMOOTHMESH; }
    98     (dup|duplicate)          { return token::T_DUPLICATE; }
    99 
    100     (ac|addcylinder)         { return token::T_CYLINDER; }
    101     (asph|addsphere)         { return token::T_SPHERE; }
    102     (acap|addcapsule)        { return token::T_CAPSULE; }
    103     (ato|addtorus)           { return token::T_TORUS; }
    104     (ab|addbox)              { return token::T_BOX; }
    105     (ascb|addsmoothchamfbox) { return token::T_SMOOTHCHAMFBOX; }
    106     (afcb|addflatchamfbox)   { return token::T_FLATCHAMFBOX; }
    107     (as|addstar)             { return token::T_STAR; }
    108     (aes|addexpandedstar)    { return token::T_EXPANDEDSTAR; }
    109     (ad|adddisc)             { return token::T_DISC; }
    110     (at|addtriangle)         { return token::T_TRIANGLE; }
    111     (aq|addquad)             { return token::T_QUAD; }
    112     (acg|addcog)             { return token::T_COG; }
    113665    */
    114     /*
    115 
    116     %{ *//* =======  BASE COLOR TYPES  ========================================= *//* %
    117 }
    118 %{ *//* COLOR *//* %}
    119 #[0-9a-fA-F]{3} {
    120 uint32_t tmp = std::strtol(yytext + 1, nullptr, 16);
    121 yylval->u32val = 0x11000000u * (tmp >> 8)
    122 | 0x00110000u * ((tmp >> 4) & 0xf)
    123 | 0x00001100u * (tmp & 0xf)
    124 | 0x000000ffu;
    125 return token::COLOR; }
    126 #[0-9a-fA-F]{4} {
    127 uint32_t tmp = std::strtol(yytext + 1, nullptr, 16);
    128 yylval->u32val = 0x11000000u * (tmp >> 12)
    129 | 0x00110000u * ((tmp >> 8) & 0xf)
    130 | 0x00001100u * ((tmp >> 4) & 0xf)
    131 | 0x00000011u * (tmp & 0xf);
    132 return token::COLOR; }
    133 #[0-9a-fA-F]{6} {
    134 yylval->u32val = 0xffu
    135 | 0x100u * (uint32_t)std::strtol(yytext + 1, nullptr, 16);
    136 return token::COLOR; }
    137 #[0-9a-fA-F]{8} {
    138 yylval->u32val = (uint32_t)std::strtol(yytext + 1, nullptr, 16);
    139 return token::COLOR; }
    140 */
    141666
    142667};
  • trunk/src/easymesh/easymeshtransform.cpp

    r3860 r3863  
    1717
    1818//-----------------------------------------------------------------------------
     19void EasyMesh::TranslateX(float t) { Translate(vec3(t, 0.f, 0.f)); }
     20void EasyMesh::TranslateY(float t) { Translate(vec3(0.f, t, 0.f)); }
     21void EasyMesh::TranslateZ(float t) { Translate(vec3(0.f, 0.f, t)); }
     22
     23//-----------------------------------------------------------------------------
    1924void EasyMesh::Translate(vec3 const &v)
    2025{
     
    189194//-----------------------------------------------------------------------------
    190195void EasyMesh::Scale(float s) { Scale(vec3(s)); }
     196void EasyMesh::ScaleX(float s) { Scale(vec3(s, 0.f, 0.f)); }
     197void EasyMesh::ScaleY(float s) { Scale(vec3(0.f, s, 0.f)); }
     198void EasyMesh::ScaleZ(float s) { Scale(vec3(0.f, 0.f, s)); }
    191199void EasyMesh::Scale(vec3 const &s)
    192200{
  • trunk/src/image/color/color.cpp

    r3602 r3863  
    5656}
    5757
     58/*
     59* Conversion from colours to hexadecimal
     60*/
     61vec4 Color::C8BppHexString(String s)
     62{
     63    String c = s[0] == '#' ? &s[1] : s;
     64    uint32_t tmp = std::strtol(c.C(), nullptr, 16);
     65    if (c.Count() == 3)
     66    {
     67        tmp = 0x11000000u * (tmp >> 8)
     68            | 0x00110000u * ((tmp >> 4) & 0xf)
     69            | 0x00001100u * (tmp & 0xf)
     70            | 0x000000ffu;
     71    }
     72    else if (c.Count() == 4)
     73    {
     74        tmp = 0x11000000u * (tmp >> 12)
     75            | 0x00110000u * ((tmp >> 8) & 0xf)
     76            | 0x00001100u * ((tmp >> 4) & 0xf)
     77            | 0x00000011u * (tmp & 0xf);
     78    }
     79    else if (c.Count() == 6)
     80    {
     81        tmp = 0xffu | 0x100u * tmp;
     82    }
     83    vec4 color(0.f);
     84    ivec4 v(tmp >> 24, (tmp >> 16) & 0xff, (tmp >> 8) & 0xff, tmp & 0xff);
     85    return vec4(v) * (1.f / 255.f);
     86}
     87
    5888} /* namespace lol */
    5989
  • trunk/src/lol/extras.h

    r3862 r3863  
    5454#include <lol/../easymesh/csgbsp.h>
    5555#include <lol/../easymesh/easymesh.h>
     56#include <lol/../easymesh/easymeshlua.h>
    5657
    5758// Managers
  • trunk/src/lol/image/color.h

    r3602 r3863  
    2222{
    2323
    24 class Color
     24class Color : public vec4
    2525{
    2626public:
     
    318318
    319319    /*
    320      * Convert colors to hex strings.
    321      */
     320    * Convert colors to hex strings.
     321    */
    322322    static String HexString4Bpp(vec3 c);
    323323    static String HexString4Bpp(vec4 c);
     
    326326
    327327    /*
    328      * Some predefined colours
     328    * Convert hex strings to colors.
     329    */
     330    static vec4 C8BppHexString(String c);
     331   
     332    /*
     333    * Some predefined colours
    329334     */
    330335    static const vec4 black, red, green, yellow, blue, magenta, cyan, white, gray_dark, gray, gray_light;
  • trunk/src/lolua/baselua.cpp

    r3861 r3863  
    2626    friend class Lolua::Loader;
    2727
    28     static int LuaPanic(Lolua::State* L)
     28    static int LuaPanic(LuaState* L)
    2929    {
    3030        char const *message = lua_tostring(L, -1);
     
    3434    }
    3535
    36     static int LuaDoFile(Lolua::State *L)
     36    static int LuaDoFile(LuaState *L)
    3737    {
    3838        if (lua_isnoneornil(L, 1))
    3939            return LUA_ERRFILE;
    4040
    41         Lolua::Var<char const*> var(L, 1);
    42         char const *filename = var.V();// lua_tostring(L, 1);
     41        LuaCharPtr var; var.Get(L, 1);
     42        char const *filename = var;// lua_tostring(L, 1);
    4343        int status = LUA_ERRFILE;
    4444
     
    7979
    8080    /* Override dofile() */
    81     Lolua::Function do_file(m_lua_state, "dofile", LuaBaseData::LuaDoFile);
     81    LuaFunction do_file(m_lua_state, "dofile", LuaBaseData::LuaDoFile);
    8282}
    8383
     
    9797
    9898//-----------------------------------------------------------------------------
    99 Lolua::State* Loader::GetLuaState()
     99LuaState* Loader::GetLuaState()
    100100{
    101101    return m_lua_state;
  • trunk/src/lolua/baselua.h

    r3861 r3863  
    2020{
    2121
     22typedef lua_State LuaState;
     23
    2224//-----------------------------------------------------------------------------
    2325namespace Lolua
     
    3234    lua_CFunction set;
    3335} ClassVar;
    34 typedef lua_State State;
    3536
    3637//-----------------------------------------------------------------------------
     
    101102    ObjectDef() { }
    102103    virtual ~ObjectDef() { }
    103     static ObjectDef* New(State* l, int arg_nb)
     104    static ObjectDef* New(LuaState* l, int arg_nb)
    104105    {
    105106        UNUSED(l);
     
    123124    //-------------------------------------------------------------------------
    124125    template <typename TLuaClass>
    125     static void Register(State *l)
     126    static void Register(LuaState *l)
    126127    {
    127128        //Default statics
     
    209210    //-------------------------------------------------------------------------
    210211    template <typename TLuaClass>
    211     static int New(State* l)
     212    static int New(LuaState* l)
    212213    {
    213214        //Number of arguments
     
    228229    //-------------------------------------------------------------------------
    229230    template <typename TLuaClass>
    230     static int Del(State * l)
    231     {
    232         VarPtr<TLuaClass> obj(l, 1);
    233         ASSERT(obj.V());
    234         delete obj.V();
     231    static int Del(LuaState * l)
     232    {
     233        VarPtr<TLuaClass> obj; obj.Get(l, 1);
     234        ASSERT(obj());
     235        delete obj();
    235236        return 0;
    236237    }
     
    241242{
    242243public:
    243     Function(State* l, const char* name, int(*function)(State*))
     244    Function(LuaState* l, const char* name, int(*function)(LuaState*))
    244245    {
    245246        lua_pushcfunction(l, function);
     
    254255protected:
    255256    T* m_value = nullptr;
    256 
    257 public:
    258     VarPtr()                        { }
    259     VarPtr(T* value)                { m_value = value; }
    260     VarPtr(State* l, int index)     { InnerGet(l, index); }
    261     inline T* V()                   { return m_value; }
    262     inline T* operator=(T* value)   { m_value = value; }
    263     inline int Return(State* l)     { InnerPush(l); return 1; }
     257    bool m_optional = false;
     258
     259public:
     260    VarPtr() { }
     261    VarPtr(T* value, bool optional = false)
     262    {
     263        m_value = value;
     264        m_optional = optional;
     265    }
     266    VarPtr(LuaState* l, int& index, bool optional = false)
     267    {
     268        m_optional = optional;
     269        GetInc(l, index);
     270    }
     271    inline T* operator ()()        { return m_value; }
     272    inline T* operator ->()        { return m_value; }
     273    inline T* operator=(T* value)  { m_value = value; }
     274    inline bool IsValid(LuaState* l, int index)
     275    {
     276        return InnerValid(l, index);
     277    }
     278private:
     279    inline void GetInc(LuaState* l, int& index)
     280    {
     281        bool is_nil = lua_isnil(l, index);
     282        if (!m_optional || (!is_nil && InnerIsValid(l, index)))
     283        {
     284            ASSERT(!is_nil);
     285            InnerGet(l, index);
     286        }
     287    }
     288public:
     289    inline void Get(LuaState* l, int index)
     290    {
     291        int idx = index;
     292        GetInc(l, idx);
     293    }
     294    inline int Return(LuaState* l)
     295    {
     296        InnerPush(l);
     297        return 1;
     298    }
    264299
    265300protected:
    266     virtual void InnerGet(State* l, int index)
    267     {
    268         T** obj = static_cast<T**>(luaL_checkudata(l, index, Object::GetMethodName<T>()));
     301    virtual bool InnerIsValid(LuaState* l, int index)
     302    {
     303        return !!lua_isuserdata(l, index);
     304    }
     305    virtual void InnerGet(LuaState* l, int& index)
     306    {
     307        T** obj = static_cast<T**>(luaL_checkudata(l, index++, Object::GetMethodName<T>()));
    269308        m_value = obj ? *obj : nullptr;
    270309    }
    271     void InnerPush(State* l)
     310    void InnerPush(LuaState* l)
    272311    {
    273312        T** data = (T**)lua_newuserdata(l, sizeof(T*));
     
    281320public:
    282321    VarPtrLight() : VarPtr() { }
    283     VarPtrLight(T* value) : VarPtr(T* value) { }
    284     VarPtrLight(State* l, int index) : VarPtr(State* l, int index) { }
     322    VarPtrLight(T* value, bool optional = false) : VarPtr(value, optional) { }
     323    VarPtrLight(LuaState* l, int& index, bool optional = false) : VarPtr(l, index, optional) { }
    285324protected:
    286     virtual void InnerGet(State* l, int index)
    287     {
    288         T** obj = static_cast<T**>(luaL_testudata(l, index, Object::GetMethodName<T>()));
     325    virtual void InnerGet(LuaState* l, int& index)
     326    {
     327        T** obj = static_cast<T**>(luaL_testudata(l, index++, Object::GetMethodName<T>()));
    289328        m_value = obj ? *obj : nullptr;
    290329    }
     
    296335{
    297336private:
     337    bool m_optional = false;
    298338    T m_value;
    299339
    300340public:
    301     Var()                       { InnerInit(); }
    302     Var(T value)                { m_value = value; }
    303     Var(State* l, int index)    { InnerGet(l, index); }
    304     inline T& V()               { return m_value; }
    305     inline int Return(State* l) { InnerPush(l); return 1; }
     341    Var(bool optional = false)
     342    {
     343        m_optional = optional;
     344        InnerInit();
     345    }
     346    Var(T value, bool optional = false)
     347    {
     348        m_optional = optional;
     349        m_value = value;
     350    }
     351    Var(LuaState* l, int& index, bool optional = false)
     352    {
     353        m_optional = optional;
     354        GetInc(l, index);
     355    }
     356    inline operator T()            { return m_value; }
     357    inline T& operator ()()        { return m_value; }
     358    inline bool IsValid(LuaState* l, int index)
     359    {
     360        return InnerIsValid(l, index);
     361    }
     362private:
     363    void GetInc(LuaState* l, int& index)
     364    {
     365        bool is_nil = lua_isnil(l, index);
     366        if (!m_optional || (!is_nil && InnerIsValid(l, index)))
     367        {
     368            ASSERT(!is_nil);
     369            InnerGet(l, index);
     370        }
     371    }
     372public:
     373    inline void Get(LuaState* l, int index)
     374    {
     375        int idx = index;
     376        GetInc(l, idx);
     377    }
     378    inline int Return(LuaState* l)
     379    {
     380        return InnerPush(l);
     381    }
    306382    inline Var<T>&  operator-(const T& value)  { m_value - value; return *this; }
    307383    inline Var<T>&  operator+(const T& value)  { m_value + value; return *this; }
     
    324400    inline bool operator==(const T& value)     { return m_value == value; }
    325401    inline bool operator!=(const T& value)     { return m_value != value; }
    326     inline bool operator==(const Var<T>& o) { return m_value == o.m_value; }
    327     inline bool operator!=(const Var<T>& o) { return m_value != o.m_value; }
     402    inline bool operator==(const Var<T>& o)    { return m_value == o.m_value; }
     403    inline bool operator!=(const Var<T>& o)    { return m_value != o.m_value; }
    328404
    329405private:
    330     void InnerInit()                   { m_value = T(0); }
    331     void InnerGet(State* l, int index) { ASSERT(false); }
    332     void InnerPush(State* l)           { ASSERT(false); }
    333 };
    334 
    335 //-----------------------------------------------------------------------------
    336 template<> inline void Var<String>     ::InnerInit() { m_value = String(); }
    337 template<> inline void Var<String>     ::InnerGet(State* l, int index) { m_value = lua_tostring(l, index); }
    338 template<> inline void Var<char const*>::InnerGet(State* l, int index) { m_value = lua_tostring(l, index); }
    339 template<> inline void Var<double>     ::InnerGet(State* l, int index) { m_value = lua_tonumber(l, index); }
    340 template<> inline void Var<float>      ::InnerGet(State* l, int index) { m_value = (float)lua_tonumber(l, index); }
    341 template<> inline void Var<int32_t>    ::InnerGet(State* l, int index) { m_value = (int32_t)lua_tointeger(l, index); }
    342 template<> inline void Var<int64_t>    ::InnerGet(State* l, int index) { m_value = lua_tointeger(l, index); }
    343 template<> inline void Var<uint32_t>   ::InnerGet(State* l, int index) { m_value = lua_tounsigned(l, index); }
    344 
    345 template<> inline void Var<String>     ::InnerPush(State* l) { lua_pushstring(l, m_value.C()); }
    346 template<> inline void Var<char const*>::InnerPush(State* l) { lua_pushstring(l, m_value); }
    347 template<> inline void Var<double>     ::InnerPush(State* l) { lua_pushnumber(l, m_value); }
    348 template<> inline void Var<float>      ::InnerPush(State* l) { lua_pushnumber(l, m_value); }
    349 template<> inline void Var<int32_t>    ::InnerPush(State* l) { lua_pushinteger(l, m_value); }
    350 template<> inline void Var<int64_t>    ::InnerPush(State* l) { lua_pushinteger(l, m_value); }
    351 template<> inline void Var<uint32_t>   ::InnerPush(State* l) { lua_pushunsigned(l, m_value); }
     406    void InnerInit()                          { m_value = T(0); }
     407    bool InnerIsValid(LuaState* l, int index) { UNUSED(l); UNUSED(index); ASSERT(false); return false; }
     408    void InnerGet(LuaState* l, int& index)    { UNUSED(l); UNUSED(index); ASSERT(false); }
     409    int InnerPush(LuaState* l)                { UNUSED(l); ASSERT(false); return 0; }
     410};
     411
     412//-----------------------------------------------------------------------------
     413template<> inline bool Var<bool>::InnerIsValid(LuaState* l, int index)
     414{
     415    return lua_isboolean(l, index);
     416}
     417template<> inline void Var<bool>::InnerGet(LuaState* l, int& index)
     418{
     419    m_value = !!lua_toboolean(l, index++);
     420}
     421template<> inline int Var<bool>::InnerPush(LuaState* l)
     422{
     423    lua_pushboolean(l, m_value);
     424    return 1;
     425}
     426//-----------------------------------------------------------------------------
     427template<> inline bool Var<char const*>::InnerIsValid(LuaState* l, int index)
     428{
     429    return !!lua_isstring(l, index);
     430}
     431template<> inline void Var<char const*>::InnerGet(LuaState* l, int& index)
     432{
     433    m_value = lua_tostring(l, index++);
     434}
     435template<> inline int Var<char const*>::InnerPush(LuaState* l)
     436{
     437    lua_pushstring(l, m_value);
     438    return 1;
     439}
     440//-----------------------------------------------------------------------------
     441template<> inline void Var<String>::InnerInit()
     442{
     443    m_value = String();
     444}
     445template<> inline bool Var<String>::InnerIsValid(LuaState* l, int index)
     446{
     447    Var<char const*> v;
     448    return v.IsValid(l, index);
     449}
     450template<> inline void Var<String>::InnerGet(LuaState* l, int& index)
     451{
     452    Var<char const*> v(l, index);
     453    m_value = v();
     454}
     455template<> inline int Var<String>::InnerPush(LuaState* l)
     456{
     457    Var<char const*> v;
     458    v = m_value.C();
     459    return v.Return(l);
     460}
     461//-----------------------------------------------------------------------------
     462template<> inline bool Var<double>::InnerIsValid(LuaState* l, int index)
     463{
     464    return !!lua_isnumber(l, index);
     465}
     466template<> inline void Var<double>::InnerGet(LuaState* l, int& index)
     467{
     468    m_value = lua_tonumber(l, index++);
     469}
     470template<> inline int Var<double>::InnerPush(LuaState* l)
     471{
     472    lua_pushnumber(l, m_value);
     473    return 1;
     474}
     475//-----------------------------------------------------------------------------
     476template<> inline bool Var<float>::InnerIsValid(LuaState* l, int index)
     477{
     478    Var<double> v;
     479    return v.IsValid(l, index);
     480}
     481template<> inline void Var<float>::InnerGet(LuaState* l, int& index)
     482{
     483    Var<double> v(l, index);
     484    m_value = (float)v();
     485}
     486template<> inline int Var<float>::InnerPush(LuaState* l)
     487{
     488    Var<double> v = (double)m_value;
     489    return v.Return(l);
     490}
     491//-----------------------------------------------------------------------------
     492template<> inline bool Var<int64_t>::InnerIsValid(LuaState* l, int index)
     493{
     494    return !!lua_isnumber(l, index);
     495}
     496template<> inline void Var<int64_t>::InnerGet(LuaState* l, int& index)
     497{
     498    m_value = lua_tointeger(l, index++);
     499}
     500template<> inline int Var<int64_t>::InnerPush(LuaState* l)
     501{
     502    lua_pushinteger(l, m_value);
     503    return 1;
     504}
     505//-----------------------------------------------------------------------------
     506template<> inline bool Var<int32_t>::InnerIsValid(LuaState* l, int index)
     507{
     508    Var<int64_t> v;
     509    return v.IsValid(l, index);
     510}
     511template<> inline void Var<int32_t>::InnerGet(LuaState* l, int& index)
     512{
     513    Var<int64_t> v(l, index);
     514    m_value = (int32_t)v();
     515}
     516template<> inline int Var<int32_t>::InnerPush(LuaState* l)
     517{
     518    Var<int64_t> v = (int64_t)m_value;
     519    return v.Return(l);
     520}
     521//-----------------------------------------------------------------------------
     522template<> inline bool Var<uint32_t>::InnerIsValid(LuaState* l, int index)
     523{
     524    return !!lua_isnumber(l, index);
     525}
     526template<> inline void Var<uint32_t>::InnerGet(LuaState* l, int& index)
     527{
     528    m_value = lua_tounsigned(l, index++);
     529}
     530template<> inline int Var<uint32_t>::InnerPush(LuaState* l)
     531{
     532    lua_pushunsigned(l, m_value);
     533    return 1;
     534}
     535//-----------------------------------------------------------------------------
     536template<> inline bool Var<uint64_t>::InnerIsValid(LuaState* l, int index)
     537{
     538    Var<uint32_t> v;
     539    return v.IsValid(l, index);
     540}
     541template<> inline void Var<uint64_t>::InnerGet(LuaState* l, int& index)
     542{
     543    Var<uint32_t> v(l, index);
     544    m_value = (uint64_t)v();
     545}
     546template<> inline int Var<uint64_t>::InnerPush(LuaState* l)
     547{
     548    Var<uint32_t> v = (uint32_t)m_value;
     549    return v.Return(l);
     550}
     551//-----------------------------------------------------------------------------
     552template<> inline bool Var<vec2>::InnerIsValid(LuaState* l, int index)
     553{
     554    Var<float> x;
     555    return x.IsValid(l, index);
     556}
     557template<> inline void Var<vec2>::InnerGet(LuaState* l, int& index)
     558{
     559    Var<float> x(l, index);
     560    Var<float> y(x(), true); y.Get(l, index);
     561    m_value = vec2(x, y);
     562}
     563template<> inline int Var<vec2>::InnerPush(LuaState* l)
     564{
     565    Var<float> x = m_value.x;
     566    Var<float> y = m_value.y;
     567    return (x.Return(l) + y.Return(l));
     568}
     569//-----------------------------------------------------------------------------
     570template<> inline bool Var<vec3>::InnerIsValid(LuaState* l, int index)
     571{
     572    Var<float> x;
     573    return x.IsValid(l, index);
     574}
     575template<> inline void Var<vec3>::InnerGet(LuaState* l, int& index)
     576{
     577    Var<float> x(l, index);
     578    Var<float> y(x(), true); y.Get(l, index);
     579    Var<float> z(x(), true); z.Get(l, index);
     580    m_value = vec3(x, y, z);
     581}
     582template<> inline int Var<vec3>::InnerPush(LuaState* l)
     583{
     584    Var<float> x = m_value.x;
     585    Var<float> y = m_value.y;
     586    Var<float> z = m_value.z;
     587    return (x.Return(l) + y.Return(l) + z.Return(l));
     588}
     589//-----------------------------------------------------------------------------
     590template<> inline bool Var<vec4>::InnerIsValid(LuaState* l, int index)
     591{
     592    Var<float> x;
     593    return x.IsValid(l, index);
     594}
     595template<> inline void Var<vec4>::InnerGet(LuaState* l, int& index)
     596{
     597    Var<float> x(l, index);
     598    Var<float> y(x(), true); y.Get(l, index);
     599    Var<float> z(x(), true); z.Get(l, index);
     600    Var<float> w(x(), true); w.Get(l, index);
     601    m_value = vec4(x, y, z, w);
     602}
     603template<> inline int Var<vec4>::InnerPush(LuaState* l)
     604{
     605    Var<float> x = m_value.x;
     606    Var<float> y = m_value.y;
     607    Var<float> z = m_value.z;
     608    Var<float> w = m_value.w;
     609    return (x.Return(l) + y.Return(l) + z.Return(l) + w.Return(l));
     610}
     611
     612//-----------------------------------------------------------------------------
     613class Stack
     614{
     615public:
     616    Stack(LuaState* l, int32_t start_index = 1)
     617    {
     618        m_state = l;
     619        m_index = start_index;
     620    }
     621    virtual ~Stack() { }
     622    inline operator int32_t() { return m_result; }
     623    int32_t GetArgs()
     624    {
     625        return lua_gettop(m_state);
     626    }
     627
     628    //-------------------------------------------------------------------------
     629    template<typename T>
     630    Stack& operator>>(Var<T>& var)
     631    {
     632        var = Var<T>(m_state, m_index);
     633        return *this;
     634    }
     635    template<typename T>
     636    Stack& operator>>(VarPtr<T>& var)
     637    {
     638        var = VarPtr<T>(m_state, m_index);
     639        return *this;
     640    }
     641    template<typename T>
     642    Stack& operator>>(VarPtrLight<T>& var)
     643    {
     644        var = VarPtrLight<T>(m_state, m_index);
     645        return *this;
     646    }
     647
     648    //-------------------------------------------------------------------------
     649    template<typename T>
     650    Stack& operator<<(Var<T>& var)
     651    {
     652        m_result += var.Return(m_state);
     653        return *this;
     654    }
     655    template<typename T>
     656    Stack& operator<<(VarPtr<T>& var)
     657    {
     658        m_result += var.Return(m_state);
     659        return *this;
     660    }
     661    template<typename T>
     662    Stack& operator<<(VarPtrLight<T>& var)
     663    {
     664        m_result += var.Return(m_state);
     665        return *this;
     666    }
     667
     668private:
     669    LuaState*  m_state = nullptr;
     670    int32_t m_index = 1;
     671    int32_t m_result = 0;
     672};
    352673
    353674//-----------------------------------------------------------------------------
     
    364685    {
    365686        lua_getglobal(m_lua_state, name.C());
    366         Var<T> var(m_lua_state, -1);
     687        Var<T> var; var.Get(m_lua_state, -1);
    367688        lua_pop(m_lua_state, 1);
    368         return var.V();
     689        return var;
    369690    }
    370691    template<typename T>
     
    372693    {
    373694        lua_getglobal(m_lua_state, name.C());
    374         VarPtr<T> var(m_lua_state, -1);
     695        VarPtr<T> var; var.Get(m_lua_state, -1);
    375696        lua_pop(m_lua_state, 1);
    376         return var.V();
     697        return var();
    377698    }
    378699
    379700protected:
    380     Lolua::State* GetLuaState();
     701    LuaState* GetLuaState();
    381702
    382703private:
    383     Lolua::State* m_lua_state;
     704    LuaState* m_lua_state;
    384705};
    385706
    386707} /* namespace Lolua */
    387708
     709typedef Lolua::Function         LuaFunction;
     710typedef Lolua::Object           LuaObject;
     711typedef Lolua::ObjectDef        LuaObjectDef;
     712typedef Lolua::ObjectLib        LuaObjectLib;
     713typedef Lolua::Loader           LuaLoader;
     714typedef Lolua::Var<bool>        LuaBool;
     715typedef Lolua::Var<char const*> LuaCharPtr;
     716typedef Lolua::Var<String>      LuaString;
     717typedef Lolua::Var<double>      LuaDouble;
     718typedef Lolua::Var<float>       LuaFloat;
     719typedef Lolua::Var<int64_t>     LuaInt64;
     720typedef Lolua::Var<int32_t>     LuaInt32;
     721typedef Lolua::Var<uint32_t>    LuaUInt32;
     722typedef Lolua::Var<uint64_t>    LuaUInt64;
     723typedef Lolua::Var<vec2>        LuaVec2;
     724typedef Lolua::Var<vec3>        LuaVec3;
     725typedef Lolua::Var<vec4>        LuaVec4;
     726typedef Lolua::Stack            LuaStack;
     727
    388728} /* namespace lol */
  • trunk/src/world.cpp

    r3857 r3863  
    3636
    3737World::World()
    38     : Lolua::Loader()
     38    : LuaLoader()
    3939{
    4040    g_world_data.m_lua_state = GetLuaState();
  • trunk/src/world.h

    r3857 r3863  
    1919{
    2020
    21 class World : public Lolua::Loader
     21class World : public LuaLoader
    2222{
    2323public:
Note: See TracChangeset for help on using the changeset viewer.