Changeset 415 for trunk/src/gfx

Timestamp:

07/09/15 20:02:58 (10 years ago)

Author:

epyon

Message:

• naming scheme for data_descriptor changed
• channels can only be created by data_channel_creators

Location:

trunk/src/gfx

Files:

• keyframed_mesh.cc (modified) (2 diffs)
• mesh_creator.cc (modified) (13 diffs)
• skeletal_mesh.cc (modified) (2 diffs)

trunk/src/gfx/keyframed_mesh.cc

@@ -23 +23 @@
         , m_active( false )
 {
-        m_index_count  = m_mesh_data->get_index_channel()->element_count();
-        m_vertex_count = m_mesh_data->get_channel<vertex_t>()->element_count();
+        m_index_count  = m_mesh_data->get_index_channel()->size();
+        m_vertex_count = m_mesh_data->get_channel<vertex_t>()->size();
         m_vchannel     = m_mesh_data->get_channel<vertex_pnt>();
         m_vsize        = sizeof( vertex_pnt );
@@ -34 +34 @@
                 m_vsize        = sizeof( vertex_pn );
         }
-        m_frame_count  = m_vchannel->element_count() / m_vertex_count;
+        m_frame_count  = m_vchannel->size() / m_vertex_count;
         m_pbuffer      = buffer();
 }

trunk/src/gfx/mesh_creator.cc

@@ -19 +19 @@
                 key_data* keys   = m_data->m_nodes[i].data;
                 key_data* pkeys  = ( parent_id != -1 ? m_data->m_nodes[parent_id].data : nullptr );
-                size_t count     = ( keys ? keys->get_channel(0)->element_count() : 0 );
-                size_t pcount    = ( pkeys ? pkeys->get_channel(0)->element_count() : 0 );
+                size_t count     = ( keys ? keys->get_channel(0)->size() : 0 );
+                size_t pcount    = ( pkeys ? pkeys->get_channel(0)->size() : 0 );
                 max_frames = nv::max<uint32>( count, max_frames );
                 if ( pkeys && pkeys->get_channel_count() > 0 && keys && keys->get_channel_count() > 0 )
@@ -58 +58 @@
                         size_t chan_count = old_keys->get_channel_count();
                         if ( chan_count == 1 
-                                && old_keys->get_channel(0)->descriptor().slot_count() == 1 
+                                && old_keys->get_channel(0)->descriptor().size() == 1
                                 && old_keys->get_channel(0)->descriptor()[0].etype == TRANSFORM ) continue;
 
@@ -64 +64 @@
                         for ( size_t c = 0; c < chan_count; ++c )
                         {
-                                max_keys = nv::max( max_keys, old_keys->get_channel(c)->element_count() );
+                                max_keys = nv::max( max_keys, old_keys->get_channel(c)->size() );
                         }
 
@@ -78 +78 @@
                                 for ( uint16 c = 0; c < chan_count; ++c )
                                 {
-                                        size_t idx = nv::min( old_keys->get_channel(c)->element_count() - 1, n );
+                                        size_t idx = nv::min( old_keys->get_channel(c)->size() - 1, n );
                                         pkey += old_keys->get_raw( old_keys->get_channel(c), idx, pkey );
                                 }
@@ -242 +242 @@
         if ( !p_channel || !n_channel || !t_channel ) return;
 
