Changeset 347

Timestamp:

01/03/15 20:28:18 (10 years ago)

Author:

epyon

Message:

• entity_store was a misnomer -> handle_store
• index_store had two functions, and entity_store double functionality: handle_manager added for pure handle management without index handle_manager+packed_index_array is handle_store (old entity_store) removed old entity_store and index_store

Location:

trunk/nv

Files:

• core/common.hh (modified) (1 diff)
• core/handle.hh (modified) (10 diffs)
• engine/particle_engine.hh (modified) (1 diff)
• fmod/fmod_audio.hh (modified) (1 diff)
• gl/gl_context.hh (modified) (1 diff)
• gl/gl_device.hh (modified) (1 diff)
• gui/gui_environment.hh (modified) (1 diff)
• sdl/sdl_audio.hh (modified) (1 diff)

trunk/nv/core/common.hh

@@ -196 +196 @@
         {
         protected:
-//              noncopyable() = default;
-//              ~noncopyable() = default;
-//              noncopyable( const noncopyable& ) = delete;
-//              noncopyable& operator=( const noncopyable& ) = delete;
-                noncopyable() {}
-                ~noncopyable() {}
-        private:
-                noncopyable( const noncopyable& );
-                noncopyable& operator=( const noncopyable& );
+                noncopyable() = default;
+                ~noncopyable() = default;
+                noncopyable( const noncopyable& ) = delete;
+                noncopyable& operator=( const noncopyable& ) = delete;
         };
 

trunk/nv/core/handle.hh

@@ -67 +67 @@
         };
 
-
-        template < typename HANDLE, typename TINDEX = sint32 >
-        class index_store
-        {
-        public:
+        template < typename HANDLE >
+        class handle_manager
+        {
+                static const sint32 NONE = -1;
+                static const sint32 USED = -2;
+        public:
+
                 typedef HANDLE handle;
-                typedef TINDEX index_type;
                 typedef typename HANDLE::value_type value_type;
 
-                index_store() : m_first_free(-1), m_last_free(-1) {}
-
-                handle create_handle( index_type index )
-                {
-                        typedef handle_operator<HANDLE> hop; 
-                        value_type i       = get_free_entry();
-                        m_entries[i].index = index;
+                handle_manager() : m_first_free( NONE ), m_last_free( NONE ) {}
+
+                handle create_handle()
+                {
+                        typedef handle_operator<HANDLE> hop;
+                        value_type i = get_free_entry();
                         m_entries[i].counter++;
+                        m_entries[i].next_free = USED;
                         return hop::create( i, m_entries[i].counter );
                 }
@@ -89 +90 @@
                 void free_handle( handle h )
                 {
-                        m_entries[ h.index() ].index     = -1;
-                        m_entries[ h.index() ].next_free = -1;
+                        m_entries[h.index()].next_free = NONE;
                         if ( m_last_free == -1 )
                         {
@@ -96 +96 @@
                                 return;
                         }
-                        m_entries[ (unsigned)m_last_free ].next_free = h.index();
+                        m_entries[(unsigned)m_last_free].next_free = h.index();
                         m_last_free = h.index();
                 }
 
-                void swap_indices( handle h1, handle h2 )
-                {
-                        std::swap( m_entries[ h1.index() ].index, m_entries[ h2.index() ].index );
-                }
-
                 bool is_valid( handle h ) const
                 {
-                        typedef handle_operator<HANDLE> hop; 
+                        typedef handle_operator<HANDLE> hop;
                         if ( h.is_nil() ) return false;
                         if ( h.index() >= m_entries.size() ) return false;
-                        const index_entry& entry = m_entries[ h.index() ];
-                        return entry.index >= 0 && entry.counter == hop::get_counter(h);
-                }
-
-                sint32 get_index( handle h ) const
-                {
-                        typedef handle_operator<HANDLE> hop; 
-                        return m_entries[ h.index() ].counter == hop::get_counter(h) ? m_entries[ h.index() ].index : -1;
-                }
+                        const index_entry& entry = m_entries[h.index()];
+                        return entry.next_free == USED && entry.counter == hop::get_counter( h );
+                }
+
         private:
                 struct index_entry
                 {
-                        index_type index;
                         value_type counter;
-                        index_type next_free;
-
-                        index_entry() : index(0), counter(0), next_free(-1) {}
+                        sint32     next_free;
+
+                        index_entry() : counter( 0 ), next_free( NONE ) {}
                 };
 
@@ -135 +124 @@
                                 value_type result = (value_type)m_first_free;
                                 m_first_free = m_entries[result].next_free;
-                                m_entries[result].next_free = -1;
+                                m_entries[result].next_free = USED;
                                 if ( m_first_free == -1 ) m_last_free = -1;
                                 return result;
@@ -143 +132 @@
                 }
 
-                index_type m_first_free;
-                index_type m_last_free;
+                sint32 m_first_free;
+                sint32 m_last_free;
                 std::vector< index_entry > m_entries;
         };
@@ -188 +177 @@
                         index_type i = m_indexes[ h.index() ];
                         return i >= 0 ? &(m_data[ (unsigned)i ]) : nullptr;
+                }
+
+                const T* get( handle h ) const
+                {
+                        if ( h.is_nil() || h.index() >= m_indexes.size() ) return nullptr;
+                        index_type i = m_indexes[h.index()];
+                        return i >= 0 ? &( m_data[(unsigned)i] ) : nullptr;
                 }
 
@@ -214 +210 @@
                 }
 
+                handle get_handle( index_type i ) const { return m_handles[(unsigned)i]; }
+
                 const value_type& operator[] ( index_type i ) const { return m_data[i]; }
                 value_type& operator[] ( index_type i ) { return m_data[i]; }
