Changeset 551

Timestamp:

03/14/17 16:44:18 (8 years ago)

Author:

epyon

Message:

• clang compatibility
• ecs upgrades

Location:

trunk

Files:

• nv.lua (modified) (3 diffs)
• nv/base/common.hh (modified) (1 diff)
• nv/core/resource.hh (modified) (3 diffs)
• nv/ecs/component.hh (modified) (17 diffs)
• nv/ecs/ecs.hh (modified) (26 diffs)
• nv/ecs/message_queue.hh (modified) (2 diffs)
• nv/engine/mesh_manager.hh (modified) (1 diff)
• nv/engine/resource_system.hh (modified) (1 diff)
• nv/interface/context.hh (modified) (1 diff)
• nv/interface/physics_world.hh (modified) (3 diffs)
• nv/lua/lua_handle.hh (modified) (1 diff)
• nv/lua/lua_proxy.hh (modified) (3 diffs)
• nv/lua/lua_state.hh (modified) (2 diffs)
• nv/stl/flags.hh (modified) (1 diff)
• nv/stl/functional/hash.hh (modified) (1 diff)
• nv/stl/handle_manager.hh (modified) (1 diff)
• nv/stl/handle_store.hh (modified) (2 diffs)
• nv/stl/index_table.hh (modified) (2 diffs)
• nv/stl/math/geometric.hh (modified) (1 diff)
• nv/stl/range.hh (modified) (1 diff)
• nv/stl/type_traits/common.hh (modified) (2 diffs)
• nv_bullet.lua (modified) (1 diff)
• premake5.lua (modified) (1 diff)
• src/engine/mesh_manager.cc (modified) (1 diff)
• src/image/png_writer.cc (modified) (5 diffs)
• src/lua/lua_proxy.cc (modified) (1 diff)

trunk/nv.lua

@@ -112 +112 @@
         links { "nv-core", "nv-lib", "nv-io", "nv-gfx", "nv-lua" }
 
