Changeset 545

Timestamp:

02/09/17 01:13:09 (8 years ago)

Author:

epyon

Message:

• components with parent/child sorted data
• index_table swap
• transform != and == operators

Location:

trunk/nv

Files:

• core/transform.hh (modified) (1 diff)
• ecs/component.hh (modified) (4 diffs)
• stl/index_table.hh (modified) (3 diffs)

trunk/nv/core/transform.hh

@@ -109 +109 @@
         }
 
+        inline bool operator==( const transform& lhs, const transform& rhs )
+        {
+                return lhs.get_position() == rhs.get_position() && lhs.get_orientation() == rhs.get_orientation();
+        }
+
+        inline bool operator!=( const transform& lhs, const transform& rhs )
+        {
+                return !( lhs == rhs );
+        }
+
+
         template <> struct enum_to_type< TRANSFORM > { typedef transform type; };
         template <> struct type_to_enum< transform > { static const datatype type = TRANSFORM; };

trunk/nv/ecs/component.hh

@@ -58 +58 @@
                         typedef typename storage_type::const_reference  const_reference;
 
-                        component( ecs_type& a_ecs, string_view a_name, uint32 reserve = 0 ) 
-                                : m_ecs( a_ecs )
+                        component( ecs_type& a_ecs, string_view a_name, bool relational = false, uint32 reserve = 0 ) 
+                                : m_ecs( a_ecs ), m_relational( relational )
                         {
                                 m_ecs.register_component<component_type, Handler>( a_name, this );
@@ -134 +134 @@
                                 }
                                 m_data.pop_back();
+                                if ( m_relational )
+                                        relational_rebuild( dead_eindex );
                         }
 
@@ -147 +149 @@
                                 }
                                 m_data.pop_back();
+                                if ( m_relational )
+                                        relational_rebuild( dead_eindex );
                         }
 
@@ -189 +193 @@
                         storage_type     m_data;
                 private:
+                        void swap( handle_type a, handle_type b )
+                        {
+                                index_type ai = m_index.get( a );
+                                index_type bi = m_index.get( b );
+                                m_index.swap( a, b );
+                                value_type t = nv::move( m_data[ai] );
+                                m_data[ai] = nv::move( m_data[bi] );
+                                m_data[bi] = nv::move( t );
+                        }
+
+                        handle_type extract_owner( index_type i )
+                        {
+                                return *(handle_type*)( &( m_data[i] ) );
+                        }
+
+                        void relational_remove( handle_type a )
+                        {
+                                index_type i = m_index.get( a );
+                                remove( a );
+                                relational_rebuild( i );
+                        }
+
+                        void relational_rebuild( index_type i )
+                        {
+                                handle_type h = extract_owner( i );
+                                handle_type p = m_ecs.get_parent( h );
+                                if ( !p ) return;
+                                if ( i < m_index.get( p ) )
+                                {
+                                        swap( h, p );
+                                        relational_rebuild( i );
+                                }
+                        }
+                        bool             m_relational;
                         index_table_type m_index;
                 };

trunk/nv/stl/index_table.hh

@@ -59 +59 @@
                 }
 
+                void swap( handle_type a, handle_type b )
+                {
+                        if ( a.is_nil() || a.index() >= m_indexes.size() || m_indexes[a.index()] == -1 ) return;
+                        if ( b.is_nil() || b.index() >= m_indexes.size() || m_indexes[b.index()] == -1 ) return;
+                        index_type a_idx = m_indexes[a.index()];
+                        index_type b_idx = m_indexes[b.index()];
+                        nv::swap( m_indexes[a.index()], m_indexes[b.index()] );
+                        nv::swap( m_handles[a_idx], m_handles[b_idx] );
+                }
+                
                 index_type remove_swap( handle_type h )
                 {
@@ -153 +163 @@
                 }
 
+                void swap( handle_type a, handle_type b )
+                {
+                        if ( a.is_nil() || b.is_nil() ) return;
+                        auto ai = m_indexes.find( a.index() );
+                        auto bi = m_indexes.find( b.index() );
+                        if ( ai == m_indexes.end() || bi == m_indexes.end() ) return;
+                        index_type a_idx = ai->second;
+                        index_type b_idx = bi->second;
+                        ai->second = b_idx;
+                        bi->second = a_idx;
+                        nv::swap( m_handles[a_idx], m_handles[b_idx] );
+                }
+
                 index_type remove_swap( handle_type h )
                 {
                         if ( h.is_nil() ) return -1;
-                        auto ih = m_indexes.find( h.index() );
+                        index_type dead_h_index = h.index();
+                        auto ih = m_indexes.find( dead_h_index );
                         if ( ih == m_indexes.end() || ih->second == index_type(-1) ) return -1;
-                        index_type swap_handle = m_handles.back();
                         index_type dead_eindex = ih->second;
-                        if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
-                        {
-                                m_handles[unsigned( dead_eindex )] = swap_handle;
-                                m_indexes[swap_handle] = dead_eindex;
-                        }
-                        m_handles.pop_back();
-                        m_indexes.erase( h.index() );
-                        return dead_eindex;
-                }
-
-                index_type remove_swap( index_type dead_eindex )
+
+                        index_type swap_handle = m_handles.back();
+                        if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
+                        {
+                                m_handles[unsigned( dead_eindex )] = swap_handle;
+                                m_indexes[swap_handle] = dead_eindex;
+                        }
+                        m_handles.pop_back();
+                        m_indexes.erase( dead_h_index );
+                        return dead_eindex;
+                }
+
+                index_type remove_swap_by_index( index_type dead_eindex )
                 {
                         if ( uint32( dead_eindex ) >= m_handles.size() ) return -1;
-                        index_type h = m_handles[dead_eindex];
-                        index_type swap_handle = m_handles.back();
-                        if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
-                        {
-                                m_handles[unsigned( dead_eindex )] = swap_handle;
-                                m_indexes[swap_handle] = dead_eindex;
-                        }
-                        m_handles.pop_back();
-                        m_indexes.erase( h );
+                        index_type dead_h_index = m_handles[dead_eindex];
+
+                        index_type swap_handle = m_handles.back();
+                        if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
+                        {
+                                m_handles[unsigned( dead_eindex )] = swap_handle;
+                                m_indexes[swap_handle] = dead_eindex;
+                        }
+                        m_handles.pop_back();
+                        m_indexes.erase( dead_h_index );
                         return dead_eindex;
                 }
@@ -200 +226 @@
         };
 
-
 }