Ignore:
Timestamp:
07/09/15 14:40:36 (10 years ago)
Author:
epyon
Message:
  • refactoring of raw_data_channel and data_descriptor access
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gfx/mesh_creator.cc

    r411 r412  
    5757                        size_t chan_count = old_keys->get_channel_count();
    5858                        if ( chan_count == 1
    59                                 && old_keys->get_channel(0)->desc.slot_count() == 1
    60                                 && old_keys->get_channel(0)->desc[0].etype == TRANSFORM ) continue;
     59                                && old_keys->get_channel(0)->descriptor().slot_count() == 1
     60                                && old_keys->get_channel(0)->descriptor()[0].etype == TRANSFORM ) continue;
    6161
    6262                        size_t max_keys = 0;
    6363                        for ( size_t c = 0; c < chan_count; ++c )
    6464                        {
    65                                 max_keys = nv::max( max_keys, old_keys->get_channel(c)->count );
     65                                max_keys = nv::max( max_keys, old_keys->get_channel(c)->element_count() );
    6666                        }
    6767
    … …  
    7979                                for ( uint16 c = 0; c < chan_count; ++c )
    8080                                {
    81                                         size_t idx = nv::min( old_keys->get_channel(c)->count - 1, n );
     81                                        size_t idx = nv::min( old_keys->get_channel(c)->element_count() - 1, n );
    8282                                        pkey += old_keys->get_raw( old_keys->get_channel(c), idx, pkey );
    8383                                }
    … …  
    107107                        {
    108108                                const raw_data_channel* channel = kdata->get_channel(c);
    109                                 size_t key_size = channel->desc.element_size();
    110                                 for ( size_t n = 0; n < channel->count; ++n )
    111                                 {
    112                                         transform_key_raw( channel->desc, channel->data + n * key_size, scale, r33, ri33 );
     109                                size_t key_size = channel->element_size();
     110                                for ( size_t n = 0; n < channel->element_count(); ++n )
     111                                {
     112                                        transform_key_raw( channel->descriptor(), channel->data + n * key_size, scale, r33, ri33 );
    113113                                }
    114114                        }
    … …  
    126126        {
    127127                const raw_data_channel* channel = m_data->get_channel(c);
    128                 const data_descriptor&  desc    = channel->desc;
     128                const data_descriptor&  desc    = channel->descriptor();
    129129                uint8* raw_data = channel->data;
    130130                uint32 vtx_size = desc.element_size();
    … …  
    142142
    143143                if ( p_offset != -1 )
    144                         for ( uint32 i = 0; i < channel->count; i++)
     144                        for ( uint32 i = 0; i < channel->element_count(); i++)
    145145                        {
    146146                                vec3& p = *reinterpret_cast<vec3*>( raw_data + vtx_size*i + p_offset );
    … …  
    149149
    150150                if ( n_offset != -1 )
    151                         for ( uint32 i = 0; i < channel->count; i++)
     151                        for ( uint32 i = 0; i < channel->element_count(); i++)
    152152                        {
    153153                                vec3& n = *reinterpret_cast<vec3*>( raw_data + vtx_size*i + n_offset );
    … …  
    155155                        }
    156156                if ( t_offset != -1 )
    157                         for ( uint32 i = 0; i < channel->count; i++)
     157                        for ( uint32 i = 0; i < channel->element_count(); i++)
    158158                        {
    159159                                vec4& t = *reinterpret_cast<vec4*>(raw_data + vtx_size*i + t_offset );
    … …  
    174174        if ( ch_n == -1 ) return;
    175175        raw_data_channel* channel = m_data->m_channels[ unsigned( ch_n ) ];
    176         for ( const auto& cslot : channel->desc )
     176        for ( const auto& cslot : channel->descriptor() )
    177177                if ( cslot.vslot == slot::NORMAL )
    178178                {
    … …  
    180180                }
    181181
    182         for ( uint32 i = 0; i < channel->count; ++i )
    183         {
    184                 vec3& normal = *reinterpret_cast<vec3*>( channel->data + channel->desc.element_size() * i + n_offset );
     182        for ( uint32 i = 0; i < channel->element_count(); ++i )
     183        {
     184                vec3& normal = *reinterpret_cast<vec3*>( channel->data + channel->element_size() * i + n_offset );
    185185                normal = -normal;
    186186        }
    … …  
    205205                const raw_data_channel* channel = m_data->get_channel(c);
    206206
    207                 for ( const auto& cslot : channel->desc )
     207                for ( const auto& cslot : channel->descriptor() )
    208208                switch ( cslot.vslot )
    209209                {
    … …  
    242242        if ( !p_channel || !n_channel || !t_channel ) return;
    243243
    244         if ( p_channel->count != n_channel->count || p_channel->count % t_channel->count != 0 || ( i_type != UINT && i_type != USHORT && i_type != NONE ) )
     244        if ( p_channel->element_count() != n_channel->element_count()
     245                || p_channel->element_count() % t_channel->element_count() != 0
     246                || ( i_type != UINT && i_type != USHORT && i_type != NONE ) )
    245247        {
    246248                return;
    247249        }
    248250
    249         raw_data_channel* g_channel = raw_data_channel::create<vertex_g>( p_channel->count );
     251        raw_data_channel* g_channel = raw_data_channel::create<vertex_g>( p_channel->element_count() );
    250252        vec4* tangents              = reinterpret_cast<vec4*>( g_channel->data );
    251         vec3* tangents2             = new vec3[ p_channel->count ];
    252         uint32 tri_count = i_channel ? i_channel->count / 3 : t_channel->count / 3;
    253         uint32 vtx_count = p_channel->count;
    254         uint32 sets      = p_channel->count / t_channel->count;
     253        vec3* tangents2             = new vec3[ p_channel->element_count() ];
     254        uint32 tri_count = i_channel ? i_channel->element_count() / 3 : t_channel->element_count() / 3;
     255        uint32 vtx_count = p_channel->element_count();
     256        uint32 sets      = p_channel->element_count() / t_channel->element_count();
    255257
    256258        for ( unsigned int i = 0; i < tri_count; ++i )
    … …  
    280282                }
    281283
    282                 const vec2& w1 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.element_size()*ti0 + t_offset );
    283                 const vec2& w2 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.element_size()*ti1 + t_offset );
    284                 const vec2& w3 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.element_size()*ti2 + t_offset );
     284                const vec2& w1 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->element_size()*ti0 + t_offset );
     285                const vec2& w2 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->element_size()*ti1 + t_offset );
     286                const vec2& w3 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->element_size()*ti2 + t_offset );
    285287                vec2 st1 = w3 - w1;
    286288                vec2 st2 = w2 - w1;
    … …  
    290292                for ( uint32 set = 0; set < sets; ++set )
    291293                {
    292                         uint32 nti0 = t_channel->count * set + ti0;
    293                         uint32 nti1 = t_channel->count * set + ti1;
    294                         uint32 nti2 = t_channel->count * set + ti2;
    295                         vec3 v1 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.element_size()*nti0 + p_offset );
    296                         vec3 v2 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.element_size()*nti1 + p_offset );
    297                         vec3 v3 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.element_size()*nti2 + p_offset );
     294                        uint32 nti0 = t_channel->element_count() * set + ti0;
     295                        uint32 nti1 = t_channel->element_count() * set + ti1;
     296                        uint32 nti2 = t_channel->element_count() * set + ti2;
     297                        vec3 v1 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->element_size()*nti0 + p_offset );
     298                        vec3 v2 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->element_size()*nti1 + p_offset );
     299                        vec3 v3 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->element_size()*nti2 + p_offset );
    298300                        vec3 xyz1 = v3 - v1;
    299301                        vec3 xyz2 = v2 - v1;
    … …  
    319321        for ( unsigned int i = 0; i < vtx_count; ++i )
    320322        {
    321                 const vec3 n = *reinterpret_cast<vec3*>( n_channel->data + n_channel->desc.element_size()*i + n_offset );
     323                const vec3 n = *reinterpret_cast<vec3*>( n_channel->data + n_channel->element_size()*i + n_offset );
    322324                const vec3 t = vec3(tangents[i]);
    323325                if ( ! ( t.x == 0.0f && t.y == 0.0f && t.z == 0.0f ) )
    … …  
    336338nv::raw_data_channel* nv::mesh_data_creator::merge_channels( raw_data_channel* a, raw_data_channel* b )
    337339{
    338         NV_ASSERT( a->count == b->count, "merge_channel - bad channels!" );
    339         data_descriptor adesc = a->desc;
    340         data_descriptor bdesc = b->desc;
    341         uint32          count = a->count;
    342 
    343         data_descriptor desc  = a->desc;
    344         for ( auto bslot : bdesc )
    345         {
    346                 desc.push_slot( bslot.etype, bslot.vslot );
    347         }
    348         uint8* data = new uint8[ count * desc.element_size() ];
    349         for ( uint32 i = 0; i < count; ++i )
    350         {
    351                 raw_copy_n( a->data + i * adesc.element_size(), adesc.element_size(), data + i*desc.element_size() );
    352                 raw_copy_n( b->data + i * bdesc.element_size(), bdesc.element_size(), data + i*desc.element_size() + adesc.element_size() );
    353         }
     340        NV_ASSERT( a->element_count() == b->element_count(), "merge_channel - bad channels!" );
     341        data_descriptor desc  = a->descriptor();
     342        desc.append( b->descriptor() );
     343
     344        uint8* data = new uint8[a->element_count() * desc.element_size() ];
     345        for ( uint32 i = 0; i < a->element_count(); ++i )
     346        {
     347                raw_copy_n( a->data + i * a->element_size(), a->element_size(), data + i*desc.element_size() );
     348                raw_copy_n( b->data + i * b->element_size(), b->element_size(), data + i*desc.element_size() + a->element_size() );
     349        }
     350
    354351        raw_data_channel* result = new raw_data_channel;
    355         result->count = count;
    356         result->desc  = desc;
     352        result->m_count = a->element_count();
     353        result->m_desc  = desc;
    357354        result->data  = data;
    358355        return result;
    … …  
    361358nv::raw_data_channel* nv::mesh_data_creator::append_channels( raw_data_channel* a, raw_data_channel* b, uint32 frame_count )
    362359{
    363         if ( a->desc != b->desc ) return nullptr;
    364         if ( a->count % frame_count != 0 ) return nullptr;
    365         if ( b->count % frame_count != 0 ) return nullptr;
    366         size_t vtx_size = a->desc.element_size();
    367 
    368         uint8* data = new uint8[ ( a->count + b->count ) * vtx_size ];
     360        if ( a->descriptor() != b->descriptor() ) return nullptr;
     361        if ( a->element_count() % frame_count != 0 ) return nullptr;
     362        if ( b->element_count() % frame_count != 0 ) return nullptr;
     363        size_t vtx_size = a->element_size();
     364
     365        uint8* data = new uint8[ ( a->element_count() + b->element_count() ) * vtx_size ];
    369366       
    370367
    371368        if ( frame_count == 1 )
    372369        {
    373                 size_t a_size = vtx_size * a->count;
     370                size_t a_size = vtx_size * a->element_count();
    374371                raw_copy_n( a->data, a_size, data );
    375                 raw_copy_n( b->data, vtx_size * b->count, data + a_size );
     372                raw_copy_n( b->data, vtx_size * b->element_count(), data + a_size );
    376373        }
    377374        else
    378375        {
    379                 size_t frame_size_a = ( a->count / frame_count ) * vtx_size;
    380                 size_t frame_size_b = ( b->count / frame_count ) * vtx_size;
     376                size_t frame_size_a = ( a->element_count() / frame_count ) * vtx_size;
     377                size_t frame_size_b = ( b->element_count() / frame_count ) * vtx_size;
    381378                size_t pos_a = 0;
    382379                size_t pos_b = 0;
    … …  
    392389
    393390        raw_data_channel* result = new raw_data_channel;
    394         result->count = a->element_count() + b->element_count();
    395         result->desc  = a->descriptor();
     391        result->m_count = a->element_count() + b->element_count();
     392        result->m_desc  = a->descriptor();
    396393        result->data  = data;
    397394        return result;
    … …  
    429426        {
    430427                raw_data_channel* old = m_data->m_channels[c];
    431                 size_t frame_count = ( old->get_buffer_type() == INDEX_BUFFER ? 1 : old->element_count() / size );
     428                bool old_is_index = old->element_count() > 0 && old->descriptor()[0].vslot == slot::INDEX;
     429                size_t frame_count = ( old_is_index ? 1 : old->element_count() / size );
    432430                m_data->m_channels[c] = append_channels( old, other->m_channels[c], frame_count );
    433431                NV_ASSERT( m_data->m_channels[c], "Merge problem!" );
    434                 if ( old->get_buffer_type() == INDEX_BUFFER )
    435                 {
    436                         switch ( old->desc[0].etype )
     432                if ( old_is_index )
     433                {
     434                        switch ( old->descriptor()[0].etype )
    437435                        {
    438436                        case USHORT :
Note: See TracChangeset for help on using the changeset viewer.