LuaBindingGuide

luabindings for global functions

• lua can call special c functions that have a special prototype/parameter layout
• to call arbitrary c functions from lua wrappers that match the prototype have to be created, we call those lua-bindings
• global functions that can be called by lua all have this prototype : static int l_MyFunction (lua_State *L) { ... }
• arguments from lua are passed on a stack and can be read using luaL_checkstring(L,1)
  • index is one-based, eg starting from 1, 1st paramter is 1, 2nd is 2 etc, left to right.
• the functions can return any number of values, including 0 or multiple
• to add a return value to lua you push it onto the stack like this : lua_pushnumber(L,1);
• the c functions c-return value is the number of lua-return-values pushed

luabindings for c++ classes

• you can also create lua-bindings for entire c++ classes
• if you want to create a lua-binding for the class cMyClass,
• this class has to inherit from cSmartPointable
• then you create a wrapper-class cMyClass_L that inherits cLuaBind<cMyClass> (you need luabind.h)
• those wrapper classes are usually in extra files named _L.cpp
• wrapped methods look like this : static int MyMethod (lua_State *L) { ... }
• parameter access is similar to global functions, except that parameter indices start at 2, as 1 is for the implicit self
• you cannot use this as the wrapper-methods have to be static, but you can get the implicit self by checkudata_alive(L)
• checkudata_alive(L) = checkudata_alive(L,1) (you can also retrieve parameters that are objects with that)
• all class-bindins have to have a unique typename : virtual const char* GetLuaTypeName () { return "sfz.objcontroller"; }
• create new instances like this : return CreateUData(L,new cMyClass()); (pushes a lua-udata and returns 1)
• method wrappers must be registered in the overridden RegisterMethods() method, usually via macro REGISTER_METHOD, see examples
• you can also register member variables in some cases if you don't like manually implementing getter/setter, see gfx3D_L.cpp
• the wrapper class has to be registered at startup : call from lua-plugin : static void LuaRegister (lua_State *L);
  • where LuaRegister is a method that calls cLuaBind<cMyClass>::GetSingletonPtr(new cMyClass_L())->LuaRegister(L);

tips and tricks

• for variable argument count, you can use lua_gettop(L) = c (-1 for methods due to implicit self)
• for default argument value you can use this : int a = (lua_gettop(L) >= 2 && !lua_isnil(L,2)) ? luaL_checkint(L,2) : 0;
• luaL_checkstring(L,2) returns const char* and is not valid for long, so you best assign it to an std::string
• see l_GetAllKeyNames() in lugre_scripting.general.cpp for an example of how to return an array/table
• you can call lua from c, but avoid that if possible (the application should be lua driven), search for examples similar to this :
  • cScripting::GetSingletonPtr()->LuaCall("NotifyMainWindowResized","ii",w,h);
  • it uses a variable argument-count syntax with format string remotely similar to printf
  • it does support multiple returns by passing pointers and return format e
  • e.g. LuaCall("MyLuaFun","i>ff",3,&fA,&fB) takes one integer and "returns" two doubles
  • warning, there is no typechecking on the params, erros will lead to undefined behaviour :
  • input/parameter values : i:int,f:double,s:char*
  • output/return values : i:int*,f:double*,s:std::string*
  • it only supports primitive parameter and return types, not tables/arrays
  • you better avoid calling lua from c
  • if you absolutely have to have to, please at least try to avoid using those ugly returnvalues
• lua uses floats internally for all numbers
  • there have been problems on some computers with 32 bit integer precision with compiler optimisation turned on in vs
  • so if you need 32 bits you might want to use the pointertype lua_pushlightuserdata(...)