Index: /trunk/nv/lua/lua_proxy.hh =================================================================== --- /trunk/nv/lua/lua_proxy.hh (revision 538) +++ /trunk/nv/lua/lua_proxy.hh (revision 539) @@ -10,4 +10,5 @@ #include #include +#include namespace nv @@ -25,13 +26,86 @@ stack_proxy( stack_proxy&& ) = default; stack_proxy& operator=( stack_proxy&& ) = default; - string64 get_string64() const; - string64 to_string64(); + + uint32 get_uint32( uint32 def = 0 ) const; + sint32 get_sint32( sint32 def = 0 ) const; + char get_char( char def = ' ' ) const; + f64 get_f64( f64 def = 0.0 ) const; + f32 get_f32( f32 def = 0.0f ) const; + bool get_bool( bool def = false ) const; + + template< typename E > + E get_enum( E def = E() ) const + { + return static_cast( get_uint32( static_cast( def ) ) ); + } + + template< typename T > + T as( const T& def ) const + { + return static_cast( pass_traits< converted_type_t >::to( *m_state, m_index, def ) ); + } + + template< typename T > + T as() const + { + return static_cast( pass_traits< converted_type_t >::to( *m_state, m_index ) ); + } + + bool is_table() const; + bool is_number() const; + bool is_bool() const; + bool is_string() const; + + const_string get_string() const { return const_string( get_string_view() ); } + const_string as_string() { return const_string( as_string_view() ); } + string32 get_string32() const { return string32( get_string_view() ); } + string32 as_string32() { return string32( as_string_view() ); } + string64 get_string64() const { return string64( get_string_view() ); } + string64 as_string64() { return string64( as_string_view() ); } + string128 get_string128() const { return string128( get_string_view() ); } + string128 as_string128() { return string128( as_string_view() ); } + shash64 get_shash64() const { return is_string() ? shash64( get_string_view() ) : shash64(); } + shash64 as_shash64() { return is_string() ? shash64( as_string_view() ) : shash64(); } + + shash64 get_string( string_table* table ) const + { + string_view result( get_string_view() ); + return table ? table->insert( result ) : result; + } + + shash64 as_string( string_table* table ) + { + string_view result( as_string_view() ); + return table ? table->insert( result ) : result; + } + // TO FUCKING DO : non-copyable stringview // string_view get_string_view() const; // string_view to_string_view(); protected: + // Not public because not permanent + string_view get_string_view() const; + // Not public because not permanent + string_view as_string_view(); + state* m_state; sint32 m_index; }; + + class temporary_proxy : public stack_proxy + { + protected: + temporary_proxy( const temporary_proxy& ) = delete; + temporary_proxy& operator=( const temporary_proxy& ) = delete; + temporary_proxy( temporary_proxy&& ) = default; + temporary_proxy& operator=( temporary_proxy&& ) = default; + + temporary_proxy( state* state ); + public: + ~temporary_proxy(); + friend class table_guard; + }; + + class kv_proxy Index: /trunk/nv/lua/lua_state.hh =================================================================== --- /trunk/nv/lua/lua_state.hh (revision 538) +++ /trunk/nv/lua/lua_state.hh (revision 539) @@ -393,47 +393,47 @@ } + const temporary_proxy operator[]( const string_view& key ) const; + const temporary_proxy operator[]( sint32 key ) const; // TO FUCKING DO: -// const stack_proxy operator[]( const string_view& key ) const; -// const stack_proxy operator[]( sint32 key ) const; -// stack_proxy operator[]( const string_view& key ); -// stack_proxy operator[]( sint32 key ); +// temporary_proxy operator[]( const string_view& key ); +// temporary_proxy operator[]( sint32 key ); bool has_field( string_view element ); - shash64 get_string_hash_64( string_view element, uint64 defval = 0 ); - shash64 get_string( string_view element, string_table* table, uint64 defval = 0 ); - const_string get_string( string_view element, string_view defval = string_view() ); - string128 get_string128( string_view element, string_view defval = string_view() ); - string64 get_string64( string_view element, string_view defval = string_view() ); - string32 get_string32( string_view element, string_view defval = string_view() ); - - char get_char( string_view element, char defval = ' ' ); - int get_integer( string_view element, int defval = 0 ); - unsigned get_unsigned( string_view element, unsigned defval = 0 ); - double get_double( string_view element, double defval = 0.0 ); - float get_float( string_view element, float defval = 0.0 ); - bool get_boolean( string_view element, bool defval = false ); - - shash64 get_string_hash_64( int i, uint64 defval = 0 ); - shash64 get_string( int i, string_table* table, uint64 defval = 0 ); - const_string get_string( int i, string_view defval = string_view() ); - string128 get_string128( int i, string_view defval = string_view() ); - - char get_char( int i, char defval = ' ' ); - int get_integer( int i, int defval = 0 ); - unsigned get_unsigned( int i, unsigned defval = 0 ); - double get_double( int i, double defval = 0.0 ); - float get_float( int i, float defval = 0.0 ); - bool get_boolean( int i, bool defval = false ); - - bool is_table( string_view element ); - bool is_number( string_view element ); - bool is_boolean( string_view element ); - bool is_string( string_view element ); - bool is_table( int i ); - bool is_number( int i ); - bool is_boolean( int i ); - bool is_string( int i ); +// shash64 get_string_hash_64( string_view element, uint64 defval = 0 ); +// shash64 get_string( string_view element, string_table* table, uint64 defval = 0 ); +// const_string get_string( string_view element, string_view defval = string_view() ); +// string128 get_string128( string_view element, string_view defval = string_view() ); +// string64 get_string64( string_view element, string_view defval = string_view() ); +// string32 get_string32( string_view element, string_view defval = string_view() ); +// +// char get_char( string_view element, char defval = ' ' ); +// int get_integer( string_view element, int defval = 0 ); +// unsigned get_unsigned( string_view element, unsigned defval = 0 ); +// double get_double( string_view element, double defval = 0.0 ); +// float get_float( string_view element, float defval = 0.0 ); +// bool get_boolean( string_view element, bool defval = false ); +// +// shash64 get_string_hash_64( int i, uint64 defval = 0 ); +// shash64 get_string( int i, string_table* table, uint64 defval = 0 ); +// const_string get_string( int i, string_view defval = string_view() ); +// string128 get_string128( int i, string_view defval = string_view() ); +// +// char get_char( int i, char defval = ' ' ); +// int get_integer( int i, int defval = 0 ); +// unsigned get_unsigned( int i, unsigned defval = 0 ); +// double get_double( int i, double defval = 0.0 ); +// float get_float( int i, float defval = 0.0 ); +// bool get_boolean( int i, bool defval = false ); +// +// bool is_table( string_view element ); +// bool is_number( string_view element ); +// bool is_boolean( string_view element ); +// bool is_string( string_view element ); +// bool is_table( int i ); +// bool is_number( int i ); +// bool is_boolean( int i ); +// bool is_string( int i ); template < typename T > Index: /trunk/src/engine/animation.cc =================================================================== --- /trunk/src/engine/animation.cc (revision 538) +++ /trunk/src/engine/animation.cc (revision 539) @@ -34,9 +34,9 @@ nv::animator_data* animator = new nv::animator_data; - animator->id = table.get_string64( "id" ); + animator->id = table["id"].get_string64(); animator->poses = poses; if ( poses == nullptr ) { - string128 poses_path = table.get_string128( "poses" ); + string128 poses_path = table["poses"].get_string128(); if ( !poses_path.empty() ) { @@ -59,6 +59,6 @@ nv::lua::table_guard layer_table( table, layer_idx ); nv::animator_layer_data& layer = animator->layers[layer_idx - 1]; - layer.name = layer_table.get_string( "name", m_strings, 0 ); - layer.mask = layer_table.get_integer( "mask", -1 ); + layer.name = layer_table["name"].get_string( m_strings ); + layer.mask = layer_table["mask"].get_sint32( -1 ); layer.def_state = -1; @@ -70,5 +70,5 @@ } - if ( layer_table.is_table( "states" ) ) + if ( layer_table["states"].is_table() ) { nv::lua::table_guard states_table( layer_table, "states" ); @@ -84,12 +84,12 @@ nv::animator_state_data& state = layer.states[state_idx - 1]; - state.name = state_table.get_string( "name", m_strings, 0 ); + state.name = state_table["name"].get_string( m_strings ); NV_ASSERT( state.name, "Animation state without name is invalid!" ); state_names[state.name] = state_idx - 1; - state.loop = state_table.get_boolean( "loop", true ); - state.duration = state_table.get_float( "duration", 0.0f ); - state.interp = nv::interpolation( state_table.get_unsigned( "interpolation", uint32( nv::interpolation::SPHERICAL ) ) ); + state.loop = state_table["loop"].get_bool( true ); + state.duration = state_table["duration"].get_f32(); + state.interp = state_table["interpolation"].get_enum( nv::interpolation::SPHERICAL ); - shash64 pose_set = state_table.get_string_hash_64( "pose_set" ); + shash64 pose_set = state_table["pose_set"].get_shash64(); if ( pose_set ) { @@ -98,6 +98,6 @@ uint32 pid = it->second.start; uint32 pose_count = it->second.count; - uint32 start = state_table.get_unsigned( "start", 0 ); - uint32 stop = state_table.get_unsigned( "stop", pose_count - 1 ); + uint32 start = state_table["start"].get_uint32(); + uint32 stop = state_table["stop"].get_uint32( pose_count - 1 ); for ( nv::uint32 i = pid + start; i < pid + stop + 1; ++i ) { @@ -116,5 +116,5 @@ nv::lua::table_guard state_table( states_table, state_idx ); - if ( state_table.is_table( "transitions" ) ) + if ( state_table["transitions"].is_table() ) { nv::lua::table_guard transitions_table( state_table, "transitions" ); @@ -125,6 +125,6 @@ { nv::lua::table_guard transition_table( transitions_table, transition_idx ); - shash64 name = transition_table.get_string( "name", m_strings, 0 ); - shash64 target_name = transition_table.get_string_hash_64( "target", 0 ); + shash64 name = transition_table["name"].get_string( m_strings ); + shash64 target_name = transition_table["target"].get_shash64(); NV_ASSERT( name, "Transition state without name is invalid!" ); NV_ASSERT( target_name, "Transition state without name is invalid!" ); @@ -134,6 +134,6 @@ nv::animator_transition_data tr_data; tr_data.target = it->second; - tr_data.duration = transition_table.get_float( "duration", 0.0f ); - tr_data.interp = nv::interpolation( transition_table.get_unsigned( "interpolation", uint32( nv::interpolation::SPHERICAL ) ) ); + tr_data.duration = transition_table["duration"].get_f32(); + tr_data.interp = transition_table["interpolation"].get_enum( nv::interpolation::SPHERICAL ); tr_data.easing = read_easing( transition_table ); @@ -149,5 +149,5 @@ - shash64 def_state_name = layer_table.get_string_hash_64( "default", 0 ); + shash64 def_state_name = layer_table["default"].get_shash64(); if ( def_state_name ) { @@ -164,10 +164,10 @@ { nv::easing result; - result.in = nv::easing_type( table.get_integer( "easing", int( nv::easing_type::NONE ) ) ); - result.in = nv::easing_type( table.get_integer( "ease_in", int( result.in ) ) ); - result.out = nv::easing_type( table.get_integer( "ease_out", int( nv::easing_type::NONE ) ) ); + result.in = table["easing"].get_enum( nv::easing_type::NONE ); + result.in = table["ease_in"].get_enum( result.in ); + result.out = table["ease_out"].get_enum( nv::easing_type::NONE ); if ( table.has_field( "ease_in_out" ) ) { - result.in = result.out = nv::easing_type( table.get_integer( "ease_in_out", int( nv::easing_type::NONE ) ) ); + result.in = result.out = table["ease_in_out"].get_enum( nv::easing_type::NONE ); } if ( result.in == nv::easing_type::NONE && result.out == nv::easing_type::NONE ) Index: /trunk/src/engine/material_manager.cc =================================================================== --- /trunk/src/engine/material_manager.cc (revision 538) +++ /trunk/src/engine/material_manager.cc (revision 539) @@ -61,8 +61,8 @@ material* m = new material; - if ( table.is_string( "path" ) ) + if ( table["path"].is_string() ) { - m->id = table.get_string128( "id" ); - string128 path = table.get_string128( "path" ); + m->id = table["id"].get_string128(); + string128 path = table["path"].get_string128(); for ( uint32 i = 0; i < 5; ++i ) m->paths[i] = path; @@ -85,9 +85,9 @@ else { - m->paths[ TEX_DIFFUSE ] = table.get_string128( "diffuse" ); - m->paths[ TEX_NORMAL ] = table.get_string128( "normal" ); - m->paths[ TEX_METALLIC] = table.get_string128( "metallic" ); - m->paths[ TEX_ROUGHNESS] = table.get_string128( "roughness" ); - m->paths[ TEX_EMISSIVE ] = table.get_string128( "emissive" ); + m->paths[ TEX_DIFFUSE ] = table[ "diffuse" ].get_string128(); + m->paths[ TEX_NORMAL ] = table[ "normal" ].get_string128(); + m->paths[ TEX_METALLIC ] = table[ "metallic" ].get_string128(); + m->paths[ TEX_ROUGHNESS] = table[ "roughness" ].get_string128(); + m->paths[ TEX_EMISSIVE ] = table[ "emissive" ].get_string128(); } add( id, m ); Index: /trunk/src/engine/model_manager.cc =================================================================== --- /trunk/src/engine/model_manager.cc (revision 538) +++ /trunk/src/engine/model_manager.cc (revision 539) @@ -18,19 +18,19 @@ model* gm = new model; - gm->flags = table.get< flags<32> >( "flags" ); - gm->attach = table.get_string_hash_64( "attach" ); - gm->root.set_position( table.get( "root_position", vec3() ) ); - gm->root.set_orientation( vec4_to_quat( table.get( "root_orientation", vec4(0.0f,0.0f,0.0f,1.0f) ) ) ); + gm->flags = table["flags"].as< flags<32> >(); + gm->attach = table["attach"].get_shash64(); + gm->root.set_position( table["root_position"].as() ); + gm->root.set_orientation( vec4_to_quat( table["root_orientation"].as( vec4(0.0f,0.0f,0.0f,1.0f) ) ) ); resource< mesh_data > def_data; - if ( table.is_string( "path" ) ) - def_data = m_rm->get< mesh_data >( table.get_string128( "path" ) ); + if ( table["path"].is_string() ) + def_data = m_rm->get< mesh_data >( table["path"].get_string128() ); - if ( table.is_string( "ragdoll" ) ) - gm->ragdoll_id = table.get_string32( "ragdoll" ); + if ( table["ragdoll"].is_string() ) + gm->ragdoll_id = table["ragdoll"].get_string32(); if ( table.has_field( "animator" ) ) { - gm->animator = m_rm->get< animator_data >( table.get_string( "animator" ) ); + gm->animator = m_rm->get< animator_data >( table["animator"].get_string() ); pose_data_set* poses = gm->animator.lock()->poses; if ( !def_data || !def_data.lock()->node_data ) @@ -42,9 +42,9 @@ if ( table.has_field( "phx_mesh" ) ) { - nv::string128 cpath( table.get_string128( "phx_mesh" ) ); + nv::string128 cpath( table["phx_mesh"].get_string128() ); gm->phx_mesh = m_mesh_datas->get_path( cpath, def_data ); } - if ( table.is_table( "model" ) ) + if ( table["model"].is_table() ) { lua::table_guard model_table( table, "model" ); @@ -66,7 +66,7 @@ sint16 attach_id = -1; - if ( table.is_string( "material" ) ) + if ( table["material"].is_string() ) { - nv::string128 mat_id( table.get_string128( "material" ) ); + nv::string128 mat_id( table["material"].get_string128() ); cmaterial = m_rm->get< material >( mat_id ); if ( !cmaterial ) @@ -74,10 +74,10 @@ } - if ( table.is_string( "tag" ) ) - node->tag = table.get_string32( "tag" ); + if ( table["tag"].is_string() ) + node->tag = table["tag"].get_string32(); if ( table.has_field( "path" ) ) { - nv::string128 cpath( table.get_string128( "path" ) ); + nv::string128 cpath( table["path"].get_string128() ); nv::data_node_info info; cmesh = m_mesh_datas->get_path( cpath, def_data, &info ); @@ -86,44 +86,44 @@ if ( table.has_field( "phx_hextents" ) ) - node->phx_hextents = table.get( "phx_hextents", vec3() ); + node->phx_hextents = table["phx_hextents"].as(); if ( table.has_field( "phx_offset" ) ) - node->phx_offset = table.get( "phx_offset", vec3() ); + node->phx_offset = table["phx_offset"].as(); if ( table.has_field( "phx_mass" ) ) - node->phx_mass = table.get( "phx_mass", 0.0f); + node->phx_mass = table["phx_mass"].as( 0.0f ); if ( table.has_field( "phx_mass" ) ) - node->phx_shape = nv::phx_shape( table.get( "phx_shape", 0 ) ); + node->phx_shape = nv::phx_shape( table["phx_shape"].as( 0 ) ); if ( table.has_field( "local_position" ) ) - node->local.set_position( table.get( "local_position", vec3() ) ); + node->local.set_position( table["local_position"].as() ); if ( table.has_field( "local_orientation" ) ) - node->local.set_orientation( vec4_to_quat( table.get( "local_orientation", vec4( 0.0f, 0.0f, 0.0f, 1.0f ) ) ) ); + node->local.set_orientation( vec4_to_quat( table["local_orientation"].as( vec4( 0.0f, 0.0f, 0.0f, 1.0f ) ) ) ); if ( table.has_field( "position" ) ) { - node->position.min = table.get( "position", vec3() ); + node->position.min = table["position"].as(); node->position.max = node->position.min; } if ( table.has_field( "rotation" ) ) { - node->rotation.min = table.get( "rotation", vec3() ); + node->rotation.min = table["rotation"].as(); node->rotation.max = node->rotation.min; } - if ( table.has_field( "position_min" ) ) node->position.min = table.get( "position_min", vec3() ); - if ( table.has_field( "position_max" ) ) node->position.max = table.get( "position_max", vec3() ); - if ( table.has_field( "position_dist" ) ) node->position.dist = random_dist( table.get_unsigned( "position_dist", 0 ) ); - if ( table.has_field( "rotation_min" ) ) node->rotation.min = table.get( "rotation_min", vec3() ); - if ( table.has_field( "rotation_max" ) ) node->rotation.max = table.get( "rotation_max", vec3() ); - if ( table.has_field( "rotation_dist" ) ) node->rotation.dist = random_dist( table.get_unsigned( "rotation_dist", 0 ) ); + if ( table.has_field( "position_min" ) ) node->position.min = table["position_min"].as(); + if ( table.has_field( "position_max" ) ) node->position.max = table["position_max"].as(); + if ( table.has_field( "position_dist" ) ) node->position.dist = random_dist( table["position_dist"].get_uint32() ); + if ( table.has_field( "rotation_min" ) ) node->rotation.min = table["rotation_min"].as(); + if ( table.has_field( "rotation_max" ) ) node->rotation.max = table["rotation_max"].as(); + if ( table.has_field( "rotation_dist" ) ) node->rotation.dist = random_dist( table["rotation_dist"].get_uint32() ); if ( table.has_field( "attach" ) ) { - if ( table.is_number( "attach" ) ) + if ( table["attach"].is_number() ) { - attach_id = sint16( table.get_integer( "attach", -1 ) ); + attach_id = sint16( table["attach"].get_sint32( -1 ) ); // parent_id = 0; } else if ( auto m = def_data.lock() ) { - auto it = m->node_names.find( table.get_string_hash_64( "attach" ) ); + auto it = m->node_names.find( table["attach"].get_shash64() ); if ( it != m->node_names.end() ) attach_id = sint16( it->second + 1 ); @@ -132,8 +132,8 @@ } - node->nflags = table.get< flags<16,uint16> >( "flags" ); - node->choice = model_node_choice( table.get_unsigned( "choice", false ) ); - node->chance = table.get_float( "chance", 1.0f ); - node->weight = static_cast< uint16 >( table.get_unsigned( "weight", 1 ) ); + node->nflags = table["flags"].as< flags<16,uint16> >(); + node->choice = model_node_choice( table["choice"].get_uint32( 0 ) ); + node->chance = table["chance"].get_f32( 1.0f ); + node->weight = static_cast< uint16 >( table["weight"].get_uint32( 1 ) ); node->mesh = cmesh; node->attach_id = attach_id; Index: /trunk/src/engine/particle_manager.cc =================================================================== --- /trunk/src/engine/particle_manager.cc (revision 538) +++ /trunk/src/engine/particle_manager.cc (revision 539) @@ -61,9 +61,9 @@ data->emitter_count = 0; data->affector_count = 0; - data->orientation = particle_orientation( table.get_unsigned("orientation", 0) ); - data->origin = particle_origin( table.get_unsigned( "origin",0 ) ); + data->orientation = particle_orientation( table["orientation"].get_uint32() ); + data->origin = particle_origin( table["origin"].get_uint32() ); - data->common_up = math::normalize( table.get("common_up", vec3(1,0,0) ) ); - data->common_dir = math::normalize( table.get("common_dir", vec3(0,1,0) ) ); + data->common_up = math::normalize( table["common_up"].as( vec3(1,0,0) ) ); + data->common_dir = math::normalize( table["common_dir"].as( vec3(0,1,0) ) ); vec2 def_size = table.get("size", vec2(0.1,0.1) ); @@ -72,6 +72,6 @@ { lua::table_guard element( table, i+1 ); - const_string type = element.get_string( "type" ); - const_string sub_type = element.get_string( "sub_type" ); + const_string type = element["type"].get_string(); + const_string sub_type = element["sub_type"].get_string(); if ( type == "emitter" ) { @@ -86,41 +86,41 @@ } - edata.position = element.get("position", vec3() ); - edata.extents = element.get("extents", vec3(1,1,1) ); - edata.extents[0] = element.get("width", edata.extents[0] ); - edata.extents[1] = element.get("depth", edata.extents[1] ); - edata.extents[2] = element.get("height", edata.extents[2] ); - edata.extents[0] = element.get("radius", edata.extents[0] ); - edata.iextents = element.get("inner_extents", vec3() ); - edata.iextents[0] = element.get("inner_width", edata.iextents[0] ); - edata.iextents[1] = element.get("inner_depth", edata.iextents[1] ); - edata.iextents[2] = element.get("inner_height", edata.iextents[2] ); - edata.iextents[0] = element.get("inner_radius", edata.iextents[0] ); + edata.position = element["position"].as( vec3() ); + edata.extents = element["extents"].as( vec3(1,1,1) ); + edata.extents[0] = element["width"].as( edata.extents[0] ); + edata.extents[1] = element["depth"].as( edata.extents[1] ); + edata.extents[2] = element["height"].as( edata.extents[2] ); + edata.extents[0] = element["radius"].as( edata.extents[0] ); + edata.iextents = element["inner_extents"].as( vec3() ); + edata.iextents[0] = element["inner_width"].as( edata.iextents[0] ); + edata.iextents[1] = element["inner_depth"].as( edata.iextents[1] ); + edata.iextents[2] = element["inner_height"].as( edata.iextents[2] ); + edata.iextents[0] = element["inner_radius"].as( edata.iextents[0] ); edata.hextents = 0.5f * edata.extents; edata.ihextents = 0.5f * edata.iextents; - edata.precise = element.get("precise", false ); - edata.square = element.get("square", true ); - vec4 color = element.get("color", vec4(1,1,1,1) ); - edata.color_min = element.get("color_min", color ); - edata.color_max = element.get("color_max", color ); - vec2 size = element.get("size", def_size ); - edata.size_min = element.get("size_min", size ); - edata.size_max = element.get("size_max", size ); - edata.angle = element.get("angle", 0.0f ); - float velocity = element.get("velocity", 0.0f ); - edata.velocity_min = element.get("velocity_min", velocity ); - edata.velocity_max = element.get("velocity_max", velocity ); - float lifetime = element.get("lifetime", 1.0f ); - edata.lifetime_min = element.get("lifetime_min", lifetime ); - edata.lifetime_max = element.get("lifetime_max", lifetime ); - float duration = element.get("duration", 0.0f ); - edata.duration_min = element.get("duration_min", duration ); - edata.duration_max = element.get("duration_max", duration ); - float repeat = element.get("repeat_delay", 0.0f ); - edata.repeat_min = element.get("repeat_delay_min", repeat ); - edata.repeat_max = element.get("repeat_delay_max", repeat ); + edata.precise = element["precise"].as( false ); + edata.square = element["square"].as( true ); + vec4 color = element["color"].as( vec4(1,1,1,1) ); + edata.color_min = element["color_min"].as( color ); + edata.color_max = element["color_max"].as( color ); + vec2 size = element["size"].as( def_size ); + edata.size_min = element["size_min"].as( size ); + edata.size_max = element["size_max"].as( size ); + edata.angle = element["angle"].as( 0.0f ); + float velocity = element["velocity"].as( 0.0f ); + edata.velocity_min = element["velocity_min"].as( velocity ); + edata.velocity_max = element["velocity_max"].as( velocity ); + float lifetime = element["lifetime"].as( 1.0f ); + edata.lifetime_min = element["lifetime_min"].as( lifetime ); + edata.lifetime_max = element["lifetime_max"].as( lifetime ); + float duration = element["duration"].as( 0.0f ); + edata.duration_min = element["duration_min"].as( duration ); + edata.duration_max = element["duration_max"].as( duration ); + float repeat = element["repeat_delay"].as( 0.0f ); + edata.repeat_min = element["repeat_delay_min"].as( repeat ); + edata.repeat_max = element["repeat_delay_max"].as( repeat ); - edata.rate = element.get("rate", 1.0f ); - edata.dir = math::normalize( element.get("direction", vec3(0,1,0) ) ); + edata.rate = element["rate"].as( 1.0f ); + edata.dir = math::normalize( element["direction"].as( vec3(0,1,0) ) ); edata.odir = vec3( 0, 0, 1 ); Index: /trunk/src/engine/program_manager.cc =================================================================== --- /trunk/src/engine/program_manager.cc (revision 538) +++ /trunk/src/engine/program_manager.cc (revision 539) @@ -18,9 +18,9 @@ bool nv::program_manager::load_resource( lua::table_guard& table, shash64 id ) { - NV_LOG_DEBUG( table.get_string("id") ); + NV_LOG_DEBUG( table["id"].get_string() ); string_buffer vsource; string_buffer fsource; string_buffer header( m_shader_head ); - if ( table.is_table("common") ) + if ( table["common"].is_table() ) { lua::table_guard common( table, "common" ); @@ -61,9 +61,9 @@ c_file_system fs; string_buffer out( append ); - if ( table.is_string( "files" ) ) + if ( table["files"].is_string() ) { - out.append( file_to_string( table.get_string( "files" ) ) ); + out.append( file_to_string( table["files"].get_string() ) ); } - else if ( table.is_table( "files" ) ) + else if ( table["files"].is_table() ) { lua::table_guard inctable( table, "files" ); @@ -77,13 +77,13 @@ } - if ( table.is_string( "file" ) ) + if ( table["file"].is_string() ) { - const_string data = file_to_string( table.get_string( "file" ) ); + const_string data = file_to_string( table["file"].get_string() ); out.append( "#line 1\n" + data ); } - if ( table.is_string( "source" ) ) + if ( table["source"].is_string() ) { - out.append( table.get_string( "source" ) ); + out.append( table["source"].get_string() ); } return out; Index: /trunk/src/engine/ragdoll_manager.cc =================================================================== --- /trunk/src/engine/ragdoll_manager.cc (revision 538) +++ /trunk/src/engine/ragdoll_manager.cc (revision 539) @@ -26,5 +26,5 @@ NV_ASSERT_ALWAYS( m_world, "Physics world not setup in ragdoll_manager!" ); bool result = false; - nv::string64 model_id = table.get_string64( "model" ); + nv::string64 model_id = table["model"].get_string64(); nv::resource< model > mr = m_model->get( model_id ); if ( !mr ) return false; @@ -66,17 +66,17 @@ if ( auto bind_data = rbind.lock() ) { - data->id = table.get_string32( "id" ); + data->id = table["id"].get_string32(); int index = data->parts.size(); data->parts.emplace_back(); auto& part = data->parts.back(); - part.name = table.get_string_hash_64( "name" ); - part.bone_id = nv::uint32( bind_data->get_bone_list().resolve( table.get_string_hash_64( "bone" ) ) ); + part.name = table["name"].get_shash64(); + part.bone_id = nv::uint32( bind_data->get_bone_list().resolve( table["bone"].get_shash64() ) ); NV_ASSERT( part.bone_id < 256, "Bone ID not found!" ); - float radius = table.get_float( "radius" ); + float radius = table["radius"].get_f32(); float length = 0.0f; if ( table.has_field( "target" ) ) { const auto& of = bind_data->get_bone_transforms().m_offsets; - int target = bind_data->get_bone_list().resolve( table.get_string_hash_64( "target" ) ); + int target = bind_data->get_bone_list().resolve( table["target"].get_shash64() ); if ( target < 0 ) return false; length = math::distance( of[part.bone_id].get_position(), of[target].get_position() ); @@ -84,16 +84,16 @@ else { - length = table.get_float( "length" ); + length = table["length"].get_f32(); } NV_ASSERT( radius > 0.0f && length > 0.0f, "Bad parameters!" ); part.shape = m_world->create_capsule( radius, length ); part.parent_idx = pindex; - part.mass = table.get_float( "mass", 1.0f ); + part.mass = table["mass"].get_f32( 1.0f ); part.cone_twist = false; // Joints if ( pindex != -1 ) { - part.cone_twist = table.get_string_hash_64("joint") == shash64( "cone_twist"_ls ); - part.limits = table.get< vec3 >( "limits" ); + part.cone_twist = table["joint"].get_shash64() == shash64( "cone_twist"_ls ); + part.limits = table["limits"].as< vec3 >(); } uint32 child_count = table.get_size(); Index: /trunk/src/engine/resource_system.cc =================================================================== --- /trunk/src/engine/resource_system.cc (revision 538) +++ /trunk/src/engine/resource_system.cc (revision 539) @@ -27,9 +27,10 @@ if ( do_clear ) clear(); lua::table_guard table( m_lua, get_storage_name() ); - uint32 count = table.get_unsigned( "__counter" ); + uint32 count = table["__counter"].get_uint32(); for ( auto i : range( count ) ) { lua::table_guard sub_table( table, i + 1 ); - load_resource( sub_table, sub_table.get_string_hash_64( "id" ) ); + shash64 id = sub_table["id"].get_shash64(); + load_resource( sub_table, id ); } } @@ -39,9 +40,9 @@ m_id_hash.clear(); lua::table_guard table( m_lua, get_storage_name() ); - uint32 count = table.get_unsigned( "__counter" ); + uint32 count = table["__counter"].get_uint32(); for ( auto i : range( count ) ) { lua::table_guard sub_table( table, i + 1 ); - string64 id = sub_table.get_string64( "id" ); + string64 id = sub_table["id"].get_string64(); NV_ASSERT( m_id_hash.find( id ) == m_id_hash.end(), "HASH COLLISION" ); m_id_hash[id] = id; Index: /trunk/src/lua/lua_proxy.cc =================================================================== --- /trunk/src/lua/lua_proxy.cc (revision 538) +++ /trunk/src/lua/lua_proxy.cc (revision 539) @@ -13,5 +13,55 @@ using namespace nv::lua; -nv::string64 nv::lua::stack_proxy::get_string64() const +uint32 nv::lua::stack_proxy::get_uint32( uint32 def ) const +{ + return lua_type( *m_state, m_index ) == LUA_TNUMBER ? nlua_tounsigned( *m_state, m_index ) : def; +} + +sint32 nv::lua::stack_proxy::get_sint32( sint32 def ) const +{ + return lua_type( *m_state, m_index ) == LUA_TNUMBER ? static_cast( lua_tointeger( *m_state, m_index ) ) : def; +} + +char nv::lua::stack_proxy::get_char( char def /*= ' ' */ ) const +{ + return ( lua_type( *m_state, m_index ) == LUA_TSTRING && nlua_rawlen( *m_state, m_index ) > 0 ) ? lua_tostring( *m_state, m_index )[0] : def; +} + +nv::f64 nv::lua::stack_proxy::get_f64( f64 def /*= 0.0 */ ) const +{ + return lua_type( *m_state, m_index ) == LUA_TNUMBER ? lua_tonumber( *m_state, m_index ) : def; +} + +nv::f32 nv::lua::stack_proxy::get_f32( f32 def /*= 0.0f */ ) const +{ + return lua_type( *m_state, m_index ) == LUA_TNUMBER ? static_cast( lua_tonumber( *m_state, m_index ) ) : def; +} + +bool nv::lua::stack_proxy::get_bool( bool def /*= false */ ) const +{ + return lua_type( *m_state, m_index ) == LUA_TBOOLEAN ? lua_toboolean( *m_state, m_index ) != 0 : def; +} + +bool nv::lua::stack_proxy::is_number() const +{ + return lua_type( *m_state, m_index ) == LUA_TNUMBER; +} + +bool nv::lua::stack_proxy::is_bool() const +{ + return lua_type( *m_state, m_index ) == LUA_TBOOLEAN; +} + +bool nv::lua::stack_proxy::is_string() const +{ + return lua_type( *m_state, m_index ) == LUA_TSTRING; +} + +bool nv::lua::stack_proxy::is_table() const +{ + return lua_type( *m_state, m_index ) == LUA_TTABLE; +} + +nv::string_view nv::lua::stack_proxy::get_string_view() const { size_t l = 0; @@ -21,12 +71,23 @@ str = lua_tolstring( *m_state, m_index, &l ); } - return string64( str, static_cast( l ) ); + return string_view( str, static_cast( l ) ); } -nv::string64 nv::lua::stack_proxy::to_string64() +nv::string_view nv::lua::stack_proxy::as_string_view() { size_t l = 0; const char* str = nullptr; str = lua_tolstring( *m_state, m_index, &l ); - return string64( str, static_cast( l ) ); + return string_view( str, static_cast( l ) ); } + +nv::lua::temporary_proxy::temporary_proxy( state* state ) + : stack_proxy( state, -1 ) +{ + +} + +nv::lua::temporary_proxy::~temporary_proxy() +{ + lua_pop( *m_state, 1 ); +} Index: /trunk/src/lua/lua_state.cc =================================================================== --- /trunk/src/lua/lua_state.cc (revision 538) +++ /trunk/src/lua/lua_state.cc (revision 539) @@ -185,341 +185,14 @@ } -shash64 nv::lua::table_guard::get_string_hash_64( string_view element, uint64 defval /*= 0 */ ) -{ - lua_getfield( m_state, -1, element.data() ); - size_t l = 0; - const char* str = nullptr; - uint64 result = defval; - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - result = hash_string< uint64 >( str, static_cast< uint32 >( l ) ); - //NV_LOG_DEBUG( str ); - } - lua_pop( m_state, 1 ); - return shash64( result ); -} - -nv::shash64 nv::lua::table_guard::get_string( string_view element, string_table* table, uint64 defval /*= 0 */ ) -{ - lua_getfield( m_state, -1, element.data() ); - size_t l = 0; - const char* str = nullptr; - shash64 result = shash64( defval ); - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - string_view sv( str, static_cast< uint32 >( l ) ); - result = table ? table->insert( sv ) : shash64( sv ); - } - lua_pop( m_state, 1 ); - return result; -} - -shash64 nv::lua::table_guard::get_string_hash_64( int i, uint64 defval /*= 0 */ ) -{ - lua_rawgeti( m_state, -1, i ); - size_t l = 0; - const char* str = nullptr; - uint64 result = defval; - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - result = hash_string< uint64 >( str, static_cast< uint32 >( l ) ); - //NV_LOG_DEBUG( str ); - } - lua_pop( m_state, 1 ); - return shash64( result ); -} - -nv::string128 nv::lua::table_guard::get_string128( int i, string_view defval /*= string_view() */ ) -{ - lua_rawgeti( m_state, -1, i ); - size_t l = 0; - const char* str = nullptr; - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - } - else - { - l = defval.size(); - str = defval.data(); - } - string128 result( str, static_cast< uint32 >( l ) ); - lua_pop( m_state, 1 ); - return result; -} - -const_string nv::lua::table_guard::get_string( int i, string_view defval /*= string_view() */ ) -{ - lua_rawgeti( m_state, -1, i ); - size_t l = 0; - const char* str = nullptr; - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - } - else - { - l = defval.size(); - str = defval.data(); - } - const_string result( str, static_cast< uint32 >( l ) ); - lua_pop( m_state, 1 ); - return result; -} - -shash64 nv::lua::table_guard::get_string( int i, string_table* table, uint64 defval /*= 0 */ ) -{ - lua_rawgeti( m_state, -1, i ); - size_t l = 0; - const char* str = nullptr; - shash64 result = shash64( defval ); - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - string_view sv( str, static_cast< uint32 >( l ) ); - result = table ? table->insert( sv ) : shash64( sv ); - } - lua_pop( m_state, 1 ); - return result; -} - -const_string lua::table_guard::get_string( string_view element, string_view defval /*= string_view() */ ) -{ - lua_getfield( m_state, -1, element.data() ); - size_t l = 0; - const char* str = nullptr; - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - } - else - { - l = defval.size(); - str = defval.data(); - } - const_string result( str, static_cast< uint32 >( l ) ); - lua_pop( m_state, 1 ); - return result; -} - -string128 lua::table_guard::get_string128( string_view element, string_view defval ) -{ - lua_getfield( m_state, -1, element.data() ); - size_t l = 0; - const char* str = nullptr; - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - } - else - { - l = defval.size(); - str = defval.data(); - } - string128 result( str, static_cast< uint32 >( l ) ); - lua_pop( m_state, 1 ); - return result; -} - -nv::string64 nv::lua::table_guard::get_string64( string_view element, string_view defval /*= string_view() */ ) -{ - lua_getfield( m_state, -1, element.data() ); - size_t l = 0; - const char* str = nullptr; - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - } - else - { - l = defval.size(); - str = defval.data(); - } - string64 result( str, static_cast< uint32 >( l ) ); - lua_pop( m_state, 1 ); - return result; -} - - -nv::string32 nv::lua::table_guard::get_string32( string_view element, string_view defval /*= string_view() */ ) -{ - lua_getfield( m_state, -1, element.data() ); - size_t l = 0; - const char* str = nullptr; - if ( lua_type( m_state, -1 ) == LUA_TSTRING ) - { - str = lua_tolstring( m_state, -1, &l ); - } - else - { - l = defval.size(); - str = defval.data(); - } - string32 result( str, static_cast< uint32 >( l ) ); - lua_pop( m_state, 1 ); - return result; -} - -char lua::table_guard::get_char( string_view element, char defval /*= "" */ ) -{ - lua_getfield( m_state, -1, element.data() ); - char result = ( lua_type( m_state, -1 ) == LUA_TSTRING && nlua_rawlen( m_state, -1 ) > 0 ) ? lua_tostring( m_state, -1 )[0] : defval; - lua_pop( m_state, 1 ); - return result; -} - -int lua::table_guard::get_integer( string_view element, int defval /*= "" */ ) -{ - lua_getfield( m_state, -1, element.data() ); - lua_Integer result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tointeger( m_state, -1 ) : defval; - lua_pop( m_state, 1 ); - return static_cast< int >( result ); -} - -unsigned lua::table_guard::get_unsigned( string_view element, unsigned defval /*= "" */ ) -{ - lua_getfield( m_state, -1, element.data() ); - unsigned result = lua_type( m_state, -1 ) == LUA_TNUMBER ? nlua_tounsigned( m_state, -1 ) : defval; - lua_pop( m_state, 1 ); - return result; -} - -double lua::table_guard::get_double( string_view element, double defval /*= "" */ ) -{ - lua_getfield( m_state, -1, element.data() ); - double result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tonumber( m_state, -1 ) : defval; - lua_pop( m_state, 1 ); - return result; -} - -char nv::lua::table_guard::get_char( int i, char defval /*= ' ' */ ) -{ - lua_rawgeti( m_state, -1, i ); - char result = ( lua_type( m_state, -1 ) == LUA_TSTRING && nlua_rawlen( m_state, -1 ) > 0 ) ? lua_tostring( m_state, -1 )[0] : defval; - lua_pop( m_state, 1 ); - return result; -} - -int nv::lua::table_guard::get_integer( int i, int defval /*= 0 */ ) -{ - lua_rawgeti( m_state, -1, i ); - lua_Integer result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tointeger( m_state, -1 ) : defval; - lua_pop( m_state, 1 ); - return static_cast( result ); -} - -unsigned nv::lua::table_guard::get_unsigned( int i, unsigned defval /*= 0 */ ) -{ - lua_rawgeti( m_state, -1, i ); - unsigned result = lua_type( m_state, -1 ) == LUA_TNUMBER ? nlua_tounsigned( m_state, -1 ) : defval; - lua_pop( m_state, 1 ); - return result; -} - -double nv::lua::table_guard::get_double( int i, double defval /*= 0.0 */ ) -{ - lua_rawgeti( m_state, -1, i ); - double result = lua_type( m_state, -1 ) == LUA_TNUMBER ? lua_tonumber( m_state, -1 ) : defval; - lua_pop( m_state, 1 ); - return result; -} - -float nv::lua::table_guard::get_float( int i, float defval /*= 0.0 */ ) -{ - lua_rawgeti( m_state, -1, i ); - float result = lua_type( m_state, -1 ) == LUA_TNUMBER ? static_cast( lua_tonumber( m_state, -1 ) ) : defval; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::get_boolean( int i, bool defval /*= false */ ) -{ - lua_rawgeti( m_state, -1, i ); - bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN ? lua_toboolean( m_state, -1 ) != 0 : defval; - lua_pop( m_state, 1 ); - return result; -} - -float nv::lua::table_guard::get_float( string_view element, float defval /*= 0.0 */ ) -{ - lua_getfield( m_state, -1, element.data() ); - float result = lua_type( m_state, -1 ) == LUA_TNUMBER ? static_cast( lua_tonumber( m_state, -1 ) ) : defval; - lua_pop( m_state, 1 ); - return result; -} - -bool lua::table_guard::get_boolean( string_view element, bool defval /*= "" */ ) -{ - lua_getfield( m_state, -1, element.data() ); - bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN ? lua_toboolean( m_state, -1 ) != 0 : defval; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::is_table( string_view element ) -{ - lua_getfield( m_state, -1, element.data() ); - bool result = lua_type( m_state, -1 ) == LUA_TTABLE; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::is_table( int i ) -{ - lua_rawgeti( m_state, -1, i ); - bool result = lua_type( m_state, -1 ) == LUA_TTABLE; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::is_number( int i ) -{ - lua_rawgeti( m_state, -1, i ); - bool result = lua_type( m_state, -1 ) == LUA_TNUMBER; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::is_boolean( int i ) -{ - lua_rawgeti( m_state, -1, i ); - bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::is_string( int i ) -{ - lua_rawgeti( m_state, -1, i ); - bool result = lua_type( m_state, -1 ) == LUA_TSTRING; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::is_number( string_view element ) -{ - lua_getfield( m_state, -1, element.data() ); - bool result = lua_type( m_state, -1 ) == LUA_TNUMBER; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::is_boolean( string_view element ) -{ - lua_getfield( m_state, -1, element.data() ); - bool result = lua_type( m_state, -1 ) == LUA_TBOOLEAN; - lua_pop( m_state, 1 ); - return result; -} - -bool nv::lua::table_guard::is_string( string_view element ) -{ - lua_getfield( m_state, -1, element.data() ); - bool result = lua_type( m_state, -1 ) == LUA_TSTRING; - lua_pop( m_state, 1 ); - return result; +const nv::lua::temporary_proxy nv::lua::table_guard::operator[]( const string_view& key ) const +{ + lua_getfield( m_state, -1, key.data() ); + return temporary_proxy( m_parent ); +} + +const nv::lua::temporary_proxy nv::lua::table_guard::operator[]( sint32 key ) const +{ + lua_rawgeti( m_state, -1, key ); + return temporary_proxy( m_parent ); }