Changeset 537 for trunk


Ignore:
Timestamp:
01/18/17 19:58:46 (8 years ago)
Author:
epyon
Message:
  • ecs split, iterators and multi-component work start
Location:
trunk
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv.lua

    r487 r537  
    66        kind "StaticLib"
    77        includedirs { "." }
    8         files { "nv/common.hh", "nv/base/**.hh", "nv/core/**.hh", "nv/stl/**.hh", "nv/interface/**.hh", "nv/detail/**.inc", "src/core/**.cc", "src/stl/**.cc"  }
     8        files { "nv/common.hh", "nv/base/**.hh", "nv/ecs/**.hh", "nv/core/**.hh", "nv/stl/**.hh", "nv/interface/**.hh", "nv/detail/**.inc", "src/core/**.cc", "src/stl/**.cc"  }
    99
    1010project "nv-lib"

  • trunk/nv/ecs/ecs.hh

    r536 r537  
    2020#include <nv/stl/priority_queue.hh>
    2121#include <nv/stl/handle_manager.hh>
     22#include <nv/stl/range.hh>
    2223#include <nv/core/types.hh>
    2324
    … …  
    2728        namespace ecs
    2829        {
    29 
    3030
    3131                template < typename Handle, typename Time = f32 >
    … …  
    6868                                virtual void* get_raw( handle_type h ) = 0;
    6969                                virtual const void* get_raw( handle_type h ) const = 0;
     70                        };
     71
     72                        class enumerator : public value_enumerator_base < handle_type >
     73                        {
     74                        public:
     75                                typedef value_enumerator_base < handle_type > base_class;
     76                                explicit enumerator( const ecs& aecs, handle_type current = handle_type() ) : base_class( current ), m_ecs( aecs ) {}
     77                                enumerator& operator++ ()
     78                                {
     79                                        base_class::m_value = m_ecs.next( base_class::m_value );
     80                                        return *this;
     81                                }
     82                                value_enumerator_base operator++ ( int )
     83                                {
     84                                        auto result = *this;
     85                                        base_class::m_value = m_ecs.next( base_class::m_value );
     86                                        return result;
     87                                }
     88                        private:
     89                                const ecs& m_ecs;
    7090                        };
    7191
    … …  
    198218                        }
    199219
    200                         handle_type first( handle_type h ) const
     220                        handle_type first_child( handle_type h ) const
    201221                        {
    202222                                return h ? m_handles.first( h ) : handle_type();
     223                        }
     224
     225                        enumerator_provider< enumerator > children( handle_type h ) const
     226                        {
     227                                return enumerator_provider< enumerator >(
     228                                        enumerator( *this, first_child( h ) ),
     229                                        enumerator( *this )
     230                                );
    203231                        }
    204232
    … …  
    241269                        time_type                                   m_time = time_type(0);
    242270                        priority_queue< message, vector< message >, message_compare_type > m_pqueue;
    243                 };
    244 
    245                 template < typename Ecs, typename Component >
    246                 class component : public Ecs::component_interface
    247                 {
    248                 public:
    249                         typedef Ecs                                    ecs_type;
    250                         typedef typename ecs_type::message             message_type;
    251                         typedef typename ecs_type::handle_type         handle_type;
    252                         typedef typename ecs_type::time_type           time_type;
    253                         typedef index_table< handle_type >             index_table_type;
    254                         typedef Component                              value_type;
    255                         typedef Component                              component_type;
    256                         typedef vector< value_type >                   storage_type;
    257                         typedef typename index_table_type::index_type  index_type;
    258 
    259                         typedef typename storage_type::iterator        iterator;
    260                         typedef typename storage_type::const_iterator  const_iterator;
    261                         typedef typename storage_type::reference       reference;
    262                         typedef typename storage_type::const_reference const_reference;
    263 
    264                         component( ecs_type& a_ecs, string_view a_name, uint32 reserve = 0 ) : m_ecs( a_ecs )
    265                         {
    266                                 m_ecs.register_component<component_type>( a_name, this );
    267                                 if ( reserve != 0 )
    268                                 {
    269                                         m_data.reserve( reserve );
    270                                 }
    271                         }
    272 
    273                         value_type& insert( handle_type h )
    274                         {
    275                                 index_type i = m_index.insert( h );
    276                                 NV_ASSERT( i == index_type( m_data.size() ), "Fail!" );
    277                                 NV_UNUSED( i );
    278                                 m_data.emplace_back();
    279                                 return m_data.back();
    280                         }
    281 
    282                         template < typename ...Args >
    283                         value_type& insert( handle_type h, Args&&... args )
    284                         {
    285                                 index_type i = m_index.insert( h );
    286                                 NV_ASSERT( i == index_type( m_data.size() ), "Fail!" );
    287                                 NV_UNUSED( i );
    288                                 m_data.emplace_back( nv::forward<Args>( args )... );
    289                                 return m_data.back();
    290                         }
    291 
    292                         bool exists( handle_type h )
    293                         {
    294                                 return m_index.exists( h );
    295                         }
    296 
    297                         virtual void update( time_type /*dtime*/ )
    298                         {
    299                                 // no-op
    300                         }
    301 
    302                         virtual void clear()
    303                         {
    304                                 for ( uint32 i = 0; i < m_index.size(); ++i )
    305                                         destroy( &m_data[i] );
    306                                 m_index.clear();
    307                                 m_data.clear();
    308                         }
    309                        
    310                         value_type* get( handle_type h )
    311                         {
    312                                 index_type i = m_index.get( h );
    313                                 return i >= 0 ? &( m_data[unsigned( i )] ) : nullptr;
    314                         }
    315 
    316                         const value_type* get( handle_type h ) const
    317                         {
    318                                 index_type i = m_index.get( h );
    319                                 return i >= 0 ? &( m_data[unsigned( i )] ) : nullptr;
    320                         }
    321 
    322                         void* get_raw( handle_type h )
    323                         {
    324                                 index_type i = m_index.get( h );
    325                                 return i >= 0 ? &( m_data[unsigned( i )] ) : nullptr;
    326                         }
    327 
    328                         const void* get_raw( handle_type h ) const
    329                         {
    330                                 index_type i = m_index.get( h );
    331                                 return i >= 0 ? &( m_data[unsigned( i )] ) : nullptr;
    332                         }
    333 
    334                         virtual void remove( handle_type h )
    335                         {
    336                                 value_type* v = get( h );
    337                                 if ( v == nullptr ) return;
    338                                 destroy( v );
    339                                 index_type dead_eindex = m_index.remove_swap( h );
    340                                 if ( dead_eindex == -1 ) return;
    341                                 if ( dead_eindex != static_cast<index_type>( m_data.size() - 1 ) )
    342                                 {
    343                                         m_data[unsigned( dead_eindex )] = move( m_data.back() );
    344                                 }
    345                                 m_data.pop_back();
    346                         }
    347 
    348                         virtual void destroy( value_type* )
    349                         {
    350                                 // cleanup
    351                         }
    352 
    353                         virtual bool handle_message( const message_type& )
    354                         {
    355                                 return true;
    356                         }
    357 
    358                         ~component()
    359                         {
    360                                 clear();
    361                         }
    362 
    363 
    364                         handle_type get_handle( index_type i ) const { return m_index.get_handle( i ); }
    365 
    366                         const value_type& operator[] ( index_type i ) const { return m_data[i]; }
    367                         value_type& operator[] ( index_type i ) { return m_data[i]; }
    368 
    369                         size_t size() const { return m_data.size(); }
    370 
    371                         iterator        begin() { return m_data.begin(); }
    372                         const_iterator  begin()  const { return m_data.cbegin(); }
    373                         const_iterator  cbegin() const { return m_data.cbegin(); }
    374 
    375                         iterator        end() { return m_data.end(); }
    376                         const_iterator  end()  const { return m_data.cend(); }
    377                         const_iterator  cend() const { return m_data.cend(); }
    378                 protected:
    379                         ecs_type&        m_ecs;
    380                         index_table_type m_index;
    381                         storage_type     m_data;
    382271                };
    383272
    … …  
    411300                        ecs_type&        m_ecs;
    412301                };
     302
    413303        }
    414304

  • trunk/nv/stl/index_table.hh

    r533 r537  
    116116        };
    117117
     118
    118119}
    119120

  • trunk/nv/stl/range.hh

    r451 r537  
    1 // Copyright (C) 2014-2015 ChaosForge Ltd
     1// Copyright (C) 2014-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
    … …  
    1717#include <nv/stl/math.hh>
    1818#include <nv/stl/iterator.hh>
     19#include <nv/stl/utility/enumerator.hh>
    1920#include <nv/stl/type_traits/transforms.hh>
    2021
    … …  
    2627
    2728                template < typename T >
    28                 class forward_iterator_base : public iterator< input_iterator_tag, T >
    29                 {
    30                 public:
    31                         forward_iterator_base( T value ) : m_value( value ) {}
    32                         T operator* () const { return m_value; }
    33                         T const* operator-> () const { return &m_value; }
    34                         bool operator== ( const forward_iterator_base& rhs ) const
    35                         {
    36                                 return m_value == rhs.m_value;
    37                         }
    38                         bool operator!= ( const forward_iterator_base& rhs ) const
    39                         {
    40                                 return !( *this == rhs );
    41                         }
    42                 protected:
    43                         T m_value;
    44                 };
    45 
    46                 template < typename T >
    47                 class range_iterator_base : public forward_iterator_base< T >
    48                 {
    49                 public:
    50                         typedef forward_iterator_base< T > base_class;
    51 
    52                         range_iterator_base( T value ) : forward_iterator_base<T>( value ) {}
     29                class range_iterator_base : public value_enumerator_base< T >
     30                {
     31                public:
     32                        typedef value_enumerator_base< T > base_class;
     33
     34                        range_iterator_base( T value ) : value_enumerator_base<T>( value ) {}
    5335                        range_iterator_base& operator++ ()
    5436                        {
    … …  
    6648                template < typename T >
    6749                class range2d_iterator_base
    68                         : public forward_iterator_base< math::tvec2<T> >
    69                 {
    70                 public:
    71                         typedef forward_iterator_base< math::tvec2<T> > base_class;
     50                        : public value_enumerator_base< math::tvec2<T> >
     51                {
     52                public:
     53                        typedef value_enumerator_base< math::tvec2<T> > base_class;
    7254
    7355                        range2d_iterator_base( math::tvec2<T> value, T min, T max )
    74                                 : forward_iterator_base< math::tvec2<T> >( value ), m_min(min), m_max(max) {}
     56                                : base_class( value ), m_min(min), m_max(max) {}
    7557                        range2d_iterator_base& operator++ ()
    7658                        {
    … …  
    9577
    9678                template < typename T >
    97                 class bits_iterator_base : public forward_iterator_base< T >
     79                class bits_iterator_base : public value_enumerator_base< T >
    9880                {
    9981                public:
    10082                        typedef make_underlying_type_t< T > base_type;
    101                         typedef forward_iterator_base< T > base_class;
     83                        typedef value_enumerator_base< T > base_class;
    10284
    10385                        static const T invalid = T( 0 );
    … …  
    136118
    137119        template < typename T >
    138         class range_iterator_provider
     120        using range_iterator_provider = enumerator_provider<
     121                detail::range_iterator_base<T> >;
     122
     123        template < typename T >
     124        class range2d_iterator_provider
    139125        {
    140126        public:
    141                 class iterator : public detail::range_iterator_base<T>
    142                 {
    143                 public:
    144                         iterator( T value ) : detail::range_iterator_base<T>(value) {}
    145                 };
    146 
    147                 range_iterator_provider( T begin, T end ) : m_begin( begin ), m_end( end ) {}
     127                typedef T value_type;
     128                typedef typename T::value_type element_type;
     129
     130                class iterator : public detail::range2d_iterator_base<element_type>
     131                {
     132                public:
     133                        iterator( value_type begin, element_type min, element_type max )
     134                                : detail::range2d_iterator_base<element_type>(begin, min, max) {}
     135                };
     136
     137                range2d_iterator_provider( value_type begin, value_type end ) : m_begin( begin, begin.x, end.x ), m_end( T(begin.x, ++end.y ), begin.x, end.x ) {}
    148138                iterator begin() { return m_begin; }
    149139                iterator end() { return m_end; }
    … …  
    155145
    156146        template < typename T >
    157         class range2d_iterator_provider
    158         {
    159         public:
    160                 typedef T value_type;
    161                 typedef typename T::value_type element_type;
    162 
    163                 class iterator : public detail::range2d_iterator_base<element_type>
    164                 {
    165                 public:
    166                         iterator( value_type begin, element_type min, element_type max )
    167                                 : detail::range2d_iterator_base<element_type>(begin, min, max) {}
    168                 };
    169 
    170                 range2d_iterator_provider( value_type begin, value_type end ) : m_begin( begin, begin.x, end.x ), m_end( T(begin.x, ++end.y ), begin.x, end.x ) {}
    171                 iterator begin() { return m_begin; }
    172                 iterator end() { return m_end; }
    173 
    174         protected:
    175                 iterator m_begin;
    176                 iterator m_end;
    177         };
    178 
    179         template < typename T >
    180147        class bits_iterator_provider
    181148        {
Note: See TracChangeset for help on using the changeset viewer.