Changeset 413


Ignore:
Timestamp:
07/09/15 18:53:08 (10 years ago)
Author:
epyon
Message:
  • data_descriptor creators ( buggy )
Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/gfx/animation.hh

    r412 r413  
    8989                        if ( channel->element_count() == 0 ) return 0;
    9090                        uint32 keyfsize = channel->element_size() / 4;
    91                         const float* fdata = reinterpret_cast<const float*>( channel->data ) + keyfsize * index;
     91                        const float* fdata = reinterpret_cast<const float*>( channel->raw_data() ) + keyfsize * index;
    9292                        uint32 mod = 0;
    9393                        if ( channel->descriptor()[0].vslot == slot::TIME ) mod = 1;
    … …  
    102102                        uint32 keyfsize = channel->element_size() / 4;
    103103                        uint32 keyfresult = keyfsize;
    104                         const float* fdata = reinterpret_cast<const float*>( channel->data );
     104                        const float* fdata = reinterpret_cast<const float*>( channel->raw_data() );
    105105
    106106                        uint32 slot = 0;
    … …  
    183183                {
    184184                        NV_ASSERT( m_data, "Data is null!" );
     185                        const KEY* keys = m_data->data_cast<KEY>( );
    185186                        uint32 count = m_data->element_count();
    186187                        if ( count == 0 ) return;
    187188                        if ( count == 1 )
    188189                        {
    189                                 result = reinterpret_cast<KEY*>(m_data->data)[0];
     190                                result = keys[0];
    190191                                return;
    191192                        }
    192193                        size_t index = glm::clamp<size_t>( size_t( frame ), 0, count - 2 );
    193194                        float factor = glm::clamp<float> ( frame - index, 0.0f, 1.0f );
    194                         KEY* keys = reinterpret_cast<KEY*>( m_data->data );
    195195                        interpolate_key( result, keys[index], keys[index+1], factor );
    196196                }
    … …  
    217217                        // TODO: this probably could be optimized
    218218                        NV_ASSERT( m_data, "Data is null!" );
    219                         const KEY* keys = reinterpret_cast<const KEY*>( m_data->data );
     219                        const KEY* keys = m_data->data_cast<KEY>( );
    220220                        uint32 count = m_data->element_count();
    221221                        if ( count == 0 ) return;
    … …  
    341341                bool empty() const { return m_channel->element_count() == 0; }
    342342                size_t size() const { return m_channel->element_count(); }
    343                 const transform& get( size_t index ) const { return reinterpret_cast<key*>(m_channel->data)[ index ].tform; }
    344                 const transform* data() const { return reinterpret_cast<const transform*>( m_channel->data ); }
     343                const transform& get( size_t index ) const { return m_channel->data_cast< key >()[ index ].tform; }
     344                const transform* data() const { return &(m_channel->data_cast< key >()[0].tform); }
    345345
    346346                virtual uint32 raw_size() const

  • trunk/nv/interface/data_descriptor.hh

    r412 r413  
    284284                }
    285285
     286                template < typename Struct >
     287                static data_descriptor create()
     288                {
     289                        data_descriptor result;
     290                        result.initialize< Struct >();
     291                        return result;
     292                }
     293
    286294        protected:
    287295
    … …  
    306314        struct raw_data_channel
    307315        {
    308                 raw_data_channel() : data( nullptr ), m_count( 0 ) {}
     316                raw_data_channel() : m_data( nullptr ), m_count( 0 ) {}
    309317                ~raw_data_channel()
    310318                {
    311                         if ( data != nullptr ) delete[] data;
     319                        if ( m_data != nullptr ) delete[] m_data;
    312320                }
    313321
    … …  
    316324                uint32 element_count() const { return m_count; }
    317325                uint32 raw_size() const { return m_count * m_desc.element_size(); }
    318                 const uint8* raw_data() const { return data; }
     326                const uint8* raw_data() const { return m_data; }
     327
     328                // TODO: constexpr compile-time cast check?
     329                template < typename Struct >
     330                const Struct* data_cast() const
     331                {
     332                        return reinterpret_cast<const Struct*>( m_data );
     333                }
    319334
    320335                bool has_slot( slot vslot ) const { return m_desc.has_slot( vslot ); }
    321336
    322                 template < typename VTX >
     337                template < typename Struct >
    323338                static raw_data_channel* create( uint32 count = 0 )
    324339                {
    325340                        raw_data_channel* result = new raw_data_channel();
    326                         result->m_desc.initialize<VTX>();
     341                        result->m_desc.initialize<Struct>();
    327342                        result->m_count = count;
    328                         result->data = ( count > 0 ? ( new uint8[result->raw_size()] ) : nullptr );
     343                        result->m_data = ( count > 0 ? ( new uint8[result->raw_size()] ) : nullptr );
    329344                        return result;
    330345                }
    … …  
    334349                        result->m_desc = desc;
    335350                        result->m_count = count;
    336                         result->data = ( count > 0 ? ( new uint8[result->raw_size()] ) : nullptr );
     351                        result->m_data = ( count > 0 ? ( new uint8[result->raw_size()] ) : nullptr );
    337352                        return result;
    338353                }
    339354
    340                 friend class mesh_creator;
    341                 friend class mesh_data_creator;
    342 
    343                 uint8*          data;
     355                template < typename Struct >
     356                friend class data_channel_creator;
     357                friend class raw_data_channel_creator;
     358
    344359        protected:
     360                uint8*          m_data;
    345361                data_descriptor m_desc;
    346362                uint32          m_count;
    … …  
    348364        };
    349365
     366        class raw_data_channel_creator
     367        {
     368        public:
     369                raw_data_channel_creator( const data_descriptor& desc, uint32 size )
     370                {
     371                        m_channel = raw_data_channel::create( desc, size );
     372                        m_owned   = true;
     373                }
     374                explicit raw_data_channel_creator( raw_data_channel* channel )
     375                {
     376                        m_channel = channel;
     377                        m_owned   = false;
     378                }
     379
     380                uint32 element_size() const { return m_channel->element_size(); }
     381                uint32 size() const { return m_channel->element_count(); }
     382                uint32 raw_size() const { return m_channel->element_count() * m_channel->element_size(); }
     383                uint8* raw_data() { return m_channel->m_data; }
     384                const uint8* raw_data() const { return m_channel->m_data; }
     385                raw_data_channel* channel() { return m_channel; }
     386
     387                data_descriptor& descriptor() { return m_channel->m_desc; }
     388                const data_descriptor& descriptor() const { return m_channel->m_desc; }
     389
     390                raw_data_channel* release()
     391                {
     392                        raw_data_channel* result = m_channel;
     393                        m_channel = nullptr;
     394                        return result;
     395                }
     396
     397                ~raw_data_channel_creator()
     398                {
     399                        if ( m_owned && m_channel ) delete m_channel;
     400                }
     401        protected:
     402                raw_data_channel* m_channel;
     403                bool              m_owned;
     404        };
     405
     406        template < typename Struct >
     407        class data_channel_creator : public raw_data_channel_creator
     408        {
     409        public:
     410                explicit data_channel_creator( uint32 size )
     411                        : raw_data_channel_creator( data_descriptor::create< Struct >(), size ) {}
     412                // TODO - descriptor check
     413                explicit data_channel_creator( raw_data_channel* channel )
     414                        : raw_data_channel_creator( channel ) {}
     415               
     416                Struct* data() { return reinterpret_cast< Struct* >( m_channel->m_data ); }
     417                const Struct* data() const { return reinterpret_cast< const Struct* >( m_channel->m_data ); }
     418
     419                const Struct& operator []( uint32 i ) const
     420                {
     421                        NV_ASSERT( i < m_channel->m_count, "data_channel_creator indexing failure!" );
     422                        return reinterpret_cast< const Struct* >( m_channel->m_data )[i];
     423                }
     424
     425                Struct& operator []( uint32 i )
     426                {
     427                        NV_ASSERT( i < m_channel->m_count, "data_channel_creator indexing failure!" );
     428                        return reinterpret_cast<Struct*>( m_channel->m_data )[i];
     429                }
     430        };
    350431}
    351432
    352433#endif // NV_INTERFACE_DATA_DESCRIPTOR_HH
    353 

  • trunk/nv/interface/mesh_data.hh

    r412 r413  
    105105                                if ( ch->descriptor() == compare )
    106106                                {
    107                                         return reinterpret_cast<VTX*>( ch->data );
     107                                        return ch->data_cast< VTX >();
    108108                                }
    109109                        }

  • trunk/src/formats/assimp_loader.cc

    r412 r413  
    77#include "nv/formats/assimp_loader.hh"
    88#include "nv/stl/unordered_map.hh"
    9 #include "nv/gfx/mesh_creator.hh"
    109#include "nv/lib/assimp.hh"
    1110
    … …  
    123122        else
    124123                channel = raw_data_channel::create< assimp_plain_vtx >( mesh->mNumVertices );
     124        uint8* cdata = const_cast< uint8*>( channel->raw_data() );
    125125
    126126        data->add_channel( channel );
    … …  
    139139                nv::vec4 vt ( t_i[0], t_i[1], t_i[2], det );
    140140                if ( skinned )
    141                         reinterpret_cast< assimp_skinned_vtx* >(channel->data)[i] = assimp_skinned_vtx( v, s, n, vt );
     141                        reinterpret_cast< assimp_skinned_vtx* >( cdata )[i] = assimp_skinned_vtx( v, s, n, vt );
    142142                else
    143                         reinterpret_cast< assimp_plain_vtx* >(channel->data)[i] = assimp_plain_vtx( v, s, n, vt );
     143                        reinterpret_cast< assimp_plain_vtx* >( cdata )[i] = assimp_plain_vtx( v, s, n, vt );
    144144        }
    145145
    146146        if ( skinned )
    147147        {
    148                 assimp_skinned_vtx* vtx = reinterpret_cast< assimp_skinned_vtx* >( channel->data );
     148                assimp_skinned_vtx* vtx = reinterpret_cast< assimp_skinned_vtx* >( cdata );
    149149                for (unsigned int m=0; m<mesh->mNumBones; m++)
    150150                {
    … …  
    169169        }
    170170
    171         raw_data_channel* ichannel = raw_data_channel::create< index_u16 >( mesh->mNumFaces * 3 );
    172         data->add_channel( ichannel );
    173         uint16* indices = reinterpret_cast<uint16*>( ichannel->data );
     171        data_channel_creator< index_u16 > ichannel( mesh->mNumFaces * 3 );
     172        uint16* indices = reinterpret_cast<uint16*>( ichannel.raw_data() );
    174173        for (unsigned int i=0; i<mesh->mNumFaces; i++)
    175174        {
    … …  
    180179                }
    181180        }
     181        data->add_channel( ichannel.release() );
    182182}
    183183
    … …  
    315315                        if ( m > 0 && bones.size() > 0 )
    316316                        {
    317                                 raw_data_channel* channel = meshes[m].get_raw_channels()[0];
    318                                 assimp_skinned_vtx* va = reinterpret_cast< assimp_skinned_vtx* >( channel->data );
    319                                 for ( unsigned v = 0; v < channel->element_count(); ++v )
     317                                data_channel_creator< assimp_skinned_vtx > channel( meshes[m].get_raw_channels()[0] );
     318                                for ( unsigned v = 0; v < channel.size(); ++v )
    320319                                {
    321                                         assimp_skinned_vtx& vertex = va[v];
     320                                        assimp_skinned_vtx& vertex = channel.data()[v];
    322321
    323322                                        for ( int i = 0 ; i < 4; ++i)
    … …  
    418417
    419418        data->data = new key_data;
    420         raw_data_channel* raw_pchannel = raw_data_channel::create<assimp_key_p>( node->mNumPositionKeys );
    421         raw_data_channel* raw_rchannel = raw_data_channel::create<assimp_key_r>( node->mNumRotationKeys );
    422         //raw_data_channel* raw_schannel = raw_data_channel::create<assimp_key_s>( node->mNumScalingKeys );
    423         data->data->add_channel( raw_pchannel );
    424         data->data->add_channel( raw_rchannel );
    425         //data->data->add_channel( raw_schannel );
    426         assimp_key_p* pchannel = reinterpret_cast< assimp_key_p* >( raw_pchannel->data );
    427         assimp_key_r* rchannel = reinterpret_cast< assimp_key_r* >( raw_rchannel->data );
     419        data_channel_creator< assimp_key_p > pchannel_creator( node->mNumPositionKeys );
     420        data_channel_creator< assimp_key_r > rchannel_creator( node->mNumRotationKeys );
     421//      data_channel_creator< assimp_key_s > schannel_creator( node->mNumScalingKeys );
     422
     423        assimp_key_p* pchannel = pchannel_creator.data();
     424        assimp_key_r* rchannel = rchannel_creator.data();
    428425        //assimp_key_s* schannel = ((assimp_key_s*)(raw_schannel->data));
    429426
    … …  
    457454//              }
    458455//      }
    459 
     456        data->data->add_channel( pchannel_creator.release() );
     457        data->data->add_channel( rchannel_creator.release() );
     458//      data->data->add_channel( schannel_creator.release() );
    460459}
    461460

  • trunk/src/formats/md2_loader.cc

    r412 r413  
    324324        size_t frame_count   = ( frame == -1 ? num_frames : 1 );
    325325
    326         raw_data_channel* mc_pn = raw_data_channel::create< vtx_md2_pn >( num_verts * frame_count );
    327         vtx_md2_pn* vtx_pn = reinterpret_cast< vtx_md2_pn* >( mc_pn->data );
     326        data_channel_creator< vtx_md2_pn > mc_pn( num_verts * frame_count );
     327        vtx_md2_pn* vtx_pn = mc_pn.data();
    328328
    329329        uint32 index = 0;
    … …  
    347347        }
    348348
    349         raw_data_channel* mc_t = raw_data_channel::create< vtx_md2_t >( num_verts );
    350         vtx_md2_t* vtx_t = reinterpret_cast< vtx_md2_t* >( mc_t->data );
     349        data_channel_creator< vtx_md2_t > mc_t( num_verts );
     350        vtx_md2_t* vtx_t = mc_t.data();
    351351
    352352        vec2 scale( 1.0f / static_cast<float>( md2->header.skinwidth ), 1.0f / static_cast<float>( md2->header.skinheight ) );
    … …  
    357357        }
    358358
    359         raw_data_channel* ic = raw_data_channel::create< index_u16 >( m_new_indexes.size() );
     359        data_channel_creator< index_u16 > ic( m_new_indexes.size() );
    360360        if ( m_new_indexes.size() > 0 )
    361361        {
    362                 uint16* icp = reinterpret_cast< uint16* >( ic->data );
     362                uint16* icp = reinterpret_cast< uint16* >( ic.raw_data() );
    363363                raw_copy_n( m_new_indexes.data(), m_new_indexes.size(), icp );
    364364        }
    365365
    366         data->add_channel( mc_pn );
    367         data->add_channel( mc_t );
    368         data->add_channel( ic );
     366        data->add_channel( mc_pn.release() );
     367        data->add_channel( mc_t.release() );
     368        data->add_channel( ic.release() );
    369369}
    370370

  • trunk/src/formats/md3_loader.cc

    r412 r413  
    289289{
    290290        md3_t* md3 = reinterpret_cast< md3_t* >( m_md3 );
    291         raw_data_channel* result = raw_data_channel::create<md3_key>( uint32( md3->header.num_frames ) );
     291        data_channel_creator< md3_key > result( uint32( md3->header.num_frames ) );
    292292        // TODO: is this brain damaged in efficiency (loop nest order) or what?
    293293        for ( sint32 f = 0; f < md3->header.num_frames; ++f )
    … …  
    303303                                vec3 axisy  ( md3_vec3( rtag.axis[2] ) );
    304304                                vec3 origin ( md3_vec3( rtag.origin )  );
    305                                 reinterpret_cast< md3_key*>(result->data)[f].tform = transform( origin, quat( mat3( axisx, axisy, axisz ) ) );
     305                                result.data()[f].tform = transform( origin, quat( mat3( axisx, axisy, axisz ) ) );
    306306                        }
    307307                }
    308308
    309309        }
    310         return result;
     310        return result.release();
    311311}
    312312
    … …  
    352352                }
    353353
    354         raw_data_channel* mc_pn = raw_data_channel::create< vtx_md3_pn >( uint32( num_verts * frame_count ) );
    355         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_u16 >( uint32( index_count ) );
    357         vtx_md3_pn* vtx_pn = reinterpret_cast< vtx_md3_pn* >( mc_pn->data );
    358         vtx_md3_t*  vtx_t  = reinterpret_cast< vtx_md3_t* >( mc_t->data );
    359         uint16*     icp    = reinterpret_cast< uint16* >( ic->data );
     354        data_channel_creator< vtx_md3_pn > mc_pn( static_cast< uint32 >( num_verts * frame_count ) );
     355        data_channel_creator< vtx_md3_t > mc_t( static_cast< uint32 >( num_verts ) );
     356        data_channel_creator< index_u16 > ic( static_cast< uint32 >( index_count ) );
     357        vtx_md3_pn* vtx_pn = mc_pn.data();
     358        vtx_md3_t*  vtx_t = mc_t.data();
     359        uint16*     icp    = &(ic.data()[0].index);
    360360
    361361        uint32 index  = 0;
    … …  
    413413
    414414        data->set_name( reinterpret_cast< char* >( md3->header.name ) );
    415         data->add_channel( mc_pn );
    416         data->add_channel( mc_t );
    417         data->add_channel( ic );
     415        data->add_channel( mc_pn.release() );
     416        data->add_channel( mc_t.release() );
     417        data->add_channel( ic.release() );
    418418}
    419419

  • trunk/src/formats/md5_loader.cc

    r412 r413  
    160160                                        md5_vtx_t* tdata = nullptr;
    161161                                        {
    162                                                 raw_data_channel* ch_pnt = raw_data_channel::create<md5_vtx_pnt>( num_verts );
    163                                                 raw_data_channel* ch_t   = raw_data_channel::create<md5_vtx_t>( num_verts );
     162                                                data_channel_creator<md5_vtx_pnt> ch_pnt( num_verts );
     163                                                data_channel_creator<md5_vtx_t>   ch_t( num_verts );
    164164                                                ch_pntiw = raw_data_channel::create<md5_vtx_pntiw>( num_verts );
    165                                                 tdata = reinterpret_cast< md5_vtx_t* >( ch_t->data );
    166                                                 mesh->add_channel( ch_pnt );
    167                                                 mesh->add_channel( ch_t );
     165                                                tdata = ch_t.data();
     166                                                mesh->add_channel( ch_pnt.release() );
     167                                                mesh->add_channel( ch_t.release() );
    168168                                                // TODO: hack to prevent rendering
    169169                                                //ch_pntiw->m_count = 0;
    … …  
    191191                                        sstream >> num_tris;
    192192
    193                                         raw_data_channel* ch_i = raw_data_channel::create<index_u32>( num_tris * 3 );
    194                                         uint32* vtx_i                = reinterpret_cast< uint32* >( ch_i->data );
     193                                        data_channel_creator< index_u32 > ch_i( num_tris * 3 );
     194                                        uint32* vtx_i                = reinterpret_cast< uint32* >( ch_i.raw_data() );
    195195                                        uint32 idx = 0;
    196                                         mesh->add_channel( ch_i );
    197196
    198197                                        next_line( sstream );
    … …  
    211210                                                vtx_i[idx++] = ti2;
    212211                                        }             
     212
     213                                        mesh->add_channel( ch_i.release() );
    213214                                }
    214215                                else if ( command == "numweights" )
    … …  
    235236                        }
    236237
    237                         prepare_mesh( reinterpret_cast< md5_vtx_pntiw* >( ch_pntiw->data ), nodes, weight_info.size(), mesh, weights.data(), weight_info.data() );
     238                        prepare_mesh( reinterpret_cast< md5_vtx_pntiw* >( const_cast< uint8* >( ch_pntiw->raw_data() ) ), nodes, weight_info.size(), mesh, weights.data(), weight_info.data() );
    238239
    239240                        m_meshes[ num_meshes ] = mesh;
    … …  
    337338{
    338339        assert( m_type == MESH );
    339         md5_vtx_pnt* vtcs       = reinterpret_cast< md5_vtx_pnt* >( mdata->get_channel< md5_vtx_pnt >()->data );
     340        data_channel_creator< md5_vtx_pnt > pnt( const_cast< raw_data_channel* >( mdata->get_channel< md5_vtx_pnt >() ) );
     341        md5_vtx_pnt* vtcs       = pnt.data();
    340342
    341343        for ( uint32 i = 0; i < vtx_count; ++i )
    … …  
    396398        }
    397399
    398         const uint32*    idata = reinterpret_cast< uint32* >( mdata->get_index_channel()->data );
     400        const uint32*    idata = reinterpret_cast< uint32* >( const_cast< uint8* >( mdata->get_index_channel()->raw_data() ) );
    399401        const md5_vtx_t* tdata = mdata->get_channel_data<md5_vtx_t>();
    400402
    … …  
    484486                {
    485487                        const mesh_node_data& pjoint = nodes[parent_id];
    486                         const transform* ptv = reinterpret_cast< const transform* >( pjoint.data->get_channel(0)->data );
     488                        const transform* ptv = reinterpret_cast< const transform* >( pjoint.data->get_channel(0)->raw_data() );
    487489                        transform ptr;
    488490                        if ( pjoint.data->get_channel(0)->element_count() > index ) ptr = ptv[ index ];
    … …  
    495497                }
    496498
    497                 reinterpret_cast< transform* >( joint.data->get_channel(0)->data )[index] = transform( pos, orient );
     499                reinterpret_cast< transform* >( const_cast< uint8* >( joint.data->get_channel(0)->raw_data() ) )[index] = transform( pos, orient );
    498500        }
    499501}

  • trunk/src/formats/nmd_loader.cc

    r412 r413  
    4343                nmd_stream_header stream_header;
    4444                source.read( &stream_header, sizeof( stream_header ), 1 );
    45                 raw_data_channel* channel = raw_data_channel::create( stream_header.format, stream_header.count );
    46                 source.read( channel->data, stream_header.format.element_size(), stream_header.count );
    47                 mesh->add_channel( channel );
     45                raw_data_channel_creator channel_creator( stream_header.format, stream_header.count );
     46                source.read( channel_creator.raw_data(), channel_creator.element_size(), channel_creator.size() );
     47                mesh->add_channel( channel_creator.release() );
    4848        }
    4949        m_mesh_names.push_back( e.name );
    … …  
    128128                                nv::nmd_stream_header cheader;
    129129                                source.read( &cheader, sizeof( cheader ), 1 );
    130                                 raw_data_channel* channel = raw_data_channel::create( cheader.format, cheader.count );
    131                                 source.read( channel->data, channel->element_size(), channel->element_count() );
    132                                 kdata->add_channel( channel );
     130                                raw_data_channel_creator channel_creator( cheader.format, cheader.count );
     131                                source.read( channel_creator.raw_data(), channel_creator.element_size(), channel_creator.size() );
     132                                kdata->add_channel( channel_creator.release() );
    133133                        }
    134134                }

  • trunk/src/formats/obj_loader.cc

    r412 r413  
    324324                }
    325325       
    326                 raw_data_channel* channel = raw_data_channel::create( m_descriptor, reader->size * 3 );
     326                raw_data_channel_creator channel( m_descriptor, reader->size * 3 );
    327327                if ( reader->raw_size() > 0 )
    328328                {
    329                         raw_copy_n( reader->raw_pointer(), reader->raw_size(), channel->data );
     329                        raw_copy_n( reader->raw_pointer(), reader->raw_size(), channel.raw_data() );
    330330                }
    331331
    332332                mesh_data* mesh = new mesh_data(reader->name);
    333                 mesh->add_channel( channel );
     333                mesh->add_channel( channel.release() );
    334334                m_meshes.push_back( mesh );
    335335

  • trunk/src/gfx/keyframed_mesh.cc

    r412 r413  
    184184{
    185185        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->data );
     186        m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, m_vchannel->raw_data() );
    187187        m_context->add_vertex_buffers( m_va, m_pbuffer, m_vchannel );
    188188
    189         buffer  vb = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * sizeof( vec2 ), m_mesh_data->get_channel<vertex_t>()->data );
     189        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>() );
    190190        m_context->add_vertex_buffers( m_va, vb, m_mesh_data->get_channel<vertex_t>() );
    191191

  • trunk/src/gfx/mesh_creator.cc

    r412 r413  
    2424                if ( pkeys && pkeys->get_channel_count() > 0 && keys && keys->get_channel_count() > 0 )
    2525                {
    26                         nv_key_transform*  channel = reinterpret_cast<nv_key_transform*>(keys->get_channel(0)->data);
    27                         nv_key_transform* pchannel = reinterpret_cast<nv_key_transform*>(pkeys->get_channel(0)->data);
     26                        data_channel_creator< nv_key_transform > channel_creator( const_cast< raw_data_channel* >( keys->get_channel( 0 ) ) );
     27                        nv_key_transform* channel = channel_creator.data();
     28                        const nv_key_transform* pchannel = pkeys->get_channel(0)->data_cast< nv_key_transform >();
    2829                        for ( unsigned n = 0; n < count; ++n )
    2930                        {
    … …  
    6667                        }
    6768
    68                         raw_data_channel* raw_channel = raw_data_channel::create<nv_key_transform>( max_keys );
     69                        data_channel_creator< nv_key_transform > kt_channel( max_keys );
    6970                        key_data* new_keys = new key_data;
    70                         new_keys->add_channel( raw_channel );
    71                         nv_key_transform* channel = reinterpret_cast<nv_key_transform*>(raw_channel->data);
    7271                        data_descriptor final_key = old_keys->get_final_key();
    7372
    … …  
    8281                                        pkey += old_keys->get_raw( old_keys->get_channel(c), idx, pkey );
    8382                                }
    84                                 channel[n].tform = extract_transform_raw( final_key, key );
     83                                kt_channel.data()[n].tform = extract_transform_raw( final_key, key );
    8584                        }
    8685
    8786                        delete old_keys;
     87                        new_keys->add_channel( kt_channel.release() );
    8888                        m_data->m_nodes[i].data = new_keys;
    8989                }
    … …  
    106106                        for ( size_t c = 0; c < kdata->get_channel_count(); ++c )
    107107                        {
    108                                 const raw_data_channel* channel = kdata->get_channel(c);
    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 );
     108                                raw_data_channel_creator channel( const_cast< raw_data_channel* >( kdata->get_channel( c ) ) );
     109                                size_t key_size = channel.element_size();
     110                                for ( size_t n = 0; n < channel.size(); ++n )
     111                                {
     112                                        transform_key_raw( kdata->get_channel( c )->descriptor(), channel.raw_data() + n * key_size, scale, r33, ri33 );
    113113                                }
    114114                        }
    … …  
    125125        for ( uint32 c = 0; c < m_data->get_channel_count(); ++c )
    126126        {
    127                 const raw_data_channel* channel = m_data->get_channel(c);
    128                 const data_descriptor&  desc    = channel->descriptor();
    129                 uint8* raw_data = channel->data;
     127                raw_data_channel_creator channel( m_data->m_channels[ c ] );
     128                const data_descriptor&  desc    = channel.descriptor();
     129                uint8* raw_data = channel.raw_data();
    130130                uint32 vtx_size = desc.element_size();
    131131                int p_offset = -1;
    … …  
    142142
    143143                if ( p_offset != -1 )
    144                         for ( uint32 i = 0; i < channel->element_count(); i++)
     144                        for ( uint32 i = 0; i < channel.size(); 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->element_count(); i++)
     151                        for ( uint32 i = 0; i < channel.size(); 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->element_count(); i++)
     157                        for ( uint32 i = 0; i < channel.size(); i++)
    158158                        {
    159159                                vec4& t = *reinterpret_cast<vec4*>(raw_data + vtx_size*i + t_offset );
    … …  
    173173        size_t n_offset = 0;
    174174        if ( ch_n == -1 ) return;
    175         raw_data_channel* channel = m_data->m_channels[ unsigned( ch_n ) ];
    176         for ( const auto& cslot : channel->descriptor() )
     175        raw_data_channel_creator channel( m_data->m_channels[ unsigned( ch_n ) ] );
     176        for ( const auto& cslot : channel.descriptor() )
    177177                if ( cslot.vslot == slot::NORMAL )
    178178                {
    … …  
    180180                }
    181181
    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 );
     182        for ( uint32 i = 0; i < channel.size(); ++i )
     183        {
     184                vec3& normal = *reinterpret_cast<vec3*>( channel.raw_data() + channel.element_size() * i + n_offset );
    185185                normal = -normal;
    186186        }
    … …  
    249249        }
    250250
    251         raw_data_channel* g_channel = raw_data_channel::create<vertex_g>( p_channel->element_count() );
    252         vec4* tangents              = reinterpret_cast<vec4*>( g_channel->data );
     251        data_channel_creator< vertex_g > g_channel( p_channel->element_count() );
     252        vec4* tangents              = &( g_channel.data()[0].tangent );
    253253        vec3* tangents2             = new vec3[ p_channel->element_count() ];
    254254        uint32 tri_count = i_channel ? i_channel->element_count() / 3 : t_channel->element_count() / 3;
    … …  
    263263                if ( i_type == UINT )
    264264                {
    265                         const uint32* idata = reinterpret_cast<const uint32*>( i_channel->data );
     265                        const uint32* idata = reinterpret_cast<const uint32*>( i_channel->raw_data() );
    266266                        ti0 = idata[ i * 3 ];
    267267                        ti1 = idata[ i * 3 + 1 ];
    … …  
    270270                else if ( i_type == USHORT )
    271271                {
    272                         const uint16* idata = reinterpret_cast<const uint16*>( i_channel->data );
     272                        const uint16* idata = reinterpret_cast<const uint16*>( i_channel->raw_data() );
    273273                        ti0 = idata[ i * 3 ];
    274274                        ti1 = idata[ i * 3 + 1 ];
    … …  
    282282                }
    283283
    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 );
     284                const vec2& w1 = *reinterpret_cast<const vec2*>(t_channel->raw_data() + t_channel->element_size()*ti0 + t_offset );
     285                const vec2& w2 = *reinterpret_cast<const vec2*>(t_channel->raw_data() + t_channel->element_size()*ti1 + t_offset );
     286                const vec2& w3 = *reinterpret_cast<const vec2*>(t_channel->raw_data() + t_channel->element_size()*ti2 + t_offset );
    287287                vec2 st1 = w3 - w1;
    288288                vec2 st2 = w2 - w1;
    … …  
    295295                        uint32 nti1 = t_channel->element_count() * set + ti1;
    296296                        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 );
     297                        const vec3& v1 = *reinterpret_cast<const vec3*>(p_channel->raw_data() + p_channel->element_size()*nti0 + p_offset );
     298                        const vec3& v2 = *reinterpret_cast<const vec3*>(p_channel->raw_data() + p_channel->element_size()*nti1 + p_offset );
     299                        const vec3& v3 = *reinterpret_cast<const vec3*>(p_channel->raw_data() + p_channel->element_size()*nti2 + p_offset );
    300300                        vec3 xyz1 = v3 - v1;
    301301                        vec3 xyz2 = v2 - v1;
    … …  
    321321        for ( unsigned int i = 0; i < vtx_count; ++i )
    322322        {
    323                 const vec3 n = *reinterpret_cast<vec3*>( n_channel->data + n_channel->element_size()*i + n_offset );
     323                const vec3 n = *reinterpret_cast<const vec3*>( n_channel->raw_data() + n_channel->element_size()*i + n_offset );
    324324                const vec3 t = vec3(tangents[i]);
    325325                if ( ! ( t.x == 0.0f && t.y == 0.0f && t.z == 0.0f ) )
    … …  
    331331        delete tangents2;
    332332
    333         m_data->m_channels[ n_channel_index ] = merge_channels( n_channel, g_channel );
     333        m_data->m_channels[ n_channel_index ] = merge_channels( n_channel, g_channel.channel() );
    334334        delete n_channel;
    335         delete g_channel;
    336335}
    337336
    … …  
    342341        desc.append( b->descriptor() );
    343342
    344         uint8* data = new uint8[a->element_count() * desc.element_size() ];
     343        raw_data_channel_creator result( desc, a->element_count() );
    345344        for ( uint32 i = 0; i < a->element_count(); ++i )
    346345        {
    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 
    351         raw_data_channel* result = new raw_data_channel;
    352         result->m_count = a->element_count();
    353         result->m_desc  = desc;
    354         result->data  = data;
    355         return result;
     346                raw_copy_n( a->raw_data() + i * a->element_size(), a->element_size(), result.raw_data() + i*desc.element_size() );
     347                raw_copy_n( b->raw_data() + i * b->element_size(), b->element_size(), result.raw_data() + i*desc.element_size() + a->element_size() );
     348        }
     349
     350        return result.release();
    356351}
    357352
    … …  
    363358        size_t vtx_size = a->element_size();
    364359
    365         uint8* data = new uint8[ ( a->element_count() + b->element_count() ) * vtx_size ];
    366        
     360        raw_data_channel_creator result( a->descriptor(), a->element_count() + b->element_count() );
    367361
    368362        if ( frame_count == 1 )
    369363        {
    370364                size_t a_size = vtx_size * a->element_count();
    371                 raw_copy_n( a->data, a_size, data );
    372                 raw_copy_n( b->data, vtx_size * b->element_count(), data + a_size );
     365                raw_copy_n( a->raw_data(), a_size, result.raw_data() );
     366                raw_copy_n( b->raw_data(), vtx_size * b->element_count(), result.raw_data() + a_size );
    373367        }
    374368        else
    … …  
    381375                for ( size_t i = 0; i < frame_count; ++i )
    382376                {
    383                         raw_copy_n( a->data + pos_a, frame_size_a, data + pos );
    384                         raw_copy_n( b->data + pos_b, frame_size_b, data + pos + frame_size_a );                         pos_a += frame_size_a;
     377                        raw_copy_n( a->raw_data() + pos_a, frame_size_a, result.raw_data() + pos );
     378                        raw_copy_n( b->raw_data() + pos_b, frame_size_b, result.raw_data() + pos + frame_size_a );                              pos_a += frame_size_a;
    385379                        pos_b += frame_size_b;
    386380                        pos   += frame_size_a + frame_size_b;
    … …  
    388382        }
    389383
    390         raw_data_channel* result = new raw_data_channel;
    391         result->m_count = a->element_count() + b->element_count();
    392         result->m_desc  = a->descriptor();
    393         result->data  = data;
    394         return result;
     384        return result.release();
    395385}
    396386
    … …  
    437427                                {
    438428                                        NV_ASSERT( size + osize < uint16(-1), "Index out of range!" );
    439                                         uint16* indexes = reinterpret_cast<uint16*>( m_data->m_channels[c]->data );
    440                                         for ( uint16 i = uint16( old->element_count() ); i < m_data->m_channels[c]->element_count(); ++i )
     429                                        raw_data_channel_creator ic( m_data->m_channels[c] );
     430                                        uint16* indexes = reinterpret_cast<uint16*>( ic.raw_data() );
     431                                        for ( uint16 i = uint16( old->element_count() ); i < ic.size(); ++i )
    441432                                                indexes[i] += uint16( size );
    442433
    … …  
    445436                        case UINT   :
    446437                                {
    447                                         uint32* indexes = reinterpret_cast<uint32*>( m_data->m_channels[c]->data );
    448                                         for ( uint32 i = old->element_count(); i < m_data->m_channels[c]->element_count(); ++i )
     438                                        raw_data_channel_creator ic( m_data->m_channels[c] );
     439                                        uint32* indexes = reinterpret_cast<uint32*>( ic.raw_data() );
     440                                        for ( uint32 i = old->element_count(); i < ic.size(); ++i )
    449441                                                indexes[i] += size;
    450442                                }

  • trunk/src/gfx/skeletal_mesh.cc

    r412 r413  
    1717        const raw_data_channel* pntiw_chan = a_mesh_data->get_channel<md5_vtx_pntiw>();
    1818
    19         m_pntdata.assign( reinterpret_cast<const md5_vtx_pnt*>( pnt_chan->data ), pnt_chan->element_count() );
     19        m_pntdata.assign( pnt_chan->data_cast< md5_vtx_pnt >(), pnt_chan->element_count() );
    2020        m_bone_offset.resize( bones->get_count() );
    2121        m_transform.resize( bones->get_count() );
Note: See TracChangeset for help on using the changeset viewer.