Index: trunk/src/engine/animation.cc =================================================================== --- trunk/src/engine/animation.cc (revision 535) +++ 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 535) +++ 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 535) +++ 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 535) +++ 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 535) +++ 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 535) +++ 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 535) +++ 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;