-        if ( p_channel->element_count() != n_channel->element_count() 
-                || p_channel->element_count() % t_channel->element_count() != 0 
+        if ( p_channel->size() != n_channel->size()
+                || p_channel->size() % t_channel->size() != 0
                 || ( i_type != UINT && i_type != USHORT && i_type != NONE ) )
         {
@@ -249 +249 @@
         }
 
-        data_channel_creator< vertex_g > g_channel( p_channel->element_count() );
+        data_channel_creator< vertex_g > g_channel( p_channel->size() );
         vec4* tangents              = &( g_channel.data()[0].tangent );
-        vec3* tangents2             = new vec3[ p_channel->element_count() ];
-        uint32 tri_count = i_channel ? i_channel->element_count() / 3 : t_channel->element_count() / 3;
-        uint32 vtx_count = p_channel->element_count();
-        uint32 sets      = p_channel->element_count() / t_channel->element_count();
+        vec3* tangents2             = new vec3[ p_channel->size() ];
+        uint32 tri_count = i_channel ? i_channel->size() / 3 : t_channel->size() / 3;
+        uint32 vtx_count = p_channel->size();
+        uint32 sets      = p_channel->size() / t_channel->size();
 
         for ( unsigned int i = 0; i < tri_count; ++i )
@@ -292 +292 @@
                 for ( uint32 set = 0; set < sets; ++set )
                 {
-                        uint32 nti0 = t_channel->element_count() * set + ti0;
-                        uint32 nti1 = t_channel->element_count() * set + ti1;
-                        uint32 nti2 = t_channel->element_count() * set + ti2;
+                        uint32 nti0 = t_channel->size() * set + ti0;
+                        uint32 nti1 = t_channel->size() * set + ti1;
+                        uint32 nti2 = t_channel->size() * set + ti2;
                         const vec3& v1 = *reinterpret_cast<const vec3*>(p_channel->raw_data() + p_channel->element_size()*nti0 + p_offset );
                         const vec3& v2 = *reinterpret_cast<const vec3*>(p_channel->raw_data() + p_channel->element_size()*nti1 + p_offset );
@@ -337 +337 @@
 nv::raw_data_channel* nv::mesh_data_creator::merge_channels( raw_data_channel* a, raw_data_channel* b )
 {
-        NV_ASSERT( a->element_count() == b->element_count(), "merge_channel - bad channels!" );
+        NV_ASSERT( a->size() == b->size(), "merge_channel - bad channels!" );
         data_descriptor desc  = a->descriptor();
         desc.append( b->descriptor() );
 
-        raw_data_channel_creator result( desc, a->element_count() );
-        for ( uint32 i = 0; i < a->element_count(); ++i )
+        raw_data_channel_creator result( desc, a->size() );
+        for ( uint32 i = 0; i < a->size(); ++i )
         {
                 raw_copy_n( a->raw_data() + i * a->element_size(), a->element_size(), result.raw_data() + i*desc.element_size() );
@@ -354 +354 @@
 {
         if ( a->descriptor() != b->descriptor() ) return nullptr;
-        if ( a->element_count() % frame_count != 0 ) return nullptr;
-        if ( b->element_count() % frame_count != 0 ) return nullptr;
+        if ( a->size() % frame_count != 0 ) return nullptr;
+        if ( b->size() % frame_count != 0 ) return nullptr;
         size_t vtx_size = a->element_size();
 
-        raw_data_channel_creator result( a->descriptor(), a->element_count() + b->element_count() );
+        raw_data_channel_creator result( a->descriptor(), a->size() + b->size() );
 
         if ( frame_count == 1 )
         {
-                size_t a_size = vtx_size * a->element_count();
+                size_t a_size = vtx_size * a->size();
                 raw_copy_n( a->raw_data(), a_size, result.raw_data() );
-                raw_copy_n( b->raw_data(), vtx_size * b->element_count(), result.raw_data() + a_size );
+                raw_copy_n( b->raw_data(), vtx_size * b->size(), result.raw_data() + a_size );
         }
         else
         {
-                size_t frame_size_a = ( a->element_count() / frame_count ) * vtx_size;
-                size_t frame_size_b = ( b->element_count() / frame_count ) * vtx_size;
+                size_t frame_size_a = ( a->size() / frame_count ) * vtx_size;
+                size_t frame_size_b = ( b->size() / frame_count ) * vtx_size;
                 size_t pos_a = 0;
                 size_t pos_b = 0;
@@ -406 +406 @@
         int och_ti = other->get_channel_index( slot::TEXCOORD );
         if ( ch_pi == -1 || ch_ti == -1 ) return;
-        size_t size   = m_data->m_channels[ unsigned(ch_ti) ]->element_count();
-        size_t osize  =  other->m_channels[ unsigned(och_ti) ]->element_count();
-        size_t count  = m_data->m_channels[ unsigned(ch_pi) ]->element_count();
-        size_t ocount =  other->m_channels[ unsigned(och_pi) ]->element_count();
+        size_t size   = m_data->m_channels[ unsigned(ch_ti) ]->size();
+        size_t osize  =  other->m_channels[ unsigned(och_ti) ]->size();
+        size_t count  = m_data->m_channels[ unsigned(ch_pi) ]->size();
+        size_t ocount =  other->m_channels[ unsigned(och_pi) ]->size();
         if ( count % size != 0 || ocount % osize != 0 ) return;
         if ( count / size != ocount / osize ) return;
@@ -416 +416 @@
         {
                 raw_data_channel* old = m_data->m_channels[c];
-                bool old_is_index = old->element_count() > 0 && old->descriptor()[0].vslot == slot::INDEX;
-                size_t frame_count = ( old_is_index ? 1 : old->element_count() / size );
+                bool old_is_index = old->size() > 0 && old->descriptor()[0].vslot == slot::INDEX;
+                size_t frame_count = ( old_is_index ? 1 : old->size() / size );
                 m_data->m_channels[c] = append_channels( old, other->m_channels[c], frame_count );
                 NV_ASSERT( m_data->m_channels[c], "Merge problem!" );
@@ -429 +429 @@
                                         raw_data_channel_creator ic( m_data->m_channels[c] );
                                         uint16* indexes = reinterpret_cast<uint16*>( ic.raw_data() );
-                                        for ( uint16 i = uint16( old->element_count() ); i < ic.size(); ++i )
+                                        for ( uint16 i = uint16( old->size() ); i < ic.size(); ++i )
                                                 indexes[i] += uint16( size );
 
@@ -438 +438 @@
                                         raw_data_channel_creator ic( m_data->m_channels[c] );
                                         uint32* indexes = reinterpret_cast<uint32*>( ic.raw_data() );
-                                        for ( uint32 i = old->element_count(); i < ic.size(); ++i )
+                                        for ( uint32 i = old->size(); i < ic.size(); ++i )
                                                 indexes[i] += size;
                                 }

trunk/src/gfx/skeletal_mesh.cc

@@ -17 +17 @@
         const raw_data_channel* pntiw_chan = a_mesh_data->get_channel<md5_vtx_pntiw>();
 
-        m_pntdata.assign( pnt_chan->data_cast< md5_vtx_pnt >(), pnt_chan->element_count() );
+        m_pntdata.assign( pnt_chan->data_cast< md5_vtx_pnt >(), pnt_chan->size() );
         m_bone_offset.resize( bones->get_count() );
         m_transform.resize( bones->get_count() );
@@ -34 +34 @@
         {
                 const raw_data_channel* channel = channels[ch];
-                if ( channel->element_count() > 0 && channel != pntiw_chan )
+                if ( channel->size() > 0 && channel != pntiw_chan )
                 {
                         const data_descriptor& desc = channel->descriptor();