+--[[
 -- injection!
 solution( solution().name )
         configuration "gmake"
-                if _ACTION == "gmake-clang" then
+                if CLANG then
                         buildoptions { 
-                                "-std=c++1z",
+                                "-std=c++14",
 --                                -- on Mac OS X don't try to use old stdc++
 --                                "-stdlib=libc++",
-                                "-Weverything",
+--                              "-Weverything",
                                 -- math is so much easier with these
+                                "-w",
                                 "-Wno-gnu-anonymous-struct", 
                                 "-Wno-nested-anon-types", 
@@ -163 +165 @@
 
 if _ACTION == "gmake-clang" then
-        premake.gcc.cc  = "clang"
-        premake.gcc.cxx = "clang++"
+        toolset "clang"
         _ACTION = "gmake"
 end
@@ -178 +179 @@
         end
 end
+
+--]]

trunk/nv/base/common.hh

@@ -184 +184 @@
 #endif
 
+#if NV_COMPILER != NV_MSVC 
+#define NULL 0
+#endif
+
 namespace nv
 {

trunk/nv/core/resource.hh

@@ -221 +221 @@
                         shash64 hid( id );
                         if ( m->second->exists( hid ) || m->second->load_resource( id ) )
-                                return m->second->create< T >( hid );
+                                return m->second->template create< T >( hid );
                         NV_ASSERT( false, "resource_manager.get failed!" );
                         return resource< T >();
@@ -234 +234 @@
                         if ( m->second->exists( hid ) )
                         {
-                                return m->second->create< T >( hid );
+                                return m->second->template create< T >( hid );
                         }
                         NV_ASSERT( false, "resource_manager.get failed!" );
@@ -246 +246 @@
                         NV_ASSERT( m != m_handlers.end(), "Resource type unrecognized!" );
                         m->second->raw_add( id, value );
-                        return m->second->create< T >( id );
+                        return m->second->template create< T >( id );
                 }
 

trunk/nv/ecs/component.hh

@@ -37 +37 @@
                         typename Component,
                         typename Handler,
-                        template < typename, typename > class IndexTable = index_table
+                        template < typename, typename > class IndexTable = flat_index_table
                 >
                 class component : public Ecs::component_interface
@@ -47 +47 @@
                         typedef typename ecs_type::time_type            time_type;
                         typedef IndexTable< handle_type, sint32 >       index_table_type;
+                        typedef index_table< handle_type, sint32 >      idx_table;
                         typedef Component                               value_type;
                         typedef Component                               component_type;
@@ -58 +59 @@
                         typedef typename storage_type::const_reference  const_reference;
 
-                        component( ecs_type& a_ecs, string_view a_name, bool relational = false, uint32 reserve = 0 ) 
+                        component( ecs_type& a_ecs, string_view a_name, bool relational = false ) 
                                 : m_ecs( a_ecs ), m_relational( relational ), m_storage( nullptr )
                         {
-                                m_storage = new storage_type;
-                                m_ecs.register_component<component_type, Handler>( a_name, this );
-                                if ( reserve != 0 )
-                                {
-                                        m_storage->reserve( reserve );
-                                }
+                                m_index = new index_table_type;
+                                m_storage = (storage_type*)m_ecs.template register_component<component_type, Handler>( a_name, this );
+//                              if ( reserve != 0 )
+//                              {
+//                                      m_storage->reserve( reserve );
+//                              }
+                        }
+
+                        void temp_storage( storage_type* storage )
+                        {
+
                         }
 
                         virtual uint32 temp_index( handle_type h ) const  final
                         {
-                                return m_index.get( h );
+                                return m_index->get( h );
                         }
 
@@ -77 +83 @@
                         inline value_type& insert( handle_type h )
                         {
-                                index_type i = m_index.insert( h );
+                                index_type i = m_index->insert( h );
                                 NV_ASSERT( i == index_type( m_storage->size() ), "Fail!" );
                                 NV_UNUSED( i );
@@ -87 +93 @@
                         value_type& insert( handle_type h, Args&&... args )
                         {
-                                index_type i = m_index.insert( h );
+                                index_type i = m_index->insert( h );
                                 NV_ASSERT( i == index_type( m_storage->size() ), "Fail!" );
                                 NV_UNUSED( i );
@@ -102 +108 @@
                         bool exists( handle_type h )
                         {
-                                return m_index.exists( h );
+                                return m_index->exists( h );
                         }
 
                         void call_destroy( value_type* data )
                         {
-                                for ( auto dh : m_destroy )
+                                for ( auto dh : this->m_destroy )
                                         dh( data );
                         }
@@ -113 +119 @@
                         virtual void clear_() final
                         {
-                                for ( uint32 i = 0; i < m_storage->size(); ++i )
-                                        call_destroy( &(*m_storage)[i] );
-                                m_index.clear();
+                                m_index->clear();
+                                for ( uint32 i = 0; i < m_storage->size(); ++i )
+                                        call_destroy( &( *m_storage )[i] );
                                 m_storage->clear();
                         }
@@ -121 +127 @@
                         value_type* get( handle_type h )
                         {
-                                index_type i = m_index.get( h );
+                                index_type i = m_index->get( h );
                                 return i >= 0 ? &( ( *m_storage )[unsigned( i )] ) : nullptr;
                         }
                         const value_type* get( handle_type h ) const
                         {
-                                index_type i = m_index.get( h );
+                                index_type i = m_index->get( h );
                                 return i >= 0 ? &( ( *m_storage )[unsigned( i )] ) : nullptr;
                         }
@@ -133 +139 @@
                         const void* get_raw( handle_type h ) const { return get( h ); }
 
-                        virtual void remove( handle_type h ) final
+                        virtual void remove_( handle_type h ) final
                         {
                                 value_type* v = get( h );
                                 if ( v == nullptr ) return;
                                 call_destroy( v );
-                                index_type dead_eindex = m_index.remove_swap( h );
+                                index_type dead_eindex = m_index->remove_swap( h );
                                 if ( dead_eindex == -1 ) return;
                                 if ( dead_eindex != static_cast<index_type>( m_storage->size() - 1 ) )
@@ -149 +155 @@
                         }
 
-                        void remove_by_index( index_type i )
-                        {
-                                if ( i > size() ) return;
+                        void remove_by_index_( uint32 i )
+                        {
+                                if ( i > m_storage->size() ) return;
                                 call_destroy( &(*m_storage)[i] );
-                                index_type dead_eindex = m_index.remove_swap_by_index( i );
+                                index_type dead_eindex = m_index->remove_swap_by_index( i );
                                 if ( dead_eindex == -1 ) return;
                                 if ( dead_eindex != static_cast<index_type>( m_storage->size() - 1 ) )
@@ -164 +170 @@
                         }
 
-                        template < typename F >
-                        void remove_if( F f )
-                        {
-                                uint32 i = 0;
-                                while ( i < size() )
-                                {
-                                        auto& md = ( *m_storage )[i];
-                                        if ( f( md ) )
-                                                remove_by_index( i );
-                                        else
-                                                ++i;
-                                }
-                        }
-
                         virtual void on_attach( handle_type, handle_type child ) final
                         {
@@ -186 +178 @@
                         }
 
-                        ~component()
-                        {
-                                clear_();
-                                delete m_storage;
-                                m_storage = nullptr;
+                        virtual ~component()
+                        {
+                                //clear_();
+                                delete m_index;
                         }
                         
-                        inline const value_type& operator[] ( index_type i ) const { return ( *m_storage )[i]; }
-                        inline value_type& operator[] ( index_type i ) { return ( *m_storage )[i]; }
-
                         inline size_t size() const { return m_storage->size(); }
-
-                        inline iterator        begin() { return m_storage->begin(); }
-                        inline const_iterator  begin()  const { return m_storage->begin(); }
-
-                        inline iterator        end() { return m_storage->end(); }
-                        inline const_iterator  end()  const { return m_storage->end(); }
-
-                        inline virtual component_storage* storage() { return m_storage; }
+                        inline virtual component_storage* storage() { return m_storage; }
                 protected:
                         ecs_type&        m_ecs;
@@ -211 +192 @@
                         void swap( handle_type a, handle_type b )
                         {
-                                index_type ai = m_index.get( a );
-                                index_type bi = m_index.get( b );
+                                index_type ai = m_index->get( a );
+                                index_type bi = m_index->get( b );
                                 if ( ai < 0 || bi < 0 ) return;
-                                m_index.swap( a, b );
+                                m_index->swap( a, b );
                                 value_type t = nv::move( ( *m_storage )[ai] );
                                 ( *m_storage )[ai] = nv::move( ( *m_storage )[bi] );
@@ -225 +206 @@
                         }
 
-                        void relational_remove( handle_type a )
-                        {
-                                index_type i = m_index.get( a );
-                                remove( a );
-                                relational_rebuild( i );
-                        }
-
                         void relational_rebuild( index_type i )
                         {
@@ -237 +211 @@
                                 handle_type p = m_ecs.get_parent( h );
                                 if ( !p ) return;
-                                if ( i < m_index.get( p ) )
+                                if ( i < m_index->get( p ) )
                                 {
                                         swap( h, p );
@@ -248 +222 @@
                                 handle_type p = m_ecs.get_parent( h );
                                 if ( !p ) return;
-                                if ( m_index.get( h ) < m_index.get( p ) )
+                                if ( m_index->get( h ) < m_index->get( p ) )
                                 {
                                         swap( h, p );
@@ -256 +230 @@
                         }
 
-                        bool             m_relational;
-                        index_table_type m_index;
+                        bool       m_relational;
+                        idx_table* m_index;
                 };
 

trunk/nv/ecs/ecs.hh

@@ -39 +39 @@
                         typedef ecs< Handle, MessageList, Time >   this_type;
                         typedef Handle                             handle_type;
-                        using base_type::time_type;
-                        using base_type::message_type;
-                        using base_type::message;
-
-                        using update_handler  = function< void( time_type ) >;
-                        using destroy_handler = function< void( void* ) >;
-                        using create_handler  = function< void( handle_type, void*, const lua::stack_proxy& ) >;
+                        typedef typename base_type::time_type      time_type;
+                        using typename base_type::message_list;
+                        using typename base_type::message_type;
+                        using typename base_type::message;
+
+                        using destructor_handler = function< void() >;
+                        using update_handler     = function< void( time_type ) >;
+                        using destroy_handler    = function< void( void* ) >;
+                        using create_handler     = function< void( handle_type, void*, const lua::stack_proxy& ) >;
 
                         class component_interface
@@ -51 +53 @@
                         public:
                                 virtual void clear_() = 0;
-                                virtual void remove( handle_type h ) = 0;
+                                virtual void remove_( handle_type h ) = 0;
                                 virtual void on_attach( handle_type parent, handle_type child ) = 0;
                                 virtual void* get_raw( handle_type h ) = 0;
                                 virtual void* insert_raw( handle_type h ) = 0;
                                 virtual const void* get_raw( handle_type h ) const = 0;
-                                virtual component_storage* storage() = 0;
                                 virtual uint32 temp_index( handle_type h ) const = 0;
+                                virtual void remove_by_index_( uint32 i ) = 0;
+
 
                                 void run_create( handle_type h, const lua::stack_proxy& p )
@@ -140 +143 @@
                         }
 
-                        template < typename... Components >
+                        template < int, typename... Components >
                         struct gather_components
                         {
@@ -175 +178 @@
 
                         private:
-                                template < int Index, typename C, typename... Components >
+                                template < int Index, typename C, typename... Cs >
                                 void fill( this_type& ecs )
                                 {
                                         cis[Index] = ecs.get_interface< C >();
                                         NV_ASSERT( cis[Index], "What the fuck is this?" );
-                                        fill< Index + 1, Components... >( ecs );
+                                        fill< Index + 1, Cs... >( ecs );
                                 }
 
@@ -186 +189 @@
                                 void fill( this_type& ) {}
 
-                                template < int Index, typename SC, typename C, typename... Components >
+                                template < int Index, typename SC, typename C, typename... Cs >
                                 C& run_get()
                                 {
-                                        return get_impl< Index, SC, C, Components... >( nv::is_same< SC, C >{} );
-                                }
-
-                                template < int Index, typename SC, typename C, typename C2, typename... Components >
+                                        return get_impl< Index, SC, C, Cs... >( nv::is_same< SC, C >{} );
+                                }
+
+                                template < int Index, typename SC, typename C, typename C2, typename... Cs >
                                 C& get_impl( false_type&& )
                                 {
-                                        return get_impl< Index + 1, SC, C2, Components...>( nv::is_same< SC, C >() );
-                                }
-
-                                template < int Index, typename SC, typename C, typename... Components >
+                                        return get_impl< Index + 1, SC, C2, Cs...>( nv::is_same< SC, C >() );
+                                }
+
+                                template < int Index, typename SC, typename C, typename... Cs >
                                 C& get_impl( true_type&& )
                                 {
@@ -206 +209 @@
                         };
 
-                        template <>
-                        struct gather_components<>
-                        {
-                                gather_components( this_type& ) {};
+                        template <int I>
+                        struct gather_components<I>
+                        {
+                                gather_components( this_type& ) {}
                                 bool run( handle_type ) { return true;  }
                                 template < typename Component >
@@ -215 +218 @@
                         };
 
-                        template< typename System >
-                        void register_system( string_view name, System* c )
-                        {
-                                register_handler< System >( name, (System*)( c ) );
-                                register_component_helper< System >( c, has_components< System >::type{} );
-                                register_ecs_update< System >( (System*)( c ),
-                                        has_ecs_update< this_type, System, time_type >::type{} );
+                        template< typename System, typename... Args >
+                        System* register_system( string_view name, Args&&... args )
+                        {
+                                System* result = new System( nv::forward< Args >( args )... );
+
+                                this->template register_handler< System >( name, (System*)( result ) );
+                                register_component_helper< System >( result, typename has_components< System >::type() );
+                                register_ecs_update< System >( (System*)( result ),
+                                        typename has_ecs_update< this_type, System, time_type >::type() );
+                                m_cleanup.emplace_back( [=] () { delete result; } );
+                                return result;
                         }
 
@@ -227 +234 @@
                         void register_component_helper( System* c, true_type&& )
                         {
-                                using component_list = System::components;
-                                register_component_messages< System, component_list >( c, message_list{} );
-                                register_ecs_component_update< System >( c, component_list{},
-                                        has_ecs_component_update< this_type, System, component_list, time_type >::type{} );
-                                register_component_update< System >( c, component_list{},
-                                        has_component_update< System, component_list, time_type >::type{} );
+                                using component_list = typename System::components;
+                                register_component_messages< System, component_list >( c, message_list() );
+                                register_ecs_component_update< System >( c, component_list(),
+                                        typename has_ecs_component_update< this_type, System, component_list, time_type >::type() );
+                                register_component_update< System >( c, component_list(),
+                                        typename has_component_update< System, component_list, time_type >::type() );
+                                register_destroy< System, mpl::head<component_list> >( (System*)( c ),
+                                        typename has_destroy< System, mpl::head<component_list> >::type() );
                         }
 
@@ -241 +250 @@
 
                         template < typename Component, typename Handler >
-                        void register_component( string_view name, component_interface* c )
-                        {
+                        component_storage* register_component( string_view name, component_interface* c )
+                        {
+                                auto s = new component_storage_handler< Component >;
+                                m_cstorage.push_back( s );
+                                m_cmap[thash64::create<Component>()] = s;
+                                m_cmap_by_name[name] = s;
+
                                 m_components.push_back( c );
                                 m_component_map[thash64::create<Component>()] = c;
                                 m_component_map_by_name[name] = c;
-                                register_handler< Handler >( name, (Handler*)c );
-                                register_component_messages< Handler, mpl::list< Component > >( (Handler*)( c ), message_list{} );
-                                register_ecs_component_update< Handler >( (Handler*)( c ), mpl::list< Component >{},
-                                        has_ecs_component_update< this_type, Handler, mpl::list< Component >, time_type >::type{} );
-                                register_component_update< Handler >( (Handler*)( c ), mpl::list< Component >{}, 
-                                        has_component_update< Handler, mpl::list< Component >, time_type >::type{} );
+                                this->template register_handler< Handler >( name, (Handler*)c );
+                                register_component_messages< Handler, mpl::list< Component > >( (Handler*)( c ), message_list() );
+                                register_ecs_component_update< Handler >( (Handler*)( c ), mpl::list< Component >(),
+                                        typename has_ecs_component_update< this_type, Handler, mpl::list< Component >, time_type >::type() );
+                                register_component_update< Handler >( (Handler*)( c ), mpl::list< Component >(),
+                                        typename has_component_update< Handler, mpl::list< Component >, time_type >::type() );
                                 register_ecs_update< Handler >( (Handler*)( c ), 
-                                        has_ecs_update< this_type, Handler, time_type >::type{} );
+                                        typename has_ecs_update< this_type, Handler, time_type >::type() );
                                 register_destroy< Handler, Component >( (Handler*)( c ),
-                                        has_destroy< Handler, Component >::type{} );
+                                        typename has_destroy< Handler, Component >::type() );
                                 register_create< Handler, Component, handle_type >( (Handler*)( c ),
-                                        has_create< Handler, Component, handle_type >::type{} );
-                                //                              auto s = c->storage();
-                                //                              m_cstorage.push_back( s );
-                                //                              m_cmap[thash64::create<Component>()] = s;
-                                //                              m_cmap_by_name[name] = s;
+                                        typename has_create< Handler, Component, handle_type >::type() );
+                                
+                                return s;
+                        }
+
+                        template < typename ComponentManager, typename ...Args >
+                        ComponentManager* register_component_manager( Args&&... args )
+                        {
+                                ComponentManager* result = new ComponentManager( *this, nv::forward< Args >( args )... );
+                                m_cleanup.emplace_back( [=] () { delete result; } );
+                                return result;
                         }
 
@@ -271 +291 @@
                         void update( time_type dtime )
                         {
-                                update_time( dtime );
+                                this->update_time( dtime );
                                 for ( auto u : m_update_handlers )
                                         u( dtime );
+                                for ( auto h : m_dead_handles )
+                                        remove( h );
+                                m_dead_handles.clear();
                         }
 
                         void clear()
                         {
-                                reset_events();
+                                this->reset_events();
                                 for ( auto c : m_components )
                                         c->clear_();
@@ -286 +309 @@
                         ~ecs()
                         {
+                                for ( auto s : m_cstorage )
+                                        delete s;
+                                m_cstorage.clear();
                                 //                              for ( auto cs : m_component_storage )
                                 //                                      delete cs;
                                 //                              m_cstorage.clear();
-
+                                // reverse order delete;
+                                if ( !m_cleanup.empty() )
+                                for ( int i = (int)m_cleanup.size() - 1; i >= 0; --i )
+                                        m_cleanup[i]();
+                                m_cleanup.clear();
                         }
 
@@ -343 +373 @@
                         }
 
+                        template < typename C, typename F >
+                        void remove_component_if( F&& f )
+                        {
+                                auto storage = get_storage<C>();
+                                auto temp_component = get_interface<C>();
+                                uint32 i = 0;
+                                while ( i < storage->size() )
+                                        if ( f( ( *storage )[i] ) )
+                                                temp_component->remove_by_index_( i );
+                                        else
+                                                ++i;
+                        }
+
+                        template < typename C>
+                        void remove_component( handle_type h )
+                        {
+                                auto temp_component = get_interface<C>();
+                                temp_component->remove_( h );
+                        }
+
+                        template < typename C, typename F >
+                        void for_each( F&& f )
+                        {
+                                auto storage = get_storage<C>();
+                                NV_ASSERT( storage, "Invalid component" );
+                                for ( auto& c : *storage )
+                                {
+                                        f( c );
+                                }
+                        }
+
+
                         template < typename F >
                         void recursive_call( handle_type h, F&& f )
@@ -351 +413 @@
                         }
 
+                        void mark_remove( handle_type h )
+                        {
+                                m_dead_handles.push_back( h );
+                        }
+
                         void remove( handle_type h )
                         {
@@ -360 +427 @@
                                 }
                                 for ( auto c : m_components )
-                                        c->remove( h );
+                                        c->remove_( h );
                                 m_handles.free_handle( h );
                         }
@@ -396 +463 @@
                         Component* get( handle_type h )
                         {
-                                return static_cast<Component*>( m_component_map[thash64::create< Component >()]->get_raw( h ) );
+                                auto it = m_component_map.find( thash64::create< Component >() );
+                                NV_ASSERT( it != m_component_map.end(), "Get fail!" );
+                                return static_cast<Component*>( it->second->get_raw( h ) );
                         }
 
@@ -402 +471 @@
                         const Component* get( handle_type h ) const
                         {
-                                return static_cast<const Component*>( m_component_map[thash64::create< Component >()]->get_raw( h ) );
-                        }
-
-                        template < typename Component >
-                        typename component_storage_handler< Component >*
+                                auto it = m_component_map.find( thash64::create< Component >() );
+                                NV_ASSERT( it != m_component_map.end(), "Get fail!" );
+                                return static_cast<const Component*>( it->second->get_raw( h ) );
+                        }
+
+                        template < typename Component >
+                        component_storage_handler< Component >*
                                 get_storage()
                         {
@@ -413 +484 @@
 
                         template < typename Component >
-                        const typename component_storage_handler< Component >*
+                        const component_storage_handler< Component >*
                                 get_storage() const
                         {
                                 return storage_cast<Component>( m_cmap[thash64::create< Component >()] );
+                        }
+                        
+                        template < typename Component >
+                        Component& add_component( handle_type h )
+                        {
+                                component_interface* ci = get_interface<Component>();
+                                return *((Component*)ci->insert_raw( h ));
+                        }
+
+                        template < typename Component, typename ...Args >
+                        Component& add_component( handle_type h, Args&&... args )
+                        {
+                                component_interface* ci = get_interface<Component>();
+                                Component& result = *( (Component*)ci->insert_raw( h ) );
+                                result = Component{ nv::forward<Args>( args )... };
+                                return result;
                         }
 
@@ -422 +509 @@
                         void register_component_messages( System* h, List<Messages...>&& )
                         {
-                                int unused_0[] = { ( register_ecs_component_message<System,Messages>( h, Components{} , has_ecs_component_message< this_type, System, Components, Messages >::type{} ), 0 )... };
-                                int unused_1[] = { ( register_component_message<System,Messages>( h, Components{}, has_component_message< System, Components, Messages >::type{} ), 0 )... };
-                                int unused_2[] = { ( register_ecs_message<System,Messages>( h, has_ecs_message< this_type, System, Messages >::type{} ), 0 )... };
-                        }
-
+                                int unused_0[] = { ( register_ecs_component_message<System,Messages>( h, Components() , typename has_ecs_component_message< this_type, System, Components, Messages >::type() ), 0 )... };
+                                int unused_1[] = { ( register_component_message<System,Messages>( h, Components(), typename has_component_message< System, Components, Messages >::type() ), 0 )... };
+                                int unused_2[] = { ( register_ecs_message<System,Messages>( h, typename has_ecs_message< this_type, System, Messages >::type() ), 0 )... };
+                        }
+                        
                         template < typename System, typename Message, typename C, typename... Cs >
                         void register_component_message( System* s, mpl::list< C, Cs...>&&, true_type&& )
@@ -438 +525 @@
                                                 if ( void* c = ci->get_raw( h ) )
                                                 {
-                                                        gather_components< Cs... > gather( *this );
+                                                        gather_components<0, Cs... > gather( *this );
                                                         if ( gather.run( h ) )
-                                                                s->on( m, *( (C*)( c ) ), gather.get<Cs>()... );
+                                                                s->on( m, *( (C*)( c ) ), gather.template get<Cs>()... );
                                                 }
                                         };
