Changeset 503 for trunk/src/lua

Timestamp:

06/28/16 21:09:19 (9 years ago)

Author:

epyon

Message:

• nv::random - support for different rng sources
• nv::types - fixes and better support
• nv::mesh_creator - full range transform
• nv::context - buffer mask as separate type
• nv::lua - initializations from lua::state instead of lua_State
• nv::lua - initial support for rtti

Location:

trunk/src/lua

Files:

• lua_area.cc (modified) (1 diff)
• lua_aux.cc (modified) (1 diff)
• lua_map_area.cc (modified) (1 diff)
• lua_map_tile.cc (modified) (1 diff)
• lua_math.cc (modified) (3 diffs)
• lua_state.cc (modified) (6 diffs)
• lua_types.cc (added)

trunk/src/lua/lua_area.cc

@@ -459 +459 @@
 }
 
-void nv::lua::register_area( lua_State* L )
-{
-        int stack = lua_gettop( L );
-        nlua_requiref(L, "area", luaopen_area, 1);
-        lua_settop( L, stack );
-}
-
+void nv::lua::register_area( lua::state* state )
+{
+        int stack = lua_gettop( state->get_raw() );
+        nlua_requiref( state->get_raw(), "area", luaopen_area, 1);
+        lua_settop( state->get_raw(), stack );
+}
+

trunk/src/lua/lua_aux.cc

@@ -137 +137 @@
 };
 
-void nv::lua::register_aux( lua_State* L )
+void nv::lua::register_aux( lua::state* state )
 {
-        nlua_register( L, "table", nluaaux_table_aux_f );
-        nlua_register( L, "math", nluaaux_math_aux_f );
+        nlua_register( state->get_raw(), "table", nluaaux_table_aux_f );
+        nlua_register( state->get_raw(), "math", nluaaux_math_aux_f );
 }
 

trunk/src/lua/lua_map_area.cc

@@ -223 +223 @@
 }
 
-void nv::lua::register_map_area_interface( lua_State* L, int index )
-{
-        nlua_register( L, nlua_map_area_f, index );
-}
-
-void nv::lua::register_map_area( lua_State* L )
-{
-        luaopen_map_area(L);
-}
-
-void nv::lua::register_map_area_instance( lua_State* L, ref object_index, map_area* area )
-{
+void nv::lua::register_map_area_interface( lua::state* state, int index )
+{
+        nlua_register( state->get_raw(), nlua_map_area_f, index );
+}
+
+void nv::lua::register_map_area( lua::state* state )
+{
+        luaopen_map_area( state->get_raw() );
+}
+
+void nv::lua::register_map_area_instance( lua::state* state, ref object_index, map_area* area )
+{
+        lua_State* L = state->get_raw();
         lua_rawgeti( L, LUA_REGISTRYINDEX, object_index.get() );
         lua_pushliteral( L, "__map_area_ptr" );

trunk/src/lua/lua_map_tile.cc

@@ -366 +366 @@
 };
 
-void nv::lua::register_map_tile( lua_State * L )
+void nv::lua::register_map_tile( lua::state* state )
 {
         // TODO: check if __gc is used!
+        lua_State* L = state->get_raw();
         luaL_newmetatable( L, NLUA_MAP_TILE_METATABLE );
         lua_pushvalue( L, -1 );

trunk/src/lua/lua_math.cc

@@ -359 +359 @@
 }
 
-void nv::lua::register_math( lua_State* L )
+template < typename T >
+void nlua_rtti_vec_push( nv::lua::state* state, const nv::type_entry*, void* object )
+{
+        T* value = reinterpret_cast<T*>( object );
+        push_vec<T>( state->get_raw(), *value );
+}
+
+template < typename T >
+bool nlua_rtti_vec_read( nv::lua::state* state, const nv::type_entry*, void* object, int index )
+{
+        T* value = reinterpret_cast<T*>( object );
+        int type = lua_type( state->get_raw(), index );
+        if ( type == LUA_TUSERDATA )
+        {
+                T* from = to_pvec<T>( state->get_raw(), index );
+                if ( !from ) return false;
+                *value = *from;
+        }
+//      else if ( type == LUA_TTABLE )
+//      {
+// 
+//      }
+        else
+                return false;
+        int todo; int table_constructor;
+        return true;
+}
+
+void nv::lua::register_math( lua::state* state )
 { 
         for (size_t i = 0; i < 256; ++i ) nlua_swizzel_lookup[i] = 255;
@@ -379 +407 @@
         nlua_swizzel_lookup[uchar8( 'v' )] = 0;
         nlua_swizzel_lookup[uchar8( '3' )] = 3;
+
+        lua_State* L = state->get_raw();
         int stack = lua_gettop( L );
 
@@ -389 +419 @@
         nlua_requiref(L, "vec4", luaopen_vec<nv::vec4>, 1);
         lua_settop( L, stack );
-}
-
+
+        state->register_rtti_type< nv::ivec2 >( nlua_rtti_vec_push<nv::ivec2>, nlua_rtti_vec_read<nv::ivec2> );
+        state->register_rtti_type< nv::ivec3 >( nlua_rtti_vec_push<nv::ivec3>, nlua_rtti_vec_read<nv::ivec3> );
+        state->register_rtti_type< nv::ivec4 >( nlua_rtti_vec_push<nv::ivec4>, nlua_rtti_vec_read<nv::ivec4> );
+        state->register_rtti_type< nv::vec2 > ( nlua_rtti_vec_push<nv::vec2>,  nlua_rtti_vec_read<nv::vec2> );
+        state->register_rtti_type< nv::vec3 > ( nlua_rtti_vec_push<nv::vec3>,  nlua_rtti_vec_read<nv::vec3> );
+        state->register_rtti_type< nv::vec4 > ( nlua_rtti_vec_push<nv::vec4>,  nlua_rtti_vec_read<nv::vec4> );
+}
+

