Index: trunk/src/formats/assimp_loader.cc =================================================================== --- trunk/src/formats/assimp_loader.cc (revision 412) +++ trunk/src/formats/assimp_loader.cc (revision 413) @@ -7,5 +7,4 @@ #include "nv/formats/assimp_loader.hh" #include "nv/stl/unordered_map.hh" -#include "nv/gfx/mesh_creator.hh" #include "nv/lib/assimp.hh" @@ -123,4 +122,5 @@ else channel = raw_data_channel::create< assimp_plain_vtx >( mesh->mNumVertices ); + uint8* cdata = const_cast< uint8*>( channel->raw_data() ); data->add_channel( channel ); @@ -139,12 +139,12 @@ nv::vec4 vt ( t_i[0], t_i[1], t_i[2], det ); if ( skinned ) - reinterpret_cast< assimp_skinned_vtx* >(channel->data)[i] = assimp_skinned_vtx( v, s, n, vt ); + reinterpret_cast< assimp_skinned_vtx* >( cdata )[i] = assimp_skinned_vtx( v, s, n, vt ); else - reinterpret_cast< assimp_plain_vtx* >(channel->data)[i] = assimp_plain_vtx( v, s, n, vt ); + reinterpret_cast< assimp_plain_vtx* >( cdata )[i] = assimp_plain_vtx( v, s, n, vt ); } if ( skinned ) { - assimp_skinned_vtx* vtx = reinterpret_cast< assimp_skinned_vtx* >( channel->data ); + assimp_skinned_vtx* vtx = reinterpret_cast< assimp_skinned_vtx* >( cdata ); for (unsigned int m=0; mmNumBones; m++) { @@ -169,7 +169,6 @@ } - raw_data_channel* ichannel = raw_data_channel::create< index_u16 >( mesh->mNumFaces * 3 ); - data->add_channel( ichannel ); - uint16* indices = reinterpret_cast( ichannel->data ); + data_channel_creator< index_u16 > ichannel( mesh->mNumFaces * 3 ); + uint16* indices = reinterpret_cast( ichannel.raw_data() ); for (unsigned int i=0; imNumFaces; i++) { @@ -180,4 +179,5 @@ } } + data->add_channel( ichannel.release() ); } @@ -315,9 +315,8 @@ if ( m > 0 && bones.size() > 0 ) { - raw_data_channel* channel = meshes[m].get_raw_channels()[0]; - assimp_skinned_vtx* va = reinterpret_cast< assimp_skinned_vtx* >( channel->data ); - for ( unsigned v = 0; v < channel->element_count(); ++v ) + data_channel_creator< assimp_skinned_vtx > channel( meshes[m].get_raw_channels()[0] ); + for ( unsigned v = 0; v < channel.size(); ++v ) { - assimp_skinned_vtx& vertex = va[v]; + assimp_skinned_vtx& vertex = channel.data()[v]; for ( int i = 0 ; i < 4; ++i) @@ -418,12 +417,10 @@ data->data = new key_data; - raw_data_channel* raw_pchannel = raw_data_channel::create( node->mNumPositionKeys ); - raw_data_channel* raw_rchannel = raw_data_channel::create( node->mNumRotationKeys ); - //raw_data_channel* raw_schannel = raw_data_channel::create( node->mNumScalingKeys ); - data->data->add_channel( raw_pchannel ); - data->data->add_channel( raw_rchannel ); - //data->data->add_channel( raw_schannel ); - assimp_key_p* pchannel = reinterpret_cast< assimp_key_p* >( raw_pchannel->data ); - assimp_key_r* rchannel = reinterpret_cast< assimp_key_r* >( raw_rchannel->data ); + data_channel_creator< assimp_key_p > pchannel_creator( node->mNumPositionKeys ); + data_channel_creator< assimp_key_r > rchannel_creator( node->mNumRotationKeys ); +// data_channel_creator< assimp_key_s > schannel_creator( node->mNumScalingKeys ); + + assimp_key_p* pchannel = pchannel_creator.data(); + assimp_key_r* rchannel = rchannel_creator.data(); //assimp_key_s* schannel = ((assimp_key_s*)(raw_schannel->data)); @@ -457,5 +454,7 @@ // } // } - + data->data->add_channel( pchannel_creator.release() ); + data->data->add_channel( rchannel_creator.release() ); +// data->data->add_channel( schannel_creator.release() ); } Index: trunk/src/formats/md2_loader.cc =================================================================== --- trunk/src/formats/md2_loader.cc (revision 412) +++ trunk/src/formats/md2_loader.cc (revision 413) @@ -324,6 +324,6 @@ size_t frame_count = ( frame == -1 ? num_frames : 1 ); - raw_data_channel* mc_pn = raw_data_channel::create< vtx_md2_pn >( num_verts * frame_count ); - vtx_md2_pn* vtx_pn = reinterpret_cast< vtx_md2_pn* >( mc_pn->data ); + data_channel_creator< vtx_md2_pn > mc_pn( num_verts * frame_count ); + vtx_md2_pn* vtx_pn = mc_pn.data(); uint32 index = 0; @@ -347,6 +347,6 @@ } - raw_data_channel* mc_t = raw_data_channel::create< vtx_md2_t >( num_verts ); - vtx_md2_t* vtx_t = reinterpret_cast< vtx_md2_t* >( mc_t->data ); + data_channel_creator< vtx_md2_t > mc_t( num_verts ); + vtx_md2_t* vtx_t = mc_t.data(); vec2 scale( 1.0f / static_cast( md2->header.skinwidth ), 1.0f / static_cast( md2->header.skinheight ) ); @@ -357,14 +357,14 @@ } - raw_data_channel* ic = raw_data_channel::create< index_u16 >( m_new_indexes.size() ); + data_channel_creator< index_u16 > ic( m_new_indexes.size() ); if ( m_new_indexes.size() > 0 ) { - uint16* icp = reinterpret_cast< uint16* >( ic->data ); + uint16* icp = reinterpret_cast< uint16* >( ic.raw_data() ); raw_copy_n( m_new_indexes.data(), m_new_indexes.size(), icp ); } - data->add_channel( mc_pn ); - data->add_channel( mc_t ); - data->add_channel( ic ); + data->add_channel( mc_pn.release() ); + data->add_channel( mc_t.release() ); + data->add_channel( ic.release() ); } Index: trunk/src/formats/md3_loader.cc =================================================================== --- trunk/src/formats/md3_loader.cc (revision 412) +++ trunk/src/formats/md3_loader.cc (revision 413) @@ -289,5 +289,5 @@ { md3_t* md3 = reinterpret_cast< md3_t* >( m_md3 ); - raw_data_channel* result = raw_data_channel::create( uint32( md3->header.num_frames ) ); + data_channel_creator< md3_key > result( uint32( md3->header.num_frames ) ); // TODO: is this brain damaged in efficiency (loop nest order) or what? for ( sint32 f = 0; f < md3->header.num_frames; ++f ) @@ -303,10 +303,10 @@ vec3 axisy ( md3_vec3( rtag.axis[2] ) ); vec3 origin ( md3_vec3( rtag.origin ) ); - reinterpret_cast< md3_key*>(result->data)[f].tform = transform( origin, quat( mat3( axisx, axisy, axisz ) ) ); + result.data()[f].tform = transform( origin, quat( mat3( axisx, axisy, axisz ) ) ); } } } - return result; + return result.release(); } @@ -352,10 +352,10 @@ } - raw_data_channel* mc_pn = raw_data_channel::create< vtx_md3_pn >( uint32( num_verts * frame_count ) ); - raw_data_channel* mc_t = raw_data_channel::create< vtx_md3_t >( uint32( num_verts ) ); - raw_data_channel* ic = raw_data_channel::create< index_u16 >( uint32( index_count ) ); - vtx_md3_pn* vtx_pn = reinterpret_cast< vtx_md3_pn* >( mc_pn->data ); - vtx_md3_t* vtx_t = reinterpret_cast< vtx_md3_t* >( mc_t->data ); - uint16* icp = reinterpret_cast< uint16* >( ic->data ); + data_channel_creator< vtx_md3_pn > mc_pn( static_cast< uint32 >( num_verts * frame_count ) ); + data_channel_creator< vtx_md3_t > mc_t( static_cast< uint32 >( num_verts ) ); + data_channel_creator< index_u16 > ic( static_cast< uint32 >( index_count ) ); + vtx_md3_pn* vtx_pn = mc_pn.data(); + vtx_md3_t* vtx_t = mc_t.data(); + uint16* icp = &(ic.data()[0].index); uint32 index = 0; @@ -413,7 +413,7 @@ data->set_name( reinterpret_cast< char* >( md3->header.name ) ); - data->add_channel( mc_pn ); - data->add_channel( mc_t ); - data->add_channel( ic ); + data->add_channel( mc_pn.release() ); + data->add_channel( mc_t.release() ); + data->add_channel( ic.release() ); } Index: trunk/src/formats/md5_loader.cc =================================================================== --- trunk/src/formats/md5_loader.cc (revision 412) +++ trunk/src/formats/md5_loader.cc (revision 413) @@ -160,10 +160,10 @@ md5_vtx_t* tdata = nullptr; { - raw_data_channel* ch_pnt = raw_data_channel::create( num_verts ); - raw_data_channel* ch_t = raw_data_channel::create( num_verts ); + data_channel_creator ch_pnt( num_verts ); + data_channel_creator ch_t( num_verts ); ch_pntiw = raw_data_channel::create( num_verts ); - tdata = reinterpret_cast< md5_vtx_t* >( ch_t->data ); - mesh->add_channel( ch_pnt ); - mesh->add_channel( ch_t ); + tdata = ch_t.data(); + mesh->add_channel( ch_pnt.release() ); + mesh->add_channel( ch_t.release() ); // TODO: hack to prevent rendering //ch_pntiw->m_count = 0; @@ -191,8 +191,7 @@ sstream >> num_tris; - raw_data_channel* ch_i = raw_data_channel::create( num_tris * 3 ); - uint32* vtx_i = reinterpret_cast< uint32* >( ch_i->data ); + data_channel_creator< index_u32 > ch_i( num_tris * 3 ); + uint32* vtx_i = reinterpret_cast< uint32* >( ch_i.raw_data() ); uint32 idx = 0; - mesh->add_channel( ch_i ); next_line( sstream ); @@ -211,4 +210,6 @@ vtx_i[idx++] = ti2; } + + mesh->add_channel( ch_i.release() ); } else if ( command == "numweights" ) @@ -235,5 +236,5 @@ } - prepare_mesh( reinterpret_cast< md5_vtx_pntiw* >( ch_pntiw->data ), nodes, weight_info.size(), mesh, weights.data(), weight_info.data() ); + prepare_mesh( reinterpret_cast< md5_vtx_pntiw* >( const_cast< uint8* >( ch_pntiw->raw_data() ) ), nodes, weight_info.size(), mesh, weights.data(), weight_info.data() ); m_meshes[ num_meshes ] = mesh; @@ -337,5 +338,6 @@ { assert( m_type == MESH ); - md5_vtx_pnt* vtcs = reinterpret_cast< md5_vtx_pnt* >( mdata->get_channel< md5_vtx_pnt >()->data ); + data_channel_creator< md5_vtx_pnt > pnt( const_cast< raw_data_channel* >( mdata->get_channel< md5_vtx_pnt >() ) ); + md5_vtx_pnt* vtcs = pnt.data(); for ( uint32 i = 0; i < vtx_count; ++i ) @@ -396,5 +398,5 @@ } - const uint32* idata = reinterpret_cast< uint32* >( mdata->get_index_channel()->data ); + const uint32* idata = reinterpret_cast< uint32* >( const_cast< uint8* >( mdata->get_index_channel()->raw_data() ) ); const md5_vtx_t* tdata = mdata->get_channel_data(); @@ -484,5 +486,5 @@ { const mesh_node_data& pjoint = nodes[parent_id]; - const transform* ptv = reinterpret_cast< const transform* >( pjoint.data->get_channel(0)->data ); + const transform* ptv = reinterpret_cast< const transform* >( pjoint.data->get_channel(0)->raw_data() ); transform ptr; if ( pjoint.data->get_channel(0)->element_count() > index ) ptr = ptv[ index ]; @@ -495,5 +497,5 @@ } - reinterpret_cast< transform* >( joint.data->get_channel(0)->data )[index] = transform( pos, orient ); + reinterpret_cast< transform* >( const_cast< uint8* >( joint.data->get_channel(0)->raw_data() ) )[index] = transform( pos, orient ); } } Index: trunk/src/formats/nmd_loader.cc =================================================================== --- trunk/src/formats/nmd_loader.cc (revision 412) +++ trunk/src/formats/nmd_loader.cc (revision 413) @@ -43,7 +43,7 @@ nmd_stream_header stream_header; source.read( &stream_header, sizeof( stream_header ), 1 ); - raw_data_channel* channel = raw_data_channel::create( stream_header.format, stream_header.count ); - source.read( channel->data, stream_header.format.element_size(), stream_header.count ); - mesh->add_channel( channel ); + raw_data_channel_creator channel_creator( stream_header.format, stream_header.count ); + source.read( channel_creator.raw_data(), channel_creator.element_size(), channel_creator.size() ); + mesh->add_channel( channel_creator.release() ); } m_mesh_names.push_back( e.name ); @@ -128,7 +128,7 @@ nv::nmd_stream_header cheader; source.read( &cheader, sizeof( cheader ), 1 ); - raw_data_channel* channel = raw_data_channel::create( cheader.format, cheader.count ); - source.read( channel->data, channel->element_size(), channel->element_count() ); - kdata->add_channel( channel ); + raw_data_channel_creator channel_creator( cheader.format, cheader.count ); + source.read( channel_creator.raw_data(), channel_creator.element_size(), channel_creator.size() ); + kdata->add_channel( channel_creator.release() ); } } Index: trunk/src/formats/obj_loader.cc =================================================================== --- trunk/src/formats/obj_loader.cc (revision 412) +++ trunk/src/formats/obj_loader.cc (revision 413) @@ -324,12 +324,12 @@ } - raw_data_channel* channel = raw_data_channel::create( m_descriptor, reader->size * 3 ); + raw_data_channel_creator channel( m_descriptor, reader->size * 3 ); if ( reader->raw_size() > 0 ) { - raw_copy_n( reader->raw_pointer(), reader->raw_size(), channel->data ); + raw_copy_n( reader->raw_pointer(), reader->raw_size(), channel.raw_data() ); } mesh_data* mesh = new mesh_data(reader->name); - mesh->add_channel( channel ); + mesh->add_channel( channel.release() ); m_meshes.push_back( mesh ); Index: trunk/src/gfx/keyframed_mesh.cc =================================================================== --- trunk/src/gfx/keyframed_mesh.cc (revision 412) +++ trunk/src/gfx/keyframed_mesh.cc (revision 413) @@ -184,8 +184,8 @@ { m_va = m_context->create_vertex_array(); - m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, m_vchannel->data ); + m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, m_vchannel->raw_data() ); m_context->add_vertex_buffers( m_va, m_pbuffer, m_vchannel ); - buffer vb = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * sizeof( vec2 ), m_mesh_data->get_channel()->data ); + buffer vb = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * sizeof( vec2 ), m_mesh_data->get_channel_data() ); m_context->add_vertex_buffers( m_va, vb, m_mesh_data->get_channel() ); Index: trunk/src/gfx/mesh_creator.cc =================================================================== --- trunk/src/gfx/mesh_creator.cc (revision 412) +++ trunk/src/gfx/mesh_creator.cc (revision 413) @@ -24,6 +24,7 @@ if ( pkeys && pkeys->get_channel_count() > 0 && keys && keys->get_channel_count() > 0 ) { - nv_key_transform* channel = reinterpret_cast(keys->get_channel(0)->data); - nv_key_transform* pchannel = reinterpret_cast(pkeys->get_channel(0)->data); + data_channel_creator< nv_key_transform > channel_creator( const_cast< raw_data_channel* >( keys->get_channel( 0 ) ) ); + nv_key_transform* channel = channel_creator.data(); + const nv_key_transform* pchannel = pkeys->get_channel(0)->data_cast< nv_key_transform >(); for ( unsigned n = 0; n < count; ++n ) { @@ -66,8 +67,6 @@ } - raw_data_channel* raw_channel = raw_data_channel::create( max_keys ); + data_channel_creator< nv_key_transform > kt_channel( max_keys ); key_data* new_keys = new key_data; - new_keys->add_channel( raw_channel ); - nv_key_transform* channel = reinterpret_cast(raw_channel->data); data_descriptor final_key = old_keys->get_final_key(); @@ -82,8 +81,9 @@ pkey += old_keys->get_raw( old_keys->get_channel(c), idx, pkey ); } - channel[n].tform = extract_transform_raw( final_key, key ); + kt_channel.data()[n].tform = extract_transform_raw( final_key, key ); } delete old_keys; + new_keys->add_channel( kt_channel.release() ); m_data->m_nodes[i].data = new_keys; } @@ -106,9 +106,9 @@ for ( size_t c = 0; c < kdata->get_channel_count(); ++c ) { - const raw_data_channel* channel = kdata->get_channel(c); - size_t key_size = channel->element_size(); - for ( size_t n = 0; n < channel->element_count(); ++n ) - { - transform_key_raw( channel->descriptor(), channel->data + n * key_size, scale, r33, ri33 ); + raw_data_channel_creator channel( const_cast< raw_data_channel* >( kdata->get_channel( c ) ) ); + size_t key_size = channel.element_size(); + for ( size_t n = 0; n < channel.size(); ++n ) + { + transform_key_raw( kdata->get_channel( c )->descriptor(), channel.raw_data() + n * key_size, scale, r33, ri33 ); } } @@ -125,7 +125,7 @@ for ( uint32 c = 0; c < m_data->get_channel_count(); ++c ) { - const raw_data_channel* channel = m_data->get_channel(c); - const data_descriptor& desc = channel->descriptor(); - uint8* raw_data = channel->data; + raw_data_channel_creator channel( m_data->m_channels[ c ] ); + const data_descriptor& desc = channel.descriptor(); + uint8* raw_data = channel.raw_data(); uint32 vtx_size = desc.element_size(); int p_offset = -1; @@ -142,5 +142,5 @@ if ( p_offset != -1 ) - for ( uint32 i = 0; i < channel->element_count(); i++) + for ( uint32 i = 0; i < channel.size(); i++) { vec3& p = *reinterpret_cast( raw_data + vtx_size*i + p_offset ); @@ -149,5 +149,5 @@ if ( n_offset != -1 ) - for ( uint32 i = 0; i < channel->element_count(); i++) + for ( uint32 i = 0; i < channel.size(); i++) { vec3& n = *reinterpret_cast( raw_data + vtx_size*i + n_offset ); @@ -155,5 +155,5 @@ } if ( t_offset != -1 ) - for ( uint32 i = 0; i < channel->element_count(); i++) + for ( uint32 i = 0; i < channel.size(); i++) { vec4& t = *reinterpret_cast(raw_data + vtx_size*i + t_offset ); @@ -173,6 +173,6 @@ size_t n_offset = 0; if ( ch_n == -1 ) return; - raw_data_channel* channel = m_data->m_channels[ unsigned( ch_n ) ]; - for ( const auto& cslot : channel->descriptor() ) + raw_data_channel_creator channel( m_data->m_channels[ unsigned( ch_n ) ] ); + for ( const auto& cslot : channel.descriptor() ) if ( cslot.vslot == slot::NORMAL ) { @@ -180,7 +180,7 @@ } - for ( uint32 i = 0; i < channel->element_count(); ++i ) - { - vec3& normal = *reinterpret_cast( channel->data + channel->element_size() * i + n_offset ); + for ( uint32 i = 0; i < channel.size(); ++i ) + { + vec3& normal = *reinterpret_cast( channel.raw_data() + channel.element_size() * i + n_offset ); normal = -normal; } @@ -249,6 +249,6 @@ } - raw_data_channel* g_channel = raw_data_channel::create( p_channel->element_count() ); - vec4* tangents = reinterpret_cast( g_channel->data ); + data_channel_creator< vertex_g > g_channel( p_channel->element_count() ); + vec4* tangents = &( g_channel.data()[0].tangent ); vec3* tangents2 = new vec3[ p_channel->element_count() ]; uint32 tri_count = i_channel ? i_channel->element_count() / 3 : t_channel->element_count() / 3; @@ -263,5 +263,5 @@ if ( i_type == UINT ) { - const uint32* idata = reinterpret_cast( i_channel->data ); + const uint32* idata = reinterpret_cast( i_channel->raw_data() ); ti0 = idata[ i * 3 ]; ti1 = idata[ i * 3 + 1 ]; @@ -270,5 +270,5 @@ else if ( i_type == USHORT ) { - const uint16* idata = reinterpret_cast( i_channel->data ); + const uint16* idata = reinterpret_cast( i_channel->raw_data() ); ti0 = idata[ i * 3 ]; ti1 = idata[ i * 3 + 1 ]; @@ -282,7 +282,7 @@ } - const vec2& w1 = *reinterpret_cast(t_channel->data + t_channel->element_size()*ti0 + t_offset ); - const vec2& w2 = *reinterpret_cast(t_channel->data + t_channel->element_size()*ti1 + t_offset ); - const vec2& w3 = *reinterpret_cast(t_channel->data + t_channel->element_size()*ti2 + t_offset ); + const vec2& w1 = *reinterpret_cast(t_channel->raw_data() + t_channel->element_size()*ti0 + t_offset ); + const vec2& w2 = *reinterpret_cast(t_channel->raw_data() + t_channel->element_size()*ti1 + t_offset ); + const vec2& w3 = *reinterpret_cast(t_channel->raw_data() + t_channel->element_size()*ti2 + t_offset ); vec2 st1 = w3 - w1; vec2 st2 = w2 - w1; @@ -295,7 +295,7 @@ uint32 nti1 = t_channel->element_count() * set + ti1; uint32 nti2 = t_channel->element_count() * set + ti2; - vec3 v1 = *reinterpret_cast(p_channel->data + p_channel->element_size()*nti0 + p_offset ); - vec3 v2 = *reinterpret_cast(p_channel->data + p_channel->element_size()*nti1 + p_offset ); - vec3 v3 = *reinterpret_cast(p_channel->data + p_channel->element_size()*nti2 + p_offset ); + const vec3& v1 = *reinterpret_cast(p_channel->raw_data() + p_channel->element_size()*nti0 + p_offset ); + const vec3& v2 = *reinterpret_cast(p_channel->raw_data() + p_channel->element_size()*nti1 + p_offset ); + const vec3& v3 = *reinterpret_cast(p_channel->raw_data() + p_channel->element_size()*nti2 + p_offset ); vec3 xyz1 = v3 - v1; vec3 xyz2 = v2 - v1; @@ -321,5 +321,5 @@ for ( unsigned int i = 0; i < vtx_count; ++i ) { - const vec3 n = *reinterpret_cast( n_channel->data + n_channel->element_size()*i + n_offset ); + const vec3 n = *reinterpret_cast( n_channel->raw_data() + n_channel->element_size()*i + n_offset ); const vec3 t = vec3(tangents[i]); if ( ! ( t.x == 0.0f && t.y == 0.0f && t.z == 0.0f ) ) @@ -331,7 +331,6 @@ delete tangents2; - m_data->m_channels[ n_channel_index ] = merge_channels( n_channel, g_channel ); + m_data->m_channels[ n_channel_index ] = merge_channels( n_channel, g_channel.channel() ); delete n_channel; - delete g_channel; } @@ -342,16 +341,12 @@ desc.append( b->descriptor() ); - uint8* data = new uint8[a->element_count() * desc.element_size() ]; + raw_data_channel_creator result( desc, a->element_count() ); for ( uint32 i = 0; i < a->element_count(); ++i ) { - raw_copy_n( a->data + i * a->element_size(), a->element_size(), data + i*desc.element_size() ); - raw_copy_n( b->data + i * b->element_size(), b->element_size(), data + i*desc.element_size() + a->element_size() ); - } - - raw_data_channel* result = new raw_data_channel; - result->m_count = a->element_count(); - result->m_desc = desc; - result->data = data; - return result; + raw_copy_n( a->raw_data() + i * a->element_size(), a->element_size(), result.raw_data() + i*desc.element_size() ); + raw_copy_n( b->raw_data() + i * b->element_size(), b->element_size(), result.raw_data() + i*desc.element_size() + a->element_size() ); + } + + return result.release(); } @@ -363,12 +358,11 @@ size_t vtx_size = a->element_size(); - uint8* data = new uint8[ ( a->element_count() + b->element_count() ) * vtx_size ]; - + raw_data_channel_creator result( a->descriptor(), a->element_count() + b->element_count() ); if ( frame_count == 1 ) { size_t a_size = vtx_size * a->element_count(); - raw_copy_n( a->data, a_size, data ); - raw_copy_n( b->data, vtx_size * b->element_count(), data + a_size ); + raw_copy_n( a->raw_data(), a_size, result.raw_data() ); + raw_copy_n( b->raw_data(), vtx_size * b->element_count(), result.raw_data() + a_size ); } else @@ -381,6 +375,6 @@ for ( size_t i = 0; i < frame_count; ++i ) { - raw_copy_n( a->data + pos_a, frame_size_a, data + pos ); - raw_copy_n( b->data + pos_b, frame_size_b, data + pos + frame_size_a ); pos_a += frame_size_a; + raw_copy_n( a->raw_data() + pos_a, frame_size_a, result.raw_data() + pos ); + raw_copy_n( b->raw_data() + pos_b, frame_size_b, result.raw_data() + pos + frame_size_a ); pos_a += frame_size_a; pos_b += frame_size_b; pos += frame_size_a + frame_size_b; @@ -388,9 +382,5 @@ } - raw_data_channel* result = new raw_data_channel; - result->m_count = a->element_count() + b->element_count(); - result->m_desc = a->descriptor(); - result->data = data; - return result; + return result.release(); } @@ -437,6 +427,7 @@ { NV_ASSERT( size + osize < uint16(-1), "Index out of range!" ); - uint16* indexes = reinterpret_cast( m_data->m_channels[c]->data ); - for ( uint16 i = uint16( old->element_count() ); i < m_data->m_channels[c]->element_count(); ++i ) + raw_data_channel_creator ic( m_data->m_channels[c] ); + uint16* indexes = reinterpret_cast( ic.raw_data() ); + for ( uint16 i = uint16( old->element_count() ); i < ic.size(); ++i ) indexes[i] += uint16( size ); @@ -445,6 +436,7 @@ case UINT : { - uint32* indexes = reinterpret_cast( m_data->m_channels[c]->data ); - for ( uint32 i = old->element_count(); i < m_data->m_channels[c]->element_count(); ++i ) + raw_data_channel_creator ic( m_data->m_channels[c] ); + uint32* indexes = reinterpret_cast( ic.raw_data() ); + for ( uint32 i = old->element_count(); i < ic.size(); ++i ) indexes[i] += size; } Index: trunk/src/gfx/skeletal_mesh.cc =================================================================== --- trunk/src/gfx/skeletal_mesh.cc (revision 412) +++ trunk/src/gfx/skeletal_mesh.cc (revision 413) @@ -17,5 +17,5 @@ const raw_data_channel* pntiw_chan = a_mesh_data->get_channel(); - m_pntdata.assign( reinterpret_cast( pnt_chan->data ), pnt_chan->element_count() ); + m_pntdata.assign( pnt_chan->data_cast< md5_vtx_pnt >(), pnt_chan->element_count() ); m_bone_offset.resize( bones->get_count() ); m_transform.resize( bones->get_count() );