Changeset 540 for trunk/src


Ignore:
Timestamp:
01/25/17 20:20:45 (8 years ago)
Author:
epyon
Message:
  • lua::stack_proxy RTTI read support
  • missing RTTI declarations
  • new lua::table_guard syntax
Location:
trunk/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/core/types.cc

    r505 r540  
    2828        db->create_type<ivec4>();
    2929        db->create_type<quat>();
     30        db->create_type<shash32>();
     31        db->create_type<shash64>();
    3032        db->create_type<string32>();
    3133        db->create_type<string64>();

  • trunk/src/engine/animation.cc

    r539 r540  
    2727nv::resource< animator_data > nv::animator_manager::load_animator( nv::lua::table_guard& table, nv::shash64 id, nv::pose_data_set* poses /*= nullptr */ )
    2828{
    29         uint32 count = table.get_size();
     29        uint32 count = table.size();
    3030        if ( count == 0 )
    3131        {
    … …  
    7373                {
    7474                        nv::lua::table_guard states_table( layer_table, "states" );
    75                         uint32 state_count = states_table.get_size();
     75                        uint32 state_count = states_table.size();
    7676                        if ( state_count > 0 )
    7777                        {
    … …  
    119119                                        {
    120120                                                nv::lua::table_guard transitions_table( state_table, "transitions" );
    121                                                 uint32 transition_count = transitions_table.get_size();
     121                                                uint32 transition_count = transitions_table.size();
    122122                                                if ( transition_count > 0 )
    123123                                                {
    … …  
    167167        result.in = table["ease_in"].get_enum( result.in );
    168168        result.out = table["ease_out"].get_enum( nv::easing_type::NONE );
    169         if ( table.has_field( "ease_in_out" ) )
     169        if ( table[ "ease_in_out" ] )
    170170        {
    171171                result.in = result.out = table["ease_in_out"].get_enum( nv::easing_type::NONE );

  • trunk/src/engine/model_manager.cc

    r539 r540  
    3030                gm->ragdoll_id = table["ragdoll"].get_string32();
    3131       
    32         if ( table.has_field( "animator" ) )
     32        if ( table["animator"] )
    3333        {
    3434                gm->animator = m_rm->get< animator_data >( table["animator"].get_string() );
    … …  
    4040        }
    4141
    42         if ( table.has_field( "phx_mesh" ) )
     42        if ( table[ "phx_mesh" ] )
    4343        {
    4444                nv::string128 cpath( table["phx_mesh"].get_string128() );
    … …  
    7777                node->tag = table["tag"].get_string32();
    7878
    79         if ( table.has_field( "path" ) )
     79        if ( table[ "path" ] )
    8080        {
    8181                nv::string128 cpath( table["path"].get_string128() );
    … …  
    8585        }
    8686
    87         if ( table.has_field( "phx_hextents" ) )
     87        if ( table[ "phx_hextents"] )
    8888                node->phx_hextents = table["phx_hextents"].as<vec3>();
    89         if ( table.has_field( "phx_offset" ) )
     89        if ( table[ "phx_offset"] )
    9090                node->phx_offset = table["phx_offset"].as<vec3>();
    91         if ( table.has_field( "phx_mass" ) )
     91        if ( table[ "phx_mass"] )
    9292                node->phx_mass = table["phx_mass"].as<float>( 0.0f );
    93         if ( table.has_field( "phx_mass" ) )
     93        if ( table["phx_mass"] )
    9494                node->phx_shape = nv::phx_shape( table["phx_shape"].as<int>( 0 ) );
    9595
    96         if ( table.has_field( "local_position" ) )
     96        if ( table["local_position"] )
    9797                node->local.set_position( table["local_position"].as<vec3>() );
    98         if ( table.has_field( "local_orientation" ) )
     98        if ( table["local_orientation"] )
    9999                node->local.set_orientation( vec4_to_quat( table["local_orientation"].as<vec4>( vec4( 0.0f, 0.0f, 0.0f, 1.0f ) ) ) );
    100100
    101         if ( table.has_field( "position" ) )
     101        if ( table["position"] )
    102102        {
    103103                node->position.min = table["position"].as<vec3>();
    104104                node->position.max = node->position.min;
    105105        }
    106         if ( table.has_field( "rotation" ) )
     106        if ( table["rotation"] )
    107107        {
    108108                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["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() );
     111        if ( table["position_min"] )  node->position.min  = table["position_min"].as<vec3>();
     112        if ( table["position_max"] )  node->position.max  = table["position_max"].as<vec3>();
     113        if ( table["position_dist"] ) node->position.dist = random_dist( table["position_dist"].get_uint32() );
     114        if ( table["rotation_min"] )  node->rotation.min  = table["rotation_min"].as<vec3>();
     115        if ( table["rotation_max"] )  node->rotation.max  = table["rotation_max"].as<vec3>();
     116        if ( table["rotation_dist"] ) node->rotation.dist = random_dist( table["rotation_dist"].get_uint32() );
    117117
    118         if ( table.has_field( "attach" ) )
     118        if ( table["attach"] )
    119119        {
    120120                if ( table["attach"].is_number() )
    … …  
    140140        node->material  = cmaterial;
    141141
    142         for ( uint32 i = 1; i <= table.get_size(); ++i )
     142        for ( uint32 i = 1; i <= table.size(); ++i )
    143143        {
    144144                lua::table_guard child_table( table, i );

  • trunk/src/engine/particle_manager.cc

    r539 r540  
    6868
    6969        vec2 def_size        = table.get<vec2>("size", vec2(0.1,0.1) );
    70         uint32 elements = table.get_size();
     70        uint32 elements = table.size();
    7171        for ( uint32 i = 0; i < elements; ++i )
    7272        {

  • trunk/src/engine/program_manager.cc

    r539 r540  
    6868        {
    6969                lua::table_guard inctable( table, "files" );
    70                 uint32 count = inctable.get_size();
     70                uint32 count = inctable.size();
    7171                for ( uint32 i = 1; i <= count; ++i )
    7272                {

  • trunk/src/engine/ragdoll_manager.cc

    r539 r540  
    7575                float radius = table["radius"].get_f32();
    7676                float length = 0.0f;
    77                 if ( table.has_field( "target" ) )
     77                if ( table[ "target" ] )
    7878                {
    7979                        const auto& of = bind_data->get_bone_transforms().m_offsets;
    … …  
    9797                        part.limits     = table["limits"].as< vec3 >();
    9898                }
    99                 uint32 child_count = table.get_size();
     99                uint32 child_count = table.size();
    100100                bool   result = true;
    101101                if ( child_count > 0 )

  • trunk/src/lua/lua_proxy.cc

    r539 r540  
    99#include "nv/lua/lua_raw.hh"
    1010#include "nv/lua/lua_state.hh"
     11#include "nv/lua/lua_types.hh"
    1112
    1213using namespace nv;
    … …  
    5859}
    5960
     61bool nv::lua::stack_proxy::is_valid() const
     62{
     63        return !( lua_isnil( *m_state, m_index ) );
     64}
     65
     66bool nv::lua::stack_proxy::read( const type_entry* entry, void* object ) const
     67{
     68        NV_ASSERT_ALWAYS( m_state->get_type_data()->get_type_database() == entry->type_db, "Type database mismatch between Lua and entry!" );
     69        if ( lua_type( *m_state, m_index ) != LUA_TTABLE ) return false;
     70        return nv::lua::read_rtti_type( m_state, entry, object, m_index );
     71}
     72
    6073bool nv::lua::stack_proxy::is_table() const
    6174{

  • trunk/src/lua/lua_state.cc

    r539 r540  
    153153                // TODO : error handling
    154154        }
     155        m_index = -1;
    155156}
    156157
    … …  
    165166                // TODO : error handling
    166167        }
     168        m_index = -1;
    167169}
    168170
    169171lua::table_guard::~table_guard()
    170172{
    171         lua_settop( m_state, m_level );
    172 }
    173 
    174 nv::uint32 lua::table_guard::get_size()
    175 {
    176         return nlua_rawlen( m_state, -1 );
    177 }
    178 
    179 bool lua::table_guard::has_field( string_view element )
    180 {
    181         lua_getfield( m_state, -1, element.data() );
    182         bool result = !( lua_isnil( m_state, -1 ) );
    183         lua_pop( m_state, 1 );
    184         return result;
     173        if ( m_index == -1 )
     174                lua_settop( m_state, m_level );
     175}
     176
     177nv::uint32 lua::table_guard::size()
     178{
     179        return nlua_rawlen( m_state, m_index );
     180}
     181
     182nv::lua::table_guard::table_guard( stack_proxy& proxy )
     183        : state_wrapper( *proxy.m_state, proxy.m_state->m_lua_types, false ), m_parent( proxy.m_state ), m_level( 0 )
     184{
     185        m_level = lua_gettop( m_state );
     186        m_index = proxy.m_index;
    185187}
    186188
    187189const nv::lua::temporary_proxy nv::lua::table_guard::operator[]( const string_view& key ) const
    188190{
    189         lua_getfield( m_state, -1, key.data() );
     191        lua_getfield( m_state, m_index, key.data() );
    190192        return temporary_proxy( m_parent );
    191193}
    … …  
    193195const nv::lua::temporary_proxy nv::lua::table_guard::operator[]( sint32 key ) const
    194196{
    195         lua_rawgeti( m_state, -1, key );
     197        lua_rawgeti( m_state, m_index, key );
    196198        return temporary_proxy( m_parent );
    197 }
    198 
    199 bool nv::lua::table_guard::read( const string_view& element, const type_entry* entry, void* object )
    200 {
    201         NV_ASSERT_ALWAYS( m_lua_types->get_type_database() == entry->type_db, "Type database mismatch between Lua and entry!" );
    202         lua_getfield( m_state, -1, element.data() );
    203         if ( lua_type( m_state, -1 ) != LUA_TTABLE )
    204         {
    205                 lua_pop( m_state, 1 );
    206                 return false;
    207         }
    208         if ( !nv::lua::read_rtti_type( m_parent, entry, object, -1 ) )
    209         {
    210                 lua_pop( m_state, 1 );
    211                 return false;
    212         }
    213         lua_pop( m_state, 1 );
    214         return true;
    215199}
    216200
    … …  
    590574}
    591575
     576template < typename T >
     577bool nlua_rtti_string_read( nv::lua::state* state, const type_entry*, void* object, int index )
     578{
     579        T* value = reinterpret_cast<T*>( object );
     580        if ( lua_type( state->get_raw(), index ) == LUA_TSTRING )
     581        {
     582                *value = T( nlua_tostringview( state->get_raw(), index ) );
     583                return true;
     584        }
     585        return false;
     586}
     587
    592588
    593589void nv::lua::type_data::insert( thash64 tid, lua_rtti_push_function p, lua_rtti_read_function r )
    … …  
    608604        insert<nv::f32>   ( nlua_rtti_floating_push<nv::f32>,    nlua_rtti_floating_read<nv::f32> );
    609605        insert<nv::f64>   ( nlua_rtti_floating_push<nv::f64>,    nlua_rtti_floating_read<nv::f64> );
    610 //      insert<nv::sint64>( nlua_rtti_floating_push<nv::sint64>, nlua_rtti_floating_read<nv::sint64> );
     606        insert<nv::shash32>  ( nullptr, nlua_rtti_string_read<nv::shash32> );
     607        insert<nv::shash64>  ( nullptr, nlua_rtti_string_read<nv::shash64> );
     608        insert<nv::string32> ( nullptr, nlua_rtti_string_read<nv::string32> );
     609        insert<nv::string64> ( nullptr, nlua_rtti_string_read<nv::string64> );
     610        insert<nv::string128>( nullptr, nlua_rtti_string_read<nv::string128> );
     611        //      insert<nv::sint64>( nlua_rtti_floating_push<nv::sint64>, nlua_rtti_floating_read<nv::sint64> );
    611612//      insert<nv::uint64>( nlua_rtti_floating_push<nv::uint64>, nlua_rtti_floating_read<nv::uint64> );
    612613}
Note: See TracChangeset for help on using the changeset viewer.