Changeset 417 for trunk/src/formats


Ignore:
Timestamp:
07/10/15 19:50:47 (10 years ago)
Author:
epyon
Message:
  • further access restrictions improvements
Location:
trunk/src/formats
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/formats/assimp_loader.cc

    r416 r417  
    124124        else
    125125                desc.initialize< assimp_plain_vtx >();
    126         raw_data_channel_creator channel( desc, mesh->mNumVertices );
    127         uint8* cdata = channel.raw_data();
     126        data_channel_set_creator maccess( data );
     127        maccess.set_name( mesh->mName.data );
     128        uint8*  cdata   = maccess.add_channel( desc, mesh->mNumVertices ).raw_data();
     129        uint16* indices = reinterpret_cast<uint16*>( maccess.add_channel< index_u16 >( mesh->mNumFaces * 3 ).raw_data() );
    128130
    129131        if ( mesh->mTangents && mesh->mBitangents )
    … …  
    171173        }
    172174
    173         data_channel_creator< index_u16 > ichannel( mesh->mNumFaces * 3 );
    174         uint16* indices = reinterpret_cast<uint16*>( ichannel.raw_data() );
    175175        for (unsigned int i=0; i<mesh->mNumFaces; i++)
    176176        {
    … …  
    182182        }
    183183
    184         data_channel_set_creator maccess( data );
    185         maccess.set_name( mesh->mName.data );
    186         maccess.add_channel( channel.release() );
    187         maccess.add_channel( ichannel.release() );
    188184}
    189185
    … …  
    321317                        if ( m > 0 && bones.size() > 0 )
    322318                        {
    323                                 data_channel_creator< assimp_skinned_vtx > channel( const_cast< raw_data_channel* >( meshes[m].get_channel(0) ) );
     319                                data_channel_access< assimp_skinned_vtx > channel( const_cast< raw_data_channel* >( meshes[m].get_channel(0) ) );
    324320                                for ( unsigned v = 0; v < channel.size(); ++v )
    325321                                {
    … …  
    422418        }
    423419
    424         data->data = new key_data;
    425         data_channel_creator< assimp_key_p > pchannel_creator( node->mNumPositionKeys );
    426         data_channel_creator< assimp_key_r > rchannel_creator( node->mNumRotationKeys );
    427 //      data_channel_creator< assimp_key_s > schannel_creator( node->mNumScalingKeys );
    428 
    429         assimp_key_p* pchannel = pchannel_creator.data();
    430         assimp_key_r* rchannel = rchannel_creator.data();
    431         //assimp_key_s* schannel = ((assimp_key_s*)(raw_schannel->data));
     420        data->data = key_channel_set_creator::create( 2 );
     421        key_channel_set_creator key_set( data->data );
     422
     423        assimp_key_p* pchannel = key_set.add_channel< assimp_key_p >( node->mNumPositionKeys ).data();
     424        assimp_key_r* rchannel = key_set.add_channel< assimp_key_r >( node->mNumRotationKeys ).data();
     425//      assimp_key_s* schannel = key_set.add_channel< assimp_key_s >( node->mNumScalingKeys ).data();
    432426
    433427        for ( unsigned np = 0; np < node->mNumPositionKeys; ++np )
    … …  
    460454//              }
    461455//      }
    462         data->data->add_key_channel( pchannel_creator.release() );
    463         data->data->add_key_channel( rchannel_creator.release() );
    464 //      data->data->add_key_channel( schannel_creator.release() );
     456
    465457}
    466458

  • trunk/src/formats/md2_loader.cc

    r416 r417  
    326326        size_t frame_count   = ( frame == -1 ? num_frames : 1 );
    327327
    328         data_channel_creator< vtx_md2_pn > mc_pn( num_verts * frame_count );
    329         vtx_md2_pn* vtx_pn = mc_pn.data();
     328        data_channel_set_creator maccess( data );
     329        vtx_md2_pn* vtx_pn = maccess.add_channel< vtx_md2_pn >( num_verts * frame_count ).data();
     330        vtx_md2_t* vtx_t   = maccess.add_channel< vtx_md2_t >( num_verts ).data();
     331        uint16* icp        = &maccess.add_channel< index_u16 >( m_new_indexes.size() ).data()->index;
    330332
    331333        uint32 index = 0;
    … …  
    349351        }
    350352
    351         data_channel_creator< vtx_md2_t > mc_t( num_verts );
    352         vtx_md2_t* vtx_t = mc_t.data();
    353 
    354353        vec2 scale( 1.0f / static_cast<float>( md2->header.skinwidth ), 1.0f / static_cast<float>( md2->header.skinheight ) );
    355354        for (size_t i = 0; i < num_verts; ++i )
    … …  
    359358        }
    360359
    361         data_channel_creator< index_u16 > ic( m_new_indexes.size() );
    362360        if ( m_new_indexes.size() > 0 )
    363361        {
    364                 uint16* icp = reinterpret_cast< uint16* >( ic.raw_data() );
    365362                raw_copy_n( m_new_indexes.data(), m_new_indexes.size(), icp );
    366363        }
    367364
    368         data_channel_set_creator maccess( data );
    369 
    370         maccess.add_channel( mc_pn.release() );
    371         maccess.add_channel( mc_t.release() );
    372         maccess.add_channel( ic.release() );
    373365}
    374366

  • trunk/src/formats/md3_loader.cc

    r416 r417  
    287287}
    288288
    289 nv::raw_data_channel* nv::md3_loader::load_tags( const string_view& tag )
     289void nv::md3_loader::load_tags( raw_data_channel* channel, const string_view& tag )
    290290{
    291291        md3_t* md3 = reinterpret_cast< md3_t* >( m_md3 );
    292         data_channel_creator< md3_key > result( uint32( md3->header.num_frames ) );
     292        data_channel_access< md3_key > access( channel );
    293293        // TODO: is this brain damaged in efficiency (loop nest order) or what?
    294294        for ( sint32 f = 0; f < md3->header.num_frames; ++f )
    … …  
    304304                                vec3 axisy  ( md3_vec3( rtag.axis[2] ) );
    305305                                vec3 origin ( md3_vec3( rtag.origin )  );
    306                                 result.data()[f].tform = transform( origin, quat( mat3( axisx, axisy, axisz ) ) );
     306                                access.data()[f].tform = transform( origin, quat( mat3( axisx, axisy, axisz ) ) );
    307307                        }
    308308                }
    309309
    310310        }
    311         return result.release();
    312311}
    313312
    … …  
    353352                }
    354353
    355         data_channel_creator< vtx_md3_pn > mc_pn( static_cast< uint32 >( num_verts * frame_count ) );
    356         data_channel_creator< vtx_md3_t > mc_t( static_cast< uint32 >( num_verts ) );
    357         data_channel_creator< index_u16 > ic( static_cast< uint32 >( index_count ) );
    358         vtx_md3_pn* vtx_pn = mc_pn.data();
    359         vtx_md3_t*  vtx_t = mc_t.data();
    360         uint16*     icp    = &(ic.data()[0].index);
     354        data_channel_set_creator maccess( data );
     355        maccess.set_name( reinterpret_cast<char*>( md3->header.name ) );
     356
     357        vtx_md3_pn* vtx_pn = maccess.add_channel< vtx_md3_pn >( static_cast< uint32 >( num_verts * frame_count ) ).data();
     358        vtx_md3_t*  vtx_t  = maccess.add_channel< vtx_md3_t >( static_cast< uint32 >( num_verts ) ).data();
     359        uint16*     icp    = reinterpret_cast< uint16* >( maccess.add_channel< index_u16 >( static_cast< uint32 >( index_count ) ).data() );
    361360
    362361        uint32 index  = 0;
    … …  
    413412        }
    414413
    415         data_channel_set_creator maccess( data );
    416         maccess.set_name( reinterpret_cast<char*>( md3->header.name ) );
    417         maccess.add_channel( mc_pn.release() );
    418         maccess.add_channel( mc_t.release() );
    419         maccess.add_channel( ic.release() );
    420414}
    421415
    … …  
    435429                nodes[i].parent_id = -1;
    436430                nodes[i].target_id = -1;
    437                 nodes[i].data      = new key_data;
    438        
    439                 raw_data_channel* keys = load_tags( name );
    440                 nodes[i].data->add_key_channel( keys );
     431                nodes[i].data      = key_channel_set_creator::create( 1 );
     432                load_tags( key_channel_set_creator( nodes[i].data ).add_channel<md3_key>( uint32( md3->header.num_frames ) ).channel(), name );
    441433        }
    442434        return new mesh_nodes_data( "tags", node_count, nodes );

  • trunk/src/formats/md5_loader.cc

    r416 r417  
    137137                {
    138138                        assert( m_type == MESH );
    139                         data_channel_set_creator mesh;
     139                        data_channel_set* mesh = data_channel_set_creator::create( 4 );
     140                        data_channel_set_creator maccess( mesh );
    140141
    141142                        uint32 num_verts   = 0;
    … …  
    160161                                        md5_vtx_t* tdata = nullptr;
    161162                                        {
    162                                                 data_channel_creator<md5_vtx_pnt>   ch_pnt( num_verts );
    163                                                 data_channel_creator<md5_vtx_t>     ch_t( num_verts );
    164                                                 data_channel_creator<md5_vtx_pntiw> ch_pntiw( num_verts );
    165                                                 tdata = ch_t.data();
    166                                                 mesh.add_channel( ch_pnt.release() );
    167                                                 mesh.add_channel( ch_t.release() );
    168                                                 // TODO: hack to prevent rendering
    169                                                 //ch_pntiw->m_count = 0;
    170                                                 mesh.add_channel( ch_pntiw.release() );
     163                                                maccess.add_channel<md5_vtx_pnt>( num_verts );
     164                                                tdata = maccess.add_channel<md5_vtx_t>( num_verts ).data();
     165                                                maccess.add_channel<md5_vtx_pntiw>( num_verts );
    171166                                        }
    172167                                        weight_info.resize( num_verts );
    … …  
    191186                                        sstream >> num_tris;
    192187
    193                                         data_channel_creator< index_u32 > ch_i( num_tris * 3 );
    194                                         uint32* vtx_i                = reinterpret_cast< uint32* >( ch_i.raw_data() );
     188                                        uint32* vtx_i = reinterpret_cast< uint32* >( maccess.add_channel< index_u32 >( num_tris * 3 ).raw_data() );
    195189                                        uint32 idx = 0;
    196190
    … …  
    211205                                        }             
    212206
    213                                         mesh.add_channel( ch_i.release() );
    214207                                }
    215208                                else if ( command == "numweights" )
    … …  
    236229                        }
    237230
    238                         data_channel_set* mdata = mesh.release();
    239                         prepare_mesh( nodes, weight_info.size(), mdata, weights.data(), weight_info.data() );
    240 
    241                         m_meshes[ num_meshes ] = mdata;
     231                        prepare_mesh( nodes, weight_info.size(), mesh, weights.data(), weight_info.data() );
     232
     233                        m_meshes[ num_meshes ] = mesh;
    242234                        num_meshes++;
    243235                } // mesh
    … …  
    258250                                nodes[i].transform = mat4();
    259251                                nodes[i].target_id = -1;
    260                                 nodes[i].data      = new key_data;
    261                                 data_channel_creator< md5_key_t > fc( num_frames );
    262                                 nodes[i].data->add_key_channel( fc.release() );
    263                                 next_line( sstream );
     252                                nodes[i].data = key_channel_set_creator::create( 1 );
     253                                key_channel_set_creator( nodes[i].data ).add_channel< md5_key_t >( num_frames );
     254                                next_line( sstream );
    264255                        }
    265256                        discard( sstream, "}" );
    … …  
    340331{
    341332        assert( m_type == MESH );
    342         data_channel_creator< md5_vtx_pnt >   pnt  ( const_cast< raw_data_channel* >( mdata->get_channel< md5_vtx_pnt >() ) );
    343         data_channel_creator< md5_vtx_pntiw > pntiw( const_cast< raw_data_channel* >( mdata->get_channel< md5_vtx_pntiw >() ) );
     333        data_channel_access< md5_vtx_pnt >   pnt  ( const_cast< raw_data_channel* >( mdata->get_channel< md5_vtx_pnt >() ) );
     334        data_channel_access< md5_vtx_pntiw > pntiw( const_cast< raw_data_channel* >( mdata->get_channel< md5_vtx_pntiw >() ) );
    344335        md5_vtx_pntiw* vtx_data = pntiw.data();
    345336        md5_vtx_pnt* vtcs = pnt.data();

  • trunk/src/formats/nmd_loader.cc

    r416 r417  
    3535bool nv::nmd_loader::load_mesh( stream& source, const nmd_element_header& e )
    3636{
    37         data_channel_set_creator mesh;
     37        data_channel_set* mesh = data_channel_set_creator::create( e.children );
     38        data_channel_set_creator mcreator( mesh );
    3839        for ( uint32 s = 0; s < e.children; ++s )
    3940        {
    … …  
    4445                nmd_stream_header stream_header;
    4546                source.read( &stream_header, sizeof( stream_header ), 1 );
    46                 raw_data_channel_creator channel_creator( stream_header.format, stream_header.count );
    47                 source.read( channel_creator.raw_data(), channel_creator.element_size(), channel_creator.size() );
    48                 mesh.add_channel( channel_creator.release() );
     47                raw_data_channel_access channel( mcreator.add_channel( stream_header.format, stream_header.count ) );
     48                source.read( channel.raw_data(), channel.element_size(), channel.size() );
    4949        }
    5050        m_mesh_names.push_back( e.name );
    51         m_meshes.push_back( mesh.release() );
     51        m_meshes.push_back( mesh );
    5252        return true;
    5353}
    … …  
    121121                if ( ch_count > 0 )
    122122                {
    123                         key_data* kdata = new key_data;
     123                        key_channel_set* kdata = key_channel_set_creator::create( ch_count );
     124                        key_channel_set_creator kaccess( kdata );
    124125                        m_node_array[i].data = kdata;
    125126                        for ( uint32 c = 0; c < ch_count; ++c )
    … …  
    129130                                nv::nmd_stream_header cheader;
    130131                                source.read( &cheader, sizeof( cheader ), 1 );
    131                                 raw_data_channel_creator channel_creator( cheader.format, cheader.count );
    132                                 source.read( channel_creator.raw_data(), channel_creator.element_size(), channel_creator.size() );
    133                                 kdata->add_key_channel( channel_creator.release() );
     132                                raw_data_channel_access channel( kaccess.add_channel( cheader.format, cheader.count ) );
     133                                source.read( channel.raw_data(), channel.element_size(), channel.size() );
    134134                        }
    135135                }

  • trunk/src/formats/obj_loader.cc

    r416 r417  
    326326                }
    327327       
    328                 raw_data_channel_creator channel( m_descriptor, reader->size * 3 );
     328                data_channel_set* result = data_channel_set_creator::create( 1 );
     329                data_channel_set_creator raccess( result );// ( reader->name );
     330                uint8* rdata = raccess.add_channel( m_descriptor, reader->size * 3 ).raw_data();
     331
    329332                if ( reader->raw_size() > 0 )
    330333                {
    331                         raw_copy_n( reader->raw_pointer(), reader->raw_size(), channel.raw_data() );
    332                 }
    333 
    334                 data_channel_set_creator result;// ( reader->name );
    335                 result.add_channel( channel.release() );
    336                 m_meshes.push_back( result.release() );
     334                        raw_copy_n( reader->raw_pointer(), reader->raw_size(), rdata );
     335                }
     336
     337                m_meshes.push_back( result );
    337338
    338339                reader->reset();
Note: See TracChangeset for help on using the changeset viewer.