Changeset 119 for trunk/tests/cachebuf_test

Timestamp:

06/12/13 09:38:06 (12 years ago)

Author:

epyon

Message:

• vertex_buffer - fixes to index buffered vertex_arrays
• cached_buffer - added indexed_buffer_slice and indexed_cached_buffer
• nv_cachebuf_test - compile define for indexed or regular arrays

File:

• trunk/tests/cachebuf_test/nv_cachebuf_test.cc (modified) (13 diffs)

trunk/tests/cachebuf_test/nv_cachebuf_test.cc

@@ -19 +19 @@
 #include <nv/gfx/cached_buffer.hh>
 
+#define INDEXED_TEST
+
 struct vertex
 {
@@ -28 +30 @@
 };
 
+#ifndef INDEXED_TEST
 struct quad
 {
@@ -63 +66 @@
 
 };
+#endif 
+
+#ifdef INDEXED_TEST
+typedef nv::indexed_cached_buffer<vertex> gcache;
+typedef nv::indexed_buffer_slice<vertex> gslice;
+#else
+typedef nv::cached_buffer<quad> gcache;
+typedef nv::buffer_slice<quad> gslice;
+#endif
 
 struct app_window
 {
-        app_window( nv::cached_buffer<quad>* cache, const glm::ivec2& a, const glm::ivec2& b, const glm::vec4& color )
-                : m_slice( cache ), m_a( a ), m_b( b ), m_c( color )
+        app_window( gcache* cache, const glm::ivec2& a, const glm::ivec2& b, const glm::vec4& color )
+                : m_slice( cache ), m_simple( false ), m_a( a ), m_b( b ), m_c( color )
         {
                 create_complex();
@@ -76 +88 @@
                 m_c = color;
                 glm::vec4 dcolor( color.x * 0.5, color.y * 0.5, color.z * 0.5, 1.0 );
+                #ifdef INDEXED_TEST
+                std::vector<vertex>& v = m_slice.lock_vertices();
+                size_t size   = v.size();
+                size_t dcount = 8;
+                size_t dmin   = 8;
+                size_t count  = size;
+                #else
                 std::vector<quad>& v = m_slice.lock();
+                size_t size   = v.size();
+                size_t dcount = (size - 1) * 6;
+                size_t dmin   = 1;
+                size_t count  = size * 6;
+                #endif
                 vertex* vtx = (vertex*)v.data();
-                if ( v.size() > 1 )
-                {
-                        for (size_t i = 0; i < (v.size() - 1) * 6; ++i )
+                if ( size > dmin )
+                {
+                        for (size_t i = 0; i < dcount; ++i )
                                 vtx[i].color = dcolor;
-                        for (size_t i = (v.size() - 1) * 6; i < (v.size()) * 6; ++i )
+                        for (size_t i = dcount; i < count; ++i )
                                 vtx[i].color = color;
                 }
                 else
                 {
-                        for (size_t i = 0; i < 6; ++i )
+                        for (size_t i = 0; i < count; ++i )
                                 vtx[i].color = color;
                 }
@@ -94 +118 @@
         void simplify_toggle()
         {
-                if ( m_slice.data().size() > 1 )
+                if ( !m_simple )
                 {
                         NV_LOG( nv::LOG_INFO, "Simplifing" );
@@ -108 +132 @@
         void create_simple()
         {
+                #ifdef INDEXED_TEST
+                std::vector<vertex>& v     = m_slice.lock_vertices();
+                std::vector<nv::uint16>& i = m_slice.lock_indices();
+                v.clear();
+                i.clear();
+                v.emplace_back( m_a, m_c );
+                v.emplace_back( nv::ivec2( m_a.x, m_b.y ), m_c );
+                v.emplace_back( m_b, m_c );
+                v.emplace_back( nv::ivec2( m_b.x, m_a.y ), m_c );
+                nv::uint16 tmp[] = { 0, 1, 2, 2, 3, 0 };
+                i.insert( i.end(), tmp, std::end( tmp ) );
+                #else
                 std::vector<quad>& v = m_slice.lock();
                 v.clear();
                 v.emplace_back( m_a, m_b, m_c );
+                #endif
+                m_simple = true;
         }
 
@@ -116 +154 @@
         {
                 glm::vec4 dcolor( m_c.x * 0.5, m_c.y * 0.5, m_c.z * 0.5, 1.0 );
-                std::vector<quad>& v = m_slice.lock();
-                v.clear();
                 nv::ivec2 a2( m_a.x, m_b.y );
                 nv::ivec2 b2( m_b.x, m_a.y );
                 nv::ivec2 t1( 10, 10 );
                 nv::ivec2 t2( -10, 10 );
+                #ifdef INDEXED_TEST
+                std::vector<vertex>& v     = m_slice.lock_vertices();
+                std::vector<nv::uint16>& i = m_slice.lock_indices();
+                v.clear();
+                i.clear();
+                v.emplace_back( m_a- t1, dcolor ); // 0
+                v.emplace_back( a2 + t2, dcolor ); // 1
+                v.emplace_back( m_b+ t1, dcolor ); // 2
+                v.emplace_back( b2 - t2, dcolor ); // 3
+
+                v.emplace_back( m_a, dcolor ); // 4
+                v.emplace_back( a2, dcolor );  // 5
+                v.emplace_back( m_b, dcolor ); // 6
+                v.emplace_back( b2, dcolor );  // 7
+                nv::uint16 tmp[] = { 
+                        0, 4, 7, 7, 3, 0,
+                        0, 1, 5, 5, 4, 0,
+                        1, 2, 6, 6, 5, 1,
+                        2, 3, 7, 7, 6, 2,
+                };
+                i.insert( i.end(), tmp, std::end( tmp ) );
+
+                v.emplace_back( m_a, m_c );    // 8
+                v.emplace_back( a2, m_c );     // 9
+                v.emplace_back( m_b, m_c );    // 10
+                v.emplace_back( b2, m_c );     // 11
+                nv::uint16 tmp2[] = { 8, 9, 10, 10, 11, 8 };
+                i.insert( i.end(), tmp2, std::end( tmp2 ) );
+
+                #else
+                std::vector<quad>& v = m_slice.lock();
+                v.clear();
                 v.emplace_back( m_a - t1, m_a,       b2, b2 - t2, dcolor );
                 v.emplace_back( m_a - t1, a2 + t2, a2, m_a,       dcolor );
@@ -127 +195 @@
                 v.emplace_back( m_b + t1, b2 - t2, b2, m_b, dcolor );
                 v.emplace_back( m_a, m_b, m_c );
+                #endif
+                m_simple = false;
         }
 
@@ -134 +204 @@
         }
 
-        nv::buffer_slice<quad> m_slice;
+        gslice m_slice;
+        bool m_simple;
         nv::ivec2 m_a;
         nv::ivec2 m_b;
@@ -157 +228 @@
         nv::render_state m_render_state;
         
-        nv::cached_buffer<quad>* m_quad_cache;
+        gcache* m_quad_cache;
         std::vector<app_window>  m_windows;
 
@@ -185 +256 @@
 {
         { 
-                m_program = m_device->create_program( nv::slurp( "cachebuf.vert" ), nv::slurp( "cachebuf.frag" ) );
-                m_va      = m_device->create_vertex_array();
-
-                m_quad_cache = new nv::cached_buffer<quad>( m_device, nv::DYNAMIC_DRAW, 20, true );
-                m_coord_loc  = m_program->get_attribute("coord")->get_location();
-                m_color_loc  = m_program->get_attribute("color")->get_location();
-
-                m_va->add_vertex_buffer( m_coord_loc, (nv::vertex_buffer*)m_quad_cache->get_buffer(), nv::INT,   2, 0, sizeof( vertex ), false );
-                m_va->add_vertex_buffer( m_color_loc, (nv::vertex_buffer*)m_quad_cache->get_buffer(), nv::FLOAT, 4, offset_of( &vertex::color ), sizeof( vertex ), false );
+                m_program   = m_device->create_program( nv::slurp( "cachebuf.vert" ), nv::slurp( "cachebuf.frag" ) );
+                m_coord_loc = m_program->get_attribute("coord")->get_location();
+                m_color_loc = m_program->get_attribute("color")->get_location();
+                m_va        = m_device->create_vertex_array();
+
+                #ifdef INDEXED_TEST
+                m_quad_cache = new gcache( m_device, nv::DYNAMIC_DRAW, 200, 200 );
+                m_va->set_index_buffer( m_quad_cache->get_index_buffer(), nv::USHORT, false );
+                nv::vertex_buffer* buffer = m_quad_cache->get_vertex_buffer();
+                #else
+                m_quad_cache = new gcache( m_device, nv::DYNAMIC_DRAW, 20, true );
+                nv::vertex_buffer* buffer = (nv::vertex_buffer*)m_quad_cache->get_buffer();
+                #endif
+
+                m_va->add_vertex_buffer( m_coord_loc, buffer, nv::INT,   2, 0, sizeof( vertex ), false );
+                m_va->add_vertex_buffer( m_color_loc, buffer, nv::FLOAT, 4, offset_of( &vertex::color ), sizeof( vertex ), false );
         }
         return true;
@@ -213 +291 @@
                 if (m_quad_cache->commit() )
                 {
-                        m_va->update_vertex_buffer( m_coord_loc, (nv::vertex_buffer*)m_quad_cache->get_buffer(), false );
-                        m_va->update_vertex_buffer( m_color_loc, (nv::vertex_buffer*)m_quad_cache->get_buffer(), false );
+                        #ifdef INDEXED_TEST
+                        m_va->set_index_buffer( m_quad_cache->get_index_buffer() );
+                        nv::vertex_buffer* buffer = m_quad_cache->get_vertex_buffer();
+                        #else
+                        nv::vertex_buffer* buffer = (nv::vertex_buffer*)m_quad_cache->get_buffer();
+                        #endif
+                        m_va->update_vertex_buffer( m_coord_loc, buffer, false );
+                        m_va->update_vertex_buffer( m_color_loc, buffer, false );
                 }
 
@@ -220 +304 @@
                 m_program->bind();
 //              m_program->set_uniform( "tex", 0 );
-                m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_program, m_va, m_quad_cache->get_size() * 6 );
+                #ifdef INDEXED_TEST
+                size_t draw_size = m_quad_cache->get_index_size();
+                #else
+                size_t draw_size = m_quad_cache->get_size() * 6;
+                #endif
+                m_window->get_context()->draw( nv::TRIANGLES, m_render_state, m_program, m_va, draw_size );
                 m_window->swap_buffers();