@@ -245 +243 @@
 
         template < typename T, typename HANDLE = handle<>, typename TINDEX = sint32 >
-        class entity_store
+        class handle_store
         {
         public:
@@ -257 +255 @@
                 typedef typename storage::const_reference const_reference;
 
-                entity_store() {}
-
-                explicit entity_store( uint32 reserve )
-                {
-                        m_handles.reserve( reserve );
+                handle_store() {}
+
+                explicit handle_store( uint32 reserve )
+                {
                         m_data.reserve( reserve );
                 }
@@ -267 +264 @@
                 handle create()
                 {
-                        m_data.emplace_back();
-                        m_handles.push_back( m_indexes.create_handle( sint32( m_data.size() - 1 ) ) );
-                        return m_handles.back();
+                        handle h = m_indexes.create_handle();
+                        m_data.insert( h );
+                        return h;
                 }
 
                 bool is_valid( handle h )
                 {
-                        return m_indexes.is_valid(h);
+                        return m_indexes.is_valid( h );
                 }
 
                 const value_type* get( handle h ) const
                 {
-                        if ( h.is_nil() ) return nullptr;
-                        sint32 eindex = m_indexes.get_index( h );
-                        return eindex >= 0 ? &(m_data[ (unsigned)eindex ]) : nullptr;
+                        return m_data.get( h );
                 }
 
                 value_type* get( handle h )
                 {
-                        if ( h.is_nil() ) return nullptr;
-                        sint32 eindex = m_indexes.get_index( h );
-                        return eindex >= 0 ? &(m_data[ (unsigned)eindex ]) : nullptr;
+                        return m_data.get( h );
                 }
 
                 void destroy( handle e )
                 {
-                        handle swap_handle    = m_handles.back();
-                        sint32 dead_eindex    = m_indexes.get_index( e );
-                        if ( dead_eindex != (sint32)m_data.size()-1 )
-                        {
-                                m_data[ (unsigned)dead_eindex ]    = m_data.back();
-                                m_handles[ (unsigned)dead_eindex ] = m_handles.back();
-                        }
-                        m_data.pop_back();
-                        m_handles.pop_back();
-                        m_indexes.swap_indices( e, swap_handle );
+                        m_data.remove( e );
                         m_indexes.free_handle( e );
                 }
 
-                handle get_handle( index_type i ) const { return m_handles[(unsigned)i]; }
+                handle get_handle( index_type i ) const { return m_data.get_handle(i); }
                 const value_type& operator[] ( index_type i ) const { return m_data[(unsigned)i]; }
                 value_type& operator[] ( index_type i ) { return m_data[(unsigned)i]; }
                 size_t size() const { return m_data.size(); }
 
-                iterator        begin()        { return m_data.begin(); }
+                iterator        begin() { return m_data.begin(); }
                 const_iterator  begin()  const { return m_data.cbegin(); }
                 const_iterator  cbegin() const { return m_data.cbegin(); }
 
-                iterator        end()        { return m_data.end(); }
+                iterator        end() { return m_data.end(); }
                 const_iterator  end()  const { return m_data.cend(); }
                 const_iterator  cend() const { return m_data.cend(); }
 
         private:
-                std::vector< handle >         m_handles;
-                storage                       m_data;
-                index_store< handle, TINDEX > m_indexes;
-        };
-
+                packed_indexed_array< T, handle, TINDEX > m_data;
+                handle_manager< handle >                  m_indexes;
+        };
+        
 }
 

trunk/nv/engine/particle_engine.hh

@@ -190 +190 @@
                 vec3     m_camera_pos;
 
-                entity_store< particle_system_info, particle_system >      m_systems;
+                handle_store< particle_system_info, particle_system >      m_systems;
                 std::unordered_map< std::string, uint32 >                  m_names;
                 std::vector< particle_system_data >                        m_data; 

trunk/nv/fmod/fmod_audio.hh

@@ -40 +40 @@
                         virtual ~audio();
                 private:
-                        entity_store< sound_info, sound >     m_sounds;
+                        handle_store< sound_info, sound >     m_sounds;
                         vec3                                  m_position;
                         void* m_system;

trunk/nv/gl/gl_context.hh

@@ -92 +92 @@
                 void* m_handle;
 
-                entity_store< vertex_array_info, vertex_array >  m_vertex_arrays;
-                entity_store< gl_framebuffer_info, framebuffer > m_framebuffers;
+                handle_store< vertex_array_info, vertex_array >  m_vertex_arrays;
+                handle_store< gl_framebuffer_info, framebuffer > m_framebuffers;
         };
 

trunk/nv/gl/gl_device.hh

@@ -67 +67 @@
                 bool compile( uint32 sh_type, const std::string& shader_code, unsigned& glid );
                 std::string m_shader_header;
-                entity_store< gl_texture_info, texture >         m_textures;
-                entity_store< gl_buffer_info,  buffer >          m_buffers;
-                entity_store< gl_program_info, program >         m_programs;
+                handle_store< gl_texture_info, texture >         m_textures;
+                handle_store< gl_buffer_info,  buffer >          m_buffers;
+                handle_store< gl_program_info, program >         m_programs;
         };
 

trunk/nv/gui/gui_environment.hh

@@ -58 +58 @@
                         void recalculate_absolute( handle e );
                         
-                        entity_store< element, handle > m_elements;
+                        handle_store< element, handle > m_elements;
                         renderer*     m_renderer;
                         window*       m_window;

trunk/nv/sdl/sdl_audio.hh

@@ -41 +41 @@
                         vec3                                  m_forward;
                         vec3                                  m_up;
-                        entity_store< sound_info, sound >     m_sounds;
+                        handle_store< sound_info, sound >     m_sounds;
                 };
         }