lol/doc/tutorial/14_lol_lua.cpp

//
// Lol Engine - Graphing tutorial
//
// Copyright: (c) 2012-2013 Sam Hocevar <sam@hocevar.net>
//   This program is free software; you can redistribute it and/or
//   modify it under the terms of the Do What The Fuck You Want To
//   Public License, Version 2, as published by Sam Hocevar. See
//   http://www.wtfpl.net/ for more details.
//

#if HAVE_CONFIG_H
#   include "config.h"
#endif

#include <lol/engine.h>
#include "loldebug.h"
#include <cstdio>

using namespace lol;

//-----------------------------------------------------------------------------
class FooTest
{
public:
    FooTest()
    {
    }
    static int New(Lolua::State* l)
    {
        int n_args = lua_gettop(l);  // Number of arguments

        // We could actually allocate Foo itself as a user data but 
        // since user data can be GC'ed and we gain unity by using CRT's heap 
        // all along.
        FooTest** udata = (FooTest**)lua_newuserdata(l, sizeof(FooTest*));
        *udata = new FooTest();

        // Usually, we'll just use "Foo" as the second parameter, but I 
        // say luaL_Foo here to distinguish the difference:
        //
        // This 2nd parameter here is an _internal label_ for luaL, it is 
        // _not_ exposed to Lua by default.
        //
        // Effectively, this metatable is not accessible by Lua by default.
        //luaL_getmetatable(l, m_table_name);

        // The Lua stack at this point looks like this:
        //     
        //     3| metatable "luaL_foo"   |-1
        //     2| userdata               |-2
        //     1| string parameter       |-3
        //
        // So the following line sets the metatable for the user data to the luaL_Foo 
        // metatable
        //
        // We must set the metatable here because Lua prohibits setting 
        // the metatable of a userdata in Lua. The only way to set a metatable 
        // of a userdata is to do it in C.
        //lua_setmetatable(l, -2);

        luaL_getmetatable(l, m_table2_name);
        lua_setmetatable(l, -2);

        // The Lua stack at this point looks like this:
        //     
        //     2| userdata               |-1
        //     1| string parameter       |-2
        // 
        // We return 1 so Lua callsite will get the user data and 
        // Lua will clean the stack after that.

        return 1;
    }
    static FooTest* Check(Lolua::State* l, int n)
    {
        // This checks that the argument is a userdata 
        // with the metatable "luaL_Foo"
        return *(FooTest**)luaL_testudata(l, n, m_table2_name);
    }
    static int Del(Lolua::State * l)
    {
        FooTest* foo = Check(l, 1);
        delete foo;

        return 0;
    }
    static void Register(Lolua::State * l)
    {
        // Create a luaL metatable. This metatable is not 
        // exposed to Lua. The "luaL_Foo" label is used by luaL
        // internally to identity things.
        luaL_newmetatable(l, m_table2_name);
        luaL_setfuncs(l, FooTest::m_statics2, 0);
        lua_pushvalue(l, -1);
        lua_setfield(l, -1, "__index");
        //lua_setglobal(l, m_class2_name);
        lua_pop(l, 1);

        // Create a luaL metatable. This metatable is not 
        // exposed to Lua. The "luaL_Foo" label is used by luaL
        // internally to identity things.
        luaL_newmetatable(l, m_table_name);

        // Register the C functions _into_ the metatable we just created.
        luaL_setfuncs(l, FooTest::m_statics, 0);

        // The Lua stack at this point looks like this:
        //     
        //     1| metatable "luaL_Foo"   |-1
        lua_pushvalue(l, -1);

        // The Lua stack at this point looks like this:
        //     
        //     2| metatable "luaL_Foo"   |-1
        //     1| metatable "luaL_Foo"   |-2

        // Set the "__index" field of the metatable to point to itself
        // This pops the stack
        lua_setfield(l, -1, "__index");

        // The Lua stack at this point looks like this:
        //     
        //     1| metatable "luaL_Foo"   |-1

        // The luaL_Foo metatable now has the following fields
        //     - __gc
        //     - __index
        //     - new

        // Now we use setglobal to officially expose the luaL_Foo metatable 
        // to Lua. And we use the name "Foo".
        //
        // This allows Lua scripts to _override_ the metatable of Foo.
        // For high security code this may not be called for but 
        // we'll do this to get greater flexibility.
        lua_setglobal(l, m_class_name);
    }
    static int Test1(Lolua::State* L)
    {
        Lolua::Var<int> i1(L, 1);
        i1 += 5;
        return i1.Return(L);
    }
    static int Test2(Lolua::State* L)
    {
        FooTest* foo = Check(L, 1);
        Lolua::Var<float> i1(L, 2);
        i1 = foo->Test2Inst(i1.V());
        return i1.Return(L);
    }
    float Test2Inst(float f)
    {
        return (f + 10);
    }