@@ -462 +549 @@
                                                 if ( void* c = ci->get_raw( h ) )
                                                 {
-                                                        gather_components< Cs... > gather( *this );
+                                                        gather_components<0, Cs... > gather( *this );
                                                         if ( gather.run( h ) )
-                                                                s->on( m, *this, *( (C*)( c ) ), gather.get<Cs>()... );
+                                                                s->on( m, *this, *( (C*)( c ) ), gather.template get<Cs>()... );
                                                 }
                                         };
@@ -514 +601 @@
                         }
 
-                        template < typename System, typename Component, typename Handle >
+                        template < typename System, typename Component, typename H >
                         void register_create( System* s, true_type&& )
                         {
                                 component_interface* ci = get_interface<Component>();
                                 NV_ASSERT( ci, "Unregistered component!" );
-                                ci->m_create.push_back( [=] ( Handle h, void* data, const lua::stack_proxy& p )
+                                ci->m_create.push_back( [=] ( H h, void* data, const lua::stack_proxy& p )
                                 {
                                         s->create( h, *( (Component*)data ), p );
@@ -529 +616 @@
                         void register_component_update( System* s, mpl::list< C, Cs...>&&, true_type&& )
                         {
-                                component_interface* ci = get_interface<C>();
-                                component_storage_handler<C>* storage = storage_cast<C>( ci->storage() );
+                                component_storage_handler<C>* storage = get_storage<C>();
                                 register_update( [=] ( time_type dtime )
                                 {
-                                        gather_components< Cs... > gather( *this );
+                                        gather_components<0, Cs... > gather( *this );
                                         for ( auto& c : *storage )
                                         {
                                                 if ( gather.runc( c ) )
-                                                        s->update( c, gather.get<Cs>()..., dtime );
+                                                        s->update( c, gather.template get<Cs>()..., dtime );
                                         }
                                 } );
@@ -545 +631 @@
                         void register_ecs_component_update( System* s, mpl::list< C, Cs...>&&, true_type&& )
                         {
-                                component_interface* ci = get_interface<C>();
-                                component_storage_handler<C>* storage = storage_cast<C>( ci->storage() );
+                                component_storage_handler<C>* storage = get_storage<C>();
                                 register_update( [=] ( time_type dtime )
                                 {
-                                        gather_components< Cs... > gather(*this);
+                                        gather_components<0, Cs... > gather(*this);
                                         for ( auto& c : *storage )
                                         {
                                                 if ( gather.runc( c ) )
-                                                        s->update( *this, c, gather.get<Cs>()..., dtime );
+                                                        s->update( *this, c, gather.template get<Cs>()..., dtime );
                                         }
                                 } );
@@ -565 +650 @@
                         void register_destroy( System*, false_type&& ) {}
 
-                        template < typename System, typename Component, typename Handle >
+                        template < typename System, typename Component, typename H >
                         void register_create( System*, false_type&& ) {}
 
@@ -582 +667 @@
 
                         handle_tree_manager< handle_type >          m_handles;
+                        vector< handle_type >                       m_dead_handles;
                         vector< component_interface* >              m_components;
                         hash_store< thash64, component_interface* > m_component_map;
@@ -587 +673 @@
                         vector< update_handler >                    m_update_handlers;
 
-                        //                      vector< component_storage* >                m_cstorage;
-                        //                      hash_store< thash64, component_storage* >   m_cmap;
-                        //                      hash_store< shash64, component_storage* >   m_cmap_by_name;
+                        vector< component_storage* >                m_cstorage;
+                        hash_store< thash64, component_storage* >   m_cmap;
+                        hash_store< shash64, component_storage* >   m_cmap_by_name;
+
+                        vector< component_interface* >              m_temp_components;
+                        vector< destructor_handler >                m_cleanup;
                 };
 

trunk/nv/ecs/message_queue.hh

@@ -84 +84 @@
                         }
 
-                        template<>
-                        void register_handler<void>( string_view /*name*/, void* )
+                        void register_handler( string_view /*name*/, void* )
                         {
                         }
@@ -123 +122 @@
                                 message m{ Payload::message_id, 0, m_time + delay };
                                 new( &m.payload ) Payload{ nv::forward<Args>( args )... };
+                                return queue( m );
+                        }
+
+                        // FIXME: Clang hack
+                        template < typename Payload >
+                        bool queue( time_type delay, Payload&& arg )
+                        {
+                                message m{ Payload::message_id, 0, m_time + delay };
+                                new( &m.payload ) Payload( arg );
                                 return queue( m );
                         }

trunk/nv/engine/mesh_manager.hh

@@ -79 +79 @@
                 string_view resolve( shash64 h ) { return ( *m_strings )[h]; }
                 resource< data_channel_set > get_path( const string_view& path,
-                        resource< mesh_data > default = resource< mesh_data >(),
+                        resource< mesh_data > def = resource< mesh_data >(),
                         data_node_info* info = nullptr );
 

trunk/nv/engine/resource_system.hh

@@ -194 +194 @@
                 virtual resource< T > load_resource( source_type u )
                 {
-                        if ( exists( u.id() ) ) return this->template create< T >( u.id() );
+                        if ( this->exists( u.id() ) ) return this->template create< T >( u.id() );
                         return create_resource( u );
                 }

trunk/nv/interface/context.hh

@@ -272 +272 @@
                 vertex_array create_vertex_array( const VTX* v, uint32 vcount, const IDX* i, uint32 icount, buffer_hint hint )
                 {
-                        buffer       vb = this->create_buffer( VERTEX_BUFFER, hint, count * sizeof( VTX ), v );
+                        buffer       vb = this->create_buffer( VERTEX_BUFFER, hint, vcount * sizeof( VTX ), v );
                         buffer       ib = this->create_buffer( INDEX_BUFFER, hint, icount * sizeof( IDX ), i );
                         vertex_array_desc desc;

trunk/nv/interface/physics_world.hh

@@ -24 +24 @@
         {
         public:
-                explicit collision_shape( void* p = nullptr, void* m = nullptr ) : internal( p ), mesh( m ) {}
+                collision_shape( void* p = nullptr, void* m = nullptr ) : internal( p ), mesh( m ) {}
                 void* internal = nullptr;
                 void* mesh     = nullptr;
@@ -33 +33 @@
         {
         public:
-                explicit rigid_body( void* p = nullptr ) : internal( p ) {}
+                rigid_body( void* p = nullptr ) : internal( p ) {}
                 void* internal = nullptr;
         };
@@ -40 +40 @@
         {
         public:
-                explicit constraint( void* p = nullptr ) : internal( p ) {}
+                constraint( void* p = nullptr ) : internal( p ) {}
                 void* internal = nullptr;
         };

trunk/nv/lua/lua_handle.hh

@@ -10 +10 @@
 #include <nv/common.hh>
 #include <nv/stl/handle.hh>
+#include <nv/stl/handle_manager.hh>
 #include <nv/lua/lua_values.hh>
 

trunk/nv/lua/lua_proxy.hh

@@ -12 +12 @@
 #include <nv/stl/string.hh>
 #include <nv/stl/string_table.hh>
+#include <nv/lua/lua_values.hh>
 
 namespace nv
@@ -87 +88 @@
                         bool read( T& t ) const
                         {
-                                NV_ASSERT( m_state->get_type_data(), "stack_proxy::read - type database not created!" );
-                                const type_database* tdb = m_state->get_type_data()->get_type_database();
+                                const type_database* tdb = get_type_db();
                                 NV_ASSERT( tdb, "stack_proxy::read - type database not set!" );
                                 const type_entry* entry = tdb->get_type<T>();
@@ -100 +100 @@
 //                      string_view to_string_view();
                 protected:
+                        const type_database* get_type_db() const;
+
                         // Not public because not permanent
                         string_view get_string_view() const;

trunk/nv/lua/lua_state.hh

@@ -57 +57 @@
                         }
                         const type_database* get_type_database() const { return m_type_database; }
+                        type_database* get_type_database() { return m_type_database; }
 
                         template < typename T >
@@ -204 +205 @@
 
                         const type_data* get_type_data() const { return m_lua_types; }
-
-
-
+                        type_data* get_type_data() { return m_lua_types; }
 
                 protected:

trunk/nv/stl/flags.hh

@@ -227 +227 @@
                 }
 
-                template < uint32 SIZE, typename T >
-                inline friend flags< SIZE, T > operator &( const flags< SIZE, T >& lhs, const flags< SIZE, T >& rhs );
-
-                template < uint32 SIZE, typename T >
-                inline friend flags< SIZE, T > operator |( const flags< SIZE, T >& lhs, const flags< SIZE, T >& rhs );
+                template < uint32 S, typename T2 >
+                inline friend flags< S, T2 > operator &( const flags< S, T2 >& lhs, const flags< S, T2 >& rhs );
+
+                template < uint32 S, typename T2 >
+                inline friend flags< S, T2 > operator |( const flags< S, T2 >& lhs, const flags< S, T2 >& rhs );
 
         private:

trunk/nv/stl/functional/hash.hh

@@ -86 +86 @@
         };
 
+//      template < typename T >
+//      struct hash< T*, uintptr_t > : detail::hash_base< T, uintptr_t >
+//      {
+//              inline uintptr_t operator()( T* value ) const { return reinterpret_cast<uintptr_t>( value ); }
+//              static constexpr uintptr_t get( T value ) { return reinterpret_cast<uintptr_t>( value ); }
+//      };
+
         template < typename T >
-        struct hash< T*, uintptr_t > : detail::hash_base< T, uintptr_t >
-        {
-                inline uintptr_t operator()( T* value ) const { return reinterpret_cast<uintptr_t>( value ); }
+                struct hash< T, uintptr_t, 
+                typename enable_if< is_function_pointer< T >::value,
+                        void
+                >::type > : detail::hash_base< T, uintptr_t >
+        {
+                inline uintptr_t operator()( T value ) const { return reinterpret_cast<uintptr_t>( value ); }
                 static constexpr uintptr_t get( T value ) { return reinterpret_cast<uintptr_t>( value ); }
         };

trunk/nv/stl/handle_manager.hh

@@ -25 +25 @@
         {
         public:
-                typedef typename Handle                  handle_type;
+                typedef Handle                           handle_type;
                 typedef typename handle_type::value_type value_type;
 

trunk/nv/stl/handle_store.hh

@@ -39 +39 @@
                 {
                         m_data.reserve( reserve );
-                        m_indexes.reserve( reserve );
+                        m_index.reserve( reserve );
                 }
 
@@ -98 +98 @@
         private:
                 storage_type                  m_data;
-                index_table< handle_type, index_type > m_index;
+                flat_index_table< handle_type, index_type > m_index;
         };
 

trunk/nv/stl/index_table.hh

@@ -31 +31 @@
                 typedef Index               index_type;
 
-                index_table() {}
-                index_table( uint32 reserve )
+                virtual index_type insert( handle_type h ) = 0;
+                virtual bool exists( handle_type h ) const = 0;
+                virtual index_type get( handle_type h ) const = 0;
+                virtual void swap( handle_type a, handle_type b ) = 0;
+                virtual index_type remove_swap( handle_type h ) = 0;
+                virtual index_type remove_swap_by_index( index_type dead_eindex ) = 0;
+                virtual void clear() = 0;
+                virtual uint32 size() const = 0;
+        };
+
+
+        template <
+                typename Handle,
+                typename Index = sint32
+        >
+        class flat_index_table : public index_table< Handle, Index >
+        {
+        public:
+                typedef Handle              handle_type;
+                typedef Index               index_type;
+
+                flat_index_table() {}
+                flat_index_table( uint32 reserve )
                 {
                         m_indexes.reserve( reserve );
@@ -129 +150 @@
                 typename Index = sint32
         >
-                class hashed_index_table
+                class hashed_index_table : public index_table< Handle, Index >
         {
         public:

trunk/nv/stl/math/geometric.hh

@@ -69 +69 @@
                 inline T inv_length( T v )
                 {
-                        return T( 1 ) / abs( x );
+                        return T( 1 ) / abs( v );
                 }
 

trunk/nv/stl/range.hh

@@ -85 +85 @@
                         static const T invalid = T( 0 );
 
-                        bits_iterator_base( T value, T current ) : forward_iterator_base<T>( current ), m_full( value )
+                        bits_iterator_base( T value, T current ) : value_enumerator_base<T>( current ), m_full( value )
                         {
                                 if( !( static_cast<base_type>( value ) & static_cast<base_type>( current ) ) )

trunk/nv/stl/type_traits/common.hh

@@ -29 +29 @@
         };
 
-        template < typename T >
-        constexpr T integral_constant_v = integral_constant<T>::value;
-
         // TODO: Propagate
         template< bool B >
@@ -38 +35 @@
         typedef bool_constant<true> true_type;
         typedef bool_constant<false> false_type;
-
-        template < typename T >
-        constexpr T bool_constant_v = bool_constant<T>::value;
 
         template< bool Test, typename T = void>

trunk/nv_bullet.lua

@@ -28 +28 @@
 
         includedirs { "D:/Libraries/bullet2/src/" }
-
-        configuration "debug"
+        
+        filter { "configurations:debug", "platforms:*32" }
                 nv_bullet_configure( "D:/Libraries/bullet2/x86/", "RelWithDebInfo", "_rdbg" )
 --              nv_bullet_configure( "D:/Libraries/bullet2/x86/", "Debug", "_debug" )
 
-        configuration "profiler"
+        filter { "configurations:profiler", "platforms:*32" }
                 nv_bullet_configure( "D:/Libraries/bullet2/x86/", "Release" )
 
-        configuration "release"
+        filter { "configurations:release", "platforms:*32" }
                 nv_bullet_configure( "D:/Libraries/bullet2/x86/", "Release" )
 
-        configuration "debug_64"
+        filter { "configurations:debug", "platforms:*64" }
                 nv_bullet_configure( "D:/Libraries/bullet2/x86_64/", "RelWithDebInfo", "_rdbg" )
 --              nv_bullet_configure( "D:/Libraries/bullet2/x86_64/", "Debug", "_debug" )
 
-        configuration "profiler_64"
+        filter { "configurations:profiler", "platforms:*64" }
                 nv_bullet_configure( "D:/Libraries/bullet2/x86_64/", "Release" )
 
-        configuration "release_64"
+        filter { "configurations:release", "platforms:*64" }
                 nv_bullet_configure( "D:/Libraries/bullet2/x86_64/", "Release" )
 
+        filter {}
 
-

trunk/premake5.lua

@@ -1 @@
-solution "nv"
+workspace "nv"
         configurations { "debug", "release" }
         targetdir "bin"

trunk/src/engine/mesh_manager.cc

@@ -29 +29 @@
 }
 
-nv::resource< nv::data_channel_set > nv::mesh_data_manager::get_path( const string_view& path, resource< mesh_data > default /*= resource< mesh_data >()*/, data_node_info* info /*= nullptr */ )
+nv::resource< nv::data_channel_set > nv::mesh_data_manager::get_path( const string_view& path, resource< mesh_data > def /*= resource< mesh_data >()*/, data_node_info* info /*= nullptr */ )
 {
-        nv::resource< nv::mesh_data > mr = default;
+        nv::resource< nv::mesh_data > mr = def;
 
         nv::string_view sub_mesh_name;

trunk/src/image/png_writer.cc

@@ -12 +12 @@
 #include <stdarg.h>  
 
-using namespace nv;
+//using namespace nv;
 
 #if NV_COMPILER == NV_CLANG
@@ -33 +33 @@
 };
 
-#define STBI_MALLOC(sz)     nvmalloc(sz)
-#define STBI_REALLOC(p,sz)  nvrealloc(p,sz)
-#define STBI_FREE(p)        nvfree(p)
-#define STBI_MEMMOVE(d,s,c) nvmemmove(d,s,c)
+#define STBI_MALLOC(sz)     nv::nvmalloc(sz)
+#define STBI_REALLOC(p,sz)  nv::nvrealloc(p,sz)
+#define STBI_FREE(p)        nv::nvfree(p)
+#define STBI_MEMMOVE(d,s,c) nv::nvmemmove(d,s,c)
 
 typedef void stbi_write_func( void *context, void *data, int size );
@@ -57 +57 @@
 
 template < typename T >
-inline uchar8 byte_cast( T x )
-{
-        return uchar8( ( x ) & 255 );
+inline nv::uchar8 byte_cast( T x )
+{
+        return nv::uchar8( ( x ) & 255 );
 }
 
@@ -246 +246 @@
 }
 
+static int iabs( int i )
+{
+        return i >= 0 ? i : -i;
+}
+
 static unsigned char stbiw__paeth( int a, int b, int c )
 {
-        int p = a + b - c, pa = abs( p - a ), pb = abs( p - b ), pc = abs( p - c );
+        int p = a + b - c, pa = iabs( p - a ), pb = iabs( p - b ), pc = iabs( p - c );
         if ( pa <= pb && pa <= pc ) return byte_cast( a );
         if ( pb <= pc ) return byte_cast( b );
@@ -320 +325 @@
                                 if ( p ) break;
                                 for ( i = 0; i < x*n; ++i )
-                                        est += abs( (signed char)line_buffer[i] );
+                                        est += iabs( (signed char)line_buffer[i] );
                                 if ( est < bestval ) { bestval = est; best = k; }
                         }

trunk/src/lua/lua_proxy.cc

@@ -76 +76 @@
 }
 
+const nv::type_database* nv::lua::stack_proxy::get_type_db() const
+{
+        NV_ASSERT( m_state->get_type_data(), "type database not created!" );
+        return m_state->get_type_data()->get_type_database();
+}
+
 nv::string_view nv::lua::stack_proxy::get_string_view() const
 {