Classe lua C++ com métodos e atributos

extern "C"
{
     #include <lua.h>
     #include <lauxlib.h>
     #include <lualib.h>
}

#include <math.h>

struct VEC3
{
    float x,y,z;
};

static void printStack (lua_State * lua,int n)
{
    int top = lua_gettop(lua);
    printf( "\n**********************************"
            "\nEstado da pilha na linha %d\n",n);
    for (int i = 1, k= top; i <= top; i++, k--)
    {
        int type = lua_type(lua, i);
        printf("\t%d| %8s |%d\n", -k , lua_typename(lua, type), i);
    }
    printf("**********************************\n\n");
}

inline VEC3* getVec3FromRawTable(lua_State * lua,const int rawi,const int indexTable)//ok 03/10/2013
{
    //printStack(lua,__LINE__);
    /*
    esperado
    **********************************
            Estado da pilha
            -2|    table |1
            -1|   string |2
    **********************************
    */
    luaL_argcheck(lua,indexTable <= lua_gettop(lua),indexTable,"argumento esperado: vec3");
    lua_rawgeti(lua,indexTable,rawi);
    //printStack(lua,__LINE__);
    /*
    **********************************
    Estado da pilha na linha 43
            -3|    table |1
            -2|   string |2
            -1| userdata |3
    **********************************
    */
    VEC3** ud = (VEC3**)lua_touserdata(lua, -1);
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -3|    table |1
            -2|   string |2
            -1| userdata |3
    **********************************
    */
    lua_pop(lua,1);
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -2|    table |1
            -1|   string |2
    **********************************
    */
    return  *ud;
}


static int onLengthVec3(lua_State * lua)
{
    VEC3 * vec3     = getVec3FromRawTable(lua, 0,1);
    const float ret = sqrt((vec3->x*vec3->x) + (vec3->y*vec3->y) + (vec3->z*vec3->z));
    lua_pushnumber(lua,ret);
    return 1;
}

static int onMulVec3(lua_State * lua)//ok 03/10/2013
{

    //printStack(lua,__LINE__);
    /*
    vec3.mul(vetor1,"lua_parametros_digi") -> Lua error: teste.lua:10: attempt to call method 'mul' (a nil value)
    vec3:mul(vetor1,"lua_parametros_digi") -> Lua error: teste.lua:10: attempt to call method 'mul' (a nil value)

    vetor1.mul(vetor1,"lua_parametros_digi") ->
    **********************************
            Estado da pilha
            -2|    table |1
            -1|   number |2
    **********************************

    vetor1:mul(vetor1,"lua_parametros_digi") ->
    **********************************
            Estado da pilha
            -3|    table |1
            -2|    table |2
            -1|   string |3
    **********************************

    vetor1:mul("lua_parametros_digi") ->
    **********************************
            Estado da pilha
            -2|    table |1
            -1|   string |2
    **********************************
    */
    VEC3 * vec3 = getVec3FromRawTable(lua, 0,1);
    //printf("Vec3 from userdata %f %f %f \n",vec3->x,vec3->y,vec3->z);
    //printStack(lua,__LINE__);
    const float x = luaL_checknumber(lua,2);
    const float y = luaL_checknumber(lua,3);
    const float z = luaL_checknumber(lua,4);
    //printStack(lua,__LINE__);
    vec3->x  = x * vec3->x;
    vec3->y  = y * vec3->y;
    vec3->z  = z * vec3->z;
    return 0;
}

