Changeset 412 for trunk/src/formats


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/formats
Files:
6 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);
Note: See TracChangeset for help on using the changeset viewer.