    static const char m_class_name[];
    static const char m_class2_name[];
    static const char m_table_name[];
    static const char m_table2_name[];
    static const luaL_Reg m_statics[];
    static const luaL_Reg m_statics2[];
    static const luaL_Reg m_methods[];
};

const luaL_Reg FooTest::m_statics[] = {
    { "New", &FooTest::New },
    { "__gc", &FooTest::Del },
    { "Test1", &FooTest::Test1 },
    { NULL, NULL } };
const luaL_Reg FooTest::m_statics2[] = {
    { "Test2", &FooTest::Test2 },
    { NULL, NULL } };
const luaL_Reg FooTest::m_methods[] = { { NULL, NULL } };
const char     FooTest::m_class_name[] = "FooTest";
const char     FooTest::m_class2_name[] = "FooTest2";
const char     FooTest::m_table_name[] = "FooTest_mt";
const char     FooTest::m_table2_name[] = "FooTest_mt2";

typedef Lolua::ObjectDef<FooTest> FooTestLuaBase;
class FooTestLua : public FooTestLuaBase
{
public:
    FooTestLua() : FooTestLuaBase() {}
    virtual ~FooTestLua() {}
    static FooTestLua* New(Lolua::State* l, int arg_nb)
    {
        return new FooTestLua();
    }
    static const char* GetClassName();
    static const char* GetClassLibName();
    static const char* GetClassInstName();
    static const Lolua::ClassMethod* GetStaticMethods();
    static const Lolua::ClassMethod* GetInstanceMethods();
    static int Test1(Lolua::State* L)
    {
        Lolua::Var<int> i1(L, 1);
        i1 += 5;
        return i1.Return(L);
    }
    static int Test2(Lolua::State* L)
    {
        Lolua::VarPtr<FooTestLua> foo(L, 1);
        Lolua::Var<float> i1(L, 2);
        i1 = foo.V()->Test2Inst(i1.V());
        return i1.Return(L);
    }
    float Test2Inst(float f)
    {
        return (f + 10);
    }
};

static const Lolua::ClassMethod FooTest_statics[] = { { "Test1", &FooTestLua::Test1 }, { NULL, NULL } };
const Lolua::ClassMethod FooTest_methods[] = { { "Test2", &FooTestLua::Test2 }, { NULL, NULL } };

const char* FooTestLua::GetClassName() { static const char name[] = "FooTest"; return name; }
const char* FooTestLua::GetClassLibName() { static const char name[] = "FooTestLib"; return name; }
const char* FooTestLua::GetClassInstName() { static const char name[] = "FooTestInst"; return name; }
const Lolua::ClassMethod* FooTestLua::GetStaticMethods() { return FooTest_statics; }
const Lolua::ClassMethod* FooTestLua::GetInstanceMethods() { return FooTest_methods; }

//-----------------------------------------------------------------------------
class LoluaDemoLoader : public Lolua::Loader
{
public:
    LoluaDemoLoader() : Lolua::Loader()
    {
        Lolua::State* l = GetLuaState();

        Lolua::Object::Register<FooTestLua>(l);

        ExecLua("14_lol_lua.lua");
    }
    virtual ~LoluaDemoLoader()
    {

    }
};

//-----------------------------------------------------------------------------
class LoluaDemo : public WorldEntity
{
public:
    LoluaDemo()
    {
    }

    virtual void TickGame(float seconds)
    {
        WorldEntity::TickGame(seconds);

        LoluaDemoLoader* demo_loader = new LoluaDemoLoader();

        float TestValueNum = demo_loader->GetVar<float>("TestValueNum");
        int32_t TestValueInt = demo_loader->GetVar<int32_t>("TestValueInt");
        uint32_t TestValueUint = demo_loader->GetVar<uint32_t>("TestValueUint");
        String TestValueStr = demo_loader->GetVar<String>("TestValueStr");
        //String test_return2 = demo_loader->GetVar<String>("test_return2");
        //String test_return3 = demo_loader->GetVar<String>("test_return3");
        int32_t testtruc_return = demo_loader->GetVar<int32_t>("footest_return");
        float testtruc_return2 = demo_loader->GetVar<float>("footest_return2");
        //int32_t testtruc2_return = demo_loader->GetVar<int32_t>("testtruc_return2");

        String::Printf("Lua Vars: TestValueNum: %.2f, TestValueInt: %i, TestValueUint: %i, TestValueStr: %s.", 
                                  TestValueNum, TestValueInt, TestValueUint, TestValueStr);

        delete demo_loader;

        Ticker::Shutdown();
    }

    virtual void TickDraw(float seconds, Scene &scene)
    {
        WorldEntity::TickDraw(seconds, scene);
    }
};

//-----------------------------------------------------------------------------
int main(int argc, char **argv)
{
    System::Init(argc, argv);

    Application app("Tutorial 14: Lolua Demo", ivec2(800, 600), 60.0f);

    new LoluaDemo();

    app.Run();
    return EXIT_SUCCESS;
}