Changeset 539


Ignore:
Timestamp:
01/24/17 17:55:00 (8 years ago)
Author:
epyon
Message:
  • temporary_proxy implemented
  • table_guard now uses temporary_proxy as main read functionality
Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/lua/lua_proxy.hh

    r538 r539  
    1010#include <nv/common.hh>
    1111#include <nv/stl/string.hh>
     12#include <nv/stl/string_table.hh>
    1213
    1314namespace nv
    … …  
    2526                        stack_proxy( stack_proxy&& ) = default;
    2627                        stack_proxy& operator=( stack_proxy&& ) = default;
    27                         string64 get_string64() const;
    28                         string64 to_string64();
     28
     29                        uint32 get_uint32( uint32 def = 0 ) const;
     30                        sint32 get_sint32( sint32 def = 0 ) const;
     31                        char get_char( char def = ' ' ) const;
     32                        f64 get_f64( f64 def = 0.0 ) const;
     33                        f32 get_f32( f32 def = 0.0f ) const;
     34                        bool get_bool( bool def = false ) const;
     35
     36                        template< typename E >
     37                        E get_enum( E def = E() ) const
     38                        {
     39                                return static_cast<E>( get_uint32( static_cast<sint32>( def ) ) );
     40                        }
     41
     42                        template< typename T >
     43                        T as( const T& def ) const
     44                        {
     45                                return static_cast<T>( pass_traits< converted_type_t<T> >::to( *m_state, m_index, def ) );
     46                        }
     47
     48                        template< typename T >
     49                        T as() const
     50                        {
     51                                return static_cast<T>( pass_traits< converted_type_t<T> >::to( *m_state, m_index ) );
     52                        }
     53
     54                        bool is_table() const;
     55                        bool is_number() const;
     56                        bool is_bool() const;
     57                        bool is_string() const;
     58
     59                        const_string get_string() const { return const_string( get_string_view() ); }
     60                        const_string as_string()        { return const_string( as_string_view() ); }
     61                        string32 get_string32() const   { return string32( get_string_view() ); }
     62                        string32 as_string32()          { return string32( as_string_view() ); }
     63                        string64 get_string64() const   { return string64( get_string_view() ); }
     64                        string64 as_string64()          { return string64( as_string_view() ); }
     65                        string128 get_string128() const { return string128( get_string_view() ); }
     66                        string128 as_string128()        { return string128( as_string_view() ); }
     67                        shash64 get_shash64() const     { return is_string() ? shash64( get_string_view() ) : shash64(); }
     68                        shash64 as_shash64()            { return is_string() ? shash64( as_string_view() ) : shash64(); }
     69
     70                        shash64 get_string( string_table* table ) const
     71                        {
     72                                string_view result( get_string_view() );
     73                                return table ? table->insert( result ) : result;
     74                        }
     75
     76                        shash64 as_string( string_table* table )
     77                        {
     78                                string_view result( as_string_view() );
     79                                return table ? table->insert( result ) : result;
     80                        }
     81
    2982                        // TO FUCKING DO : non-copyable stringview
    3083//                      string_view get_string_view() const;
    3184//                      string_view to_string_view();
    3285                protected:
     86                        // Not public because not permanent
     87                        string_view get_string_view() const;
     88                        // Not public because not permanent
     89                        string_view as_string_view();
     90
    3391                        state* m_state;
    3492                        sint32 m_index;
    3593                };
     94
     95                class temporary_proxy : public stack_proxy
     96                {
     97                protected:
     98                        temporary_proxy( const temporary_proxy& ) = delete;
     99                        temporary_proxy& operator=( const temporary_proxy& ) = delete;
     100                        temporary_proxy( temporary_proxy&& ) = default;
     101                        temporary_proxy& operator=( temporary_proxy&& ) = default;
     102
     103                        temporary_proxy( state* state );
     104                public:
     105                        ~temporary_proxy();
     106                        friend class table_guard;
     107                };
     108
     109
    36110
    37111                class kv_proxy

  • trunk/nv/lua/lua_state.hh

    r538 r539  
    393393                        }
    394394
     395                        const temporary_proxy operator[]( const string_view& key ) const;
     396                        const temporary_proxy operator[]( sint32 key ) const;
    395397// TO FUCKING DO:
    396 //                      const stack_proxy operator[]( const string_view& key ) const;
    397 //                      const stack_proxy operator[]( sint32 key ) const;
    398 //                      stack_proxy operator[]( const string_view& key );
    399 //                      stack_proxy operator[]( sint32 key );
     398//                      temporary_proxy operator[]( const string_view& key );
     399//                      temporary_proxy operator[]( sint32 key );
    400400
    401401
    402402                        bool has_field( string_view element );
    403403                       
    404                         shash64 get_string_hash_64( string_view element, uint64 defval = 0 );
    405                         shash64 get_string( string_view element, string_table* table, uint64 defval = 0 );
    406                         const_string get_string( string_view element, string_view defval = string_view() );
    407                         string128 get_string128( string_view element, string_view defval = string_view() );
    408                         string64 get_string64( string_view element, string_view defval = string_view() );
    409                         string32 get_string32( string_view element, string_view defval = string_view() );
    410 
    411                         char get_char( string_view element, char defval = ' ' );
    412                         int get_integer( string_view element, int defval = 0 );
    413                         unsigned get_unsigned( string_view element, unsigned defval = 0 );
    414                         double get_double( string_view element, double defval = 0.0 );
    415                         float get_float( string_view element, float defval = 0.0 );
    416                         bool get_boolean( string_view element, bool defval = false );
    417 
    418                         shash64 get_string_hash_64( int i, uint64 defval = 0 );
    419                         shash64 get_string( int i, string_table* table, uint64 defval = 0 );
    420                         const_string get_string( int i, string_view defval = string_view() );
    421                         string128 get_string128( int i, string_view defval = string_view() );
    422 
    423                         char get_char( int i, char defval = ' ' );
    424                         int get_integer( int i, int defval = 0 );
    425                         unsigned get_unsigned( int i, unsigned defval = 0 );
    426                         double get_double( int i, double defval = 0.0 );
    427                         float get_float( int i, float defval = 0.0 );
    428                         bool get_boolean( int i, bool defval = false );
    429 
    430                         bool is_table( string_view element );
    431                         bool is_number( string_view element );
    432                         bool is_boolean( string_view element );
    433                         bool is_string( string_view element );
    434                         bool is_table( int i );
    435                         bool is_number( int i );
    436                         bool is_boolean( int i );
    437                         bool is_string( int i );
     404//                      shash64 get_string_hash_64( string_view element, uint64 defval = 0 );
     405//                      shash64 get_string( string_view element, string_table* table, uint64 defval = 0 );
     406//                      const_string get_string( string_view element, string_view defval = string_view() );
     407//                      string128 get_string128( string_view element, string_view defval = string_view() );
     408//                      string64 get_string64( string_view element, string_view defval = string_view() );
     409//                      string32 get_string32( string_view element, string_view defval = string_view() );
     410//
     411//                      char get_char( string_view element, char defval = ' ' );
     412//                      int get_integer( string_view element, int defval = 0 );
     413//                      unsigned get_unsigned( string_view element, unsigned defval = 0 );
     414//                      double get_double( string_view element, double defval = 0.0 );
     415//                      float get_float( string_view element, float defval = 0.0 );
     416//                      bool get_boolean( string_view element, bool defval = false );
     417//
     418//                      shash64 get_string_hash_64( int i, uint64 defval = 0 );
     419//                      shash64 get_string( int i, string_table* table, uint64 defval = 0 );
     420//                      const_string get_string( int i, string_view defval = string_view() );
     421//                      string128 get_string128( int i, string_view defval = string_view() );
     422//
     423//                      char get_char( int i, char defval = ' ' );
     424//                      int get_integer( int i, int defval = 0 );
     425//                      unsigned get_unsigned( int i, unsigned defval = 0 );
     426//                      double get_double( int i, double defval = 0.0 );
     427//                      float get_float( int i, float defval = 0.0 );
     428//                      bool get_boolean( int i, bool defval = false );
     429//
     430//                      bool is_table( string_view element );
     431//                      bool is_number( string_view element );
     432//                      bool is_boolean( string_view element );
     433//                      bool is_string( string_view element );
     434//                      bool is_table( int i );
     435//                      bool is_number( int i );
     436//                      bool is_boolean( int i );
     437//                      bool is_string( int i );
    438438
    439439                        template < typename T >

  • trunk/src/engine/animation.cc

    r509 r539  
    3434
    3535        nv::animator_data* animator = new nv::animator_data;
    36         animator->id = table.get_string64( "id" );
     36        animator->id = table["id"].get_string64();
    3737        animator->poses = poses;
    3838        if ( poses == nullptr )
    3939        {
    40                 string128 poses_path = table.get_string128( "poses" );
     40                string128 poses_path = table["poses"].get_string128();
    4141                if ( !poses_path.empty() )
    4242                {
    … …  
    5959                nv::lua::table_guard layer_table( table, layer_idx );
    6060                nv::animator_layer_data& layer = animator->layers[layer_idx - 1];
    61                 layer.name = layer_table.get_string( "name", m_strings, 0 );
    62                 layer.mask = layer_table.get_integer( "mask", -1 );
     61                layer.name = layer_table["name"].get_string( m_strings );
     62                layer.mask = layer_table["mask"].get_sint32( -1 );
    6363                layer.def_state = -1;
    6464
    … …  
    7070                }
    7171
    72                 if ( layer_table.is_table( "states" ) )
     72                if ( layer_table["states"].is_table() )
    7373                {
    7474                        nv::lua::table_guard states_table( layer_table, "states" );
    … …  
    8484                                        nv::animator_state_data& state = layer.states[state_idx - 1];
    8585
    86                                         state.name = state_table.get_string( "name", m_strings, 0 );
     86                                        state.name = state_table["name"].get_string( m_strings );
    8787                                        NV_ASSERT( state.name, "Animation state without name is invalid!" );
    8888                                        state_names[state.name] = state_idx - 1;
    89                                         state.loop = state_table.get_boolean( "loop", true );
    90                                         state.duration = state_table.get_float( "duration", 0.0f );
    91                                         state.interp = nv::interpolation( state_table.get_unsigned( "interpolation", uint32( nv::interpolation::SPHERICAL ) ) );
     89                                        state.loop = state_table["loop"].get_bool( true );
     90                                        state.duration = state_table["duration"].get_f32();
     91                                        state.interp = state_table["interpolation"].get_enum( nv::interpolation::SPHERICAL );
    9292
    93                                         shash64 pose_set = state_table.get_string_hash_64( "pose_set" );
     93                                        shash64 pose_set = state_table["pose_set"].get_shash64();
    9494                                        if ( pose_set )
    9595                                        {
    … …  
    9898                                                uint32 pid = it->second.start;
    9999                                                uint32 pose_count = it->second.count;
    100                                                 uint32 start = state_table.get_unsigned( "start", 0 );
    101                                                 uint32 stop = state_table.get_unsigned( "stop", pose_count - 1 );
     100                                                uint32 start = state_table["start"].get_uint32();
     101                                                uint32 stop = state_table["stop"].get_uint32( pose_count - 1 );
    102102                                                for ( nv::uint32 i = pid + start; i < pid + stop + 1; ++i )
    103103                                                {
    … …  
    116116                                        nv::lua::table_guard state_table( states_table, state_idx );
    117117
    118                                         if ( state_table.is_table( "transitions" ) )
     118                                        if ( state_table["transitions"].is_table() )
    119119                                        {
    120120                                                nv::lua::table_guard transitions_table( state_table, "transitions" );
    … …  
    125125                                                        {
    126126                                                                nv::lua::table_guard transition_table( transitions_table, transition_idx );
    127                                                                 shash64 name = transition_table.get_string( "name", m_strings, 0 );
    128                                                                 shash64 target_name = transition_table.get_string_hash_64( "target", 0 );
     127                                                                shash64 name = transition_table["name"].get_string( m_strings );
     128                                                                shash64 target_name = transition_table["target"].get_shash64();
    129129                                                                NV_ASSERT( name, "Transition state without name is invalid!" );
    130130                                                                NV_ASSERT( target_name, "Transition state without name is invalid!" );
    … …  
    134134                                                                nv::animator_transition_data tr_data;
    135135                                                                tr_data.target = it->second;
    136                                                                 tr_data.duration = transition_table.get_float( "duration", 0.0f );
    137                                                                 tr_data.interp = nv::interpolation( transition_table.get_unsigned( "interpolation", uint32( nv::interpolation::SPHERICAL ) ) );
     136                                                                tr_data.duration = transition_table["duration"].get_f32();
     137                                                                tr_data.interp = transition_table["interpolation"].get_enum( nv::interpolation::SPHERICAL );
    138138                                                                tr_data.easing = read_easing( transition_table );
    139139
    … …  
    149149
    150150
    151                 shash64 def_state_name = layer_table.get_string_hash_64( "default", 0 );
     151                shash64 def_state_name = layer_table["default"].get_shash64();
    152152                if ( def_state_name )
    153153                {
    … …  
    164164{
    165165        nv::easing result;
    166         result.in = nv::easing_type( table.get_integer( "easing", int( nv::easing_type::NONE ) ) );
    167         result.in = nv::easing_type( table.get_integer( "ease_in", int( result.in ) ) );
    168         result.out = nv::easing_type( table.get_integer( "ease_out", int( nv::easing_type::NONE ) ) );
     166        result.in = table["easing"].get_enum( nv::easing_type::NONE );
     167        result.in = table["ease_in"].get_enum( result.in );
     168        result.out = table["ease_out"].get_enum( nv::easing_type::NONE );
    169169        if ( table.has_field( "ease_in_out" ) )
    170170        {
    171                 result.in = result.out = nv::easing_type( table.get_integer( "ease_in_out", int( nv::easing_type::NONE ) ) );
     171                result.in = result.out = table["ease_in_out"].get_enum( nv::easing_type::NONE );
    172172        }
    173173        if ( result.in == nv::easing_type::NONE && result.out == nv::easing_type::NONE )

  • trunk/src/engine/material_manager.cc

    r535 r539  
    6161        material* m = new material;
    6262
    63         if ( table.is_string( "path" ) )
     63        if ( table["path"].is_string() )
    6464        {
    65                 m->id = table.get_string128( "id" );
    66                 string128 path = table.get_string128( "path" );
     65                m->id = table["id"].get_string128();
     66                string128 path = table["path"].get_string128();
    6767                for ( uint32 i = 0; i < 5; ++i )
    6868                        m->paths[i] = path;
    … …  
    8585        else
    8686        {
    87                 m->paths[ TEX_DIFFUSE ]  = table.get_string128( "diffuse" );
    88                 m->paths[ TEX_NORMAL ]   = table.get_string128( "normal" );
    89                 m->paths[ TEX_METALLIC]  = table.get_string128( "metallic" );
    90                 m->paths[ TEX_ROUGHNESS] = table.get_string128( "roughness" );
    91                 m->paths[ TEX_EMISSIVE ] = table.get_string128( "emissive" );
     87                m->paths[ TEX_DIFFUSE  ] = table[ "diffuse"   ].get_string128();
     88                m->paths[ TEX_NORMAL   ] = table[ "normal"    ].get_string128();
     89                m->paths[ TEX_METALLIC ] = table[ "metallic"  ].get_string128();
     90                m->paths[ TEX_ROUGHNESS] = table[ "roughness" ].get_string128();
     91                m->paths[ TEX_EMISSIVE ] = table[ "emissive"  ].get_string128();
    9292        }
    9393        add( id, m );

  • trunk/src/engine/model_manager.cc

    r529 r539  
    1818
    1919        model* gm = new model;
    20         gm->flags  = table.get< flags<32> >( "flags" );
    21         gm->attach = table.get_string_hash_64( "attach" );
    22         gm->root.set_position( table.get<vec3>( "root_position", vec3() ) );
    23         gm->root.set_orientation( vec4_to_quat( table.get<vec4>( "root_orientation", vec4(0.0f,0.0f,0.0f,1.0f) ) ) );
     20        gm->flags  = table["flags"].as< flags<32> >();
     21        gm->attach = table["attach"].get_shash64();
     22        gm->root.set_position( table["root_position"].as<vec3>() );
     23        gm->root.set_orientation( vec4_to_quat( table["root_orientation"].as<vec4>( vec4(0.0f,0.0f,0.0f,1.0f) ) ) );
    2424       
    2525        resource< mesh_data > def_data;
    26         if ( table.is_string( "path" ) )
    27                 def_data = m_rm->get< mesh_data >( table.get_string128( "path" ) );
     26        if ( table["path"].is_string() )
     27                def_data = m_rm->get< mesh_data >( table["path"].get_string128() );
    2828
    29         if ( table.is_string( "ragdoll" ) )
    30                 gm->ragdoll_id = table.get_string32( "ragdoll" );
     29        if ( table["ragdoll"].is_string() )
     30                gm->ragdoll_id = table["ragdoll"].get_string32();
    3131       
    3232        if ( table.has_field( "animator" ) )
    3333        {
    34                 gm->animator = m_rm->get< animator_data >( table.get_string( "animator" ) );
     34                gm->animator = m_rm->get< animator_data >( table["animator"].get_string() );
    3535                pose_data_set* poses = gm->animator.lock()->poses;
    3636                if ( !def_data || !def_data.lock()->node_data )
    … …  
    4242        if ( table.has_field( "phx_mesh" ) )
    4343        {
    44                 nv::string128 cpath( table.get_string128( "phx_mesh" ) );
     44                nv::string128 cpath( table["phx_mesh"].get_string128() );
    4545                gm->phx_mesh = m_mesh_datas->get_path( cpath, def_data );
    4646        }
    4747
    48         if ( table.is_table( "model" ) )
     48        if ( table["model"].is_table() )
    4949        {
    5050                lua::table_guard model_table( table, "model" );
    … …  
    6666        sint16 attach_id = -1;
    6767
    68         if ( table.is_string( "material" ) )
     68        if ( table["material"].is_string() )
    6969        {
    70                 nv::string128 mat_id( table.get_string128( "material" ) );
     70                nv::string128 mat_id( table["material"].get_string128() );
    7171                cmaterial = m_rm->get< material >( mat_id );
    7272                if ( !cmaterial )
    … …  
    7474        }
    7575
    76         if ( table.is_string( "tag" ) )
    77                 node->tag = table.get_string32( "tag" );
     76        if ( table["tag"].is_string() )
     77                node->tag = table["tag"].get_string32();
    7878
    7979        if ( table.has_field( "path" ) )
    8080        {
    81                 nv::string128 cpath( table.get_string128( "path" ) );
     81                nv::string128 cpath( table["path"].get_string128() );
    8282                nv::data_node_info info;
    8383                cmesh = m_mesh_datas->get_path( cpath, def_data, &info );
    … …  
    8686
    8787        if ( table.has_field( "phx_hextents" ) )
    88                 node->phx_hextents = table.get<vec3>( "phx_hextents", vec3() );
     88                node->phx_hextents = table["phx_hextents"].as<vec3>();
    8989        if ( table.has_field( "phx_offset" ) )
    90                 node->phx_offset = table.get<vec3>( "phx_offset", vec3() );
     90                node->phx_offset = table["phx_offset"].as<vec3>();
    9191        if ( table.has_field( "phx_mass" ) )
    92                 node->phx_mass = table.get<float>( "phx_mass", 0.0f);
     92                node->phx_mass = table["phx_mass"].as<float>( 0.0f );
    9393        if ( table.has_field( "phx_mass" ) )
    94                 node->phx_shape = nv::phx_shape( table.get<int>( "phx_shape", 0 ) );
     94                node->phx_shape = nv::phx_shape( table["phx_shape"].as<int>( 0 ) );
    9595
    9696        if ( table.has_field( "local_position" ) )
    97                 node->local.set_position( table.get<vec3>( "local_position", vec3() ) );
     97                node->local.set_position( table["local_position"].as<vec3>() );
    9898        if ( table.has_field( "local_orientation" ) )
    99                 node->local.set_orientation( vec4_to_quat( table.get<vec4>( "local_orientation", vec4( 0.0f, 0.0f, 0.0f, 1.0f ) ) ) );
     99                node->local.set_orientation( vec4_to_quat( table["local_orientation"].as<vec4>( vec4( 0.0f, 0.0f, 0.0f, 1.0f ) ) ) );
    100100
    101101        if ( table.has_field( "position" ) )
    102102        {
    103                 node->position.min = table.get<vec3>( "position", vec3() );
     103                node->position.min = table["position"].as<vec3>();
    104104                node->position.max = node->position.min;
    105105        }
    106106        if ( table.has_field( "rotation" ) )
    107107        {
    108                 node->rotation.min = table.get<vec3>( "rotation", vec3() );
     108                node->rotation.min = table["rotation"].as<vec3>();
    109109                node->rotation.max = node->rotation.min;
    110110        }
    111         if ( table.has_field( "position_min" ) )  node->position.min  = table.get<vec3>( "position_min", vec3() );
    112         if ( table.has_field( "position_max" ) )  node->position.max  = table.get<vec3>( "position_max", vec3() );
    113         if ( table.has_field( "position_dist" ) ) node->position.dist = random_dist( table.get_unsigned( "position_dist", 0 ) );
    114         if ( table.has_field( "rotation_min" ) )  node->rotation.min  = table.get<vec3>( "rotation_min", vec3() );
    115         if ( table.has_field( "rotation_max" ) )  node->rotation.max  = table.get<vec3>( "rotation_max", vec3() );
    116         if ( table.has_field( "rotation_dist" ) ) node->rotation.dist = random_dist( table.get_unsigned( "rotation_dist", 0 ) );
     111        if ( table.has_field( "position_min" ) )  node->position.min  = table["position_min"].as<vec3>();
     112        if ( table.has_field( "position_max" ) )  node->position.max  = table["position_max"].as<vec3>();
     113        if ( table.has_field( "position_dist" ) ) node->position.dist = random_dist( table["position_dist"].get_uint32() );
     114        if ( table.has_field( "rotation_min" ) )  node->rotation.min  = table["rotation_min"].as<vec3>();
     115        if ( table.has_field( "rotation_max" ) )  node->rotation.max  = table["rotation_max"].as<vec3>();
     116        if ( table.has_field( "rotation_dist" ) ) node->rotation.dist = random_dist( table["rotation_dist"].get_uint32() );
    117117
    118118        if ( table.has_field( "attach" ) )
    119119        {
    120                 if ( table.is_number( "attach" ) )
     120                if ( table["attach"].is_number() )
    121121                {
    122                         attach_id = sint16( table.get_integer( "attach", -1 ) );
     122                        attach_id = sint16( table["attach"].get_sint32( -1 ) );
    123123                        //                              parent_id = 0;
    124124                }
    125125                else if ( auto m = def_data.lock() )
    126126                {
    127                         auto it = m->node_names.find( table.get_string_hash_64( "attach" ) );
     127                        auto it = m->node_names.find( table["attach"].get_shash64() );
    128128                        if ( it != m->node_names.end() )
    129129                                attach_id = sint16( it->second + 1 );
    … …  
    132132        }
    133133       
    134         node->nflags    = table.get< flags<16,uint16> >( "flags" );
    135         node->choice    = model_node_choice( table.get_unsigned( "choice", false ) );
    136         node->chance    = table.get_float( "chance", 1.0f );
    137         node->weight    = static_cast< uint16 >( table.get_unsigned( "weight", 1 ) );
     134        node->nflags    = table["flags"].as< flags<16,uint16> >();
     135        node->choice    = model_node_choice( table["choice"].get_uint32( 0 ) );
     136        node->chance    = table["chance"].get_f32( 1.0f );
     137        node->weight    = static_cast< uint16 >( table["weight"].get_uint32( 1 ) );
    138138        node->mesh      = cmesh;
    139139        node->attach_id = attach_id;

  • trunk/src/engine/particle_manager.cc

    r520 r539  
    6161        data->emitter_count   = 0;
    6262        data->affector_count  = 0;
    63         data->orientation     = particle_orientation( table.get_unsigned("orientation", 0) );
    64         data->origin          = particle_origin( table.get_unsigned( "origin",0  ) );
     63        data->orientation     = particle_orientation( table["orientation"].get_uint32() );
     64        data->origin          = particle_origin( table["origin"].get_uint32() );
    6565
    66         data->common_up  = math::normalize( table.get<vec3>("common_up", vec3(1,0,0) ) );
    67         data->common_dir = math::normalize( table.get<vec3>("common_dir", vec3(0,1,0) ) );
     66        data->common_up  = math::normalize( table["common_up"].as( vec3(1,0,0) ) );
     67        data->common_dir = math::normalize( table["common_dir"].as( vec3(0,1,0) ) );
    6868
    6969        vec2 def_size        = table.get<vec2>("size", vec2(0.1,0.1) );
    … …  
    7272        {
    7373                lua::table_guard element( table, i+1 );
    74                 const_string type     = element.get_string( "type" );
    75                 const_string sub_type = element.get_string( "sub_type" );
     74                const_string type     = element["type"].get_string();
     75                const_string sub_type = element["sub_type"].get_string();
    7676                if ( type == "emitter" )
    7777                {
    … …  
    8686                                }
    8787
    88                                 edata.position     = element.get<vec3>("position", vec3() );
    89                                 edata.extents      = element.get<vec3>("extents", vec3(1,1,1) );
    90                                 edata.extents[0]   = element.get<float>("width", edata.extents[0] );
    91                                 edata.extents[1]   = element.get<float>("depth", edata.extents[1] );
    92                                 edata.extents[2]   = element.get<float>("height", edata.extents[2] );
    93                                 edata.extents[0]   = element.get<float>("radius", edata.extents[0] );
    94                                 edata.iextents     = element.get<vec3>("inner_extents", vec3() );
    95                                 edata.iextents[0]  = element.get<float>("inner_width", edata.iextents[0] );
    96                                 edata.iextents[1]  = element.get<float>("inner_depth", edata.iextents[1] );
    97                                 edata.iextents[2]  = element.get<float>("inner_height", edata.iextents[2] );
    98                                 edata.iextents[0]  = element.get<float>("inner_radius", edata.iextents[0] );
     88                                edata.position     = element["position"].as( vec3() );
     89                                edata.extents      = element["extents"].as( vec3(1,1,1) );
     90                                edata.extents[0]   = element["width"].as( edata.extents[0] );
     91                                edata.extents[1]   = element["depth"].as( edata.extents[1] );
     92                                edata.extents[2]   = element["height"].as( edata.extents[2] );
     93                                edata.extents[0]   = element["radius"].as( edata.extents[0] );
     94                                edata.iextents     = element["inner_extents"].as( vec3() );
     95                                edata.iextents[0]  = element["inner_width"].as( edata.iextents[0] );
     96                                edata.iextents[1]  = element["inner_depth"].as( edata.iextents[1] );
     97                                edata.iextents[2]  = element["inner_height"].as( edata.iextents[2] );
     98                                edata.iextents[0]  = element["inner_radius"].as( edata.iextents[0] );
    9999                                edata.hextents     = 0.5f * edata.extents;
    100100                                edata.ihextents    = 0.5f * edata.iextents;
    101                                 edata.precise      = element.get<bool>("precise", false );
    102                                 edata.square       = element.get<bool>("square", true );
    103                                 vec4 color         = element.get<vec4>("color", vec4(1,1,1,1) );
    104                                 edata.color_min    = element.get<vec4>("color_min", color );
    105                                 edata.color_max    = element.get<vec4>("color_max", color );
    106                                 vec2 size          = element.get<vec2>("size", def_size );
    107                                 edata.size_min     = element.get<vec2>("size_min", size );
    108                                 edata.size_max     = element.get<vec2>("size_max", size );
    109                                 edata.angle        = element.get<float>("angle", 0.0f );
    110                                 float velocity     = element.get<float>("velocity", 0.0f );
    111                                 edata.velocity_min = element.get<float>("velocity_min", velocity );
    112                                 edata.velocity_max = element.get<float>("velocity_max", velocity );
    113                                 float lifetime     = element.get<float>("lifetime", 1.0f );
    114                                 edata.lifetime_min = element.get<float>("lifetime_min", lifetime );
    115                                 edata.lifetime_max = element.get<float>("lifetime_max", lifetime );
    116                                 float duration     = element.get<float>("duration", 0.0f );
    117                                 edata.duration_min = element.get<float>("duration_min", duration );
    118                                 edata.duration_max = element.get<float>("duration_max", duration );
    119                                 float repeat       = element.get<float>("repeat_delay", 0.0f );
    120                                 edata.repeat_min   = element.get<float>("repeat_delay_min", repeat );
    121                                 edata.repeat_max   = element.get<float>("repeat_delay_max", repeat );
     101                                edata.precise      = element["precise"].as( false );
     102                                edata.square       = element["square"].as( true );
     103                                vec4 color         = element["color"].as( vec4(1,1,1,1) );
     104                                edata.color_min    = element["color_min"].as( color );
     105                                edata.color_max    = element["color_max"].as( color );
     106                                vec2 size          = element["size"].as( def_size );
     107                                edata.size_min     = element["size_min"].as( size );
     108                                edata.size_max     = element["size_max"].as( size );
     109                                edata.angle        = element["angle"].as( 0.0f );
     110                                float velocity     = element["velocity"].as( 0.0f );
     111                                edata.velocity_min = element["velocity_min"].as( velocity );
     112                                edata.velocity_max = element["velocity_max"].as( velocity );
     113                                float lifetime     = element["lifetime"].as( 1.0f );
     114                                edata.lifetime_min = element["lifetime_min"].as( lifetime );
     115                                edata.lifetime_max = element["lifetime_max"].as( lifetime );
     116                                float duration     = element["duration"].as( 0.0f );
     117                                edata.duration_min = element["duration_min"].as( duration );
     118                                edata.duration_max = element["duration_max"].as( duration );
     119                                float repeat       = element["repeat_delay"].as( 0.0f );
     120                                edata.repeat_min   = element["repeat_delay_min"].as( repeat );
     121                                edata.repeat_max   = element["repeat_delay_max"].as( repeat );
    122122
    123                                 edata.rate         = element.get<float>("rate", 1.0f );
    124                                 edata.dir          = math::normalize( element.get<vec3>("direction", vec3(0,1,0) ) );
     123                                edata.rate         = element["rate"].as( 1.0f );
     124                                edata.dir          = math::normalize( element["direction"].as( vec3(0,1,0) ) );
    125125                               
    126126                                edata.odir = vec3( 0, 0, 1 );

  • trunk/src/engine/program_manager.cc

    r534 r539  
    1818bool nv::program_manager::load_resource( lua::table_guard& table, shash64 id )
    1919{
    20         NV_LOG_DEBUG( table.get_string("id") );
     20        NV_LOG_DEBUG( table["id"].get_string() );
    2121        string_buffer vsource;
    2222        string_buffer fsource;
    2323        string_buffer header( m_shader_head );
    24         if ( table.is_table("common") )
     24        if ( table["common"].is_table() )
    2525        {
    2626                lua::table_guard common( table, "common" );
    … …  
    6161        c_file_system fs;
    6262        string_buffer out( append );
    63         if ( table.is_string( "files" ) )
     63        if ( table["files"].is_string() )
    6464        {
    65                 out.append( file_to_string( table.get_string( "files" ) ) );
     65                out.append( file_to_string( table["files"].get_string() ) );
    6666        }
    67         else if ( table.is_table( "files" ) )
     67        else if ( table["files"].is_table() )
    6868        {
    6969                lua::table_guard inctable( table, "files" );
    … …  
    7777        }
    7878
    79         if ( table.is_string( "file" ) )
     79        if ( table["file"].is_string() )
    8080        {
    81                 const_string data = file_to_string( table.get_string( "file" ) );
     81                const_string data = file_to_string( table["file"].get_string() );
    8282                out.append( "#line 1\n" + data );
    8383        }
    8484
    85         if ( table.is_string( "source" ) )
     85        if ( table["source"].is_string() )
    8686        {
    87                 out.append( table.get_string( "source" ) );
     87                out.append( table["source"].get_string() );
    8888        }
    8989        return out;

  • trunk/src/engine/ragdoll_manager.cc

    r524 r539  
    2626        NV_ASSERT_ALWAYS( m_world, "Physics world not setup in ragdoll_manager!" );
    2727        bool result = false;
    28         nv::string64 model_id = table.get_string64( "model" );
     28        nv::string64 model_id = table["model"].get_string64();
    2929        nv::resource< model > mr = m_model->get( model_id );
    3030        if ( !mr ) return false;
    … …  
    6666        if ( auto bind_data = rbind.lock() )
    6767        {
    68                 data->id = table.get_string32( "id" );
     68                data->id = table["id"].get_string32();
    6969                int index = data->parts.size();
    7070                data->parts.emplace_back();
    7171                auto& part = data->parts.back();
    72                 part.name = table.get_string_hash_64( "name" );
    73                 part.bone_id = nv::uint32( bind_data->get_bone_list().resolve( table.get_string_hash_64( "bone" ) ) );
     72                part.name = table["name"].get_shash64();
     73                part.bone_id = nv::uint32( bind_data->get_bone_list().resolve( table["bone"].get_shash64() ) );
    7474                NV_ASSERT( part.bone_id < 256, "Bone ID not found!" );
    75                 float radius = table.get_float( "radius" );
     75                float radius = table["radius"].get_f32();
    7676                float length = 0.0f;
    7777                if ( table.has_field( "target" ) )
    7878                {
    7979                        const auto& of = bind_data->get_bone_transforms().m_offsets;
    80                         int target = bind_data->get_bone_list().resolve( table.get_string_hash_64( "target" ) );
     80                        int target = bind_data->get_bone_list().resolve( table["target"].get_shash64() );
    8181                        if ( target < 0 ) return false;
    8282                        length = math::distance( of[part.bone_id].get_position(), of[target].get_position() );
    … …  
    8484                else
    8585                {
    86                         length = table.get_float( "length" );
     86                        length = table["length"].get_f32();
    8787                }
    8888                NV_ASSERT( radius > 0.0f && length > 0.0f, "Bad parameters!" );
    8989                part.shape      = m_world->create_capsule( radius, length );
    9090                part.parent_idx = pindex;
    91                 part.mass       = table.get_float( "mass", 1.0f );
     91                part.mass       = table["mass"].get_f32( 1.0f );
    9292                part.cone_twist = false;
    9393                // Joints
    9494                if ( pindex != -1 )
    9595                {
    96                         part.cone_twist = table.get_string_hash_64("joint") == shash64( "cone_twist"_ls );
    97                         part.limits     = table.get< vec3 >( "limits" );
     96                        part.cone_twist = table["joint"].get_shash64() == shash64( "cone_twist"_ls );
     97                        part.limits     = table["limits"].as< vec3 >();
    9898                }
    9999                uint32 child_count = table.get_size();

  • trunk/src/engine/resource_system.cc

    r529 r539  
    2727        if ( do_clear ) clear();
    2828        lua::table_guard table( m_lua, get_storage_name() );
    29         uint32 count = table.get_unsigned( "__counter" );
     29        uint32 count = table["__counter"].get_uint32();
    3030        for ( auto i : range( count ) )
    3131        {
    3232                lua::table_guard sub_table( table, i + 1 );
    33                 load_resource( sub_table, sub_table.get_string_hash_64( "id" ) );
     33                shash64 id = sub_table["id"].get_shash64();
     34                load_resource( sub_table, id );
    3435        }
    3536}
    … …  
    3940        m_id_hash.clear();
    4041        lua::table_guard table( m_lua, get_storage_name() );
    41         uint32 count = table.get_unsigned( "__counter" );
     42        uint32 count = table["__counter"].get_uint32();
    4243        for ( auto i : range( count ) )
    4344        {
    4445                lua::table_guard sub_table( table, i + 1 );
    45                 string64 id = sub_table.get_string64( "id" );
     46                string64 id = sub_table["id"].get_string64();
    4647                NV_ASSERT( m_id_hash.find( id ) == m_id_hash.end(), "HASH COLLISION" );
    4748                m_id_hash[id] = id;

  • trunk/src/lua/lua_proxy.cc

    r538 r539  
    1313using namespace nv::lua;
    1414
    15 nv::string64 nv::lua::stack_proxy::get_string64() const
     15uint32 nv::lua::stack_proxy::get_uint32( uint32 def ) const
     16{
     17        return lua_type( *m_state, m_index ) == LUA_TNUMBER ? nlua_tounsigned( *m_state, m_index ) : def;
     18}
     19
     20sint32 nv::lua::stack_proxy::get_sint32( sint32 def ) const
     21{
     22        return lua_type( *m_state, m_index ) == LUA_TNUMBER ? static_cast<sint32>( lua_tointeger( *m_state, m_index ) ) : def;
     23}
     24
     25char nv::lua::stack_proxy::get_char( char def /*= ' ' */ ) const
     26{
     27        return ( lua_type( *m_state, m_index ) == LUA_TSTRING && nlua_rawlen( *m_state, m_index ) > 0 ) ? lua_tostring( *m_state, m_index )[0] : def;
     28}
     29
     30nv::f64 nv::lua::stack_proxy::get_f64( f64 def /*= 0.0 */ ) const
     31{
     32        return lua_type( *m_state, m_index ) == LUA_TNUMBER ? lua_tonumber( *m_state, m_index ) : def;
     33}
     34
     35nv::f32 nv::lua::stack_proxy::get_f32( f32 def /*= 0.0f */ ) const
     36{
     37        return lua_type( *m_state, m_index ) == LUA_TNUMBER ? static_cast<float>( lua_tonumber( *m_state, m_index ) ) : def;
     38}
     39
     40bool nv::lua::stack_proxy::get_bool( bool def /*= false */ ) const
     41{
     42        return lua_type( *m_state, m_index ) == LUA_TBOOLEAN ? lua_toboolean( *m_state, m_index ) != 0 : def;
     43}
     44
     45bool nv::lua::stack_proxy::is_number() const
     46{
     47        return lua_type( *m_state, m_index ) == LUA_TNUMBER;
     48}
     49
     50bool nv::lua::stack_proxy::is_bool() const
     51{
     52        return lua_type( *m_state, m_index ) == LUA_TBOOLEAN;
     53}
     54
     55bool nv::lua::stack_proxy::is_string() const
     56{
     57        return lua_type( *m_state, m_index ) == LUA_TSTRING;
     58}
     59
     60bool nv::lua::stack_proxy::is_table() const
     61{
     62        return lua_type( *m_state, m_index ) == LUA_TTABLE;
     63}
     64
     65nv::string_view nv::lua::stack_proxy::get_string_view() const
    1666{
    1767        size_t l = 0;
    … …  
    2171                str = lua_tolstring( *m_state, m_index, &l );
    2272        }
    23         return string64( str, static_cast<uint32>( l ) );
     73        return string_view( str, static_cast<uint32>( l ) );
    2474}
    2575
    26 nv::string64 nv::lua::stack_proxy::to_string64()
     76nv::string_view nv::lua::stack_proxy::as_string_view()
    2777{
    2878        size_t l = 0;
    2979        const char* str = nullptr;
    3080        str = lua_tolstring( *m_state, m_index, &l );
    31         return string64( str, static_cast<uint32>( l ) );
     81        return string_view( str, static_cast<uint32>( l ) );
    3282}
     83
     84nv::lua::temporary_proxy::temporary_proxy( state* state )
     85        : stack_proxy( state, -1 )
     86{
     87
     88}
     89
     90nv::lua::temporary_proxy::~temporary_proxy()
     91{
     92        lua_pop( *m_state, 1 );
     93}

  • trunk/src/lua/lua_state.cc

    r538 r539  
    185185}
    186186
    187 shash64 nv::lua::table_guard::get_string_hash_64( string_view element, uint64 defval /*= 0 */ )
    188 {
    189         lua_getfield( m_state, -1, element.data() );
    190         size_t l = 0;
    191         const char* str = nullptr;
    192         uint64 result = defval;
    193         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    194         {
    195                 str = lua_tolstring( m_state, -1, &l );
    196                 result = hash_string< uint64 >( str, static_cast< uint32 >( l ) );
    197                 //NV_LOG_DEBUG( str );
    198         }
    199         lua_pop( m_state, 1 );
    200         return shash64( result );
    201 }
    202 
    203 nv::shash64 nv::lua::table_guard::get_string( string_view element, string_table* table, uint64 defval /*= 0 */ )
    204 {
    205         lua_getfield( m_state, -1, element.data() );
    206         size_t l = 0;
    207         const char* str = nullptr;
    208         shash64 result = shash64( defval );
    209         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    210         {
    211                 str = lua_tolstring( m_state, -1, &l );
    212                 string_view sv( str, static_cast< uint32 >( l ) );
    213                 result = table ? table->insert( sv ) : shash64( sv );
    214         }
    215         lua_pop( m_state, 1 );
    216         return result;
    217 }
    218 
    219 shash64 nv::lua::table_guard::get_string_hash_64( int i, uint64 defval /*= 0 */ )
    220 {
    221         lua_rawgeti( m_state, -1, i );
    222         size_t l = 0;
    223         const char* str = nullptr;
    224         uint64 result = defval;
    225         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    226         {
    227                 str = lua_tolstring( m_state, -1, &l );
    228                 result = hash_string< uint64 >( str, static_cast< uint32 >( l ) );
    229                 //NV_LOG_DEBUG( str );
    230         }
    231         lua_pop( m_state, 1 );
    232         return shash64( result );
    233 }
    234 
    235 nv::string128 nv::lua::table_guard::get_string128( int i, string_view defval /*= string_view() */ )
    236 {
    237         lua_rawgeti( m_state, -1, i );
    238         size_t l = 0;
    239         const char* str = nullptr;
    240         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    241         {
    242                 str = lua_tolstring( m_state, -1, &l );
    243         }
    244         else
    245         {
    246                 l = defval.size();
    247                 str = defval.data();
    248         }
    249         string128 result( str, static_cast< uint32 >( l ) );
    250         lua_pop( m_state, 1 );
    251         return result;
    252 }
    253 
    254 const_string nv::lua::table_guard::get_string( int i, string_view defval /*= string_view() */ )
    255 {
    256         lua_rawgeti( m_state, -1, i );
    257         size_t l = 0;
    258         const char* str = nullptr;
    259         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    260         {
    261                 str = lua_tolstring( m_state, -1, &l );
    262         }
    263         else
    264         {
    265                 l = defval.size();
    266                 str = defval.data();
    267         }
    268         const_string result( str, static_cast< uint32 >( l ) );
    269         lua_pop( m_state, 1 );
    270         return result;
    271 }
    272 
    273 shash64 nv::lua::table_guard::get_string( int i, string_table* table, uint64 defval /*= 0 */ )
    274 {
    275         lua_rawgeti( m_state, -1, i );
    276         size_t l = 0;
    277         const char* str = nullptr;
    278         shash64 result = shash64( defval );
    279         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    280         {
    281                 str = lua_tolstring( m_state, -1, &l );
    282                 string_view sv( str, static_cast< uint32 >( l ) );
    283                 result = table ? table->insert( sv ) : shash64( sv );
    284         }
    285         lua_pop( m_state, 1 );
    286         return result;
    287 }
    288 
    289 const_string lua::table_guard::get_string( string_view element, string_view defval /*= string_view() */ )
    290 {
    291         lua_getfield( m_state, -1, element.data() );
    292         size_t l = 0;
    293         const char* str = nullptr;
    294         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    295         {
    296                 str = lua_tolstring( m_state, -1, &l );
    297         }
    298         else
    299         {
    300                 l = defval.size();
    301                 str = defval.data();
    302         }
    303         const_string result( str, static_cast< uint32 >( l ) );
    304         lua_pop( m_state, 1 );
    305         return result;
    306 }
    307 
    308 string128 lua::table_guard::get_string128( string_view element, string_view defval )
    309 {
    310         lua_getfield( m_state, -1, element.data() );
    311         size_t l = 0;
    312         const char* str = nullptr;
    313         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    314         {
    315                 str = lua_tolstring( m_state, -1, &l );
    316         }
    317         else
    318         {
    319                 l = defval.size();
    320                 str = defval.data();
    321         }
    322         string128 result( str, static_cast< uint32 >( l ) );
    323         lua_pop( m_state, 1 );
    324         return result;
    325 }
    326 
    327 nv::string64 nv::lua::table_guard::get_string64( string_view element, string_view defval /*= string_view() */ )
    328 {
    329         lua_getfield( m_state, -1, element.data() );
    330         size_t l = 0;
    331         const char* str = nullptr;
    332         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    333         {
    334                 str = lua_tolstring( m_state, -1, &l );
    335         }
    336         else
    337         {
    338                 l = defval.size();
    339                 str = defval.data();
    340         }
    341         string64 result( str, static_cast< uint32 >( l ) );
    342         lua_pop( m_state, 1 );
    343         return result;
    344 }
    345 
    346 
    347 nv::string32 nv::lua::table_guard::get_string32( string_view element, string_view defval /*= string_view() */ )
    348 {
    349         lua_getfield( m_state, -1, element.data() );
    350         size_t l = 0;
    351         const char* str = nullptr;
    352         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    353         {
    354                 str = lua_tolstring( m_state, -1, &l );
    355         }
    356         else
    357         {
    358                 l = defval.size();
    359                 str = defval.data();
    360         }
    361         string32 result( str, static_cast< uint32 >( l ) );
    362         lua_pop( m_state, 1 );
    363         return result;
    364 }
    365 
    366 char lua::table_guard::get_char( string_view element, char defval /*= "" */ )
    367 {
    368         lua_getfield( m_state, -1, element.data() );
    369         char result = ( lua_type( m_state, -1 ) == LUA_TSTRING && nlua_rawlen( m_state, -1 ) > 0 ) ? lua_tostring( m_state, -1 )[0] : defval;
    370         lua_pop( m_state, 1 );
    371         return result;
    372 }
    373 
    374 int lua::table_guard::get_integer( string_view element, int defval /*= "" */ )
    375 {
    376         lua_getfield( m_state, -1, element.data() );
    377         lua_Integer result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tointeger( m_state, -1 ) : defval;
    378         lua_pop( m_state, 1 );
    379         return static_cast< int >( result );
    380 }
    381 
    382 unsigned lua::table_guard::get_unsigned( string_view element, unsigned defval /*= "" */ )
    383 {
    384         lua_getfield( m_state, -1, element.data() );
    385         unsigned result = lua_type( m_state, -1 ) == LUA_TNUMBER ? nlua_tounsigned( m_state, -1 ) : defval;
    386         lua_pop( m_state, 1 );
    387         return result;
    388 }
    389 
    390 double lua::table_guard::get_double( string_view element, double defval /*= "" */ )
    391 {
    392         lua_getfield( m_state, -1, element.data() );
    393         double result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tonumber( m_state, -1 ) : defval;
    394         lua_pop( m_state, 1 );
    395         return result;
    396 }
    397 
    398 char nv::lua::table_guard::get_char( int i, char defval /*= ' ' */ )
    399 {
    400         lua_rawgeti( m_state, -1, i );
    401         char result = ( lua_type( m_state, -1 ) == LUA_TSTRING && nlua_rawlen( m_state, -1 ) > 0 ) ? lua_tostring( m_state, -1 )[0] : defval;
    402         lua_pop( m_state, 1 );
    403         return result;
    404 }
    405 
    406 int nv::lua::table_guard::get_integer( int i, int defval /*= 0 */ )
    407 {
    408         lua_rawgeti( m_state, -1, i );
    409         lua_Integer result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tointeger( m_state, -1 ) : defval;
    410         lua_pop( m_state, 1 );
    411         return static_cast<int>( result );
    412 }
    413 
    414 unsigned nv::lua::table_guard::get_unsigned( int i, unsigned defval /*= 0 */ )
    415 {
    416         lua_rawgeti( m_state, -1, i );
    417         unsigned result = lua_type( m_state, -1 ) == LUA_TNUMBER ? nlua_tounsigned( m_state, -1 ) : defval;
    418         lua_pop( m_state, 1 );
    419         return result;
    420 }
    421 
    422 double nv::lua::table_guard::get_double( int i, double defval /*= 0.0 */ )
    423 {
    424         lua_rawgeti( m_state, -1, i );
    425         double result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tonumber( m_state, -1 ) : defval;
    426         lua_pop( m_state, 1 );
    427         return result;
    428 }
    429 
    430 float nv::lua::table_guard::get_float( int i, float defval /*= 0.0 */ )
    431 {
    432         lua_rawgeti( m_state, -1, i );
    433         float result = lua_type( m_state, -1 ) == LUA_TNUMBER ? static_cast<float>( lua_tonumber( m_state, -1 ) ) : defval;
    434         lua_pop( m_state, 1 );
    435         return result;
    436 }
    437 
    438 bool nv::lua::table_guard::get_boolean( int i, bool defval /*= false */ )
    439 {
    440         lua_rawgeti( m_state, -1, i );
    441         bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN ? lua_toboolean( m_state, -1 ) != 0 : defval;
    442         lua_pop( m_state, 1 );
    443         return result;
    444 }
    445 
    446 float nv::lua::table_guard::get_float( string_view element, float defval /*= 0.0 */ )
    447 {
    448         lua_getfield( m_state, -1, element.data() );
    449         float result = lua_type( m_state, -1 ) == LUA_TNUMBER ? static_cast<float>( lua_tonumber( m_state, -1 ) ) : defval;
    450         lua_pop( m_state, 1 );
    451         return result;
    452 }
    453 
    454 bool lua::table_guard::get_boolean( string_view element, bool defval /*= "" */ )
    455 {
    456         lua_getfield( m_state, -1, element.data() );
    457         bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN ? lua_toboolean( m_state, -1 ) != 0 : defval;
    458         lua_pop( m_state, 1 );
    459         return result;
    460 }
    461 
    462 bool nv::lua::table_guard::is_table( string_view element )
    463 {
    464         lua_getfield( m_state, -1, element.data() );
    465         bool result = lua_type( m_state, -1 ) == LUA_TTABLE;
    466         lua_pop( m_state, 1 );
    467         return result;
    468 }
    469 
    470 bool nv::lua::table_guard::is_table( int i )
    471 {
    472         lua_rawgeti( m_state, -1, i );
    473         bool result = lua_type( m_state, -1 ) == LUA_TTABLE;
    474         lua_pop( m_state, 1 );
    475         return result;
    476 }
    477 
    478 bool nv::lua::table_guard::is_number( int i )
    479 {
    480         lua_rawgeti( m_state, -1, i );
    481         bool result = lua_type( m_state, -1 ) == LUA_TNUMBER;
    482         lua_pop( m_state, 1 );
    483         return result;
    484 }
    485 
    486 bool nv::lua::table_guard::is_boolean( int i )
    487 {
    488         lua_rawgeti( m_state, -1, i );
    489         bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN;
    490         lua_pop( m_state, 1 );
    491         return result;
    492 }
    493 
    494 bool nv::lua::table_guard::is_string( int i )
    495 {
    496         lua_rawgeti( m_state, -1, i );
    497         bool result = lua_type( m_state, -1 ) == LUA_TSTRING;
    498         lua_pop( m_state, 1 );
    499         return result;
    500 }
    501 
    502 bool nv::lua::table_guard::is_number( string_view element )
    503 {
    504         lua_getfield( m_state, -1, element.data() );
    505         bool result = lua_type( m_state, -1 ) == LUA_TNUMBER;
    506         lua_pop( m_state, 1 );
    507         return result;
    508 }
    509 
    510 bool nv::lua::table_guard::is_boolean( string_view element )
    511 {
    512         lua_getfield( m_state, -1, element.data() );
    513         bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN;
    514         lua_pop( m_state, 1 );
    515         return result;
    516 }
    517 
    518 bool nv::lua::table_guard::is_string( string_view element )
    519 {
    520         lua_getfield( m_state, -1, element.data() );
    521         bool result = lua_type( m_state, -1 ) == LUA_TSTRING;
    522         lua_pop( m_state, 1 );
    523         return result;
     187const nv::lua::temporary_proxy nv::lua::table_guard::operator[]( const string_view& key ) const
     188{
     189        lua_getfield( m_state, -1, key.data() );
     190        return temporary_proxy( m_parent );
     191}
     192
     193const nv::lua::temporary_proxy nv::lua::table_guard::operator[]( sint32 key ) const
     194{
     195        lua_rawgeti( m_state, -1, key );
     196        return temporary_proxy( m_parent );
    524197}
    525198
Note: See TracChangeset for help on using the changeset viewer.