Changeset 207 for trunk/src


Ignore:
Timestamp:
08/19/13 07:42:00 (12 years ago)
Author:
epyon
Message:
  • lua - concept change - all functionality in nv::lua except raw
  • lua - all modules made header-independent from raw (except obviously raw)
Location:
trunk/src/lua
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/lua/lua_area.cc

    r206 r207  
    1111#include "nv/random.hh"
    1212
    13 static const char* NLUA_AREA_METATABLE = "area";
    14 
    15 bool nlua_is_area( lua_State* L, int index )
    16 {
    17         return luaL_testudata( L, index, NLUA_AREA_METATABLE ) != 0;
    18 }
    19 
    20 nv::rectangle nlua_to_area( lua_State* L, int index )
    21 {
    22         return *(nv::rectangle*)luaL_checkudata( L, index, NLUA_AREA_METATABLE );
    23 }
    24 
    25 nv::rectangle* nlua_to_parea( lua_State* L, int index )
    26 {
    27         return (nv::rectangle*)luaL_checkudata( L, index, NLUA_AREA_METATABLE );
    28 }
    29 
    30 void nlua_push_area( lua_State* L, const nv::rectangle& v )
    31 {
    32         new (lua_newuserdata(L, sizeof(nv::rectangle))) nv::rectangle(v);
    33         luaL_setmetatable( L, NLUA_AREA_METATABLE );
    34 }
     13const char* nv::lua::detail::AREA_METATABLE = "area";
     14
     15using nv::lua::detail::is_coord;
     16using nv::lua::detail::to_coord;
     17using nv::lua::detail::to_pcoord;
     18using nv::lua::detail::push_coord;
     19
     20using nv::lua::detail::is_area;
     21using nv::lua::detail::to_area;
     22using nv::lua::detail::to_parea;
     23using nv::lua::detail::push_area;
    3524
    3625static void nlua_area_construct( lua_State* L, int sidx )
    3726{
    38         if ( nlua_is_coord( L, sidx ) )
    39         {
    40                 if ( nlua_is_coord( L, sidx+1 ) )
     27        if ( is_coord( L, sidx ) )
     28        {
     29                if ( is_coord( L, sidx+1 ) )
    4130                {
    42                         nv::rectangle a( nlua_to_coord( L, sidx ), nlua_to_coord( L, sidx+1 ) );
    43                         nlua_push_area( L, a );
     31                        nv::rectangle a( to_coord( L, sidx ), to_coord( L, sidx+1 ) );
     32                        push_area( L, a );
    4433                        return;
    4534                }
    … …  
    5140                nv::ivec2( lua_tointeger( L, sidx+2 ), lua_tointeger( L, sidx+3 ) )
    5241                );
    53         nlua_push_area( L, a );
     42        push_area( L, a );
    5443}
    5544
    … …  
    6958static int nlua_area_eq( lua_State* L )
    7059{
    71         lua_pushboolean( L, nlua_to_area( L, 1 ) == nlua_to_area( L, 2 ) );
     60        lua_pushboolean( L, to_area( L, 1 ) == to_area( L, 2 ) );
    7261        return 1;
    7362}
    … …  
    7564static int nlua_area_get( lua_State* L )
    7665{
    77         nv::rectangle r( nlua_to_area( L, 1 ) );
    78         nlua_push_coord( L, r.ul );
    79         nlua_push_coord( L, r.lr );
     66        nv::rectangle r( to_area( L, 1 ) );
     67        push_coord( L, r.ul );
     68        push_coord( L, r.lr );
    8069        return 2;
    8170}
    … …  
    8372static int nlua_area_clone( lua_State* L )
    8473{
    85         nlua_push_area( L, *nlua_to_parea( L, 1 ) );
     74        push_area( L, *to_parea( L, 1 ) );
    8675        return 1;
    8776}
    … …  
    8978static int nlua_area_index( lua_State* L )
    9079{
    91         nv::rectangle* a = nlua_to_parea( L, 1 );
     80        nv::rectangle* a = to_parea( L, 1 );
    9281        std::size_t l;
    9382        const char* index = lua_tolstring( L, 2, &l );
    9483        if ( l == 1 && index[0] == 'a' )
    9584        {
    96                 nlua_push_coord( L, a->ul );
     85                push_coord( L, a->ul );
    9786        }
    9887        else if ( l == 1 && index[0] == 'b' )
    9988        {
    100                 nlua_push_coord( L, a->lr );
     89                push_coord( L, a->lr );
    10190        }
    10291        else
    … …  
    111100static int nlua_area_newindex( lua_State* L )
    112101{
    113         nv::rectangle* a = nlua_to_parea( L, 1 );
     102        nv::rectangle* a = to_parea( L, 1 );
    114103        std::size_t l;
    115104        const char* index = lua_tolstring( L, 2, &l );
    116         nv::ivec2 value( nlua_to_coord( L, 3 ) );
     105        nv::ivec2 value( to_coord( L, 3 ) );
    117106        if ( l == 1 && index[0] == 'a' )
    118107        {
    … …  
    128117static int lua_area_coords_closure( lua_State* L )
    129118{
    130         nv::rectangle* a( nlua_to_parea( L, lua_upvalueindex(1) ) );
    131         nv::ivec2*     c( nlua_to_pcoord( L, lua_upvalueindex(2) ) );
     119        nv::rectangle* a( to_parea( L, lua_upvalueindex(1) ) );
     120        nv::ivec2*     c( to_pcoord( L, lua_upvalueindex(2) ) );
    132121
    133122        c->x++;
    … …  
    144133        }
    145134
    146         nlua_push_coord( L, *c );
     135        push_coord( L, *c );
    147136        return 1;
    148137}
    … …  
    150139static int nlua_area_coords( lua_State* L )
    151140{
    152         nv::rectangle* a( nlua_to_parea( L, 1 ) );
     141        nv::rectangle* a( to_parea( L, 1 ) );
    153142        nv::ivec2      c( a->ul );
    154143        c.x--;
    155         nlua_push_coord( L, c );
     144        push_coord( L, c );
    156145        lua_pushcclosure( L, lua_area_coords_closure, 2 );
    157146        return 1;
    … …  
    160149static int nlua_area_edges_closure( lua_State* L )
    161150{
    162         nv::rectangle* a( nlua_to_parea( L, lua_upvalueindex(1) ) );
    163         nv::ivec2*     c( nlua_to_pcoord( L, lua_upvalueindex(2) ) );
     151        nv::rectangle* a( to_parea( L, lua_upvalueindex(1) ) );
     152        nv::ivec2*     c( to_pcoord( L, lua_upvalueindex(2) ) );
    164153
    165154        c->x++;
    … …  
    178167
    179168
    180         nlua_push_coord( L, *c );
     169        push_coord( L, *c );
    181170        return 1;
    182171}
    … …  
    184173static int nlua_area_edges( lua_State* L )
    185174{
    186         nv::rectangle*   a( nlua_to_parea( L, 1 ) );
     175        nv::rectangle*   a( to_parea( L, 1 ) );
    187176        nv::ivec2 c( a->ul );
    188177        c.x--;
    189         nlua_push_coord( L, c );
     178        push_coord( L, c );
    190179        lua_pushcclosure( L, nlua_area_edges_closure, 2 );
    191180        return 1;
    … …  
    203192static int nlua_area_corners( lua_State* L )
    204193{
    205         nv::rectangle* a = nlua_to_parea( L, 1 );
     194        nv::rectangle* a = to_parea( L, 1 );
    206195
    207196        lua_createtable(L, 4, 0);
    208         nlua_push_coord( L, a->ul );
     197        push_coord( L, a->ul );
    209198        lua_rawseti( L, -2, 1 );
    210         nlua_push_coord( L, a->ur() );
     199        push_coord( L, a->ur() );
    211200        lua_rawseti( L, -2, 2 );
    212         nlua_push_coord( L, a->ll() );
     201        push_coord( L, a->ll() );
    213202        lua_rawseti( L, -2, 3 );
    214         nlua_push_coord( L, a->lr );
     203        push_coord( L, a->lr );
    215204        lua_rawseti( L, -2, 4 );
    216205
    … …  
    222211static int nlua_area_shrink( lua_State* L )
    223212{
    224         nv::rectangle* a = nlua_to_parea( L, 1 );
     213        nv::rectangle* a = to_parea( L, 1 );
    225214        a->shrink( static_cast< int >( lua_tointeger( L, 2 ) ) );
    226215        return 0;
    … …  
    229218static int nlua_area_shrinked( lua_State* L )
    230219{
    231         nv::rectangle* a = nlua_to_parea( L, 1 );
    232         nlua_push_area( L, a->shrinked( static_cast< int >( lua_tointeger( L, 2 ) ) ) );
     220        nv::rectangle* a = to_parea( L, 1 );
     221        push_area( L, a->shrinked( static_cast< int >( lua_tointeger( L, 2 ) ) ) );
    233222        return 1;
    234223}
    … …  
    236225static int nlua_area_expand( lua_State* L )
    237226{
    238         nv::rectangle* a = nlua_to_parea( L, 1 );
     227        nv::rectangle* a = to_parea( L, 1 );
    239228        a->expand( static_cast< int >( lua_tointeger( L, 2 ) ) );
    240229        return 0;
    … …  
    243232static int nlua_area_expanded( lua_State* L )
    244233{
    245         nv::rectangle* a = nlua_to_parea( L, 1 );
    246         nlua_push_area( L, a->expanded( static_cast< int >( lua_tointeger( L, 2 ) ) ) );
     234        nv::rectangle* a = to_parea( L, 1 );
     235        push_area( L, a->expanded( static_cast< int >( lua_tointeger( L, 2 ) ) ) );
    247236        return 1;
    248237}
    … …  
    250239static int nlua_area_clamp( lua_State* L )
    251240{
    252         nv::rectangle* a1 = nlua_to_parea( L, 1 );
    253         nv::rectangle* a2 = nlua_to_parea( L, 2 );
     241        nv::rectangle* a1 = to_parea( L, 1 );
     242        nv::rectangle* a2 = to_parea( L, 2 );
    254243        a1->clamp_to( *a2 );
    255244        return 0;
    … …  
    258247static int nlua_area_clamped( lua_State* L )
    259248{
    260         nv::rectangle  a1 = nlua_to_area( L, 1 );
    261         nv::rectangle* a2 = nlua_to_parea( L, 2 );
     249        nv::rectangle  a1 = to_area( L, 1 );
     250        nv::rectangle* a2 = to_parea( L, 2 );
    262251        a1.clamp_to( *a2 );
    263         nlua_push_area( L, a1 );
     252        push_area( L, a1 );
    264253        return 1;
    265254}
    … …  
    267256static int nlua_area_clamp_coord( lua_State* L )
    268257{
    269         nv::rectangle* a = nlua_to_parea( L, 1 );
    270         nv::ivec2*     c = nlua_to_pcoord( L, 2 );
     258        nv::rectangle* a = to_parea( L, 1 );
     259        nv::ivec2*     c = to_pcoord( L, 2 );
    271260        *c = glm::clamp( *c, a->ul, a->lr );
    272261        return 0;
    … …  
    275264static int nlua_area_clamped_coord( lua_State* L )
    276265{
    277         nv::rectangle* a = nlua_to_parea( L, 1 );
    278         nv::ivec2*     c = nlua_to_pcoord( L, 2 );
    279         nlua_push_coord( L, glm::clamp( *c, a->ul, a->lr ) );
     266        nv::rectangle* a = to_parea( L, 1 );
     267        nv::ivec2*     c = to_pcoord( L, 2 );
     268        push_coord( L, glm::clamp( *c, a->ul, a->lr ) );
    280269        return 0;
    281270}
    … …  
    283272static int nlua_area_fix( lua_State* L )
    284273{
    285         nv::rectangle* a = nlua_to_parea( L, 1 );
     274        nv::rectangle* a = to_parea( L, 1 );
    286275        if ( a->ul.x > a->lr.x ) a->ul.x = a->lr.x;
    287276        if ( a->ul.y > a->lr.y ) a->ul.y = a->lr.y;
    … …  
    291280static int nlua_area_proper( lua_State* L )
    292281{
    293         nv::rectangle* a = nlua_to_parea( L, 1 );
     282        nv::rectangle* a = to_parea( L, 1 );
    294283        lua_pushboolean( L, a->ul.x <= a->lr.x && a->ul.y <= a->lr.y );
    295284        return 1;
    … …  
    298287static int nlua_area_dim( lua_State* L )
    299288{
    300         nv::rectangle* a = nlua_to_parea( L, 1 );
    301         nlua_push_coord( L, a->ul - a->lr + nv::ivec2(1,1) );
     289        nv::rectangle* a = to_parea( L, 1 );
     290        push_coord( L, a->ul - a->lr + nv::ivec2(1,1) );
    302291        return 1;
    303292}
    … …  
    305294static int nlua_area_size( lua_State* L )
    306295{
    307         nv::rectangle* a = nlua_to_parea( L, 1 );
     296        nv::rectangle* a = to_parea( L, 1 );
    308297        lua_pushinteger( L, a->get_enclosed_area() );
    309298        return 1;
    … …  
    312301static int nlua_area_contains( lua_State* L )
    313302{
    314         lua_pushboolean( L, nlua_to_parea( L, 1 )->contains( nlua_to_coord( L, 2 ) ) );
     303        lua_pushboolean( L, to_parea( L, 1 )->contains( to_coord( L, 2 ) ) );
    315304        return 1;
    316305}
    … …  
    318307static int nlua_area_is_edge( lua_State* L )
    319308{
    320         nv::rectangle a = nlua_to_area( L, 1 );
    321         nv::ivec2     c = nlua_to_coord( L, 2 );
     309        nv::rectangle a = to_area( L, 1 );
     310        nv::ivec2     c = to_coord( L, 2 );
    322311        lua_pushboolean( L, a.contains( c ) && ( c.x == a.ul.x || c.x == a.lr.x || c.y == a.ul.y || c.y == a.lr.y ) );
    323312        return 1;
    … …  
    326315static int nlua_area_around( lua_State* L )
    327316{
    328         nv::ivec2 c = nlua_to_coord( L, 1 );
     317        nv::ivec2 c = to_coord( L, 1 );
    329318        int amount = static_cast< int >( lua_tointeger( L, 1 ) );
    330319        nv::ivec2 shift( amount, amount );
    331         nlua_push_area( L, nv::rectangle( c - shift, c + shift ) );
     320        push_area( L, nv::rectangle( c - shift, c + shift ) );
    332321        return 1;
    333322}
    … …  
    335324static int nlua_area_tostring( lua_State* L )
    336325{
    337         nv::rectangle a = nlua_to_area( L, 1 );
     326        nv::rectangle a = to_area( L, 1 );
    338327        std::string s = "(";
    339328        s += nv::to_string(a.ul.x);
    … …  
    351340static int nlua_area_random_edge_coord( lua_State* L )
    352341{
    353         nv::rectangle area = nlua_to_area( L, 1 );
     342        nv::rectangle area = to_area( L, 1 );
    354343        nv::ivec2 a   = area.ul;
    355344        nv::ivec2 b   = area.lr;
    … …  
    368357                result = ( roll < ys ) ? nv::ivec2( a.x, a.y + roll + 1 ) : nv::ivec2( b.x, a.y + roll - ys + 1);
    369358        }
    370         nlua_push_coord( L, result );
     359        push_coord( L, result );
    371360        return 1;
    372361}
    … …  
    374363static int nlua_area_random_inner_edge_coord( lua_State* L )
    375364{
    376         nv::rectangle area = nlua_to_area( L, 1 );
     365        nv::rectangle area = to_area( L, 1 );
    377366        nv::ivec2 a   = area.ul;
    378367        nv::ivec2 b   = area.lr;
    … …  
    391380                result = ( roll < ys ) ? nv::ivec2( a.x, a.y + roll + 1 ) : nv::ivec2( b.x, a.y + roll - ys + 1);
    392381        }
    393         nlua_push_coord( L, result );
     382        push_coord( L, result );
    394383        return 1;
    395384}
    … …  
    397386static int nlua_area_random_coord( lua_State* L )
    398387{
    399         nv::rectangle area = nlua_to_area( L, 1 );
    400         nlua_push_coord( L, nv::random::get().range( area.ul, area.lr ) );
     388        nv::rectangle area = to_area( L, 1 );
     389        push_coord( L, nv::random::get().range( area.ul, area.lr ) );
    401390        return 1;
    402391}
    … …  
    404393static int nlua_area_random_subarea( lua_State* L )
    405394{
    406         nv::rectangle area  = nlua_to_area( L, 1 );
    407         nv::ivec2     dim   = nlua_to_coord( L, 2 );
     395        nv::rectangle area  = to_area( L, 1 );
     396        nv::ivec2     dim   = to_coord( L, 2 );
    408397        nv::ivec2     start = nv::random::get().range( area.ul, area.lr - dim );
    409         nlua_push_area( L, nv::rectangle( start, start + dim ) );
     398        push_area( L, nv::rectangle( start, start + dim ) );
    410399        return 1;
    411400}
    … …  
    466455        };
    467456
    468         luaL_newmetatable( L, NLUA_AREA_METATABLE );
     457        luaL_newmetatable( L, nv::lua::detail::AREA_METATABLE );
    469458        nlua_register( L, nlua_area_m, -1 );
    470459        lua_createtable( L, 0, 0 );
    … …  
    481470}
    482471
    483 void nlua_register_area( lua_State* L )
     472void nv::lua::register_area( lua_State* L )
    484473{
    485474        int stack = lua_gettop( L );

  • trunk/src/lua/lua_aux.cc

    r204 r207  
    138138};
    139139
    140 void nlua_register_aux( lua_State* L )
     140void nv::lua::register_aux( lua_State* L )
    141141{
    142142        nlua_register( L, "table", nluaaux_table_aux_f );

  • trunk/src/lua/lua_glm.cc

    r177 r207  
    1313static size_t nlua_swizzel_lookup[256];
    1414
     15using nv::lua::detail::is_vec;
     16using nv::lua::detail::to_vec;
     17using nv::lua::detail::to_pvec;
     18using nv::lua::detail::push_vec;
     19
    1520inline bool nlua_is_swizzel( const unsigned char* str, size_t max )
    1621{
    … …  
    4247        static inline T construct( lua_State* L, int index ) {
    4348                if ( lua_type( L, index ) == LUA_TUSERDATA )
    44                         return nlua_to_vec<T>( L, index );
     49                        return to_vec<T>( L, index );
    4550                else
    4651                        return T( lua_tonumber( L, index ), lua_tonumber( L, index + 1 ) );
    … …  
    5459                if ( lua_type( L, index ) == LUA_TUSERDATA )
    5560                {
    56                         if ( nlua_is_vec<T>( L, index ) )
    57                                 return nlua_to_vec<T>( L, index );
     61                        if ( is_vec<T>( L, index ) )
     62                                return to_vec<T>( L, index );
    5863                        else
    59                                 return T( nlua_to_vec<vec2>( L, index ), lua_tonumber( L, index + 1 ) );
     64                                return T( to_vec<vec2>( L, index ), lua_tonumber( L, index + 1 ) );
    6065                }
    6166                else
    6267                {
    6368                        if ( lua_type( L, index+1 ) == LUA_TUSERDATA )
    64                                 return T( lua_tonumber( L, index ), nlua_to_vec<vec2>( L, index+1 ) );
     69                                return T( lua_tonumber( L, index ), to_vec<vec2>( L, index+1 ) );
    6570                        else
    6671                                return T( lua_tonumber( L, index ), lua_tonumber( L, index + 1 ), lua_tonumber( L, index + 2 ) );
    … …  
    7681                if ( lua_type( L, index ) == LUA_TUSERDATA )
    7782                {
    78                         if ( nlua_is_vec<T>( L, index ) )
    79                                 return nlua_to_vec<T>( L, index );
     83                        if ( is_vec<T>( L, index ) )
     84                                return to_vec<T>( L, index );
    8085                        else
    8186                        {
    82                                 if ( nlua_is_vec<vec3>( L, index ) )
    83                                         return T( nlua_to_vec<vec3>( L, index ), lua_tonumber( L, index + 1 ) );
     87                                if ( is_vec<vec3>( L, index ) )
     88                                        return T( to_vec<vec3>( L, index ), lua_tonumber( L, index + 1 ) );
    8489                                else
    8590                                {
    8691                                        if ( lua_type( L, index+1 ) == LUA_TUSERDATA )
    87                                                 return T( nlua_to_vec<vec2>( L, index ), nlua_to_vec<vec2>( L, index + 1 ) );
     92                                                return T( to_vec<vec2>( L, index ), to_vec<vec2>( L, index + 1 ) );
    8893                                        else
    89                                                 return T( nlua_to_vec<vec2>( L, index ), lua_tonumber( L, index + 1 ), lua_tonumber( L, index + 2 ) );
     94                                                return T( to_vec<vec2>( L, index ), lua_tonumber( L, index + 1 ), lua_tonumber( L, index + 2 ) );
    9095                                }
    9196                        }
    … …  
    95100                        if ( lua_type( L, index+1 ) == LUA_TUSERDATA )
    96101                        {
    97                                 if ( nlua_is_vec<vec3>( L, index+1 ) )
    98                                         return T( lua_tonumber( L, index ), nlua_to_vec<vec3>( L, index+1 ) );
     102                                if ( is_vec<vec3>( L, index+1 ) )
     103                                        return T( lua_tonumber( L, index ), to_vec<vec3>( L, index+1 ) );
    99104                                else
    100                                         return T( lua_tonumber( L, index ), nlua_to_vec<vec2>( L, index+1 ), lua_tonumber( L, index + 2 ) );
     105                                        return T( lua_tonumber( L, index ), to_vec<vec2>( L, index+1 ), lua_tonumber( L, index + 2 ) );
    101106                        }
    102107                        else
    103108                        {
    104109                                if ( lua_type( L, index+2 ) == LUA_TUSERDATA )
    105                                         return T( lua_tonumber( L, index ), lua_tonumber( L, index + 1 ), nlua_to_vec<vec2>( L, index+2 ) );
     110                                        return T( lua_tonumber( L, index ), lua_tonumber( L, index + 1 ), to_vec<vec2>( L, index+2 ) );
    106111                                else
    107112                                        return T( lua_tonumber( L, index ), lua_tonumber( L, index + 1 ), lua_tonumber( L, index + 2 ), lua_tonumber( L, index + 3 ) );
    … …  
    114119int nlua_vec_new( lua_State* L )
    115120{
    116         nlua_push_vec<T>( L, nlua_vec_constructor<T,sizeof( T ) / sizeof( typename T::value_type )>::construct( L, 1 ) );
     121        push_vec<T>( L, nlua_vec_constructor<T,sizeof( T ) / sizeof( typename T::value_type )>::construct( L, 1 ) );
    117122        return 1;
    118123}
    … …  
    121126int nlua_vec_random( lua_State* L )
    122127{
    123         nlua_push_vec<T>( L, nv::random::get().range( nlua_to_vec<T>( L, 1 ), nlua_to_vec<T>( L, 2 ) ) );
     128        push_vec<T>( L, nv::random::get().range( to_vec<T>( L, 1 ), to_vec<T>( L, 2 ) ) );
    124129        return 1;
    125130}
    … …  
    128133int nlua_vec_clone( lua_State* L )
    129134{
    130         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) );
     135        push_vec<T>( L, to_vec<T>( L, 1 ) );
    131136        return 1;
    132137}
    … …  
    135140int nlua_vec_call( lua_State* L )
    136141{
    137         nlua_push_vec<T>( L, nlua_vec_constructor<T,sizeof( T ) / sizeof( typename T::value_type )>::construct( L, 2 ) );
     142        push_vec<T>( L, nlua_vec_constructor<T,sizeof( T ) / sizeof( typename T::value_type )>::construct( L, 2 ) );
    138143        return 1;
    139144}
    … …  
    142147static int nlua_vec_unm( lua_State* L )
    143148{
    144         nlua_push_vec<T>( L, -nlua_to_vec<T>( L, 1 ) );
     149        push_vec<T>( L, -to_vec<T>( L, 1 ) );
    145150        return 1;
    146151}
    … …  
    150155{
    151156        if ( lua_type( L, 1 ) == LUA_TNUMBER )
    152                 nlua_push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) + nlua_to_vec<T>( L, 2 ) );
     157                push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) + to_vec<T>( L, 2 ) );
    153158        else
    154159                if ( lua_type( L, 2 ) == LUA_TNUMBER )
    155                         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) + (typename T::value_type)(lua_tonumber( L, 2 )) );
    156                 else
    157                         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) + nlua_to_vec<T>( L, 2 ) );
     160                        push_vec<T>( L, to_vec<T>( L, 1 ) + (typename T::value_type)(lua_tonumber( L, 2 )) );
     161                else
     162                        push_vec<T>( L, to_vec<T>( L, 1 ) + to_vec<T>( L, 2 ) );
    158163        return 1;
    159164}
    … …  
    163168{
    164169        if ( lua_type( L, 1 ) == LUA_TNUMBER )
    165                 nlua_push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) - nlua_to_vec<T>( L, 2 ) );
     170                push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) - to_vec<T>( L, 2 ) );
    166171        else
    167172                if ( lua_type( L, 2 ) == LUA_TNUMBER )
    168                         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) - (typename T::value_type)(lua_tonumber( L, 2 )) );
    169                 else
    170                         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) - nlua_to_vec<T>( L, 2 ) );
     173                        push_vec<T>( L, to_vec<T>( L, 1 ) - (typename T::value_type)(lua_tonumber( L, 2 )) );
     174                else
     175                        push_vec<T>( L, to_vec<T>( L, 1 ) - to_vec<T>( L, 2 ) );
    171176        return 1;
    172177}
    … …  
    176181{
    177182        if ( lua_type( L, 1 ) == LUA_TNUMBER )
    178                 nlua_push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) * nlua_to_vec<T>( L, 2 ) );
     183                push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) * to_vec<T>( L, 2 ) );
    179184        else
    180185                if ( lua_type( L, 2 ) == LUA_TNUMBER )
    181                         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) * (typename T::value_type)(lua_tonumber( L, 2 )) );
    182                 else
    183                         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) * nlua_to_vec<T>( L, 2 ) );
     186                        push_vec<T>( L, to_vec<T>( L, 1 ) * (typename T::value_type)(lua_tonumber( L, 2 )) );
     187                else
     188                        push_vec<T>( L, to_vec<T>( L, 1 ) * to_vec<T>( L, 2 ) );
    184189        return 1;
    185190}
    … …  
    189194{
    190195        if ( lua_type( L, 1 ) == LUA_TNUMBER )
    191                 nlua_push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) / nlua_to_vec<T>( L, 2 ) );
     196                push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) / to_vec<T>( L, 2 ) );
    192197        else
    193198                if ( lua_type( L, 2 ) == LUA_TNUMBER )
    194                         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) / (typename T::value_type)(lua_tonumber( L, 2 )) );
    195                 else
    196                         nlua_push_vec<T>( L, nlua_to_vec<T>( L, 1 ) / nlua_to_vec<T>( L, 2 ) );
     199                        push_vec<T>( L, to_vec<T>( L, 1 ) / (typename T::value_type)(lua_tonumber( L, 2 )) );
     200                else
     201                        push_vec<T>( L, to_vec<T>( L, 1 ) / to_vec<T>( L, 2 ) );
    197202        return 1;
    198203}
    … …  
    201206int nlua_vec_eq( lua_State* L )
    202207{
    203         lua_pushboolean( L, nlua_to_vec<T>( L, 1 ) == nlua_to_vec<T>( L, 2 ) );
     208        lua_pushboolean( L, to_vec<T>( L, 1 ) == to_vec<T>( L, 2 ) );
    204209        return 1;
    205210}
    … …  
    208213int nlua_vec_get( lua_State* L )
    209214{
    210         T v = nlua_to_vec<T>( L, 1 );
     215        T v = to_vec<T>( L, 1 );
    211216        for ( size_t i = 0; i < v.length(); ++i )
    212217        {
    … …  
    219224int nlua_vec_index( lua_State* L )
    220225{
    221         T* v = nlua_to_pvec<T>( L, 1 );
     226        T* v = to_pvec<T>( L, 1 );
    222227        size_t len  = 0;
    223228        size_t vlen = v->length();
    … …  
    237242        {
    238243                switch (len) {
    239                 case 2 : nlua_push_vec( L, glm::detail::tvec2<typename T::value_type>( (*v)[nlua_swizzel_lookup[key[0]]], (*v)[nlua_swizzel_lookup[key[1]]] ) ); return 1;
    240                 case 3 : nlua_push_vec( L, glm::detail::tvec3<typename T::value_type>( (*v)[nlua_swizzel_lookup[key[0]]], (*v)[nlua_swizzel_lookup[key[1]]], (*v)[nlua_swizzel_lookup[key[2]]] ) ); return 1;
    241                 case 4 : nlua_push_vec( L, glm::detail::tvec4<typename T::value_type>( (*v)[nlua_swizzel_lookup[key[0]]], (*v)[nlua_swizzel_lookup[key[1]]], (*v)[nlua_swizzel_lookup[key[2]]], (*v)[nlua_swizzel_lookup[key[3]]] ) ); return 1;
     244                case 2 : push_vec( L, glm::detail::tvec2<typename T::value_type>( (*v)[nlua_swizzel_lookup[key[0]]], (*v)[nlua_swizzel_lookup[key[1]]] ) ); return 1;
     245                case 3 : push_vec( L, glm::detail::tvec3<typename T::value_type>( (*v)[nlua_swizzel_lookup[key[0]]], (*v)[nlua_swizzel_lookup[key[1]]], (*v)[nlua_swizzel_lookup[key[2]]] ) ); return 1;
     246                case 4 : push_vec( L, glm::detail::tvec4<typename T::value_type>( (*v)[nlua_swizzel_lookup[key[0]]], (*v)[nlua_swizzel_lookup[key[1]]], (*v)[nlua_swizzel_lookup[key[2]]], (*v)[nlua_swizzel_lookup[key[3]]] ) ); return 1;
    242247                default: break;
    243248                }
    … …  
    257262        typedef glm::detail::tvec4<typename T::value_type> vec4;
    258263
    259         T* v = nlua_to_pvec<T>( L, 1 );
     264        T* v = to_pvec<T>( L, 1 );
    260265        size_t len  = 0;
    261266        size_t vlen = v->length();
    … …  
    274279        {
    275280                switch (len) {
    276                 case 2 : { vec2 v2 = nlua_to_vec<vec2>(L,3); for (size_t i = 0; i<len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v2[i]; } return 0;
    277                 case 3 : { vec3 v3 = nlua_to_vec<vec3>(L,3); for (size_t i = 0; i<len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v3[i]; } return 0;
    278                 case 4 : { vec4 v4 = nlua_to_vec<vec4>(L,3); for (size_t i = 0; i<len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v4[i]; } return 0;
     281                case 2 : { vec2 v2 = to_vec<vec2>(L,3); for (size_t i = 0; i<len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v2[i]; } return 0;
     282                case 3 : { vec3 v3 = to_vec<vec3>(L,3); for (size_t i = 0; i<len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v3[i]; } return 0;
     283                case 4 : { vec4 v4 = to_vec<vec4>(L,3); for (size_t i = 0; i<len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v4[i]; } return 0;
    279284                default: break;
    280285                }
    … …  
    286291static int nlua_vec_tostring( lua_State* L )
    287292{
    288         T v = nlua_to_vec<T>( L, 1 );
     293        T v = to_vec<T>( L, 1 );
    289294        std::string s = "(";
    290295        for ( size_t i = 0; i < v.length(); ++i )
    … …  
    332337        };
    333338
    334         luaL_newmetatable( L, nlua_metatable_name<T>() );
     339        luaL_newmetatable( L, nv::lua::detail::glm_metatable_name<T>() );
    335340        nlua_register( L, nlua_vec_m, -1 );
    336341        lua_createtable( L, 0, 0 );
    … …  
    345350        lua_setmetatable( L, -2 );
    346351
    347         nlua_push_vec( L, T() );
     352        nv::lua::detail::push_vec( L, T() );
    348353        lua_setfield( L, -2, "ZERO" );
    349         nlua_push_vec( L, nlua_vec_constructor<T,sizeof( T ) / sizeof( typename T::value_type )>::unit() );
     354        nv::lua::detail::push_vec( L, nlua_vec_constructor<T,sizeof( T ) / sizeof( typename T::value_type )>::unit() );
    350355        lua_setfield( L, -2, "UNIT" );
    351356        return 1;
    352357}
    353358
    354 void nlua_register_glm( lua_State* L )
     359void nv::lua::register_glm( lua_State* L )
    355360{
    356361        for (size_t i = 0; i < 256; ++i ) nlua_swizzel_lookup[i] = 255;

  • trunk/src/lua/lua_map_area.cc

    r206 r207  
    4747// }
    4848
    49 bool nlua_is_map_area( lua_State* L, int index )
     49bool nv::lua::detail::is_map_area( lua_State* L, int index )
    5050{
    5151        return luaL_testudata( L, index, NLUA_MAP_AREA_METATABLE ) != 0;
    5252}
    5353
    54 nv::map_area* nlua_to_map_area( lua_State* L, int index )
     54nv::map_area* nv::lua::detail::to_map_area( lua_State* L, int index )
    5555{
    5656        if ( lua_type( L, index ) == LUA_TTABLE )
    … …  
    7575}
    7676
    77 void nlua_push_map_area( lua_State* L, nv::map_area* c )
     77using nv::lua::detail::is_map_area;
     78using nv::lua::detail::to_map_area;
     79using nv::lua::detail::push_map_area;
     80
     81using nv::lua::detail::is_coord;
     82using nv::lua::detail::to_coord;
     83using nv::lua::detail::to_pcoord;
     84using nv::lua::detail::push_coord;
     85
     86using nv::lua::detail::is_area;
     87using nv::lua::detail::to_area;
     88using nv::lua::detail::to_parea;
     89using nv::lua::detail::push_area;
     90
     91void nv::lua::detail::push_map_area( lua_State* L, nv::map_area* c )
    7892{
    7993        nv::map_area** pm = (nv::map_area**) (lua_newuserdata(L, sizeof(nv::map_area*)));
    … …  
    91105static int nlua_map_area_gc( lua_State* L )
    92106{
    93         nv::map_area* ma = nlua_to_map_area( L, 1 );
     107        nv::map_area* ma = to_map_area( L, 1 );
    94108        if ( ma != nullptr )
    95109        {
    … …  
    101115static int nlua_map_area_get_area( lua_State* L )
    102116{
    103         nv::map_area* ma = nlua_to_map_area( L, 1 );
     117        nv::map_area* ma = to_map_area( L, 1 );
    104118        nv::rectangle r  = ma->get_rectangle();
    105119        r.lr.x -= 1;
    106120        r.lr.y -= 1;
    107         nlua_push_area( L, r );
     121        push_area( L, r );
    108122        return 1;
    109123}
    … …  
    111125static int nlua_map_area_get_shift( lua_State* L )
    112126{
    113         nv::map_area* ma = nlua_to_map_area( L, 1 );
    114         nlua_push_coord( L, ma->get_shift() );
     127        nv::map_area* ma = to_map_area( L, 1 );
     128        push_coord( L, ma->get_shift() );
    115129        return 1;
    116130}
    … …  
    118132static int nlua_map_area_get_size( lua_State* L )
    119133{
    120         nv::map_area* ma = nlua_to_map_area( L, 1 );
    121         nlua_push_coord( L, ma->get_size() );
     134        nv::map_area* ma = to_map_area( L, 1 );
     135        push_coord( L, ma->get_size() );
    122136        return 1;
    123137}
    … …  
    125139static int nlua_map_area_get_cell( lua_State* L )
    126140{
    127         nv::map_area* ma = nlua_to_map_area( L, 1 );
    128         lua_pushstring( L, ma->id_to_string( ma->get_cell( nlua_to_coord( L, 2 ) ) ).c_str() );
     141        nv::map_area* ma = to_map_area( L, 1 );
     142        lua_pushstring( L, ma->id_to_string( ma->get_cell( to_coord( L, 2 ) ) ).c_str() );
    129143        return 1;
    130144}
    … …  
    132146static int nlua_map_area_set_cell( lua_State* L )
    133147{
    134         nv::map_area* ma = nlua_to_map_area( L, 1 );
    135         ma->set_cell( nlua_to_coord( L, 2 ), nlua_to_cell_id( L, 3, ma ) );
     148        nv::map_area* ma = to_map_area( L, 1 );
     149        ma->set_cell( to_coord( L, 2 ), nlua_to_cell_id( L, 3, ma ) );
    136150        return 0;
    137151}
    … …  
    139153static int nlua_map_area_raw_get_cell( lua_State* L )
    140154{
    141         nv::map_area* ma = nlua_to_map_area( L, 1 );
    142         lua_pushunsigned( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
     155        nv::map_area* ma = to_map_area( L, 1 );
     156        lua_pushunsigned( L, ma->get_cell( to_coord( L, 2 ) ) );
    143157        return 1;
    144158}
    … …  
    146160static int nlua_map_area_raw_set_cell( lua_State* L )
    147161{
    148         nv::map_area* ma = nlua_to_map_area( L, 1 );
    149         ma->set_cell( nlua_to_coord( L, 2 ), lua_tounsigned( L, 3 ) );
     162        nv::map_area* ma = to_map_area( L, 1 );
     163        ma->set_cell( to_coord( L, 2 ), lua_tounsigned( L, 3 ) );
    150164        return 0;
    151165}
    … …  
    153167static int nlua_map_area_index( lua_State* L )
    154168{
    155         nv::map_area* ma = nlua_to_map_area( L, 1 );
     169        nv::map_area* ma = to_map_area( L, 1 );
    156170        if ( lua_type( L, 1 ) == LUA_TSTRING )
    157171        {
    … …  
    162176        else
    163177        {
    164                 lua_pushunsigned( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
     178                lua_pushunsigned( L, ma->get_cell( to_coord( L, 2 ) ) );
    165179        }
    166180        return 1;
    … …  
    169183static int nlua_map_area_newindex( lua_State* L )
    170184{
    171         nv::map_area* ma = nlua_to_map_area( L, 1 );
    172         ma->set_cell( nlua_to_coord( L, 2 ), lua_tounsigned( L, 3 ) );
     185        nv::map_area* ma = to_map_area( L, 1 );
     186        ma->set_cell( to_coord( L, 2 ), lua_tounsigned( L, 3 ) );
    173187        return 0;
    174188}
    … …  
    176190static int nlua_map_area_new_sub_area( lua_State* L )
    177191{
    178         nv::map_area* ma = nlua_to_map_area( L, 1 );
    179         nlua_push_map_area( L, ma->create_sub_area( nlua_to_area( L, 2 ) ) );
     192        nv::map_area* ma = to_map_area( L, 1 );
     193        push_map_area( L, ma->create_sub_area( to_area( L, 2 ) ) );
    180194        return 1;
    181195}
    … …  
    212226}
    213227
    214 void nlua_register_map_area_interface( lua_State* L, int index )
     228void nv::lua::register_map_area_interface( lua_State* L, int index )
    215229{
    216230        nlua_register( L, nlua_map_area_f, index );
    217231}
    218232
    219 void nlua_register_map_area( lua_State* L )
     233void nv::lua::register_map_area( lua_State* L )
    220234{
    221235        luaopen_map_area(L);

  • trunk/src/lua/lua_state.cc

    r206 r207  
    142142}
    143143
    144 bool lua::state::push( const std::string& path, bool global )
    145 {
    146         size_t point = path.find('.');
    147 
    148         if (point == std::string::npos)
    149         {
    150                 if (global)
    151                 {
    152                         lua_getglobal( m_state, path.c_str() );
    153                 }
    154                 else
    155                 {
    156                         lua_getfield( m_state, -1, path.c_str() );
    157                 }
    158                 return !lua_isnil( m_state, -1 );
    159         }
    160 
    161         size_t idx = 0;
    162         size_t start = 0;
    163 
    164         while( point != std::string::npos )
    165         {
    166                 if (idx == 0)
    167                 {
    168                         if (global)
    169                         {
    170                                 lua_getglobal( m_state, path.substr(start,point-start).c_str() );
    171                         }
    172                         else
    173                         {
    174                                 lua_getfield( m_state, -1, path.substr(start,point-start).c_str() );
    175                         }
    176                 }
    177                 else
    178                 {
    179                         if ( lua_istable( m_state, -1 ) )
    180                         {
    181                                 lua_pushstring( m_state, path.substr(start,point-start).c_str() );
    182                                 lua_gettable( m_state, -2 );
    183                                 lua_insert( m_state, -2 );
    184                                 lua_pop( m_state, 1 );
    185                         }
    186                         else
    187                         {
    188                                 lua_pop(m_state, 1);
    189                                 lua_pushnil(m_state);
    190                                 return false;
    191                         }
    192                 }
    193                 start = point+1;
    194                 point = path.find( '.', start );
    195         }
    196         return true;
    197 }
    198 
    199 
    200144int lua::state::get_stack_size()
    201145{

  • trunk/src/lua/lua_values.cc

    r206 r207  
    104104}
    105105
     106bool nv::lua::detail::is_userdata( lua_State *L, int index, const char* metatable )
     107{
     108        return luaL_testudata( L, index, metatable ) != 0;
     109}
     110
     111void* nv::lua::detail::check_userdata( lua_State *L, int index, const char* metatable )
     112{
     113        return luaL_checkudata( L, index, metatable );
     114}
     115
     116void* nv::lua::detail::allocate_userdata( lua_State *L, size_t size, const char* metatable )
     117{
     118        void* result = lua_newuserdata(L, size);
     119        luaL_setmetatable( L, metatable );
     120        return result;
     121}
     122
     123void nv::lua::detail::pop_and_discard( lua_State *L, int count )
     124{
     125        lua_pop( L, count );
     126}
     127
Note: See TracChangeset for help on using the changeset viewer.