static int onNewVec3Lua(lua_State* lua)//ok 03/10/2013
{
    //printStack(lua,__LINE__);
    /*
    //esperado
    **********************************
            Estado da pilha
            -1|    table |1
    **********************************
    ou
    **********************************
            Estado da pilha
            -4|    table |1
            -3|   number |2
            -2|   number |3
            -1|   number |4
    **********************************
    ou
    **********************************
            Estado da pilha
            -2|    table |1
            -1|    table |2
    **********************************

    */
    const int top           = lua_gettop(lua);
    const VEC3 * vec3Copy   = (top == 2 && lua_type(lua,2) == LUA_TTABLE) ? getVec3FromRawTable(lua, 0,2) : NULL;
    const float x           = vec3Copy ? vec3Copy->x : (top > 1 ? luaL_checknumber(lua,2) : 0.0f);
    const float y           = vec3Copy ? vec3Copy->y : (top > 2 ? luaL_checknumber(lua,3) : 0.0f);
    const float z           = vec3Copy ? vec3Copy->z : (top > 3 ? luaL_checknumber(lua,4) : 0.0f);
    lua_settop(lua,0);
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
    **********************************
    */
    luaL_Reg regVec3Methods[] =
    {
        {"mul",         onMulVec3},
        {"length",      onLengthVec3},
        {NULL,          NULL}
    };
    luaL_newlib(lua, regVec3Methods);
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -1|    table |1
    **********************************
    */
    luaL_getmetatable(lua, "_luaVEC3");
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -2|    table |1
            -1|    table |2
    **********************************
    */
    lua_setmetatable(lua, -2);
    /*
    **********************************
            Estado da pilha
            -1|    table |1
    **********************************
    */
    VEC3 ** udata   = (VEC3 ** )lua_newuserdata(lua, sizeof(VEC3*));
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -2|    table |1
            -1| userdata |2
    **********************************
    */
    VEC3* vec3      = new VEC3();

    vec3->x         =   x;
    vec3->y         =   y;
    vec3->z         =   z;
    *udata = vec3;
    lua_rawseti(lua, -2, 0);
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -1|    table |1
    **********************************
    */
    return 1;
}

static int onDestroyVec3Lua(lua_State * lua)
{
    //printStack(lua,__LINE__);
    VEC3 * vec3 = getVec3FromRawTable(lua, 0,1);
    static int v=1;
    printf("Destruindo vetor %d X: %f  Y: %f Z: %f\n",v++,vec3->x,vec3->y,vec3->z);
    delete vec3;
    return 0;
}

static int onNewIndexVec3(lua_State * lua)//escrita ok 03/10/2013
{
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -3|    table |1
            -2|   string |2
            -1|   number |3
    **********************************
    */
    const char* what    =   luaL_checkstring(lua,2);
    VEC3* vec3          =   getVec3FromRawTable(lua, 0,1);
    switch(what[0])
    {
        case 'x':
            vec3->x         =   luaL_checknumber(lua,3);
        break;
        case 'y':
            vec3->y         =   luaL_checknumber(lua,3);
        break;
        case 'z':
            vec3->z         =   luaL_checknumber(lua,3);
        break;
        default:
        {
            //printf("\nnewindex %s inexistente!!!\n",what);
            printStack(lua,__LINE__);
        }
    }
    return 0;
}

static int onIndexVec3(lua_State * lua)//leitura ok 03/10/2013
{
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -2|    table |1
            -1|   string |2
    **********************************
    */
    const char* what    =   luaL_checkstring(lua,2);
    VEC3* vec3          =   getVec3FromRawTable(lua,0,1);
    switch(what[0])
    {
        case 'x':
            lua_pushnumber(lua,vec3->x);
        break;
        case 'y':
            lua_pushnumber(lua,vec3->y);
        break;
        case 'z':
            lua_pushnumber(lua,vec3->z);
        break;
        case 'l':
        {
            const float ret = sqrt((vec3->x*vec3->x) + (vec3->y*vec3->y) + (vec3->z*vec3->z));
            lua_pushnumber(lua,ret);
        }
        break;
        default:
        {

            lua_pushnil(lua);
        }
    }
    return 1;
}



static void registerClassVec3(lua_State * lua)
{
    luaL_Reg regVec3MMethods[] =
    {
        {"__newindex",  onNewIndexVec3},
        {"__index",     onIndexVec3},
        {"new",         onNewVec3Lua},
        {"__gc",        onDestroyVec3Lua},
        {NULL,          NULL}
    };
    luaL_newmetatable(lua, "_luaVEC3");
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -1|    table |1
    **********************************
    */
    luaL_setfuncs(lua, regVec3MMethods,0);
    //printStack(lua,__LINE__);
    /*
    **********************************
            Estado da pilha
            -1|    table |1
    **********************************
    */
    lua_setglobal(lua, "vec3");
    //printStack(lua,__LINE__);
/*
    **********************************
            Estado da pilha
    **********************************
*/
}

int main()
{
    lua_State * lua = luaL_newstate();
    luaL_openlibs(lua);
    registerClassVec3(lua);

    printf("Executando script teste.lua (C++)\n");
    int erred = luaL_dofile(lua, "teste.lua");
    if (erred)
        printf("Lua error: %s\n",luaL_checkstring(lua, -1));
    printf("Fim ...(C++)\n");
    lua_close(lua);
    return 0;
}