Changeset 412 for trunk/src


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
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/formats/assimp_loader.cc

    r411 r412  
    169169        }
    170170
    171         raw_data_channel* ichannel = raw_data_channel::create_index( USHORT, mesh->mNumFaces * 3 );
     171        raw_data_channel* ichannel = raw_data_channel::create< index_u16 >( mesh->mNumFaces * 3 );
    172172        data->add_channel( ichannel );
    173173        uint16* indices = reinterpret_cast<uint16*>( ichannel->data );
    … …  
    317317                                raw_data_channel* channel = meshes[m].get_raw_channels()[0];
    318318                                assimp_skinned_vtx* va = reinterpret_cast< assimp_skinned_vtx* >( channel->data );
    319                                 for ( unsigned v = 0; v < channel->count; ++v )
     319                                for ( unsigned v = 0; v < channel->element_count(); ++v )
    320320                                {
    321321                                        assimp_skinned_vtx& vertex = va[v];

  • trunk/src/formats/md2_loader.cc

    r411 r412  
    357357        }
    358358
    359         raw_data_channel* ic = raw_data_channel::create_index< uint16 >( m_new_indexes.size() );
     359        raw_data_channel* ic = raw_data_channel::create< index_u16 >( m_new_indexes.size() );
    360360        if ( m_new_indexes.size() > 0 )
    361361        {

  • trunk/src/formats/md3_loader.cc

    r411 r412  
    354354        raw_data_channel* mc_pn = raw_data_channel::create< vtx_md3_pn >( uint32( num_verts * frame_count ) );
    355355        raw_data_channel* mc_t  = raw_data_channel::create< vtx_md3_t >( uint32( num_verts ) );
    356         raw_data_channel* ic = raw_data_channel::create_index< uint16 >( uint32( index_count ) );
     356        raw_data_channel* ic = raw_data_channel::create< index_u16 >( uint32( index_count ) );
    357357        vtx_md3_pn* vtx_pn = reinterpret_cast< vtx_md3_pn* >( mc_pn->data );
    358358        vtx_md3_t*  vtx_t  = reinterpret_cast< vtx_md3_t* >( mc_t->data );

  • trunk/src/formats/md5_loader.cc

    r411 r412  
    137137                        assert( m_type == MESH );
    138138                        mesh_data* mesh = new mesh_data("md5_mesh");
     139                        raw_data_channel* ch_pntiw = nullptr;
    139140
    140141                        uint32 num_verts   = 0;
    … …  
    161162                                                raw_data_channel* ch_pnt = raw_data_channel::create<md5_vtx_pnt>( num_verts );
    162163                                                raw_data_channel* ch_t   = raw_data_channel::create<md5_vtx_t>( num_verts );
    163                                                 raw_data_channel* ch_pntiw = raw_data_channel::create<md5_vtx_pntiw>( num_verts );
     164                                                ch_pntiw = raw_data_channel::create<md5_vtx_pntiw>( num_verts );
    164165                                                tdata = reinterpret_cast< md5_vtx_t* >( ch_t->data );
    165166                                                mesh->add_channel( ch_pnt );
    166167                                                mesh->add_channel( ch_t );
    167168                                                // TODO: hack to prevent rendering
    168                                                 ch_pntiw->count = 0;
     169                                                //ch_pntiw->m_count = 0;
    169170                                                mesh->add_channel( ch_pntiw );
    170171                                        }
    … …  
    190191                                        sstream >> num_tris;
    191192
    192                                         raw_data_channel* ch_i = raw_data_channel::create_index<uint32>( num_tris * 3 );
     193                                        raw_data_channel* ch_i = raw_data_channel::create<index_u32>( num_tris * 3 );
    193194                                        uint32* vtx_i                = reinterpret_cast< uint32* >( ch_i->data );
    194195                                        uint32 idx = 0;
    … …  
    234235                        }
    235236
    236                         prepare_mesh( nodes, weight_info.size(), mesh, weights.data(), weight_info.data() );
     237                        prepare_mesh( reinterpret_cast< md5_vtx_pntiw* >( ch_pntiw->data ), nodes, weight_info.size(), mesh, weights.data(), weight_info.data() );
    237238
    238239                        m_meshes[ num_meshes ] = mesh;
    … …  
    333334}
    334335
    335 bool md5_loader::prepare_mesh( mesh_node_data* nodes, uint32 vtx_count, mesh_data* mdata, md5_weight* weights, md5_weight_info* weight_info )
     336bool md5_loader::prepare_mesh( md5_vtx_pntiw* vtx_data, mesh_node_data* nodes, uint32 vtx_count, mesh_data* mdata, md5_weight* weights, md5_weight_info* weight_info )
    336337{
    337338        assert( m_type == MESH );
    338339        md5_vtx_pnt* vtcs       = reinterpret_cast< md5_vtx_pnt* >( mdata->get_channel< md5_vtx_pnt >()->data );
    339         md5_vtx_pntiw* vtx_data = reinterpret_cast< md5_vtx_pntiw* >( mdata->get_channel< md5_vtx_pntiw >()->data );
    340340
    341341        for ( uint32 i = 0; i < vtx_count; ++i )
    … …  
    486486                        const transform* ptv = reinterpret_cast< const transform* >( pjoint.data->get_channel(0)->data );
    487487                        transform ptr;
    488                         if ( pjoint.data->get_channel(0)->count > index ) ptr = ptv[ index ];
     488                        if ( pjoint.data->get_channel(0)->element_count() > index ) ptr = ptv[ index ];
    489489                        vec3 rot_pos = ptr.get_orientation() * pos;
    490490

  • trunk/src/formats/nmd_loader.cc

    r411 r412  
    129129                                source.read( &cheader, sizeof( cheader ), 1 );
    130130                                raw_data_channel* channel = raw_data_channel::create( cheader.format, cheader.count );
    131                                 source.read( channel->data, channel->desc.element_size(), channel->count );
     131                                source.read( channel->data, channel->element_size(), channel->element_count() );
    132132                                kdata->add_channel( channel );
    133133                        }
    … …  
    168168        {
    169169                size += sizeof( nmd_element_header ) + sizeof( nmd_stream_header );
    170                 size += chan->size();
     170                size += chan->raw_size();
    171171        }
    172172
    … …  
    184184                cheader.type     = nmd_type::STREAM;
    185185                cheader.children = 0;
    186                 cheader.size     = chan->size() + sizeof( nmd_stream_header );
     186                cheader.size     = chan->raw_size() + sizeof( nmd_stream_header );
    187187                stream_out.write( &cheader, sizeof( cheader ), 1 );
    188188
    189189                nmd_stream_header sheader;
    190                 sheader.format = chan->desc;
    191                 sheader.count  = chan->count;
     190                sheader.format = chan->descriptor();
     191                sheader.count  = chan->element_count();
    192192                stream_out.write( &sheader, sizeof( sheader ), 1 );
    193                 stream_out.write( chan->data, chan->desc.element_size(), chan->count );
     193                stream_out.write( chan->raw_data(), chan->element_size(), chan->element_count() );
    194194        }
    195195}
    … …  
    206206                        {
    207207                                total += sizeof( nmd_element_header ) + sizeof( nmd_stream_header );
    208                                 total += node->data->get_channel(c)->size();
     208                                total += node->data->get_channel(c)->raw_size();
    209209                        }
    210210        }
    … …  
    231231                {
    232232                        chan_size += sizeof( nmd_element_header ) + sizeof( nv::nmd_stream_header );
    233                         chan_size += node->data->get_channel(c)->size();
     233                        chan_size += node->data->get_channel(c)->raw_size();
    234234                }
    235235
    … …  
    252252                        eheader.type     = nmd_type::KEY_CHANNEL;
    253253                        eheader.children = 0;
    254                         eheader.size     = sizeof( nmd_stream_header ) + channel->size();
     254                        eheader.size     = sizeof( nmd_stream_header ) + channel->raw_size();
    255255                        stream_out.write( &eheader, sizeof( eheader ), 1 );
    256256
    257257                        nmd_stream_header cheader;
    258                         cheader.format    = channel->desc;
    259                         cheader.count     = channel->count;
     258                        cheader.format    = channel->descriptor();
     259                        cheader.count     = channel->element_count();
    260260                        stream_out.write( &cheader, sizeof( cheader ), 1 );
    261                         stream_out.write( channel->data, channel->desc.element_size(), channel->count );
     261                        stream_out.write( channel->raw_data(), channel->element_size(), channel->element_count() );
    262262                }
    263263        }

  • trunk/src/formats/obj_loader.cc

    r411 r412  
    324324                }
    325325       
    326                 raw_data_channel* channel = new raw_data_channel();
    327                 nv::uint8* data = nullptr;
    328 
    329                 if ( reader->raw_size() > 0 )
    330                 {
    331                         data = new uint8[ reader->raw_size() ];
    332                         raw_copy_n( reader->raw_pointer(), reader->raw_size(), data );
    333                 }
    334                 channel->data  = data;
    335                 channel->desc  = m_descriptor;
    336                 channel->count = reader->size * 3;
     326                raw_data_channel* channel = raw_data_channel::create( m_descriptor, reader->size * 3 );
     327                if ( reader->raw_size() > 0 )
     328                {
     329                        raw_copy_n( reader->raw_pointer(), reader->raw_size(), channel->data );
     330                }
    337331
    338332                mesh_data* mesh = new mesh_data(reader->name);

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