Changeset 3866


Ignore:
Timestamp:
Mar 14, 2015, 9:32:07 PM (7 years ago)
Author:
touky
Message:

Add color var in lua
Add SafeEnum var in lua
MeshViewer SceneSetup is operational
Added imGui to vs-solution, not implemented yet

Location:
trunk
Files:
78 added
5 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/build/Lol (vs2013).sln

    r3857 r3866  
    155155EndProject
    156156Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "14_lol_lua", "..\doc\tutorial\14_lol_lua.vcxproj", "{81C83B42-D00A-4FA3-9A3D-80F9D46524BF}"
     157EndProject
     158Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lolimgui", "..\src\imgui\lolimgui.vcxproj", "{A7F6FDF8-937E-41EF-B44D-04CD1A48C179}"
    157159EndProject
    158160Global
     
    639641                {81C83B42-D00A-4FA3-9A3D-80F9D46524BF}.Release|x64.ActiveCfg = Release|x64
    640642                {81C83B42-D00A-4FA3-9A3D-80F9D46524BF}.Release|x64.Build.0 = Release|x64
     643                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Debug|ORBIS.ActiveCfg = Debug|Win32
     644                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Debug|Win32.ActiveCfg = Debug|Win32
     645                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Debug|Win32.Build.0 = Debug|Win32
     646                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Debug|x64.ActiveCfg = Debug|x64
     647                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Debug|x64.Build.0 = Debug|x64
     648                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Release|ORBIS.ActiveCfg = Release|Win32
     649                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Release|Win32.ActiveCfg = Release|Win32
     650                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Release|Win32.Build.0 = Release|Win32
     651                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Release|x64.ActiveCfg = Release|x64
     652                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179}.Release|x64.Build.0 = Release|x64
    641653        EndGlobalSection
    642654        GlobalSection(SolutionProperties) = preSolution
     
    662674                {E4DFEBF9-C310-462F-9876-7EB59C1E4D4E} = {1AFD580B-98B8-4689-B661-38C41132C60E}
    663675                {9E62F2FE-3408-4EAE-8238-FD84238CEEDA} = {1AFD580B-98B8-4689-B661-38C41132C60E}
     676                {A7F6FDF8-937E-41EF-B44D-04CD1A48C179} = {1AFD580B-98B8-4689-B661-38C41132C60E}
    664677                {962D4E25-45D3-4ACE-8C02-69FA3713ABD4} = {E4DFEBF9-C310-462F-9876-7EB59C1E4D4E}
    665678                {1782F849-B6E1-466D-9F02-A751F3F8712C} = {E4DFEBF9-C310-462F-9876-7EB59C1E4D4E}
  • trunk/doc/samples/meshviewer.cpp

    r3788 r3866  
    183183        m_camera = nullptr;
    184184        m_controller = nullptr;
     185
     186        //Scene setup
     187        m_setup_loader.ExecLua("meshviewer_init.lua");
    185188
    186189        //Compile ref meshes
     
    332335        }
    333336#else
     337        //TOUKY CHANGE THAT
     338        /*
    334339        m_ssetup->Compile("addlight 0.0 position (4 -1 -4) color (.0 .2 .5 1) "
    335340                          "addlight 0.0 position (8 2 6) color #ffff "
    336341                          "showgizmo true ");
     342        */
    337343        m_ssetup->Startup();
    338344#endif //NO_SC_SETUP
     
    578584            {
    579585                SceneSetup* new_ssetup = new SceneSetup();
    580                 if (new_ssetup->Compile(mesh.C()) && new_ssetup->m_lights.Count())
     586                if (false) //new_ssetup->Compile(mesh.C()) && new_ssetup->m_lights.Count())
    581587                {
    582588                    //Store current light datas, in World
     
    890896private:
    891897    SceneSetup*         m_ssetup;
     898    SceneSetupLuaLoader m_setup_loader;
    892899    array<LightData>    m_light_datas;
    893900    Controller*         m_controller;
  • trunk/doc/samples/meshviewer.vcxproj

    r3788 r3866  
    3636  </ItemGroup>
    3737  <ItemGroup>
    38     <ClCompile Include="generated\scenesetup-parser.cpp" />
    39     <ClCompile Include="generated\scenesetup-scanner.cpp" />
    4038    <ClCompile Include="meshviewer.cpp" />
    41     <ClCompile Include="scenesetup-compiler.cpp" />
    4239    <ClCompile Include="scenesetup.cpp" />
    4340  </ItemGroup>
     
    5754      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
    5855    </None>
    59     <None Include="generated\location.hh" />
    60     <None Include="generated\position.hh" />
    61     <None Include="generated\scenesetup-parser.output" />
    62     <None Include="generated\stack.hh" />
    6356    <None Include="meshviewer.index.html">
    6457      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
     
    7366      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
    7467    </None>
    75     <None Include="scenesetup-parser.y" />
    76     <None Include="scenesetup-scanner.l" />
    7768    <None Include="easymeshdictionnary.js">
    7869      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
    7970    </None>
     71    <None Include="meshviewer_buffer.lua" />
     72    <None Include="meshviewer_init.lua" />
    8073    <None Include="scenesetupdictionnary.js">
    8174      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
     
    9992  </ItemGroup>
    10093  <ItemGroup>
    101     <ClInclude Include="generated\scenesetup-parser.h" />
    102     <ClInclude Include="scenesetup-compiler.h" />
    10394    <ClInclude Include="scenesetup.h" />
    10495  </ItemGroup>
  • trunk/doc/samples/scenesetup.cpp

    r3788 r3866  
    1616#include <lol/engine.h>
    1717#include "scenesetup.h"
    18 #include "scenesetup-compiler.h"
    1918
    2019namespace lol
     
    2322//-----------------------------------------------------------------------------
    2423//CTor/DTor
    25 SceneSetup::SceneSetup()
    26 {
     24SceneSetup::SceneSetup(String const& name)
     25{
     26    m_name = name;
    2727    m_clear_color = vec4(vec3::zero, 1.f);
    2828    m_show_gizmo = true;
     
    3737
    3838//-----------------------------------------------------------------------------
    39 bool SceneSetup::Compile(char const *command)
    40 {
    41     SceneSetupCompiler mc(*this);
    42     return mc.ParseString(command);
    43 }
    44 
    45 //-----------------------------------------------------------------------------
    4639bool SceneSetup::Startup()
    4740{
     
    6356}
    6457
     58//-----------------------------------------------------------------------------
     59void SceneSetup::AddLight(LightType type)
     60{
     61    m_last_cmd = SceneSetup::Command::AddLight;
     62    m_lights << new Light();
     63    m_lights.Last()->SetType(type);
     64}
     65
     66//-----------------------------------------------------------------------------
     67void SceneSetup::SetupScene()
     68{
     69    m_last_cmd = SceneSetup::Command::SetupScene;
     70}
     71
     72//-----------------------------------------------------------------------------
     73void SceneSetup::SetPosition(vec3 const& v)
     74{
     75    switch (m_last_cmd.ToScalar())
     76    {
     77    case SceneSetup::Command::AddLight:
     78        m_lights.Last()->SetPosition(v);
     79        break;
     80    }
     81}
     82
     83//-----------------------------------------------------------------------------
     84void SceneSetup::SetLookAt(vec3 const& v)
     85{
     86    switch (m_last_cmd.ToScalar())
     87    {
     88    case SceneSetup::Command::AddLight:
     89        //TODO: Do better
     90        m_lights.Last()->SetPosition(v - m_lights.Last()->GetPosition());
     91        break;
     92    }
     93}
     94
     95//-----------------------------------------------------------------------------
     96void SceneSetup::SetColor(vec4 const& c)
     97{
     98    switch (m_last_cmd.ToScalar())
     99    {
     100    case SceneSetup::Command::AddLight:
     101        m_lights.Last()->SetColor(c);
     102        break;
     103    case SceneSetup::Command::SetupScene:
     104        m_clear_color = c;
     105        break;
     106    }
     107}
     108
     109//-----------------------------------------------------------------------------
     110void SceneSetup::Show(SceneSetup::Display const& d)
     111{
     112    Set(d, DisplayFlag::On);
     113}
     114
     115//-----------------------------------------------------------------------------
     116void SceneSetup::Hide(SceneSetup::Display const& d)
     117{
     118    Set(d, DisplayFlag::Off);
     119}
     120
     121//-----------------------------------------------------------------------------
     122void SceneSetup::Toggle(SceneSetup::Display const& d)
     123{
     124    Set(d, DisplayFlag::Toggle);
     125}
     126
     127//-----------------------------------------------------------------------------
     128void SceneSetup::Set(SceneSetup::Display const& d, DisplayFlag const& f)
     129{
     130    bool value = f == DisplayFlag::On ? true : false;
     131    switch (m_last_cmd.ToScalar())
     132    {
     133    case SceneSetup::Command::SetupScene:
     134        switch (d.ToScalar())
     135        {
     136        case SceneSetup::Display::Gizmo:
     137            m_show_gizmo = f == DisplayFlag::Toggle ? !m_show_gizmo : value;
     138            break;
     139        case SceneSetup::Display::Light:
     140            m_show_lights = f == DisplayFlag::Toggle ? !m_show_lights : value;
     141            break;
     142        }
     143        break;
     144    }
     145}
     146
     147//-----------------------------------------------------------------------------
     148SceneSetupLuaObject::SceneSetupLuaObject(String& name) : LuaObjectDef()
     149{
     150    m_setup = new SceneSetup(name);
     151    SceneSetupLuaLoader::RegisterSetup(m_setup);
     152}
     153
     154//-----------------------------------------------------------------------------
     155SceneSetupLuaObject::~SceneSetupLuaObject()
     156{
     157}
     158
     159//-----------------------------------------------------------------------------
     160SceneSetupLuaObject* SceneSetupLuaObject::New(LuaState* l, int arg_nb)
     161{
     162    UNUSED(l);
     163    UNUSED(arg_nb);
     164    LuaStack s(l);
     165    LuaString n;
     166    s >> n;
     167    return new SceneSetupLuaObject(n());
     168}
     169
     170//-- Setup command ------------------------------------------------------------
     171int SceneSetupLuaObject::AddLight(LuaState* l)
     172{
     173    LuaStack s(l);
     174    LuaSSetupPtr o;
     175    LuaString t;
     176    s >> o >> t;
     177    o->m_setup->AddLight(FindValue<LightType>(t().C()));
     178    return 0;
     179}
     180int SceneSetupLuaObject::SetupScene(LuaState* l)
     181{
     182    LuaStack s(l);
     183    LuaSSetupPtr o;
     184    s >> o;
     185    o->m_setup->SetupScene();
     186    return 0;
     187}
     188//-- main funcs ---------------------------------------------------------------
     189int SceneSetupLuaObject::SetPosition(LuaState* l)
     190{
     191    LuaStack s(l);
     192    LuaSSetupPtr o;
     193    LuaVec3 c;
     194    s >> o >> c;
     195    o->m_setup->SetPosition(c);
     196    return 0;
     197}
     198int SceneSetupLuaObject::SetLookAt(LuaState* l)
     199{
     200    LuaStack s(l);
     201    LuaSSetupPtr o;
     202    LuaVec3 c;
     203    s >> o >> c;
     204    o->m_setup->SetLookAt(c);
     205    return 0;
     206}
     207int SceneSetupLuaObject::SetColor(LuaState* l)
     208{
     209    LuaStack s(l);
     210    LuaSSetupPtr o;
     211    LuaColor c;
     212    s >> o >> c;
     213    o->m_setup->SetColor(c);
     214    return 0;
     215}
     216int SceneSetupLuaObject::Show(LuaState* l)
     217{
     218    LuaStack s(l);
     219    LuaSSetupPtr o;
     220    LuaDisplay e;
     221    s >> o >> e;
     222    o->m_setup->Show(e);
     223    return 0;
     224}
     225int SceneSetupLuaObject::Hide(LuaState* l)
     226{
     227    LuaStack s(l);
     228    LuaSSetupPtr o;
     229    LuaDisplay e;
     230    s >> o >> e;
     231    o->m_setup->Hide(e);
     232    return 0;
     233}
     234int SceneSetupLuaObject::Toggle(LuaState* l)
     235{
     236    LuaStack s(l);
     237    LuaSSetupPtr o;
     238    LuaDisplay e;
     239    s >> o >> e;
     240    o->m_setup->Toggle(e);
     241    return 0;
     242}
     243
     244//-----------------------------------------------------------------------------
     245const LuaObjectLib* SceneSetupLuaObject::GetLib()
     246{
     247    typedef SceneSetupLuaObject SSLO;
     248    static const LuaObjectLib lib = LuaObjectLib(
     249        "SceneSetup",
     250        //Statics
     251        { { nullptr, nullptr } },
     252        //Methods
     253        {
     254            //-----------------------------------------------------------------
     255            { "AddLight", AddLight },
     256            { "Setup", SetupScene },
     257            //-- main funcs
     258            { "Position", SetPosition },
     259            { "LookAt", SetLookAt },
     260            { "Color", SetColor },
     261            { "Show", Show },
     262            { "Hide", Hide },
     263            { "Toggle", Toggle },
     264        },
     265        //Variables
     266        { { nullptr, nullptr, nullptr } });
     267            return &lib;
     268}
     269
     270//-----------------------------------------------------------------------------
     271map<String, SceneSetup*> SceneSetupLuaLoader::m_setups;
     272SceneSetupLuaLoader::SceneSetupLuaLoader() : LuaLoader()
     273{
     274    LuaState* l = GetLuaState();
     275
     276    LuaObject::Register<SceneSetupLuaObject>(l);
     277}
     278
     279//-----------------------------------------------------------------------------
     280SceneSetupLuaLoader::~SceneSetupLuaLoader() { }
     281
     282//-----------------------------------------------------------------------------
     283void SceneSetupLuaLoader::RegisterSetup(SceneSetup* setup)
     284{
     285    m_setups[setup->m_name] = setup;
     286}
     287
    65288} /* namespace lol */
  • trunk/doc/samples/scenesetup.h

    r3788 r3866  
    2020{
    2121
     22//-----------------------------------------------------------------------------
    2223class SceneSetup
    2324{
    24     friend class SceneSetupParser;
     25    friend class SceneSetupLuaLoader;
     26    friend class SceneSetupLuaObject;
    2527
    2628public:
    2729    //CTor/DTor
    28     SceneSetup();
     30    SceneSetup() : SceneSetup("default") { }
     31    SceneSetup(String const& name);
    2932    ~SceneSetup();
    3033
    3134    static char const *GetName() { return "<scenesetup>"; }
    32 
    33     //--
    34     bool Compile(char const *command);
    3535
    3636    //--
     
    3838    bool Shutdown(bool destroy=false);
    3939
     40    //-- Setup command
     41    void AddLight(LightType type);
     42    void SetupScene();
     43
     44    //-- main funcs
     45    void SetPosition(vec3 const& v);
     46    void SetLookAt(vec3 const& v);
     47    void SetColor(vec4 const& c);
     48
     49    //-------------------------------------------------------------------------
     50    struct DisplayBase : public StructSafeEnum
     51    {
     52        enum Type
     53        {
     54            Gizmo,
     55            Light,
     56
     57            Max
     58        };
     59    protected:
     60        virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     61        {
     62            enum_map[Gizmo] = "Gizmo";
     63            enum_map[Light] = "Light";
     64            return true;
     65        }
     66    };
     67    typedef SafeEnum<DisplayBase>   Display;
     68
     69    void Show(Display const& d);
     70    void Hide(Display const& d);
     71    void Toggle(Display const& d);
     72protected:
     73    void Set(Display const& d, DisplayFlag const& f);
     74
     75protected:
     76    //-------------------------------------------------------------------------
     77    struct CommandBase : public StructSafeEnum
     78    {
     79        enum Type
     80        {
     81            AddLight,
     82            SetupScene,
     83
     84            Max
     85        };
     86    protected:
     87        virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     88        {
     89            enum_map[AddLight] = "AddLight";
     90            enum_map[SetupScene] = "SetupScene";
     91            return true;
     92        }
     93    };
     94    typedef SafeEnum<CommandBase> Command;
     95
     96public:
    4097    //--
    41     vec4                    m_clear_color;
    42     array<Light *>          m_lights;
    43     array<String, String>   m_custom_cmd;
    44     bool                    m_show_gizmo;
    45     bool                    m_show_lights;
     98    String                      m_name;
     99    Command                     m_last_cmd;
     100    vec4                        m_clear_color;
     101    array<Light *>              m_lights;
     102    array<String, String>       m_custom_cmd;
     103    bool                        m_show_gizmo;
     104    bool                        m_show_lights;
    46105};
     106typedef Lolua::VarEnum<SceneSetup::DisplayBase> LuaDisplay;
     107
     108//-----------------------------------------------------------------------------
     109class SceneSetupLuaObject : public LuaObjectDef
     110{
     111    typedef Lolua::VarPtr<SceneSetupLuaObject> LuaSSetupPtr;
     112public:
     113    //-------------------------------------------------------------------------
     114    SceneSetupLuaObject(String& name);
     115    virtual ~SceneSetupLuaObject();
     116
     117    //-------------------------------------------------------------------------
     118    static SceneSetupLuaObject* New(LuaState* l, int arg_nb);
     119    static const LuaObjectLib* GetLib();
     120
     121    //-------------------------------------------------------------------------
     122public:
     123    //-- Setup command
     124    static int AddLight(LuaState* l);
     125    static int SetupScene(LuaState* l);
     126    //-- main funcs
     127    static int SetPosition(LuaState* l);
     128    static int SetLookAt(LuaState* l);
     129    static int SetColor(LuaState* l);
     130    static int Show(LuaState* l);
     131    static int Hide(LuaState* l);
     132    static int Toggle(LuaState* l);
     133
     134    //-- Setup command
     135    void AddLight(LightType type);
     136    void SetupScene();
     137
     138    //-- main funcs
     139    void SetPosition(vec3& v);
     140    void SetLookAt(vec3& v);
     141    void SetColor(vec4& c);
     142    void Show(SceneSetup::Display const& d);
     143    void Hide(SceneSetup::Display const& d);
     144    void Toggle(SceneSetup::Display const& d);
     145
     146private:
     147    SceneSetup* m_setup = nullptr;
     148};
     149
     150//-----------------------------------------------------------------------------
     151class SceneSetupLuaLoader : public LuaLoader
     152{
     153    friend class SceneSetupLuaObject;
     154public:
     155    SceneSetupLuaLoader();
     156    virtual ~SceneSetupLuaLoader();
     157
     158    //-------------------------------------------------------------------------
     159protected:
     160    static void RegisterSetup(SceneSetup* setup);
     161
     162private:
     163    static map<String, SceneSetup*> m_setups;
     164};
     165
     166/*
     167addlight            { return token::T_ADDLIGHT;     }
     168position            { return token::T_OBJPOSITION;  }
     169lookat              { return token::T_OBJLOOKAT;    }
     170color               { return token::T_OBJCOLOR;     }
     171clearcolor          { return token::T_CLEARCOLOR;   }
     172
     173showgizmo           { return token::T_SHOWGIZMO;    }
     174showlight           { return token::T_SHOWLIGHT;    }
     175custom              { return token::T_CUSTOMCMD;    }
     176
     177custom              { return token::T_CUSTOMCMD;    }
     178
     179light_command:
     180T_ADDLIGHT                      { uc.m_sstp.m_lights << new Light(); uc.m_last_cmd = "ADDLIGHT"; }
     181| T_ADDLIGHT      fv              { uc.m_sstp.m_lights << new Light(); uc.m_last_cmd = "ADDLIGHT";
     182uc.m_sstp.m_lights.Last()->SetType(LightType($2)); }
     183| T_ADDLIGHT      svv             { uc.m_sstp.m_lights << new Light(); uc.m_last_cmd = "ADDLIGHT";
     184uc.m_sstp.m_lights.Last()->SetType(FindValue<LightType>($2)); }
     185;
     186
     187setup_command:
     188T_OBJPOSITION   v3              { if (uc.m_last_cmd == "ADDLIGHT")
     189uc.m_sstp.m_lights.Last()->SetPosition(vec3($2[0], $2[1], $2[2])); }
     190| T_OBJLOOKAT     v3              { if (uc.m_last_cmd == "ADDLIGHT")
     191{
     192} }
     193| T_OBJCOLOR      v4{ if (uc.m_last_cmd == "ADDLIGHT")
     194uc.m_sstp.m_lights.Last()->SetColor(vec4($2[0], $2[1], $2[2], $2[3])); }
     195| T_OBJCOLOR      COLOR{ uint32_t x = $2;
     196ivec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
     197vec4 vv = vec4(v) * (1.f / 255.f);
     198if (uc.m_last_cmd == "ADDLIGHT")
     199uc.m_sstp.m_lights.Last()->SetColor(vv); }
     200;
     201
     202scene_command:
     203T_CLEARCOLOR    v4{ uc.m_sstp.m_clear_color = vec4($2[0], $2[1], $2[2], $2[3]); }
     204T_CLEARCOLOR    v3{ uc.m_sstp.m_clear_color = vec4($2[0], $2[1], $2[2], 1.f); }
     205| T_CLEARCOLOR    COLOR{ uint32_t x = $2; ivec4 v(x >> 24, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
     206uc.m_sstp.m_clear_color = vec4(v) * (1.f / 255.f); }
     207| T_SHOWGIZMO     bv{ uc.m_sstp.m_show_gizmo = $2; }
     208| T_SHOWLIGHT     bv{ uc.m_sstp.m_show_lights = $2; }
     209;
     210
     211custom_command:
     212T_CUSTOMCMD     svv sv{ uc.m_sstp.m_custom_cmd.Push($2, $3); }
     213;
     214
     215*/
    47216
    48217} /* namespace lol */
  • trunk/src/easymesh/easymeshlua.h

    r3865 r3866  
    610610        LuaStack s(l);
    611611        EzMeshPtr m;
    612         s >> m;
    613         LuaVec4 c;
    614         if (s.GetArgs() == 2 && !c.IsValid(l, 2))
    615         {
    616             LuaString str;
    617             s >> str;
    618             c = Color::C8BppHexString(str);
    619         }
     612        LuaColor c;
     613        s >> m >> c;
    620614        m->m_instance.SetCurColor(c);
    621615        return 0;
     
    625619        LuaStack s(l);
    626620        EzMeshPtr m;
    627         s >> m;
    628         LuaVec4 c;
    629         if (s.GetArgs() == 1 && !c.IsValid(l, 2))
    630         {
    631             LuaString str;
    632             s >> str;
    633             c = Color::C8BppHexString(str);
    634         }
     621        LuaColor c;
     622        s >> m >> c;
    635623        m->m_instance.SetCurColorA(c);
    636624        return 0;
     
    640628        LuaStack s(l);
    641629        EzMeshPtr m;
    642         s >> m;
    643         LuaVec4 c;
    644         if (s.GetArgs() == 1 && !c.IsValid(l, 2))
    645         {
    646             LuaString str;
    647             s >> str;
    648             c = Color::C8BppHexString(str);
    649         }
     630        LuaColor c;
    650631        m->m_instance.SetCurColorB(c);
    651632        return 0;
     
    655636        LuaStack s(l);
    656637        EzMeshPtr m;
    657         s >> m;
    658         LuaVec4 c;
    659         if (s.GetArgs() == 1 && !c.IsValid(l, 2))
    660         {
    661             LuaString str;
    662             s >> str;
    663             c = Color::C8BppHexString(str);
    664         }
     638        LuaColor c;
     639        s >> m >> c;
    665640        m->m_instance.SetVertColor(c);
    666641        return 0;
  • trunk/src/lol/base/enum.h

    r3836 r3866  
    100100};
    101101
     102//-------------------------------------------------------------------------
     103struct DisplayFlagBase : public StructSafeEnum
     104{
     105    enum Type
     106    {
     107        On,
     108        Off,
     109        Toggle,
     110
     111        MAX
     112    };
     113protected:
     114    virtual bool BuildEnumMap(map<int64_t, String>& enum_map)
     115    {
     116        enum_map[On] = "On";
     117        enum_map[Off] = "Off";
     118        enum_map[Toggle] = "Toggle";
     119        return true;
     120    }
     121};
     122typedef SafeEnum<DisplayFlagBase> DisplayFlag;
     123
    102124} /* namespace lol */
    103125
  • trunk/src/lol/math/vector.h

    r3809 r3866  
    281281        struct { T r, g; };
    282282        struct { T s, t; };
     283        struct { T r, t; };
    283284
    284285#if !_DOXYGEN_SKIP_ME
    285         vec_t<T,2,9000> const xx, rr, ss;
    286         vec_t<T,2,9001> _____ xy, rg, st;
    287         vec_t<T,2,9010> _____ yx, gr, ts;
    288         vec_t<T,2,9011> const yy, gg, tt;
    289 
    290         vec_t<T,3,90000> const xxx, rrr, sss;
    291         vec_t<T,3,90001> const xxy, rrg, sst;
    292         vec_t<T,3,90010> const xyx, rgr, sts;
    293         vec_t<T,3,90011> const xyy, rgg, stt;
    294         vec_t<T,3,90100> const yxx, grr, tss;
    295         vec_t<T,3,90101> const yxy, grg, tst;
    296         vec_t<T,3,90110> const yyx, ggr, tts;
    297         vec_t<T,3,90111> const yyy, ggg, ttt;
    298 
    299         vec_t<T,4,900000> const xxxx, rrrr, ssss;
    300         vec_t<T,4,900001> const xxxy, rrrg, ssst;
    301         vec_t<T,4,900010> const xxyx, rrgr, ssts;
    302         vec_t<T,4,900011> const xxyy, rrgg, sstt;
    303         vec_t<T,4,900100> const xyxx, rgrr, stss;
    304         vec_t<T,4,900101> const xyxy, rgrg, stst;
    305         vec_t<T,4,900110> const xyyx, rggr, stts;
    306         vec_t<T,4,900111> const xyyy, rggg, sttt;
    307         vec_t<T,4,901000> const yxxx, grrr, tsss;
    308         vec_t<T,4,901001> const yxxy, grrg, tsst;
    309         vec_t<T,4,901010> const yxyx, grgr, tsts;
    310         vec_t<T,4,901011> const yxyy, grgg, tstt;
    311         vec_t<T,4,901100> const yyxx, ggrr, ttss;
    312         vec_t<T,4,901101> const yyxy, ggrg, ttst;
    313         vec_t<T,4,901110> const yyyx, gggr, ttts;
    314         vec_t<T,4,901111> const yyyy, gggg, tttt;
     286        vec_t<T, 2, 9000> const xx, rr, ss/**/;
     287        vec_t<T, 2, 9001> _____ xy, rg, st, rt;
     288        vec_t<T, 2, 9010> _____ yx, gr, ts, tr;
     289        vec_t<T, 2, 9011> const yy, gg, tt/**/;
     290
     291        vec_t<T, 3, 90000> const xxx, rrr, sss /**/;
     292        vec_t<T, 3, 90001> const xxy, rrg, sst, rrt;
     293        vec_t<T, 3, 90010> const xyx, rgr, sts, rtr;
     294        vec_t<T, 3, 90011> const xyy, rgg, stt, rtt;
     295        vec_t<T, 3, 90100> const yxx, grr, tss, trr;
     296        vec_t<T, 3, 90101> const yxy, grg, tst, trt;
     297        vec_t<T, 3, 90110> const yyx, ggr, tts, ttr;
     298        vec_t<T, 3, 90111> const yyy, ggg, ttt /**/;
     299
     300        vec_t<T, 4, 900000> const xxxx, rrrr, ssss  /**/;
     301        vec_t<T, 4, 900001> const xxxy, rrrg, ssst, rrrt;
     302        vec_t<T, 4, 900010> const xxyx, rrgr, ssts, rrtr;
     303        vec_t<T, 4, 900011> const xxyy, rrgg, sstt, rrtt;
     304        vec_t<T, 4, 900100> const xyxx, rgrr, stss, rtrr;
     305        vec_t<T, 4, 900101> const xyxy, rgrg, stst, rtrt;
     306        vec_t<T, 4, 900110> const xyyx, rggr, stts, rttr;
     307        vec_t<T, 4, 900111> const xyyy, rggg, sttt, rttt;
     308        vec_t<T, 4, 901000> const yxxx, grrr, tsss, trrr;
     309        vec_t<T, 4, 901001> const yxxy, grrg, tsst, trrt;
     310        vec_t<T, 4, 901010> const yxyx, grgr, tsts, trtr;
     311        vec_t<T, 4, 901011> const yxyy, grgg, tstt, trtt;
     312        vec_t<T, 4, 901100> const yyxx, ggrr, ttss, ttrr;
     313        vec_t<T, 4, 901101> const yyxy, ggrg, ttst, ttrt;
     314        vec_t<T, 4, 901110> const yyyx, gggr, ttts, tttr;
     315        vec_t<T, 4, 901111> const yyyy, gggg, tttt  /**/;
    315316#endif
    316317
     
    437438        struct { T r, g, b; };
    438439        struct { T s, t, p; };
     440        struct { T r, t, p; };
    439441
    440442#if !_DOXYGEN_SKIP_ME
    441         vec_t<T,2,9000> const xx, rr, ss;
    442         vec_t<T,2,9001> _____ xy, rg, st;
    443         vec_t<T,2,9002> _____ xz, rb, sp;
    444         vec_t<T,2,9010> _____ yx, gr, ts;
    445         vec_t<T,2,9011> const yy, gg, tt;
    446         vec_t<T,2,9012> _____ yz, gb, tp;
    447         vec_t<T,2,9020> _____ zx, br, ps;
    448         vec_t<T,2,9021> _____ zy, bg, pt;
    449         vec_t<T,2,9022> const zz, bb, pp;
    450 
    451         vec_t<T,3,90000> const xxx, rrr, sss;
    452         vec_t<T,3,90001> const xxy, rrg, sst;
    453         vec_t<T,3,90002> const xxz, rrb, ssp;
    454         vec_t<T,3,90010> const xyx, rgr, sts;
    455         vec_t<T,3,90011> const xyy, rgg, stt;
    456         vec_t<T,3,90012> _____ xyz, rgb, stp;
    457         vec_t<T,3,90020> const xzx, rbr, sps;
    458         vec_t<T,3,90021> _____ xzy, rbg, spt;
    459         vec_t<T,3,90022> const xzz, rbb, spp;
    460         vec_t<T,3,90100> const yxx, grr, tss;
    461         vec_t<T,3,90101> const yxy, grg, tst;
    462         vec_t<T,3,90102> _____ yxz, grb, tsp;
    463         vec_t<T,3,90110> const yyx, ggr, tts;
    464         vec_t<T,3,90111> const yyy, ggg, ttt;
    465         vec_t<T,3,90112> const yyz, ggb, ttp;
    466         vec_t<T,3,90120> _____ yzx, gbr, tps;
    467         vec_t<T,3,90121> const yzy, gbg, tpt;
    468         vec_t<T,3,90122> const yzz, gbb, tpp;
    469         vec_t<T,3,90200> const zxx, brr, pss;
    470         vec_t<T,3,90201> _____ zxy, brg, pst;
    471         vec_t<T,3,90202> const zxz, brb, psp;
    472         vec_t<T,3,90210> _____ zyx, bgr, pts;
    473         vec_t<T,3,90211> const zyy, bgg, ptt;
    474         vec_t<T,3,90212> const zyz, bgb, ptp;
    475         vec_t<T,3,90220> const zzx, bbr, pps;
    476         vec_t<T,3,90221> const zzy, bbg, ppt;
    477         vec_t<T,3,90222> const zzz, bbb, ppp;
     443        vec_t<T, 2, 9000> const xx, rr, ss/**/;
     444        vec_t<T, 2, 9001> _____ xy, rg, st, rt;
     445        vec_t<T, 2, 9002> _____ xz, rb, sp, rp;
     446        vec_t<T, 2, 9010> _____ yx, gr, ts, tr;
     447        vec_t<T, 2, 9011> const yy, gg, tt/**/;
     448        vec_t<T, 2, 9012> _____ yz, gb, tp/**/;
     449        vec_t<T, 2, 9020> _____ zx, br, ps, pr;
     450        vec_t<T, 2, 9021> _____ zy, bg, pt/**/;
     451        vec_t<T, 2, 9022> const zz, bb, pp/**/;
     452
     453        vec_t<T, 3, 90000> const xxx, rrr, sss /**/;
     454        vec_t<T, 3, 90001> const xxy, rrg, sst, rrt;
     455        vec_t<T, 3, 90002> const xxz, rrb, ssp, rrp;
     456        vec_t<T, 3, 90010> const xyx, rgr, sts, rtr;
     457        vec_t<T, 3, 90011> const xyy, rgg, stt, rtt;
     458        vec_t<T, 3, 90012> _____ xyz, rgb, stp, rtp;
     459        vec_t<T, 3, 90020> const xzx, rbr, sps, rpr;
     460        vec_t<T, 3, 90021> _____ xzy, rbg, spt, rpt;
     461        vec_t<T, 3, 90022> const xzz, rbb, spp, rpp;
     462        vec_t<T, 3, 90100> const yxx, grr, tss, trr;
     463        vec_t<T, 3, 90101> const yxy, grg, tst, trt;
     464        vec_t<T, 3, 90102> _____ yxz, grb, tsp, trp;
     465        vec_t<T, 3, 90110> const yyx, ggr, tts, ttr;
     466        vec_t<T, 3, 90111> const yyy, ggg, ttt /**/;
     467        vec_t<T, 3, 90112> const yyz, ggb, ttp /**/;
     468        vec_t<T, 3, 90120> _____ yzx, gbr, tps, tpr;
     469        vec_t<T, 3, 90121> const yzy, gbg, tpt /**/;
     470        vec_t<T, 3, 90122> const yzz, gbb, tpp /**/;
     471        vec_t<T, 3, 90200> const zxx, brr, pss, prr;
     472        vec_t<T, 3, 90201> _____ zxy, brg, pst, prt;
     473        vec_t<T, 3, 90202> const zxz, brb, psp, prp;
     474        vec_t<T, 3, 90210> _____ zyx, bgr, pts, ptr;
     475        vec_t<T, 3, 90211> const zyy, bgg, ptt /**/;
     476        vec_t<T, 3, 90212> const zyz, bgb, ptp /**/;
     477        vec_t<T, 3, 90220> const zzx, bbr, pps, ppr;
     478        vec_t<T, 3, 90221> const zzy, bbg, ppt /**/;
     479        vec_t<T, 3, 90222> const zzz, bbb, ppp /**/;
    478480
    479481        vec_t<T,4,900000> const xxxx, rrrr, ssss;
     
    12191221
    12201222template<typename T, int N, int SWIZZLE>
    1221 static inline vec_t<T,N> radians(vec_t<T,N,SWIZZLE> const &a)
    1222 {
    1223     vec_t<T,N> ret;
     1223static inline vec_t<T, N> radians(vec_t<T, N, SWIZZLE> const &a)
     1224{
     1225    vec_t<T, N> ret;
    12241226    for (int i = 0; i < N; ++i)
    12251227        ret[i] = lol::radians(a[i]);
     1228    return ret;
     1229}
     1230
     1231//Cartesian operation consider that you're in spherical coordinate
     1232template<typename T, int SWIZZLE>
     1233static inline vec_t<T, 2> cartesian(vec_t<T, 2, SWIZZLE> const &a)
     1234{
     1235    vec_t<T, 2> ret;
     1236    ret.x = r * lol::cos(t);
     1237    ret.y = r * lol::sin(t);
     1238    return ret;
     1239}
     1240
     1241template<typename T, int SWIZZLE>
     1242static inline vec_t<T, 3> cartesian(vec_t<T, 3, SWIZZLE> const &a)
     1243{
     1244    vec_t<T, 3> ret;
     1245    ret.x = r * lol::sin(t) * lol::cos(p);
     1246    ret.y = r * lol::sin(t) * lol::sin(p);
     1247    ret.z = r * lol::cos(t);
     1248    return ret;
     1249}
     1250
     1251//Spherical operation consider that you're in cartesian coordinate
     1252template<typename T, int SWIZZLE>
     1253static inline vec_t<T, 2> spherical(vec_t<T, 2, SWIZZLE> const &a)
     1254{
     1255    vec_t<T, 2> ret;
     1256    ret.r = lol::sqrt(lol::sq(x) + lol::sq(y));
     1257    ret.t = lol::atan2(y, x);
     1258    return ret;
     1259}
     1260
     1261template<typename T, int SWIZZLE>
     1262static inline vec_t<T, 3> spherical(vec_t<T, 3, SWIZZLE> const &a)
     1263{
     1264    vec_t<T, 3> ret;
     1265    ret.r = lol::sqrt(lol::sq(x) + lol::sq(y) + lol::sq(z));
     1266    ret.t = lol::acos(z / ret.x);
     1267    ret.p = lol::atan(y / x);
    12261268    return ret;
    12271269}
  • trunk/src/lolua/baselua.h

    r3863 r3866  
    258258
    259259public:
    260     VarPtr() { }
     260    VarPtr(bool optional = false)
     261    {
     262        m_optional = optional;
     263    }
    261264    VarPtr(T* value, bool optional = false)
     265        : VarPtr(optional)
    262266    {
    263267        m_value = value;
    264         m_optional = optional;
    265268    }
    266269    VarPtr(LuaState* l, int& index, bool optional = false)
    267     {
    268         m_optional = optional;
     270        : VarPtr(optional)
     271    {
     272        GetInc(l, index);
     273    }
     274    VarPtr(T* value, LuaState* l, int& index, bool optional = false)
     275        : VarPtr(value, optional)
     276    {
    269277        GetInc(l, index);
    270278    }
     
    319327{
    320328public:
    321     VarPtrLight() : VarPtr() { }
     329    VarPtrLight(bool optional = false) : VarPtr(optional) { }
    322330    VarPtrLight(T* value, bool optional = false) : VarPtr(value, optional) { }
    323331    VarPtrLight(LuaState* l, int& index, bool optional = false) : VarPtr(l, index, optional) { }
     332    VarPtrLight(T* value, LuaState* l, int& index, bool optional = false) : VarPtr(value, l, index, optional) { }
    324333protected:
    325334    virtual void InnerGet(LuaState* l, int& index)
     
    334343class Var
    335344{
    336 private:
     345protected:
    337346    bool m_optional = false;
    338347    T m_value;
     
    354363        GetInc(l, index);
    355364    }
    356     inline operator T()            { return m_value; }
    357     inline T& operator ()()        { return m_value; }
     365    Var(T value, LuaState* l, int& index, bool optional = false)
     366    {
     367        m_optional = optional;
     368        m_value = value;
     369        GetInc(l, index);
     370    }
     371    inline operator T()     { return m_value; }
     372    inline T& operator ()() { return m_value; }
     373    inline T& GetValue()    { return m_value; }
    358374    inline bool IsValid(LuaState* l, int index)
    359375    {
    360376        return InnerIsValid(l, index);
     377    }
     378    inline bool IsOptional()
     379    {
     380        return m_optional;
    361381    }
    362382private:
     
    403423    inline bool operator!=(const Var<T>& o)    { return m_value != o.m_value; }
    404424
    405 private:
     425protected:
    406426    void InnerInit()                          { m_value = T(0); }
    407427    bool InnerIsValid(LuaState* l, int index) { UNUSED(l); UNUSED(index); ASSERT(false); return false; }
     
    558578{
    559579    Var<float> x(l, index);
    560     Var<float> y(x(), true); y.Get(l, index);
     580    Var<float> y(x(), l, index, true);
    561581    m_value = vec2(x, y);
    562582}
     
    576596{
    577597    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);
     598    Var<float> y(x(), l, index, true);
     599    Var<float> z(x(), l, index, true);
    580600    m_value = vec3(x, y, z);
    581601}
     
    596616{
    597617    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);
     618    Var<float> y(x(), l, index, true);
     619    Var<float> z(x(), l, index, true);
     620    Var<float> w(x(), l, index, true);
    601621    m_value = vec4(x, y, z, w);
    602622}
     
    611631
    612632//-----------------------------------------------------------------------------
     633class VarColor
     634{
     635protected:
     636    Var<vec4> m_value;
     637
     638public:
     639    VarColor(bool optional = false)
     640    {
     641        m_value = Var<vec4>(optional);
     642        InnerInit();
     643    }
     644    VarColor(vec4 value, bool optional = false)
     645    {
     646        m_value = Var<vec4>(value, optional);
     647    }
     648    VarColor(LuaState* l, int& index, bool optional = false)
     649        : VarColor(optional)
     650    {
     651        GetInc(l, index);
     652    }
     653    VarColor(vec4 value, LuaState* l, int& index, bool optional = false)
     654        : VarColor(value, optional)
     655    {
     656        GetInc(l, index);
     657    }
     658
     659    inline operator vec4()     { return m_value; }
     660    inline vec4& operator ()() { return m_value(); }
     661    inline vec4& GetValue()    { return m_value.GetValue(); }
     662    inline bool IsValid(LuaState* l, int index)
     663    {
     664        return InnerIsValid(l, index);
     665    }
     666private:
     667    void GetInc(LuaState* l, int& index)
     668    {
     669        bool is_nil = lua_isnil(l, index);
     670        if (!m_value.IsOptional() || (!is_nil && InnerIsValid(l, index)))
     671        {
     672            ASSERT(!is_nil);
     673            InnerGet(l, index);
     674        }
     675    }
     676public:
     677    inline void Get(LuaState* l, int index)
     678    {
     679        int idx = index;
     680        GetInc(l, idx);
     681    }
     682    inline int Return(LuaState* l)
     683    {
     684        return InnerPush(l);
     685    }
     686    inline VarColor&  operator-(const vec4& value)  { m_value - value; return *this; }
     687    inline VarColor&  operator+(const vec4& value)  { m_value + value; return *this; }
     688    inline VarColor&  operator*(const vec4& value)  { m_value  * value; return *this; }
     689    inline VarColor&  operator/(const vec4& value)  { m_value / value; return *this; }
     690    inline VarColor&  operator=(const vec4& value)  { m_value = value; return *this; }
     691    inline VarColor& operator-=(const vec4& value)  { m_value -= value; return *this; }
     692    inline VarColor& operator+=(const vec4& value)  { m_value += value; return *this; }
     693    inline VarColor& operator*=(const vec4& value)  { m_value *= value; return *this; }
     694    inline VarColor& operator/=(const vec4& value)  { m_value /= value; return *this; }
     695    inline VarColor&  operator-(const Var<vec4>& o) { m_value - o; return *this; }
     696    inline VarColor&  operator+(const Var<vec4>& o) { m_value + o; return *this; }
     697    inline VarColor&  operator*(const Var<vec4>& o) { m_value  * o; return *this; }
     698    inline VarColor&  operator/(const Var<vec4>& o) { m_value / o; return *this; }
     699    inline VarColor&  operator=(const Var<vec4>& o) { m_value = o; return *this; }
     700    inline VarColor& operator-=(const Var<vec4>& o) { m_value -= o; return *this; }
     701    inline VarColor& operator+=(const Var<vec4>& o) { m_value += o; return *this; }
     702    inline VarColor& operator*=(const Var<vec4>& o) { m_value *= o; return *this; }
     703    inline VarColor& operator/=(const Var<vec4>& o) { m_value /= o; return *this; }
     704    inline bool operator==(const vec4& value)     { return m_value == value; }
     705    inline bool operator!=(const vec4& value)     { return m_value != value; }
     706    inline bool operator==(const Var<vec4>& o)    { return m_value == o; }
     707    inline bool operator!=(const Var<vec4>& o)    { return m_value != o; }
     708    inline VarColor&  operator-(const VarColor& v)  { m_value -  v.m_value; return *this; }
     709    inline VarColor&  operator+(const VarColor& v)  { m_value +  v.m_value; return *this; }
     710    inline VarColor&  operator*(const VarColor& v)  { m_value  * v.m_value; return *this; }
     711    inline VarColor&  operator/(const VarColor& v)  { m_value /  v.m_value; return *this; }
     712    inline VarColor&  operator=(const VarColor& v)  { m_value =  v.m_value; return *this; }
     713    inline VarColor& operator-=(const VarColor& v)  { m_value -= v.m_value; return *this; }
     714    inline VarColor& operator+=(const VarColor& v)  { m_value += v.m_value; return *this; }
     715    inline VarColor& operator*=(const VarColor& v)  { m_value *= v.m_value; return *this; }
     716    inline VarColor& operator/=(const VarColor& v)  { m_value /= v.m_value; return *this; }
     717    inline bool operator==(const VarColor& v)     { return m_value == v.m_value; }
     718    inline bool operator!=(const VarColor& v)     { return m_value != v.m_value; }
     719
     720protected:
     721    void InnerInit()
     722    {
     723        m_value = vec4::zero;
     724    }
     725    bool InnerIsValid(LuaState* l, int index)
     726    {
     727        Var<String> s;
     728        return m_value.IsValid(l, index) || s.IsValid(l, index);
     729    }
     730    void InnerGet(LuaState* l, int& index)
     731    {
     732        //Try vec4 first
     733        if (m_value.IsValid(l, index))
     734        {
     735            m_value.Get(l, index);
     736        }
     737        else
     738        {
     739            Var<String> c(l, index);
     740            *this = Color::C8BppHexString(c);
     741        }
     742    }
     743    int InnerPush(LuaState* l)
     744    {
     745        Var<String> c = Color::HexString8Bpp(m_value);
     746        return c.Return(l);
     747    }
     748};
     749
     750//-----------------------------------------------------------------------------
     751template<typename E>
     752class VarEnum
     753{
     754protected:
     755    SafeEnum<E> m_value;
     756    bool m_optional = false;
     757
     758public:
     759    VarEnum(bool optional = false)
     760    {
     761        m_optional = optional;
     762        InnerInit();
     763    }
     764    VarEnum(SafeEnum<E> value, bool optional = false)
     765        : VarEnum(optional)
     766    {
     767        m_value = value;
     768    }
     769    VarEnum(LuaState* l, int& index, bool optional = false)
     770        : VarEnum(optional)
     771    {
     772        GetInc(l, index);
     773    }
     774    VarEnum(vec4 value, LuaState* l, int& index, bool optional = false)
     775        : VarEnum(value, optional)
     776    {
     777        GetInc(l, index);
     778    }
     779
     780    inline operator SafeEnum<E>()     { return m_value; }
     781    inline SafeEnum<E>& operator ()() { return m_value; }
     782    inline SafeEnum<E>& GetValue()    { return m_value; }
     783    inline bool IsValid(LuaState* l, int index)
     784    {
     785        return InnerIsValid(l, index);
     786    }
     787private:
     788    void GetInc(LuaState* l, int& index)
     789    {
     790        bool is_nil = lua_isnil(l, index);
     791        if (!m_optional || (!is_nil && InnerIsValid(l, index)))
     792        {
     793            ASSERT(!is_nil);
     794            InnerGet(l, index);
     795        }
     796    }
     797public:
     798    inline void Get(LuaState* l, int index)
     799    {
     800        int idx = index;
     801        GetInc(l, idx);
     802    }
     803    inline int Return(LuaState* l)
     804    {
     805        return InnerPush(l);
     806    }
     807    inline VarEnum<E>&  operator-(const SafeEnum<E>& value)  { m_value - value; return *this; }
     808    inline VarEnum<E>&  operator+(const SafeEnum<E>& value)  { m_value + value; return *this; }
     809    inline VarEnum<E>&  operator*(const SafeEnum<E>& value)  { m_value  * value; return *this; }
     810    inline VarEnum<E>&  operator/(const SafeEnum<E>& value)  { m_value / value; return *this; }
     811    inline VarEnum<E>&  operator=(const SafeEnum<E>& value)  { m_value = value; return *this; }
     812    inline VarEnum<E>& operator-=(const SafeEnum<E>& value)  { m_value -= value; return *this; }
     813    inline VarEnum<E>& operator+=(const SafeEnum<E>& value)  { m_value += value; return *this; }
     814    inline VarEnum<E>& operator*=(const SafeEnum<E>& value)  { m_value *= value; return *this; }
     815    inline VarEnum<E>& operator/=(const SafeEnum<E>& value)  { m_value /= value; return *this; }
     816    inline bool operator==(const SafeEnum<E>& value)     { return m_value == value; }
     817    inline bool operator!=(const SafeEnum<E>& value)     { return m_value != value; }
     818    inline VarEnum<E>&  operator-(const VarEnum<E>& v)  { m_value - v.m_value; return *this; }
     819    inline VarEnum<E>&  operator+(const VarEnum<E>& v)  { m_value + v.m_value; return *this; }
     820    inline VarEnum<E>&  operator*(const VarEnum<E>& v)  { m_value  * v.m_value; return *this; }
     821    inline VarEnum<E>&  operator/(const VarEnum<E>& v)  { m_value / v.m_value; return *this; }
     822    inline VarEnum<E>&  operator=(const VarEnum<E>& v)  { m_value = v.m_value; return *this; }
     823    inline VarEnum<E>& operator-=(const VarEnum<E>& v)  { m_value -= v.m_value; return *this; }
     824    inline VarEnum<E>& operator+=(const VarEnum<E>& v)  { m_value += v.m_value; return *this; }
     825    inline VarEnum<E>& operator*=(const VarEnum<E>& v)  { m_value *= v.m_value; return *this; }
     826    inline VarEnum<E>& operator/=(const VarEnum<E>& v)  { m_value /= v.m_value; return *this; }
     827    inline bool operator==(const VarEnum<E>& v)     { return m_value == v.m_value; }
     828    inline bool operator!=(const VarEnum<E>& v)     { return m_value != v.m_value; }
     829
     830protected:
     831    void InnerInit()
     832    {
     833        m_value = SafeEnum<E>(0);
     834    }
     835    bool InnerIsValid(LuaState* l, int index)
     836    {
     837        Var<String> s;
     838        return s.IsValid(l, index);
     839    }
     840    void InnerGet(LuaState* l, int& index)
     841    {
     842        Var<String> c(l, index);
     843        *this = FindValue<SafeEnum<E> >(c);
     844    }
     845    int InnerPush(LuaState* l)
     846    {
     847        Var<String> s = this->GetValue().ToString();
     848        return s.Return(l);
     849    }
     850};
     851
     852//-----------------------------------------------------------------------------
    613853class Stack
    614854{
     
    628868    //-------------------------------------------------------------------------
    629869    template<typename T>
     870    Stack& operator>>(T& var)
     871    {
     872        var = T(m_state, m_index);
     873        return *this;
     874    }
     875    /*
     876    template<typename T>
    630877    Stack& operator>>(Var<T>& var)
    631878    {
    632         var = Var<T>(m_state, m_index);
    633         return *this;
     879    var = Var<T>(m_state, m_index);
     880    return *this;
    634881    }
    635882    template<typename T>
     
    645892        return *this;
    646893    }
     894    */
    647895
    648896    //-------------------------------------------------------------------------
    649897    template<typename T>
    650     Stack& operator<<(Var<T>& var)
     898    Stack& operator<<(T& var)
    651899    {
    652900        m_result += var.Return(m_state);
    653901        return *this;
    654902    }
     903    /*
     904    template<typename T>
     905    Stack& operator<<(Var<T>& var)
     906    {
     907        m_result += var.Return(m_state);
     908        return *this;
     909    }
    655910    template<typename T>
    656911    Stack& operator<<(VarPtr<T>& var)
     
    665920        return *this;
    666921    }
     922    */
    667923
    668924private:
     
    724980typedef Lolua::Var<vec3>        LuaVec3;
    725981typedef Lolua::Var<vec4>        LuaVec4;
     982typedef Lolua::VarColor         LuaColor;
    726983typedef Lolua::Stack            LuaStack;
    727984
  • trunk/src/utils.h

    r3816 r3866  
    6969    {
    7070        String s = T(i).ToString().to_lower();
    71         if (s == n)
     71        if (s.Contains(n))
    7272            return T(i);
    7373    }
    7474    return T::Max;
    7575}
     76template<class T> inline T FindValue(String const& name)
     77{
     78    return FindValue<T>(name.C());
     79}
    7680
    7781} /* namespace lol */
Note: See TracChangeset for help on using the changeset viewer.