SHARE
TWEET

Classe lua C++ com métodos e atributos

michelBrazMorais Oct 3rd, 2013 41 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. extern "C"
  3. {
  4.          #include <lua.h>
  5.          #include <lauxlib.h>
  6.          #include <lualib.h>
  7. }
  8.  
  9. #include <math.h>
  10.  
  11. struct VEC3
  12. {
  13.         float x,y,z;
  14. };
  15.  
  16. static void printStack (lua_State * lua,int n)
  17. {
  18.         int top = lua_gettop(lua);
  19.         printf( "\n**********************************"
  20.                     "\nEstado da pilha na linha %d\n",n);
  21.         for (int i = 1, k= top; i <= top; i++, k--)
  22.         {
  23.                 int type = lua_type(lua, i);
  24.                 printf("\t%d| %8s |%d\n", -k , lua_typename(lua, type), i);
  25.         }
  26.         printf("**********************************\n\n");
  27. }
  28.  
  29. inline VEC3* getVec3FromRawTable(lua_State * lua,const int rawi,const int indexTable)//ok 03/10/2013
  30. {
  31.         //printStack(lua,__LINE__);
  32.         /*
  33.         esperado
  34.         **********************************
  35.                         Estado da pilha
  36.                         -2|    table |1
  37.                         -1|   string |2
  38.         **********************************
  39.         */
  40.         luaL_argcheck(lua,indexTable <= lua_gettop(lua),indexTable,"argumento esperado: vec3");
  41.         lua_rawgeti(lua,indexTable,rawi);
  42.         //printStack(lua,__LINE__);
  43.         /*
  44.         **********************************
  45.         Estado da pilha na linha 43
  46.                         -3|    table |1
  47.                         -2|   string |2
  48.                         -1| userdata |3
  49.         **********************************
  50.         */
  51.         VEC3** ud = (VEC3**)lua_touserdata(lua, -1);
  52.         //printStack(lua,__LINE__);
  53.         /*
  54.         **********************************
  55.                         Estado da pilha
  56.                         -3|    table |1
  57.                         -2|   string |2
  58.                         -1| userdata |3
  59.         **********************************
  60.         */
  61.         lua_pop(lua,1);
  62.         //printStack(lua,__LINE__);
  63.         /*
  64.         **********************************
  65.                         Estado da pilha
  66.                         -2|    table |1
  67.                         -1|   string |2
  68.         **********************************
  69.         */
  70.         return  *ud;
  71. }
  72.  
  73.  
  74. static int onLengthVec3(lua_State * lua)
  75. {
  76.         VEC3 * vec3     = getVec3FromRawTable(lua, 0,1);
  77.         const float ret = sqrt((vec3->x*vec3->x) + (vec3->y*vec3->y) + (vec3->z*vec3->z));
  78.         lua_pushnumber(lua,ret);
  79.         return 1;
  80. }
  81.  
  82. static int onMulVec3(lua_State * lua)//ok 03/10/2013
  83. {
  84.        
  85.         //printStack(lua,__LINE__);
  86.         /*
  87.         vec3.mul(vetor1,"lua_parametros_digi") -> Lua error: teste.lua:10: attempt to call method 'mul' (a nil value)
  88.         vec3:mul(vetor1,"lua_parametros_digi") -> Lua error: teste.lua:10: attempt to call method 'mul' (a nil value)
  89.        
  90.         vetor1.mul(vetor1,"lua_parametros_digi") ->
  91.         **********************************
  92.                         Estado da pilha
  93.                         -2|    table |1
  94.                         -1|   number |2
  95.         **********************************
  96.        
  97.         vetor1:mul(vetor1,"lua_parametros_digi") ->
  98.         **********************************
  99.                         Estado da pilha
  100.                         -3|    table |1
  101.                         -2|    table |2
  102.                         -1|   string |3
  103.         **********************************
  104.        
  105.         vetor1:mul("lua_parametros_digi") ->
  106.         **********************************
  107.                         Estado da pilha
  108.                         -2|    table |1
  109.                         -1|   string |2
  110.         **********************************
  111.         */
  112.         VEC3 * vec3 = getVec3FromRawTable(lua, 0,1);
  113.         //printf("Vec3 from userdata %f %f %f \n",vec3->x,vec3->y,vec3->z);
  114.         //printStack(lua,__LINE__);
  115.         const float x = luaL_checknumber(lua,2);
  116.         const float y = luaL_checknumber(lua,3);
  117.         const float z = luaL_checknumber(lua,4);
  118.         //printStack(lua,__LINE__);
  119.         vec3->x  = x * vec3->x;
  120.         vec3->y  = y * vec3->y;
  121.         vec3->z  = z * vec3->z;
  122.         return 0;
  123. }
  124.  
  125. static int onNewVec3Lua(lua_State* lua)//ok 03/10/2013
  126. {
  127.         //printStack(lua,__LINE__);
  128.         /*
  129.         //esperado
  130.         **********************************
  131.                         Estado da pilha
  132.                         -1|    table |1
  133.         **********************************
  134.         ou     
  135.         **********************************
  136.                         Estado da pilha
  137.                         -4|    table |1
  138.                         -3|   number |2
  139.                         -2|   number |3
  140.                         -1|   number |4
  141.         **********************************
  142.         ou
  143.         **********************************
  144.                         Estado da pilha
  145.                         -2|    table |1
  146.                         -1|    table |2
  147.         **********************************
  148.        
  149.         */
  150.         const int top                   = lua_gettop(lua);
  151.         const VEC3 * vec3Copy   = (top == 2 && lua_type(lua,2) == LUA_TTABLE) ? getVec3FromRawTable(lua, 0,2) : NULL;
  152.         const float x                   = vec3Copy ? vec3Copy->x : (top > 1 ? luaL_checknumber(lua,2) : 0.0f);
  153.         const float y                   = vec3Copy ? vec3Copy->y : (top > 2 ? luaL_checknumber(lua,3) : 0.0f);
  154.         const float z                   = vec3Copy ? vec3Copy->z : (top > 3 ? luaL_checknumber(lua,4) : 0.0f);
  155.         lua_settop(lua,0);
  156.         //printStack(lua,__LINE__);
  157.         /*
  158.         **********************************
  159.                         Estado da pilha
  160.         **********************************
  161.         */
  162.         luaL_Reg regVec3Methods[] =
  163.         {
  164.                 {"mul",         onMulVec3},
  165.                 {"length",              onLengthVec3},
  166.                 {NULL,                  NULL}
  167.         };
  168.         luaL_newlib(lua, regVec3Methods);
  169.         //printStack(lua,__LINE__);
  170.         /*
  171.         **********************************
  172.                         Estado da pilha
  173.                         -1|    table |1
  174.         **********************************
  175.         */
  176.         luaL_getmetatable(lua, "_luaVEC3");
  177.         //printStack(lua,__LINE__);
  178.         /*
  179.         **********************************
  180.                         Estado da pilha
  181.                         -2|    table |1
  182.                         -1|    table |2
  183.         **********************************
  184.         */
  185.         lua_setmetatable(lua, -2);
  186.         /*
  187.         **********************************
  188.                         Estado da pilha
  189.                         -1|    table |1
  190.         **********************************
  191.         */
  192.         VEC3 ** udata   = (VEC3 ** )lua_newuserdata(lua, sizeof(VEC3*));
  193.         //printStack(lua,__LINE__);
  194.         /*
  195.         **********************************
  196.                         Estado da pilha
  197.                         -2|    table |1
  198.                         -1| userdata |2
  199.         **********************************
  200.         */
  201.         VEC3* vec3              = new VEC3();
  202.        
  203.         vec3->x                 =       x;
  204.         vec3->y                 =       y;
  205.         vec3->z                 =       z;
  206.         *udata = vec3;
  207.         lua_rawseti(lua, -2, 0);
  208.         //printStack(lua,__LINE__);
  209.         /*
  210.         **********************************
  211.                         Estado da pilha
  212.                         -1|    table |1
  213.         **********************************
  214.         */
  215.         return 1;
  216. }
  217.  
  218. static int onDestroyVec3Lua(lua_State * lua)
  219. {
  220.         //printStack(lua,__LINE__);
  221.         VEC3 * vec3 = getVec3FromRawTable(lua, 0,1);
  222.         static int v=1;
  223.         printf("Destruindo vetor %d X: %f  Y: %f Z: %f\n",v++,vec3->x,vec3->y,vec3->z);
  224.         delete vec3;
  225.         return 0;
  226. }
  227.  
  228. static int onNewIndexVec3(lua_State * lua)//escrita ok 03/10/2013
  229. {
  230.         //printStack(lua,__LINE__);
  231.         /*
  232.         **********************************
  233.                         Estado da pilha
  234.                         -3|    table |1
  235.                         -2|   string |2
  236.                         -1|   number |3
  237.         **********************************
  238.         */
  239.         const char* what        =       luaL_checkstring(lua,2);
  240.         VEC3* vec3                      =       getVec3FromRawTable(lua, 0,1);
  241.         switch(what[0])
  242.         {
  243.                 case 'x':
  244.                         vec3->x                 =       luaL_checknumber(lua,3);
  245.                 break;
  246.                 case 'y':
  247.                         vec3->y                 =       luaL_checknumber(lua,3);
  248.                 break;
  249.                 case 'z':
  250.                         vec3->z                 =       luaL_checknumber(lua,3);
  251.                 break;
  252.                 default:
  253.                 {
  254.                         //printf("\nnewindex %s inexistente!!!\n",what);
  255.                         printStack(lua,__LINE__);
  256.                 }
  257.         }
  258.         return 0;
  259. }
  260.  
  261. static int onIndexVec3(lua_State * lua)//leitura ok 03/10/2013
  262. {
  263.         //printStack(lua,__LINE__);
  264.         /*
  265.         **********************************
  266.                         Estado da pilha
  267.                         -2|    table |1
  268.                         -1|   string |2
  269.         **********************************
  270.         */
  271.         const char* what        =       luaL_checkstring(lua,2);
  272.         VEC3* vec3                      =       getVec3FromRawTable(lua,0,1);
  273.         switch(what[0])
  274.         {
  275.                 case 'x':
  276.                         lua_pushnumber(lua,vec3->x);
  277.                 break;
  278.                 case 'y':
  279.                         lua_pushnumber(lua,vec3->y);
  280.                 break;
  281.                 case 'z':
  282.                         lua_pushnumber(lua,vec3->z);
  283.                 break;
  284.                 case 'l':
  285.                 {
  286.                         const float ret = sqrt((vec3->x*vec3->x) + (vec3->y*vec3->y) + (vec3->z*vec3->z));
  287.                         lua_pushnumber(lua,ret);
  288.                 }
  289.                 break;
  290.                 default:
  291.                 {
  292.                        
  293.                         lua_pushnil(lua);
  294.                 }
  295.         }
  296.         return 1;
  297. }
  298.  
  299.  
  300.  
  301. static void registerClassVec3(lua_State * lua)
  302. {
  303.         luaL_Reg regVec3MMethods[] =
  304.         {
  305.                 {"__newindex",  onNewIndexVec3},
  306.                 {"__index",     onIndexVec3},
  307.                 {"new",                 onNewVec3Lua},
  308.                 {"__gc",        onDestroyVec3Lua},
  309.                 {NULL,          NULL}
  310.         };
  311.         luaL_newmetatable(lua, "_luaVEC3");
  312.         //printStack(lua,__LINE__);
  313.         /*
  314.         **********************************
  315.                         Estado da pilha
  316.                         -1|    table |1
  317.         **********************************
  318.         */
  319.         luaL_setfuncs(lua, regVec3MMethods,0);
  320.         //printStack(lua,__LINE__);
  321.         /*
  322.         **********************************
  323.                         Estado da pilha
  324.                         -1|    table |1
  325.         **********************************
  326.         */
  327.         lua_setglobal(lua, "vec3");
  328.         //printStack(lua,__LINE__);
  329. /*
  330.         **********************************
  331.                         Estado da pilha
  332.         **********************************
  333. */
  334. }
  335.  
  336. int main()
  337. {
  338.         lua_State * lua = luaL_newstate();
  339.         luaL_openlibs(lua);
  340.         registerClassVec3(lua);
  341.        
  342.         printf("Executando script teste.lua (C++)\n");
  343.         int erred = luaL_dofile(lua, "teste.lua");
  344.         if (erred)
  345.                 printf("Lua error: %s\n",luaL_checkstring(lua, -1));
  346.         printf("Fim ...(C++)\n");
  347.         lua_close(lua);
  348.         return 0;
  349. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top