Changeset 417


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

Legend:

Unmodified
Added
Removed

  • trunk/nv/formats/md3_loader.hh

    r416 r417  
    4141        private:
    4242                void release_mesh_frame( data_channel_set* data, sint32 frame, sint32 surface );
    43                 raw_data_channel* load_tags( const string_view& tag );
     43                void load_tags( raw_data_channel* channel, const string_view& tag );
     44
    4445                bool m_merge_all;
    4546                void* m_md3;

  • trunk/nv/gfx/animation.hh

    r416 r417  
    2020{
    2121
    22         class key_data : public data_channel_set
    23         {
    24         public:
    25                 key_data() {}
    26 
    27                 void add_key_channel( raw_data_channel* channel )
    28                 {
    29                         NV_ASSERT( channel, "nullptr passed to add_channel!" );
    30                         add_channel( channel );
    31                         for ( const auto& cslot : channel->descriptor() )
    32                                 if ( cslot.vslot != slot::TIME )
    33                                         m_final_key.push_slot( cslot.etype, cslot.vslot );
    34                 }
    35 
     22        class key_channel_set : public data_channel_set
     23        {
     24        public:
    3625                mat4 get_raw_matrix( uint32 index ) const
    3726                {
    … …  
    151140
    152141        private:
     142                friend class key_channel_set_creator;
     143
     144                key_channel_set() {}
     145
    153146                data_descriptor m_final_key;
    154147        };

  • trunk/nv/gfx/keyframed_mesh.hh

    r411 r417  
    5252                const mesh_data*        m_mesh_data;
    5353                const mesh_nodes_data*  m_tag_map;
    54                 const raw_data_channel* m_vchannel;
    5554
    5655                buffer       m_pbuffer;

  • trunk/nv/interface/context.hh

    r416 r417  
    155155                }
    156156
    157                 void add_vertex_buffers( vertex_array va, buffer buf, const raw_data_channel* channel )
    158                 {
    159                         for ( const auto& cslot : channel->descriptor() )
     157                void add_vertex_buffers( vertex_array va, buffer buf, const data_descriptor& descriptor )
     158                {
     159                        for ( const auto& cslot : descriptor )
    160160                        {
    161161                                const datatype_info& info = get_datatype_info( cslot.etype );
    162                                 add_vertex_buffer( va, cslot.vslot, buf, info.base, info.elements, cslot.offset, channel->descriptor().element_size(), false );
     162                                add_vertex_buffer( va, cslot.vslot, buf, info.base, info.elements, cslot.offset, descriptor.element_size(), false );
    163163                        }
    164164                }
    … …  
    300300                {
    301301                        vertex_array  va = create_vertex_array();
    302                         //array_view< raw_data_channel* > channels = data->get_raw_channels();
    303                         //for ( uint32 ch = 0; ch < channels.size(); ++ch )
    304302                        for ( auto channel : *data )
    305303                        {
    306 //                              const raw_data_channel* channel = channels[ch];
    307304                                if ( channel->size() > 0 )
    308305                                {
    … …  
    317314                                        {
    318315                                                buffer b = m_device->create_buffer( VERTEX_BUFFER, hint, channel->raw_size(), channel->raw_data() );
    319                                                 add_vertex_buffers( va, b, channel );
     316                                                add_vertex_buffers( va, b, desc );
    320317                                        }
    321318                                }

  • trunk/nv/interface/data_descriptor.hh

    r416 r417  
    3939        {
    4040                datatype etype = NONE;
    41                 uint32   offset = 0;
     41                uint8    offset = 0;
    4242                slot     vslot = slot::POSITION;
    4343        };
    … …  
    277277                        m_slots[m_size].offset = m_element_size;
    278278                        m_slots[m_size].vslot = vslot;
    279                         m_element_size += get_datatype_info( etype ).size;
     279                        m_element_size += static_cast< uint8 >( get_datatype_info( etype ).size );
    280280                        m_size++;
    281281                }
    … …  
    288288                                m_slots[m_size].offset = m_element_size;
    289289                                m_slots[m_size].vslot = dslot.vslot;
    290                                 m_element_size += get_datatype_info( dslot.etype ).size;
     290                                m_element_size += static_cast< uint8 >( get_datatype_info( dslot.etype ).size );
    291291                                m_size++;
    292292                        }
    … …  
    304304
    305305                data_descriptor_slot m_slots[uint16( slot::MAX_STORE )];
    306                 uint32               m_size = 0;
    307                 uint32               m_element_size = 0;
     306                uint8                m_size = 0;
     307                uint8                m_element_size = 0;
    308308
    309309                template < typename Struct, slot Slot >

  • trunk/nv/interface/mesh_data.hh

    r416 r417  
    2828                sint16    parent_id;
    2929                mat4      transform;
    30                 key_data* data;
     30                key_channel_set* data;
    3131        };
    3232
    … …  
    7575                }
    7676
    77                 key_data* release_node_data( size_t i )
     77                key_channel_set* release_node_data( size_t i )
    7878                {
    79                         key_data* result = m_nodes[i].data;
     79                        key_channel_set* result = m_nodes[i].data;
    8080                        m_nodes[i].data = nullptr;
    8181                        return result;

  • trunk/nv/stl/math.hh

    r398 r417  
    112112        };
    113113
    114         enum datatype
     114        enum datatype : uint8
    115115        {
    116116                NONE,

  • 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();

  • trunk/src/gfx/keyframed_mesh.cc

    r416 r417  
    2323        , m_active( false )
    2424{
    25         m_index_count  = m_mesh_data->get_channel( slot::INDEX )->size();
    26         m_vertex_count = m_mesh_data->get_channel<vertex_t>()->size();
    27         m_vchannel     = m_mesh_data->get_channel<vertex_pnt>();
    28         m_vsize        = sizeof( vertex_pnt );
    29         m_has_tangent  = true;
    30         if ( m_vchannel == nullptr )
    31         {
    32                 m_vchannel     = m_mesh_data->get_channel<vertex_pn>();
    33                 m_has_tangent  = false;
    34                 m_vsize        = sizeof( vertex_pn );
    35         }
    36         m_frame_count  = m_vchannel->size() / m_vertex_count;
     25        m_index_count   = m_mesh_data->get_channel_size( slot::INDEX );
     26        m_vertex_count  = m_mesh_data->get_channel_size<vertex_t>();
     27        uint32 pos_size = m_mesh_data->get_channel_size<vertex_pnt>();
     28        if ( pos_size == 0 )
     29        {
     30                pos_size      = m_mesh_data->get_channel_size<vertex_pn>();
     31                m_has_tangent = false;
     32                m_vsize       = sizeof( vertex_pn );
     33        }
     34        else
     35        {
     36                m_has_tangent = true;
     37                m_vsize       = sizeof( vertex_pnt );
     38        }
     39        m_frame_count  = pos_size / m_vertex_count;
    3740        m_pbuffer      = buffer();
    3841}
    … …  
    4750        if ( !m_tag_map ) return transform();
    4851        NV_ASSERT( node_id < m_tag_map->get_count(), "TAGMAP FAIL" );
    49         const key_data* data = m_tag_map->get_node( node_id )->data;
     52        const key_channel_set* data = m_tag_map->get_node( node_id )->data;
    5053        NV_ASSERT( data, "TAG FAIL" );
    5154        transform last = data->get_raw_transform( m_last_frame );
    … …  
    183186        : keyframed_mesh( a_context, a_data, a_tag_map )
    184187{
     188        const raw_data_channel* vchannel = m_has_tangent ? a_data->get_channel< vertex_pnt >() : a_data->get_channel< vertex_pn >();
    185189        m_va      = m_context->create_vertex_array();
    186         m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, m_vchannel->raw_data() );
    187         m_context->add_vertex_buffers( m_va, m_pbuffer, m_vchannel );
     190        m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, vchannel->raw_data() );
     191        m_context->add_vertex_buffers( m_va, m_pbuffer, vchannel->descriptor() );
    188192
    189193        buffer  vb = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * sizeof( vec2 ), m_mesh_data->get_channel_data<vertex_t>() );
    190         m_context->add_vertex_buffers( m_va, vb, m_mesh_data->get_channel<vertex_t>() );
     194        m_context->add_vertex_buffers( m_va, vb, m_mesh_data->get_channel<vertex_t>()->descriptor() );
    191195
    192196        const raw_data_channel* index_channel = m_mesh_data->get_channel( slot::INDEX );

  • trunk/src/gfx/mesh_creator.cc

    r416 r417  
    1919        {
    2020                sint16 parent_id = m_data->m_nodes[i].parent_id;
    21                 key_data* keys   = m_data->m_nodes[i].data;
    22                 key_data* pkeys  = ( parent_id != -1 ? m_data->m_nodes[parent_id].data : nullptr );
    23                 size_t count     = ( keys ? keys->get_channel(0)->size() : 0 );
    24                 size_t pcount    = ( pkeys ? pkeys->get_channel(0)->size() : 0 );
     21                key_channel_set* keys   = m_data->m_nodes[i].data;
     22                key_channel_set* pkeys  = ( parent_id != -1 ? m_data->m_nodes[parent_id].data : nullptr );
     23                size_t count     = ( keys ? keys->get_channel_size(0) : 0 );
     24                size_t pcount    = ( pkeys ? pkeys->get_channel_size(0) : 0 );
    2525                max_frames = nv::max<uint32>( count, max_frames );
    2626                if ( pkeys && pkeys->size() > 0 && keys && keys->size() > 0 )
    2727                {
    28                         data_channel_creator< nv_key_transform > channel_creator( const_cast< raw_data_channel* >( keys->get_channel( 0 ) ) );
     28                        data_channel_access< nv_key_transform > channel_creator( keys, 0 );
    2929                        nv_key_transform* channel = channel_creator.data();
    3030                        const nv_key_transform* pchannel = pkeys->get_channel(0)->data_cast< nv_key_transform >();
    … …  
    5555        for ( size_t i = 0; i < m_data->get_count(); ++i )
    5656        {
    57                 key_data* old_keys = m_data->m_nodes[i].data;
     57                key_channel_set* old_keys = m_data->m_nodes[i].data;
    5858                if ( old_keys && old_keys->size() > 0 )
    5959                {
    … …  
    6969                        }
    7070
    71                         data_channel_creator< nv_key_transform > kt_channel( max_keys );
    72                         key_data* new_keys = new key_data;
     71                        key_channel_set* new_keys = key_channel_set_creator::create( 1 );
     72                        key_channel_set_creator nk_access( new_keys );
     73                        data_channel_access< nv_key_transform > kt_channel( nk_access.add_channel<nv_key_transform>( max_keys ) );
     74
    7375                        data_descriptor final_key = old_keys->get_final_key();
    7476
    … …  
    8789
    8890                        delete old_keys;
    89                         new_keys->add_key_channel( kt_channel.release() );
    9091                        m_data->m_nodes[i].data = new_keys;
    9192                }
    … …  
    105106                if ( node.data )
    106107                {
    107                         key_data* kdata  = node.data;
     108                        key_channel_set* kdata  = node.data;
    108109                        for ( size_t c = 0; c < kdata->size(); ++c )
    109110                        {
    110                                 raw_data_channel_creator channel( const_cast< raw_data_channel* >( kdata->get_channel( c ) ) );
     111                                raw_data_channel_access channel( kdata, c );
    111112                                size_t key_size = channel.element_size();
    112113                                for ( size_t n = 0; n < channel.size(); ++n )
    … …  
    127128        for ( uint32 c = 0; c < m_data->size(); ++c )
    128129        {
    129                 raw_data_channel_creator channel( m_data, c );
     130                raw_data_channel_access channel( m_data, c );
    130131                const data_descriptor&  desc    = channel.descriptor();
    131132                uint8* raw_data = channel.raw_data();
    … …  
    175176        size_t n_offset = 0;
    176177        if ( ch_n == -1 ) return;
    177         raw_data_channel_creator channel( m_data, unsigned( ch_n ) );
     178        raw_data_channel_access channel( m_data, unsigned( ch_n ) );
    178179        for ( const auto& cslot : channel.descriptor() )
    179180                if ( cslot.vslot == slot::NORMAL )
    … …  
    251252        }
    252253
    253         data_channel_creator< vertex_g > g_channel( p_channel->size() );
    254         vec4* tangents              = &( g_channel.data()[0].tangent );
     254        raw_data_channel* g_channel = data_channel_creator::create< vertex_g >( p_channel->size() );
     255        vec4* tangents              = &( data_channel_access< vertex_g >( g_channel ).data()[0].tangent );
    255256        vec3* tangents2             = new vec3[ p_channel->size() ];
    256257        uint32 tri_count = i_channel ? i_channel->size() / 3 : t_channel->size() / 3;
    … …  
    333334        delete tangents2;
    334335
    335         ( data_channel_set_creator( m_data ))[ n_channel_index ] = merge_channels( n_channel, g_channel.channel() );
    336         delete n_channel;
     336        data_channel_set_creator( m_data ).set_channel( n_channel_index, merge_channels( n_channel, g_channel ) );
     337        delete g_channel;
    337338}
    338339
    … …  
    343344        desc.append( b->descriptor() );
    344345
    345         raw_data_channel_creator result( desc, a->size() );
     346        raw_data_channel* result = data_channel_creator::create( desc, a->size() );
    346347        for ( uint32 i = 0; i < a->size(); ++i )
    347348        {
    348                 raw_copy_n( a->raw_data() + i * a->element_size(), a->element_size(), result.raw_data() + i*desc.element_size() );
    349                 raw_copy_n( b->raw_data() + i * b->element_size(), b->element_size(), result.raw_data() + i*desc.element_size() + a->element_size() );
    350         }
    351 
    352         return result.release();
     349                raw_copy_n( a->raw_data() + i * a->element_size(), a->element_size(), raw_data_channel_access( result ).raw_data() + i*desc.element_size() );
     350                raw_copy_n( b->raw_data() + i * b->element_size(), b->element_size(), raw_data_channel_access( result ).raw_data() + i*desc.element_size() + a->element_size() );
     351        }
     352
     353        return result;
    353354}
    354355
    … …  
    360361        size_t vtx_size = a->element_size();
    361362
    362         raw_data_channel_creator result( a->descriptor(), a->size() + b->size() );
     363        raw_data_channel* result = data_channel_creator::create( a->descriptor(), a->size() + b->size() );
     364        uint8* rdata = raw_data_channel_access( result ).raw_data();
    363365
    364366        if ( frame_count == 1 )
    365367        {
    366368                size_t a_size = vtx_size * a->size();
    367                 raw_copy_n( a->raw_data(), a_size, result.raw_data() );
    368                 raw_copy_n( b->raw_data(), vtx_size * b->size(), result.raw_data() + a_size );
     369                raw_copy_n( a->raw_data(), a_size, rdata );
     370                raw_copy_n( b->raw_data(), vtx_size * b->size(), rdata + a_size );
    369371        }
    370372        else
    … …  
    377379                for ( size_t i = 0; i < frame_count; ++i )
    378380                {
    379                         raw_copy_n( a->raw_data() + pos_a, frame_size_a, result.raw_data() + pos );
    380                         raw_copy_n( b->raw_data() + pos_b, frame_size_b, result.raw_data() + pos + frame_size_a );                              pos_a += frame_size_a;
     381                        raw_copy_n( a->raw_data() + pos_a, frame_size_a, rdata + pos );
     382                        raw_copy_n( b->raw_data() + pos_b, frame_size_b, rdata + pos + frame_size_a );                          pos_a += frame_size_a;
    381383                        pos_b += frame_size_b;
    382384                        pos   += frame_size_a + frame_size_b;
    … …  
    384386        }
    385387
    386         return result.release();
     388        return result;
    387389}
    388390
    … …  
    422424                bool old_is_index = old->size() > 0 && old->descriptor()[0].vslot == slot::INDEX;
    423425                size_t frame_count = ( old_is_index ? 1 : old->size() / size );
    424                 data[c] = append_channels( old, other->get_channel(c), frame_count );
     426                data.set_channel( c, append_channels( old, other->get_channel(c), frame_count ) );
    425427                NV_ASSERT( data[c], "Merge problem!" );
    426428                if ( old_is_index )
    … …  
    431433                                {
    432434                                        NV_ASSERT( size + osize < uint16(-1), "Index out of range!" );
    433                                         raw_data_channel_creator ic( data[c] );
     435                                        raw_data_channel_access ic( data[c] );
    434436                                        uint16* indexes = reinterpret_cast<uint16*>( ic.raw_data() );
    435437                                        for ( uint16 i = uint16( old->size() ); i < ic.size(); ++i )
    … …  
    440442                        case UINT   :
    441443                                {
    442                                         raw_data_channel_creator ic( data[c] );
     444                                        raw_data_channel_access ic( data[c] );
    443445                                        uint32* indexes = reinterpret_cast<uint32*>( ic.raw_data() );
    444446                                        for ( uint32 i = old->size(); i < ic.size(); ++i )

  • trunk/src/gfx/skeletal_mesh.cc

    r416 r417  
    4545                        {
    4646                                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 );
     47                                a_context->add_vertex_buffers( m_va, b, desc );
    4848                        }
    4949                }
Note: See TracChangeset for help on using the changeset viewer.