Changeset 539 for trunk/src/engine/model_manager.cc

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

File:

• trunk/src/engine/model_manager.cc (modified) (6 diffs)

trunk/src/engine/model_manager.cc

@@ -18 +18 @@
 
         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<vec3>( "root_position", vec3() ) );
-        gm->root.set_orientation( vec4_to_quat( table.get<vec4>( "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<vec3>() );
+        gm->root.set_orientation( vec4_to_quat( table["root_orientation"].as<vec4>( 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 +42 @@
         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 +66 @@
         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 +74 @@
         }
 
-        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 +86 @@
 
         if ( table.has_field( "phx_hextents" ) )
-                node->phx_hextents = table.get<vec3>( "phx_hextents", vec3() );
+                node->phx_hextents = table["phx_hextents"].as<vec3>();
         if ( table.has_field( "phx_offset" ) )
-                node->phx_offset = table.get<vec3>( "phx_offset", vec3() );
+                node->phx_offset = table["phx_offset"].as<vec3>();
         if ( table.has_field( "phx_mass" ) )
-                node->phx_mass = table.get<float>( "phx_mass", 0.0f);
+                node->phx_mass = table["phx_mass"].as<float>( 0.0f );
         if ( table.has_field( "phx_mass" ) )
-                node->phx_shape = nv::phx_shape( table.get<int>( "phx_shape", 0 ) );
+                node->phx_shape = nv::phx_shape( table["phx_shape"].as<int>( 0 ) );
 
         if ( table.has_field( "local_position" ) )
-                node->local.set_position( table.get<vec3>( "local_position", vec3() ) );
+                node->local.set_position( table["local_position"].as<vec3>() );
         if ( table.has_field( "local_orientation" ) )
-                node->local.set_orientation( vec4_to_quat( table.get<vec4>( "local_orientation", vec4( 0.0f, 0.0f, 0.0f, 1.0f ) ) ) );
+                node->local.set_orientation( vec4_to_quat( table["local_orientation"].as<vec4>( vec4( 0.0f, 0.0f, 0.0f, 1.0f ) ) ) );
 
         if ( table.has_field( "position" ) )
         {
-                node->position.min = table.get<vec3>( "position", vec3() );
+                node->position.min = table["position"].as<vec3>();
                 node->position.max = node->position.min;
         }
         if ( table.has_field( "rotation" ) )
         {
-                node->rotation.min = table.get<vec3>( "rotation", vec3() );
+                node->rotation.min = table["rotation"].as<vec3>();
                 node->rotation.max = node->rotation.min;
         }
-        if ( table.has_field( "position_min" ) )  node->position.min  = table.get<vec3>( "position_min", vec3() );
-        if ( table.has_field( "position_max" ) )  node->position.max  = table.get<vec3>( "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<vec3>( "rotation_min", vec3() );
-        if ( table.has_field( "rotation_max" ) )  node->rotation.max  = table.get<vec3>( "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<vec3>();
+        if ( table.has_field( "position_max" ) )  node->position.max  = table["position_max"].as<vec3>();
+        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<vec3>();
+        if ( table.has_field( "rotation_max" ) )  node->rotation.max  = table["rotation_max"].as<vec3>();
+        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 +132 @@
         }
         
-        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;