trunk/src/lua/lua_state.cc

@@ -9 +9 @@
 #include "nv/lua/lua_raw.hh"
 #include "nv/lua/lua_nova.hh"
+#include "nv/lua/lua_types.hh"
 #include "nv/core/logging.hh"
 #include "nv/stl/string.hh"
@@ -143 +144 @@
 
 lua::table_guard::table_guard( lua::state* lstate, const path& p, bool global )
-        : state_wrapper( lstate->get_raw(), false ), m_level(0)
+        : state_wrapper( lstate->get_raw(), lstate->m_lua_types, false ), m_parent( lstate ), m_level(0)
 {
         m_global = false;
@@ -155 +156 @@
 
 lua::table_guard::table_guard( const table_guard& parent, const path& p )
-        : state_wrapper( parent.m_state, false ), m_level(0)
+        : state_wrapper( parent.m_state, parent.m_lua_types, false ), m_parent( parent.m_parent ), m_level(0)
 {
         m_global = false;
@@ -350 +351 @@
 
 
+bool nv::lua::table_guard::read( const string_view& element, const type_entry* entry, void* object )
+{
+        NV_ASSERT_ALWAYS( m_lua_types->get_type_database() == entry->type_db, "Type database mismatch between Lua and entry!" );
+        lua_getfield( m_state, -1, element.data() );
+        if ( lua_type( m_state, -1 ) != LUA_TTABLE )
+        {
+                lua_pop( m_state, 1 );
+                return false;
+        }
+        if ( !nv::lua::read_rtti_type( m_parent, entry, object, -1 ) )
+        {
+                lua_pop( m_state, 1 );
+                return false;
+        }
+        lua_pop( m_state, 1 );
+        return true;
+}
+
 // state
 
-lua::state::state( lua_State* state ) : state_wrapper( state, false )
-{
-
-}
-
-lua::state::state( bool load_libs /*= false*/ ) : state_wrapper( nullptr, true )
+lua::state::state( lua_State* state, type_database* types )
+        : state_wrapper( state, new type_data( types ), false )
+{
+
+}
+
+lua::state::state( bool load_libs /*= false*/, type_database* types )
+        : state_wrapper( nullptr, new type_data( types ), true )
 {
         load_lua_library();
@@ -575 +596 @@
 }
 
+void nv::lua::state::register_rtti_type( thash64 tid, lua_rtti_push_function p, lua_rtti_read_function r )
+{
+        m_lua_types->insert( tid, p, r );
+}
+
 nv::lua::ref nv::lua::state::register_handle_component_impl( string_view id, bool empty )
 {
@@ -626 +652 @@
 }
 
+nv::lua::state::~state()
+{
+        delete m_lua_types;
+        m_lua_types = nullptr;
+}
+
+template < typename T >
+void nlua_rtti_signed_push( nv::lua::state* state, const type_entry*, void* object )
+{
+        T* value = reinterpret_cast<T*>( object );
+        lua_pushinteger( state->get_raw(), lua_Integer( *value ) );
+}
+
+template < typename T >
+void nlua_rtti_unsigned_push( nv::lua::state* state, const type_entry*, void* object )
+{
+        T* value = reinterpret_cast<T*>( object );
+        lua_pushinteger( state->get_raw(), lua_Unsigned( *value ) );
+}
+
+template < typename T >
+void nlua_rtti_floating_push( nv::lua::state* state, const type_entry*, void* object )
+{
+        T* value = reinterpret_cast< T* >( object );
+        lua_pushnumber( state->get_raw(), lua_Number( *value ) );
+}
+
+static void nlua_rtti_boolean_push( nv::lua::state* state, const type_entry*, void* object )
+{
+        bool* value = reinterpret_cast<bool*>( object );
+        lua_pushboolean( state->get_raw(), *value );
+}
+
+template < typename T >
+bool nlua_rtti_signed_read( nv::lua::state* state, const type_entry*, void* object, int index )
+{
+        T* value = reinterpret_cast<T*>( object );
+        if ( lua_type( state->get_raw(), index ) == LUA_TNUMBER )
+        {
+                *value = T( lua_tointeger( state->get_raw(), index ) );
+                return true;
+        }
+        return false;
+}
+
+template < typename T >
+bool nlua_rtti_unsigned_read( nv::lua::state* state, const type_entry*, void* object, int index )
+{
+        T* value = reinterpret_cast<T*>( object );
+        if ( lua_type( state->get_raw(), index ) == LUA_TNUMBER )
+        {
+                *value = T( lua_tointeger( state->get_raw(), index ) );
+                return true;
+        }
+        return false;
+}
+
+template < typename T >
+bool nlua_rtti_floating_read( nv::lua::state* state, const type_entry*, void* object, int index )
+{
+        T* value = reinterpret_cast<T*>( object );
+        if ( lua_type( state->get_raw(), index ) == LUA_TNUMBER )
+        {
+                *value = T( lua_tonumber( state->get_raw(), index ) );
+                return true;
+        }
+        return false;
+}
+
+static bool nlua_rtti_boolean_read( nv::lua::state* state, const type_entry*, void* object, int index )
+{
+        bool* value = reinterpret_cast<bool*>( object );
+        if ( lua_type( state->get_raw(), index ) == LUA_TBOOLEAN )
+        {
+                *value = bool( lua_toboolean( state->get_raw(), index ) );
+                return true;
+        }
+        return false;
+}
+
+
+void nv::lua::type_data::insert( thash64 tid, lua_rtti_push_function p, lua_rtti_read_function r )
+{
+        m_type_read.assign( tid, r );
+        m_type_push.assign( tid, p );
+}
+
+void nv::lua::type_data::register_standard_types()
+{
+        insert<bool>( nlua_rtti_boolean_push, nlua_rtti_boolean_read );
+        insert<nv::sint8> ( nlua_rtti_signed_push<nv::sint8>,    nlua_rtti_signed_read<nv::sint8> );
+        insert<nv::sint16>( nlua_rtti_signed_push<nv::sint16>,   nlua_rtti_signed_read<nv::sint16> );
+        insert<nv::sint32>( nlua_rtti_signed_push<nv::sint32>,   nlua_rtti_signed_read<nv::sint32> );
+        insert<nv::uint8> ( nlua_rtti_unsigned_push<nv::uint8>,  nlua_rtti_unsigned_read<nv::uint8> );
+        insert<nv::uint16>( nlua_rtti_unsigned_push<nv::uint16>, nlua_rtti_unsigned_read<nv::uint16> );
+        insert<nv::uint32>( nlua_rtti_unsigned_push<nv::uint32>, nlua_rtti_unsigned_read<nv::uint32> );
+        insert<nv::f32>   ( nlua_rtti_floating_push<nv::f32>,    nlua_rtti_floating_read<nv::f32> );
+        insert<nv::f64>   ( nlua_rtti_floating_push<nv::f64>,    nlua_rtti_floating_read<nv::f64> );
+//      insert<nv::sint64>( nlua_rtti_floating_push<nv::sint64>, nlua_rtti_floating_read<nv::sint64> );
+//      insert<nv::uint64>( nlua_rtti_floating_push<nv::uint64>, nlua_rtti_floating_read<nv::uint64> );
+}