Changeset 543


Ignore:
Timestamp:
02/06/17 21:13:58 (8 years ago)
Author:
epyon
Message:
  • fixes in handle store
  • removal of get_handle
  • indices instead of handles
  • efficient handle store clears
Location:
trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/ecs/component.hh

    r542 r543  
    136136                        }
    137137
     138                        void remove_by_index( index_type i )
     139                        {
     140                                if ( i > size() ) return;
     141                                destroy( &m_data[i] );
     142                                index_type dead_eindex = m_index.remove_swap_by_index( i );
     143                                if ( dead_eindex == -1 ) return;
     144                                if ( dead_eindex != static_cast<index_type>( m_data.size() - 1 ) )
     145                                {
     146                                        m_data[unsigned( dead_eindex )] = move( m_data.back() );
     147                                }
     148                                m_data.pop_back();
     149                        }
     150
     151                        template < typename F >
     152                        void remove_if( F f )
     153                        {
     154                                uint32 i = 0;
     155                                while ( i < size() )
     156                                {
     157                                        auto& md = m_data[i];
     158                                        if ( f( md ) )
     159                                                remove_by_index( i );
     160                                        else
     161                                                ++i;
     162                                }
     163                        }
     164
    138165                        virtual void destroy( value_type* )
    139166                        {
    … …  
    146173                        }
    147174                       
    148                         inline handle_type _get_handle( index_type i ) const { return m_index.get_handle( i ); }
    149 
    150175                        inline const value_type& operator[] ( index_type i ) const { return m_data[i]; }
    151176                        inline value_type& operator[] ( index_type i ) { return m_data[i]; }
    … …  
    159184                        inline const_iterator  end()  const { return m_data.end(); }
    160185
    161                         //inline virtual component_storage* storage() { return &m_data; }
     186                        inline virtual component_storage* storage() { return &m_data; }
    162187                protected:
    163188                        ecs_type&        m_ecs;

  • trunk/nv/ecs/component_storage.hh

    r542 r543  
    156156                        return ( component_storage_handler< Component >* )storage;
    157157                }
    158 
     158                /*
    159159                template < typename Handle, typename Component >
    160160                class index_storage
    … …  
    237237
    238238                        }
    239 
    240                         inline handle_type get_handle( index_type i ) const { return m_handles[unsigned( i )]; }
    241239
    242240                        inline const value_type& operator[] ( index_type i ) const { return m_data[i]; }
    … …  
    428426
    429427                class direct_storage;
    430                 /*
     428               
    431429                template < typename Handle, typename Component >
    432430                class hash_storage

  • trunk/nv/ecs/ecs.hh

    r542 r543  
    3636        namespace ecs
    3737        {
     38
     39                namespace detail
     40                {
     41                        template<typename, typename T>
     42                        struct has_update
     43                        {
     44                                static_assert( nv::integral_constant<T, false>::value, "Second template parameter needs to be of function type." );
     45                        };
     46
     47                        template< typename C, typename Ret, typename... Args >
     48                        struct has_update<C, Ret( Args... )>
     49                        {
     50                        private:
     51                                template<typename T>
     52                                static constexpr auto check( T* )
     53                                        -> typename nv::is_same< decltype( nv::declval<T>().update( nv::declval<Args>()... ) ), Ret >::type;
     54
     55                                template<typename>
     56                                static constexpr nv::false_type check( ... );
     57
     58                                typedef decltype( check<C>( 0 ) ) type;
     59
     60                        public:
     61                                static constexpr bool value = type::value;
     62                        };
     63                }
     64
     65                template < typename E, typename S, typename T >
     66                using has_ecs_update = detail::has_update<S, void( E&, T ) >;
     67
     68                template < typename S, typename C, typename T >
     69                using has_component_update = detail::has_update<S, void( C&, T ) >;
     70
     71                template < typename E, typename S, typename C, typename T >
     72                using has_ecs_component_update = detail::has_update<S, void( E&, C&, T ) >;
     73
    3874                template < typename S, typename C, typename M >
    3975                using has_component_message = detail::has_message<S, void( const M&, C& ) >;
    … …  
    4480                template < typename E, typename S, typename M >
    4581                using has_ecs_message = detail::has_message<S, void( const M&, E& ) >;
    46 
    4782
    4883                template < typename Handle, typename MessageList, typename Time = f32 >
    … …  
    5792                        using base_type::message;
    5893
    59 
     94                        using update_handler = function< void( time_type ) >;
    6095
    6196                        class component_interface
    … …  
    68103                                virtual void* get_raw( handle_type h ) = 0;
    69104                                virtual const void* get_raw( handle_type h ) const = 0;
    70 //                              virtual component_storage* storage() = 0;
     105                                virtual component_storage* storage() = 0;
    71106                        };
    72107
    … …  
    81116                                        return *this;
    82117                                }
    83 //                              enumerator operator++ ( int )
    84 //                              {
    85 //                                      auto result = *this;
    86 //                                      base_class::m_value = m_ecs.next( base_class::m_value );
    87 //                                      return result;
    88 //                              }
    89118                        private:
    90119                                const ecs& m_ecs;
    … …  
    115144                                }
    116145                                Component& operator* () { return *m_component; }
    117                                 Component* operator-> () { return &m_component; }
    118146                                const Component& operator* () const { return *m_component; }
    119                                 const Component* operator-> () const { return &m_component; }
    120147                                bool operator== ( const component_enumerator& rhs ) const
    121148                                {
    … …  
    149176                                register_handler< Handler >( name, (Handler*)c );
    150177                                register_component_messages< Handler, Component >( (Handler*)( c ), message_list{} );
     178                                register_ecs_component_update< Handler, Component >( (Handler*)( c ) );
     179                                register_component_update< Handler, Component >( (Handler*)( c ) );
     180                                register_ecs_update< Handler >( (Handler*)( c ) );
    151181//                              auto s = c->storage();
    152182//                              m_cstorage.push_back( s );
    … …  
    165195                                for ( auto c : m_components )
    166196                                        c->update( dtime );
     197                                for ( auto u : m_update_handlers )
     198                                        u( dtime );
    167199                        }
    168200
    … …  
    294326                        void register_component_messages( System* h, List<Messages...>&& )
    295327                        {
    296                                 int unused_0[] = { ( register_component_message<System,Components,Messages>( h ), 0 )... };
    297                                 int unused_1[] = { ( register_ecs_component_message<System,Components,Messages>( h ), 0 )... };
     328                                int unused_0[] = { ( register_ecs_component_message<System,Components,Messages>( h ), 0 )... };
     329                                int unused_1[] = { ( register_component_message<System,Components,Messages>( h ), 0 )... };
    298330                                int unused_2[] = { ( register_ecs_message<System,Messages>( h ), 0 )... };
    299331                        }
    … …  
    349381                        register_ecs_message( System* ) {}
    350382
    351 
     383                        template < typename System >
     384                        typename enable_if< has_ecs_update< this_type, System, time_type >::value, void >::type
     385                        register_ecs_update( System* s )
     386                        {
     387                                register_update( [=] ( time_type dtime )
     388                                {
     389                                        s->update( *this, dtime );
     390                                } );
     391                        }
     392
     393                        template < typename System, typename Components >
     394                        typename enable_if< has_component_update< System, Components, time_type >::value, void >::type
     395                        register_component_update( System* s )
     396                        {
     397                                component_interface* ci = get_interface<Components>();
     398                                component_storage_handler<Components>* storage = storage_cast<Components>( ci->storage() );
     399                                register_update( [=] ( time_type dtime )
     400                                {
     401                                        for ( auto& c : *storage )
     402                                                s->update( c, dtime );
     403                                } );
     404                        }
     405
     406                        template < typename System, typename Components >
     407                        typename enable_if< has_ecs_component_update< this_type, System, Components, time_type >::value, void >::type
     408                        register_ecs_component_update( System* s )
     409                        {
     410                                component_interface* ci = get_interface<Components>();
     411                                component_storage_handler<Components>* storage = storage_cast<Components>( ci->storage() );
     412                                register_update( [=] ( time_type dtime )
     413                                {
     414                                        for ( auto& c : *storage )
     415                                                s->update( *this, c, dtime );
     416                                } );
     417                        }
     418
     419
     420                        template < typename System >
     421                        typename enable_if< !has_ecs_update< this_type, System, time_type >::value, void >::type
     422                        register_ecs_update( System* ) {}
     423
     424                        template < typename System, typename Components >
     425                        typename enable_if< !has_component_message< System, Components, time_type >::value, void >::type
     426                        register_component_update( System* ) {}
     427
     428                        template < typename System, typename Components >
     429                        typename enable_if< !has_ecs_component_update< this_type, System, Components, time_type >::value, void >::type
     430                        register_ecs_component_update( System* ) {}
     431
     432                        void register_update( update_handler&& handler )
     433                        {
     434                                m_update_handlers.push_back( handler );
     435                        }
    352436
    353437                        handle_tree_manager< handle_type >          m_handles;
    … …  
    355439                        hash_store< thash64, component_interface* > m_component_map;
    356440                        hash_store< shash64, component_interface* > m_component_map_by_name;
     441                        vector< update_handler >                    m_update_handlers;
     442
    357443//                      vector< component_storage* >                m_cstorage;
    358444//                      hash_store< thash64, component_storage* >   m_cmap;

  • trunk/nv/engine/particle_engine.hh

    r522 r543  
    149149                ~particle_engine();
    150150        private:
     151                void release( particle_system_info* system );
    151152                void clear();
    152153                void register_standard_emitters();

  • trunk/nv/engine/particle_group.hh

    r530 r543  
    113113                bool unref( particle_group group );
    114114        protected:
     115                void release( particle_group_info* group );
    115116                void clear();
    116117

  • trunk/nv/fmod/fmod_audio.hh

    r530 r543  
    4242                        virtual ~audio();
    4343                private:
     44                        void release( sound_info* info );
     45
    4446                        handle_store< sound_info, sound >     m_sounds;
    4547                        vec3                                  m_position;

  • trunk/nv/gl/gl_context.hh

    r535 r543  
    9090
    9191        protected:
     92                void release( gl_vertex_array_info* va );
     93                void release( gl_framebuffer_info* f );
     94
    9295                void bind( program p );
    9396                void bind( vertex_array va );

  • trunk/nv/gl/gl_device.hh

    r530 r543  
    7373                virtual ~gl_device();
    7474        protected:
     75
     76                void release( gl_buffer_info* b );
     77                void release( gl_texture_info* t );
     78                void release( gl_program_info* p );
     79                void release( gl_shader_info* s );
     80
    7581                gl_texture_info* get_full_texture_info( texture t );
    7682                gl_buffer_info* get_full_buffer_info( buffer t );

  • trunk/nv/sdl/sdl_audio.hh

    r530 r543  
    4040                        virtual ~audio();
    4141                private:
     42                        void release( sound_info* info );
     43
    4244                        vec3                                  m_position;
    4345                        vec3                                  m_forward;

  • trunk/nv/stl/handle_store.hh

    r530 r543  
    8484                }
    8585
    86                 handle_type get_handle( index_type i ) const { return m_index.get_handle( i ); }
    87 
    8886                const value_type& operator[] ( index_type i ) const { return m_data[i]; }
    8987                value_type& operator[] ( index_type i ) { return m_data[i]; }
    … …  
    116114                typedef typename storage::const_reference const_reference;
    117115
     116                static const index_type INVALID = index_type( -1 );
     117
    118118                unpacked_indexed_array() {}
    119119                unpacked_indexed_array( uint32 reserve )
    120120                {
    121121                        m_data.reserve( reserve );
     122                        m_indices.reserve( reserve );
    122123                }
    123124
    … …  
    126127                        NV_ASSERT( !exists( h ), "Reinserting handle!" );
    127128                        resize_to( index_type( h.index() ) );
    128                         m_handles[h.index()] = h;
     129                        m_indices[h.index()] = h.index();
    129130                        return &( m_data[h.index()] );
    130131                }
    … …  
    133134                {
    134135                        if ( h.is_nil() || h.index() >= m_data.size() ) return false;
    135                         return m_handles[h.index()].is_valid();
     136                        return m_indices[h.index()] != INVALID;
    136137                }
    137138
    … …  
    152153                void remove( handle h )
    153154                {
    154                         m_handles[h.index()] = handle();
     155                        m_indices[h.index()] = INVALID;
    155156                }
    156157
    … …  
    158159                {
    159160                        m_data.clear();
    160                         m_handles.clear();
    161                 }
    162 
    163                 handle get_handle( index_type i ) const { return m_handles[unsigned( i )]; }
     161                        m_indices.clear();
     162                }
    164163
    165164                const value_type& operator[] ( index_type i ) const { return m_data[i]; }
    … …  
    178177                void resize_to( index_type i )
    179178                {
    180                         index_type size = index_type( m_handles.size() );
     179                        index_type size = index_type( m_indices.size() );
    181180                        if ( i >= size )
    182181                        {
    … …  
    184183                                while ( i >= size ) size = size * 2;
    185184                                m_data.resize( static_cast<size_t>( size ) );
    186                                 m_handles.resize( static_cast<size_t>( size ) );
     185                                m_indices.resize( static_cast<size_t>( size ), INVALID );
    187186                        }
    188187                }
    189188
    190189                vector< T >          m_data;
    191                 vector< handle >     m_handles;
     190                vector< index_type > m_indices;
    192191        };
    193192
    … …  
    241240                }
    242241
    243                 handle get_handle( index_type i ) const { return m_data.get_handle( i ); }
     242                void clear()
     243                {
     244                        m_data.clear();
     245                        m_indexes.clear();
     246                }
     247
    244248                const value_type& operator[] ( index_type i ) const { return m_data[unsigned( i )]; }
    245249                value_type& operator[] ( index_type i ) { return m_data[unsigned( i )]; }

  • trunk/nv/stl/index_table.hh

    r542 r543  
    2525                typename Index = sint32
    2626        >
    27                 class index_table
     27        class index_table
    2828        {
    2929        public:
    … …  
    4343                        index_type lindex = m_handles.size();
    4444                        m_indexes[h.index()] = index_type( lindex );
    45                         m_handles.push_back( h );
     45                        m_handles.push_back( h.index() );
    4646                        return lindex;
    4747                }
    … …  
    6363                        if ( h.is_nil() || h.index() >= m_indexes.size() || m_indexes[h.index()] == -1 )
    6464                                return -1;
    65                         handle_type swap_handle = m_handles.back();
    66                         index_type  dead_eindex = m_indexes[h.index()];
    67                         if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
    68                         {
    69                                 m_handles[unsigned( dead_eindex )] = swap_handle;
    70                                 m_indexes[swap_handle.index()] = dead_eindex;
     65                        index_type swap_handle = m_handles.back();
     66                        index_type dead_eindex = m_indexes[h.index()];
     67                        if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
     68                        {
     69                                m_handles[unsigned( dead_eindex )] = swap_handle;
     70                                m_indexes[swap_handle] = dead_eindex;
    7171                        }
    7272                        m_handles.pop_back();
    … …  
    7575                }
    7676
    77 //              index_type remove_swap( index_type dead_eindex )
    78 //              {
    79 //                      if ( uint32( dead_eindex ) >= m_handles.size() ) return -1;
    80 //                      handle_type h = m_handles[dead_eindex];
    81 //                      handle_type swap_handle = m_handles.back();
    82 //                      if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
    83 //                      {
    84 //                              m_handles[unsigned( dead_eindex )] = swap_handle;
    85 //                              m_indexes[swap_handle.index()] = dead_eindex;
    86 //                      }
    87 //                      m_handles.pop_back();
    88 //                      m_indexes[h.index()] = -1;
    89 //                      return dead_eindex;
    90 //              }
     77                index_type remove_swap_by_index( index_type dead_eindex )
     78                {
     79                        if ( uint32( dead_eindex ) >= m_handles.size() ) return -1;
     80                        index_type h = m_handles[dead_eindex];
     81                        index_type swap_handle = m_handles.back();
     82                        if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
     83                        {
     84                                m_handles[unsigned( dead_eindex )] = swap_handle;
     85                                m_indexes[swap_handle] = dead_eindex;
     86                        }
     87                        m_handles.pop_back();
     88                        m_indexes[h] = -1;
     89                        return dead_eindex;
     90                }
    9191
    9292
    … …  
    9696                        m_indexes.clear();
    9797                }
    98 
    99                 handle_type get_handle( index_type i ) const { return m_handles[unsigned( i )]; }
    10098
    10199                uint32 size() const { return m_handles.size(); }
    … …  
    113111                }
    114112
    115                 vector< handle_type > m_handles;
    116                 vector< index_type >  m_indexes;
     113                vector< index_type > m_handles;
     114                vector< index_type > m_indexes;
    117115        };
    118116
    … …  
    135133                index_type insert( handle_type h )
    136134                {
    137                         NV_ASSERT( m_indexes.find( h ) == m_indexes.end(), "Reinserting handle!" );
     135                        NV_ASSERT( m_indexes.find( h.index() ) == m_indexes.end(), "Reinserting handle!" );
    138136                        index_type lindex = m_handles.size();
    139                         m_indexes[h] = index_type( lindex );
    140                         m_handles.push_back( h );
     137                        m_indexes[h.index()] = index_type( lindex );
     138                        m_handles.push_back( h.index() );
    141139                        return lindex;
    142140                }
    … …  
    144142                bool exists( handle_type h ) const
    145143                {
    146                         auto ih = m_indexes.find( h );
     144                        auto ih = m_indexes.find( h.index() );
    147145                        return ( ih != m_indexes.end() );
    148146                }
    … …  
    150148                index_type get( handle_type h ) const
    151149                {
    152                         auto ih = m_indexes.find( h );
     150                        auto ih = m_indexes.find( h.index() );
    153151                        if ( ih == m_indexes.end() ) return -1;
    154152                        return ih->second;
    … …  
    158156                {
    159157                        if ( h.is_nil() ) return -1;
    160                         auto ih = m_indexes.find( h );
     158                        auto ih = m_indexes.find( h.index() );
    161159                        if ( ih == m_indexes.end() || ih->second == index_type(-1) ) return -1;
    162                         handle_type swap_handle = m_handles.back();
    163                         index_type  dead_eindex = ih->second;
     160                        index_type swap_handle = m_handles.back();
     161                        index_type dead_eindex = ih->second;
     162                        if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
     163                        {
     164                                m_handles[unsigned( dead_eindex )] = swap_handle;
     165                                m_indexes[swap_handle] = dead_eindex;
     166                        }
     167                        m_handles.pop_back();
     168                        m_indexes.erase( h.index() );
     169                        return dead_eindex;
     170                }
     171
     172                index_type remove_swap( index_type dead_eindex )
     173                {
     174                        if ( uint32( dead_eindex ) >= m_handles.size() ) return -1;
     175                        index_type h = m_handles[dead_eindex];
     176                        index_type swap_handle = m_handles.back();
    164177                        if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
    165178                        {
    … …  
    171184                        return dead_eindex;
    172185                }
    173 
    174 //              index_type remove_swap( index_type dead_eindex )
    175 //              {
    176 //                      if ( uint32( dead_eindex ) >= m_handles.size() ) return -1;
    177 //                      handle_type h = m_handles[dead_eindex];
    178 //                      handle_type swap_handle = m_handles.back();
    179 //                      if ( dead_eindex != static_cast<index_type>( m_handles.size() - 1 ) )
    180 //                      {
    181 //                              m_handles[unsigned( dead_eindex )] = swap_handle;
    182 //                              m_indexes[swap_handle] = dead_eindex;
    183 //                      }
    184 //                      m_handles.pop_back();
    185 //                      m_indexes.erase( h );
    186 //                      return dead_eindex;
    187 //              }
    188186
    189187
    … …  
    194192                }
    195193
    196                 handle_type get_handle( index_type i ) const { return m_handles[unsigned( i )]; }
    197 
    198194                uint32 size() const { return m_handles.size(); }
    199195
    200196        private:
    201197
    202                 vector< handle_type > m_handles;
    203                 hash_map< handle_type, index_type > m_indexes;
     198                vector< index_type > m_handles;
     199                hash_map< index_type, index_type > m_indexes;
    204200        };
    205201
     202
    206203}
    207204

  • trunk/src/engine/particle_engine.cc

    r534 r543  
    350350}
    351351
     352void nv::particle_engine::release( particle_system_info* info )
     353{
     354        if ( info )
     355        {
     356                m_pgm->unref( info->group );
     357                delete[] info->particles;
     358        }
     359}
     360
    352361void nv::particle_engine::clear()
    353362{
    354         while ( m_systems.size() > 0 )
    355                 release( m_systems.get_handle( 0 ) );
     363        for ( auto& s : m_systems )
     364                release( &s );
     365        m_systems.clear();
    356366        if ( m_pgm )
    357367                m_pgm->reset();
    … …  
    363373void nv::particle_engine::release( particle_system system )
    364374{
    365         particle_system_info* info = m_systems.get( system );
    366         if ( info )
    367         {
    368                 m_pgm->unref( info->group );
    369                 delete[] info->particles;
     375        if ( particle_system_info* info = m_systems.get( system ) )
     376        {
     377                release( info );
    370378                m_systems.destroy( system );
    371379        }

  • trunk/src/engine/particle_group.cc

    r520 r543  
    3333void particle_group_manager::release( particle_group group )
    3434{
    35         particle_group_info* info = m_groups.get( group );
    36         if ( info )
    37         {
    38                 delete[] info->quads;
    39                 m_context->release( info->vtx_array );
     35        if ( particle_group_info* info = m_groups.get( group ) )
     36        {
     37                release( info );
    4038                m_groups.destroy( group );
    4139        }
    … …  
    194192}
    195193
     194void nv::particle_group_manager::release( particle_group_info* info )
     195{
     196        if ( info )
     197        {
     198                delete[] info->quads;
     199                m_context->release( info->vtx_array );
     200        }
     201}
     202
    196203particle_group_manager::~particle_group_manager()
    197204{
    … …  
    201208void particle_group_manager::clear()
    202209{
    203         while ( m_groups.size() > 0 )
    204                 release( m_groups.get_handle( 0 ) );
     210        for ( auto& g : m_groups )
     211                release( &g );
     212        m_groups.clear();
    205213}
    206214

  • trunk/src/fmod/fmod_audio.cc

    r406 r543  
    107107{
    108108        sound_info* info = m_sounds.get( a_sound );
     109        release( info );
     110        m_sounds.destroy( a_sound );
     111}
     112
     113void nv::fmod::audio::release( sound_info* info )
     114{
    109115        if ( info )
    110         {
    111116                FMOD_Sound_Release( static_cast<FMOD_SOUND*>( info->fmod_sound ) );
    112                 m_sounds.destroy( a_sound );
    113         }
    114117}
    115118
    … …  
    146149fmod::audio::~audio()
    147150{
    148         while ( m_sounds.size() > 0 )
    149                 release( m_sounds.get_handle(0) );
     151        for ( auto& s : m_sounds )
     152                release( &s );
     153        m_sounds.clear();
    150154        FMOD_System_Release( static_cast<FMOD_SYSTEM*>( m_system ) );
    151155}

  • trunk/src/gl/gl_context.cc

    r535 r543  
    9797void nv::gl_context::release( vertex_array va )
    9898{
    99         gl_vertex_array_info* info = m_vertex_arrays.get( va );
     99        if ( gl_vertex_array_info* info = m_vertex_arrays.get( va ) )
     100        {
     101                release( info );
     102                m_vertex_arrays.destroy( va );
     103        }
     104}
     105
     106void nv::gl_context::release( gl_vertex_array_info* info )
     107{
    100108        if ( info )
    101109        {
    102110                for ( uint32 i = 0; i < info->count; ++i )
    103111                {
    104                         if ( info->attr[i].owner ) 
     112                        if ( info->attr[i].owner )
    105113                                release( info->attr[i].vbuffer );
    106114                }
    107                 if ( info->index.is_valid() && info->index_owner) release( info->index );
     115                if ( info->index.is_valid() && info->index_owner ) release( info->index );
    108116                glDeleteVertexArrays( 1, &info->glid );
    109                 m_vertex_arrays.destroy( va );
    110117        }
    111118}
    … …  
    113120void nv::gl_context::release( framebuffer f )
    114121{
    115         gl_framebuffer_info* info = m_framebuffers.get( f );
     122        if ( gl_framebuffer_info* info = m_framebuffers.get( f ) )
     123        {
     124                release( info );
     125                m_framebuffers.destroy( f );
     126        }
     127}
     128
     129void nv::gl_context::release( gl_framebuffer_info* info )
     130{
    116131        if ( info )
    117132        {
    … …  
    122137                        glDeleteRenderbuffers( 1, &info->depth_rb_glid );
    123138                glDeleteFramebuffers( 1, &info->glid );
    124                 m_framebuffers.destroy( f );
    125139        }
    126140}
    … …  
    881895nv::gl_context::~gl_context()
    882896{
    883         while ( m_framebuffers.size() > 0 )
    884                 release( m_framebuffers.get_handle(0) );
    885         while ( m_vertex_arrays.size() > 0 )
    886                 release( m_vertex_arrays.get_handle(0) );
     897        for ( auto& info : m_framebuffers )
     898                release( &info );
     899        for ( auto& info : m_vertex_arrays )
     900                release( &info );
    887901}
    888902

  • trunk/src/gl/gl_device.cc

    r535 r543  
    6969gl_device::~gl_device()
    7070{
    71         while ( m_textures.size() > 0 )
    72                 release( m_textures.get_handle(0) );
    73         while ( m_buffers.size() > 0 )
    74                 release( m_buffers.get_handle(0) );
    75         while ( m_programs.size() > 0 )
    76                 release( m_programs.get_handle(0) );
    77         while ( m_shaders.size() > 0 )
    78                 release( m_shaders.get_handle( 0 ) );
     71        for ( auto& t : m_textures )
     72                release( &t );
     73        for ( auto& b : m_buffers )
     74                release( &b );
     75        for ( auto& p : m_programs )
     76                release( &p );
     77        for ( auto& s : m_shaders )
     78                release( &s );
    7979}
    8080
    … …  
    131131void nv::gl_device::release( texture t )
    132132{
    133         gl_texture_info* info = m_textures.get( t );
    134         if ( info )
    135         {
    136                 if ( info->glid != 0 )
    137                 {
    138                         glDeleteTextures( 1, &(info->glid) );
    139                 }
     133        if ( auto info = m_textures.get( t ) )
     134        {
     135                release( info );
    140136                m_textures.destroy( t );
    141137        }
    142138}
    143139
     140void nv::gl_device::release( gl_shader_info* s )
     141{
     142        if ( s && s->ref == 0 && s->glid != 0 )
     143                glDeleteShader( s->glid );
     144}
     145
     146void nv::gl_device::release( gl_program_info* p )
     147{
     148        if ( p && p->glid != 0 )
     149        {
     150                for ( auto& i : *p->m_uniform_map )
     151                        delete i.second;
     152
     153                gl_shader_info* vi = m_shaders.get( p->vertex );
     154                gl_shader_info* fi = m_shaders.get( p->fragment );
     155                if ( vi )
     156                {
     157                        glDetachShader( p->glid, vi->glid );
     158                        vi->ref--;
     159                        release( vi );
     160                }
     161                if ( fi )
     162                {
     163                        glDetachShader( p->glid, fi->glid );
     164                        fi->ref--;
     165                        release( fi );
     166                }
     167                glDeleteProgram( p->glid );
     168
     169                delete p->m_attribute_map;
     170                delete p->m_engine_uniforms;
     171                delete p->m_uniform_map;
     172        }
     173
     174}
     175
     176void nv::gl_device::release( gl_texture_info* t )
     177{
     178        if ( t && t->glid != 0 )
     179                glDeleteTextures( 1, &( t->glid ) );
     180}
     181
     182void nv::gl_device::release( gl_buffer_info* b )
     183{
     184        if ( b && b->glid != 0 )
     185                glDeleteBuffers( 1, &( b->glid ) );
     186}
     187
    144188void nv::gl_device::release( buffer b )
    145189{
    146         gl_buffer_info* info = m_buffers.get( b );
    147         if ( info )
    148         {
    149                 if ( info->glid != 0 )
    150                 {
    151                         glDeleteBuffers( 1, &(info->glid) );
    152                 }
     190        if ( auto info = m_buffers.get( b ) )
     191        {
     192                release( info );
    153193                m_buffers.destroy( b );
    154194        }
    … …  
    204244void nv::gl_device::release( program p )
    205245{
    206         gl_program_info* info = m_programs.get( p );
    207         if ( info )
    208         {
    209                 for ( auto& i : *info->m_uniform_map )
    210                         delete i.second;
    211 
    212                 detach( p, info->vertex );
    213                 detach( p, info->fragment );
    214                 glDeleteProgram( info->glid );
    215 
    216                 delete info->m_attribute_map;
    217                 delete info->m_engine_uniforms;
    218                 delete info->m_uniform_map;
    219 
     246        if ( auto info = m_programs.get( p ) )
     247        {
     248                release( info );
    220249                m_programs.destroy( p );
    221250        }
    … …  
    224253void nv::gl_device::release( shader s )
    225254{
    226         gl_shader_info* info = m_shaders.get( s );
    227         if ( info && info->ref == 0 )
    228         {
    229                 glDeleteShader( info->glid );
     255        if ( auto info = m_shaders.get( s ) )
     256        {
     257                release( info );
    230258                m_shaders.destroy( s );
    231259        }

  • trunk/src/sdl/sdl_audio.cc

    r454 r543  
    111111nv::sdl::audio::~audio()
    112112{
    113         while ( m_sounds.size() > 0 )
    114                 release( m_sounds.get_handle(0) );
     113        for ( auto& s : m_sounds )
     114                release( &s );
    115115        Mix_CloseAudio();
    116116        // TODO: should we do it here?
    … …  
    121121{
    122122        sound_info* info = m_sounds.get( a_sound );
     123        release( info );
     124        m_sounds.destroy( a_sound );
     125}
     126
     127void nv::sdl::audio::release( sound_info* info )
     128{
    123129        if ( info )
    124         {
    125130                Mix_FreeChunk( static_cast<Mix_Chunk*>( info->sdl_sound ) );
    126                 m_sounds.destroy( a_sound );
    127         }
    128131}
    129132
Note: See TracChangeset for help on using the changeset viewer.