Changeset 413 for trunk/src/gfx


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

Legend:

Unmodified
Added
Removed

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