Changeset 118 for trunk


Ignore:
Timestamp:
06/12/13 04:01:20 (12 years ago)
Author:
epyon
Message:
  • cached_buffer - size caching, partial updates
  • cached_buffer - you can now freely change the size of locked vector, the cache will update accordingly
  • nv_cachebuf_test - added test for complexity change
Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/nv/gfx/cached_buffer.hh

    r106 r118  
    2626
    2727                buffer_slice( cache* c )
    28                         : m_cache( c ), m_offset( 0 ), m_locked( true )
     28                        : m_cache( c ), m_offset( 0 ), m_cached_size( 0 ), m_locked( true )
    2929                {
    3030                        m_cache->reset();
     
    3333                {
    3434                        m_cache->commit( this );
    35                         m_locked = false;
     35                        m_cached_size = m_data.size();
     36                        m_locked      = false;
    3637                }
    3738                vector& lock()
     
    5455                cache* m_cache;
    5556                size_t m_offset;
     57                size_t m_cached_size;
    5658                bool   m_locked;
    5759        };
     
    9092                        {
    9193                                const vector& bv = bslice->data();
    92                                 std::copy( bv.cbegin(), bv.cend(), m_data.begin() + bslice->m_offset );
    93                                 m_min = glm::min<int>( m_min, bslice->m_offset );
    94                                 m_max = glm::max<int>( m_max, bslice->m_offset + bv.size() );
     94                                if ( bslice->m_cached_size != bv.size() )
     95                                {
     96                                        m_data.erase( m_data.begin() + bslice->m_offset, m_data.end() );
     97                                        m_full_update = true;
     98                                        m_data.insert( m_data.end(), bv.cbegin(), bv.cend() );
     99                                        m_min = glm::min<int>( m_min, bslice->m_offset );
     100                                }
     101                                else
     102                                {
     103                                        std::copy( bv.cbegin(), bv.cend(), m_data.begin() + bslice->m_offset );
     104                                        m_min = glm::min<int>( m_min, bslice->m_offset );
     105                                        m_max = glm::max<int>( m_max, bslice->m_offset + bv.size() );
     106                                }
    95107                        }
    96108                }
     
    121133                        if ( m_full_update )
    122134                        {
    123                                 m_buffer->update( m_data.data(), 0, m_data.size() * value_type_size );
     135                                if ( m_min > 0 )
     136                                {
     137                                        int offset = m_min * value_type_size;
     138                                        int size   = m_data.size() * value_type_size - offset;
     139                                        m_buffer->update( m_data.data() + m_min, offset, size );
     140                                }
     141                                else
     142                                {
     143                                        m_buffer->update( m_data.data(), 0, m_data.size() * value_type_size );
     144                                }
    124145                        }
    125146                        else if ( m_max > 0 )
  • trunk/tests/cachebuf_test/nv_cachebuf_test.cc

    r106 r118  
    6767{
    6868        app_window( nv::cached_buffer<quad>* cache, const glm::ivec2& a, const glm::ivec2& b, const glm::vec4& color )
    69                 : m_slice( cache )
    70         {
    71                 glm::vec4 dcolor( color.x * 0.5, color.y * 0.5, color.z * 0.5, 1.0 );
    72                 std::vector<quad>& v = m_slice.lock();
    73                 nv::ivec2 a2( a.x, b.y );
    74                 nv::ivec2 b2( b.x, a.y );
    75                 nv::ivec2 t1( 10, 10 );
    76                 nv::ivec2 t2( -10, 10 );
    77                 v.emplace_back( a - t1, a,       b2, b2 - t2, dcolor );
    78                 v.emplace_back( a - t1, a2 + t2, a2, a,       dcolor );
    79                 v.emplace_back( a2 + t2, b + t1, b, a2, dcolor );
    80                 v.emplace_back( b + t1, b2 - t2, b2, b, dcolor );
    81                 v.emplace_back( a, b, color );
     69                : m_slice( cache ), m_a( a ), m_b( b ), m_c( color )
     70        {
     71                create_complex();
    8272        }
    8373
    8474        void change_color( const glm::vec4& color )
    8575        {
     76                m_c = color;
    8677                glm::vec4 dcolor( color.x * 0.5, color.y * 0.5, color.z * 0.5, 1.0 );
    8778                std::vector<quad>& v = m_slice.lock();
    8879                vertex* vtx = (vertex*)v.data();
    89                 for (size_t i = 0; i < (v.size() - 1) * 6; ++i )
    90                         vtx[i].color = color;
    91                 for (size_t i = (v.size() - 1) * 6; i < (v.size()) * 6; ++i )
    92                         vtx[i].color = dcolor;
     80                if ( v.size() > 1 )
     81                {
     82                        for (size_t i = 0; i < (v.size() - 1) * 6; ++i )
     83                                vtx[i].color = dcolor;
     84                        for (size_t i = (v.size() - 1) * 6; i < (v.size()) * 6; ++i )
     85                                vtx[i].color = color;
     86                }
     87                else
     88                {
     89                        for (size_t i = 0; i < 6; ++i )
     90                                vtx[i].color = color;
     91                }
     92        }
     93
     94        void simplify_toggle()
     95        {
     96                if ( m_slice.data().size() > 1 )
     97                {
     98                        NV_LOG( nv::LOG_INFO, "Simplifing" );
     99                        create_simple();
     100                }
     101                else
     102                {
     103                        NV_LOG( nv::LOG_INFO, "Complexifing" );
     104                        create_complex();
     105                }
     106        }
     107
     108        void create_simple()
     109        {
     110                std::vector<quad>& v = m_slice.lock();
     111                v.clear();
     112                v.emplace_back( m_a, m_b, m_c );
     113        }
     114
     115        void create_complex()
     116        {
     117                glm::vec4 dcolor( m_c.x * 0.5, m_c.y * 0.5, m_c.z * 0.5, 1.0 );
     118                std::vector<quad>& v = m_slice.lock();
     119                v.clear();
     120                nv::ivec2 a2( m_a.x, m_b.y );
     121                nv::ivec2 b2( m_b.x, m_a.y );
     122                nv::ivec2 t1( 10, 10 );
     123                nv::ivec2 t2( -10, 10 );
     124                v.emplace_back( m_a - t1, m_a,       b2, b2 - t2, dcolor );
     125                v.emplace_back( m_a - t1, a2 + t2, a2, m_a,       dcolor );
     126                v.emplace_back( a2 + t2, m_b + t1, m_b, a2, dcolor );
     127                v.emplace_back( m_b + t1, b2 - t2, b2, m_b, dcolor );
     128                v.emplace_back( m_a, m_b, m_c );
    93129        }
    94130
     
    99135
    100136        nv::buffer_slice<quad> m_slice;
     137        nv::ivec2 m_a;
     138        nv::ivec2 m_b;
     139        nv::vec4 m_c;
    101140};
    102141
     
    109148        void kill_window();
    110149        void spawn_window();
     150        void simplify_window();
    111151        void recolor_window();
    112152        ~application();
     
    180220                m_program->bind();
    181221//              m_program->set_uniform( "tex", 0 );
    182                 m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_program, m_va, m_windows.size() * 5 * 6 );
     222                m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_program, m_va, m_quad_cache->get_size() * 6 );
    183223                m_window->swap_buffers();
    184224
     
    197237                                        {
    198238                                        case nv::KEY_N      : spawn_window(); break;
     239                                        case nv::KEY_S      : simplify_window(); break;
    199240                                        case nv::KEY_C      : recolor_window(); break;
    200241                                        case nv::KEY_K      : kill_window(); break;
     
    223264        m_windows.erase( m_windows.begin() + index );
    224265}
     266
    225267void application::recolor_window()
    226268{
     
    228270        size_t index = rand() % m_windows.size();
    229271        m_windows[ index ].change_color( nv::vec4( (float)rand() / float(RAND_MAX), (float)rand() / float(RAND_MAX), (float)rand() / float(RAND_MAX), 1.0 ) );
     272}
     273
     274void application::simplify_window()
     275{
     276        if ( m_windows.size() == 0 ) return;
     277        size_t index = rand() % m_windows.size();
     278        NV_LOG( nv::LOG_INFO, "Simplify " << index );
     279        m_windows[ index ].simplify_toggle();
    230280}
    231281
Note: See TracChangeset for help on using the changeset viewer.