Changeset 539 for trunk/src/engine/animation.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/animation.cc (modified) (10 diffs)

trunk/src/engine/animation.cc

@@ -34 +34 @@
 
         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 +59 @@
                 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 +70 @@
                 }
 
-                if ( layer_table.is_table( "states" ) )
+                if ( layer_table["states"].is_table() )
                 {
                         nv::lua::table_guard states_table( layer_table, "states" );
@@ -84 +84 @@
                                         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 +98 @@
                                                 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 +116 @@
                                         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 +125 @@
                                                         {
                                                                 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 +134 @@
                                                                 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 +149 @@
 
 
-                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 +164 @@
 {
         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 )