Changeset 412 for trunk/src/gfx


Ignore:
Timestamp:
07/09/15 14:40:36 (10 years ago)
Author:
epyon
Message:
  • refactoring of raw_data_channel and data_descriptor access
Location:
trunk/src/gfx
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gfx/keyframed_mesh.cc

    r410 r412  
    2323        , m_active( false )
    2424{
    25         m_index_count  = m_mesh_data->get_index_channel()->count;
    26         m_vertex_count = m_mesh_data->get_channel<vertex_t>()->count;
     25        m_index_count  = m_mesh_data->get_index_channel()->element_count();
     26        m_vertex_count = m_mesh_data->get_channel<vertex_t>()->element_count();
    2727        m_vchannel     = m_mesh_data->get_channel<vertex_pnt>();
    2828        m_vsize        = sizeof( vertex_pnt );
    … …  
    3434                m_vsize        = sizeof( vertex_pn );
    3535        }
    36         m_frame_count  = m_vchannel->count / m_vertex_count;
     36        m_frame_count  = m_vchannel->element_count() / m_vertex_count;
    3737        m_pbuffer      = buffer();
    3838}
    … …  
    190190        m_context->add_vertex_buffers( m_va, vb, m_mesh_data->get_channel<vertex_t>() );
    191191
    192         buffer  ib = m_context->get_device()->create_buffer( INDEX_BUFFER, STATIC_DRAW, m_mesh_data->get_index_channel()->size(), m_mesh_data->get_index_channel()->data );
    193 
    194         m_context->set_index_buffer( m_va, ib, m_mesh_data->get_index_channel()->desc[0].etype, true );
     192        const raw_data_channel* index_channel = m_mesh_data->get_index_channel();
     193        buffer  ib = m_context->get_device()->create_buffer( INDEX_BUFFER, STATIC_DRAW, index_channel->raw_size(), index_channel->raw_data() );
     194
     195        m_context->set_index_buffer( m_va, ib, m_mesh_data->get_index_channel()->descriptor()[0].etype, true );
    195196
    196197        m_data = new uint8[ m_vertex_count * m_vsize ];

  • 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 :

  • trunk/src/gfx/skeletal_mesh.cc

    r411 r412  
    1313nv::skeletal_mesh_cpu::skeletal_mesh_cpu( context* a_context, const mesh_data* a_mesh_data, const mesh_nodes_data* bones )
    1414        : skeletal_mesh( a_context )
    15         , m_data( a_mesh_data )
    16 {
    17         const raw_data_channel* pnt_chan = a_mesh_data->get_channel<md5_vtx_pnt>();
    18         m_pntdata.assign( reinterpret_cast<const md5_vtx_pnt*>( pnt_chan->data ), pnt_chan->count );
     15{
     16        const raw_data_channel* pnt_chan   = a_mesh_data->get_channel<md5_vtx_pnt>();
     17        const raw_data_channel* pntiw_chan = a_mesh_data->get_channel<md5_vtx_pntiw>();
     18
     19        m_pntdata.assign( reinterpret_cast<const md5_vtx_pnt*>( pnt_chan->data ), pnt_chan->element_count() );
    1920        m_bone_offset.resize( bones->get_count() );
    2021        m_transform.resize( bones->get_count() );
    … …  
    2425                m_bone_offset[i] = transform( bones->get_node(i)->transform );
    2526        }
     27
    2628        m_vtx_data  = a_mesh_data->get_channel_data<md5_vtx_pntiw>();
    2729        m_indices   = a_mesh_data->get_count();
    28         m_va        = a_context->create_vertex_array( a_mesh_data,
    29 STREAM_DRAW );
     30        m_va        = a_context->create_vertex_array();
     31
     32        array_view< raw_data_channel* > channels = a_mesh_data->get_raw_channels();
     33        for ( uint32 ch = 0; ch < channels.size(); ++ch )
     34        {
     35                const raw_data_channel* channel = channels[ch];
     36                if ( channel->element_count() > 0 && channel != pntiw_chan )
     37                {
     38                        const data_descriptor& desc = channel->descriptor();
     39                        if ( desc[0].vslot == slot::INDEX )
     40                        {
     41                                buffer b = a_context->get_device()->create_buffer( INDEX_BUFFER, STREAM_DRAW, channel->raw_size(), channel->raw_data() );
     42                                a_context->set_index_buffer( m_va, b, desc[0].etype, true );
     43                        }
     44                        else
     45                        {
     46                                buffer b = a_context->get_device()->create_buffer( VERTEX_BUFFER, STREAM_DRAW, channel->raw_size(), channel->raw_data() );
     47                                a_context->add_vertex_buffers( m_va, b, channel );
     48                        }
     49                }
     50        }
     51
    3052        m_pbuffer   = a_context->find_buffer( m_va, slot::POSITION );
    3153}
Note: See TracChangeset for help on using the changeset viewer.