Index: trunk/src/formats/assimp_loader.cc =================================================================== --- trunk/src/formats/assimp_loader.cc (revision 411) +++ trunk/src/formats/assimp_loader.cc (revision 412) @@ -169,5 +169,5 @@ } - raw_data_channel* ichannel = raw_data_channel::create_index( USHORT, mesh->mNumFaces * 3 ); + raw_data_channel* ichannel = raw_data_channel::create< index_u16 >( mesh->mNumFaces * 3 ); data->add_channel( ichannel ); uint16* indices = reinterpret_cast( ichannel->data ); @@ -317,5 +317,5 @@ 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->count; ++v ) + for ( unsigned v = 0; v < channel->element_count(); ++v ) { assimp_skinned_vtx& vertex = va[v]; Index: trunk/src/formats/md2_loader.cc =================================================================== --- trunk/src/formats/md2_loader.cc (revision 411) +++ trunk/src/formats/md2_loader.cc (revision 412) @@ -357,5 +357,5 @@ } - raw_data_channel* ic = raw_data_channel::create_index< uint16 >( m_new_indexes.size() ); + raw_data_channel* ic = raw_data_channel::create< index_u16 >( m_new_indexes.size() ); if ( m_new_indexes.size() > 0 ) { Index: trunk/src/formats/md3_loader.cc =================================================================== --- trunk/src/formats/md3_loader.cc (revision 411) +++ trunk/src/formats/md3_loader.cc (revision 412) @@ -354,5 +354,5 @@ 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< uint16 >( uint32( index_count ) ); + 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 ); Index: trunk/src/formats/md5_loader.cc =================================================================== --- trunk/src/formats/md5_loader.cc (revision 411) +++ trunk/src/formats/md5_loader.cc (revision 412) @@ -137,4 +137,5 @@ assert( m_type == MESH ); mesh_data* mesh = new mesh_data("md5_mesh"); + raw_data_channel* ch_pntiw = nullptr; uint32 num_verts = 0; @@ -161,10 +162,10 @@ raw_data_channel* ch_pnt = raw_data_channel::create( num_verts ); raw_data_channel* ch_t = raw_data_channel::create( num_verts ); - raw_data_channel* ch_pntiw = raw_data_channel::create( 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 ); // TODO: hack to prevent rendering - ch_pntiw->count = 0; + //ch_pntiw->m_count = 0; mesh->add_channel( ch_pntiw ); } @@ -190,5 +191,5 @@ sstream >> num_tris; - raw_data_channel* ch_i = raw_data_channel::create_index( num_tris * 3 ); + raw_data_channel* ch_i = raw_data_channel::create( num_tris * 3 ); uint32* vtx_i = reinterpret_cast< uint32* >( ch_i->data ); uint32 idx = 0; @@ -234,5 +235,5 @@ } - prepare_mesh( nodes, weight_info.size(), mesh, weights.data(), weight_info.data() ); + prepare_mesh( reinterpret_cast< md5_vtx_pntiw* >( ch_pntiw->data ), nodes, weight_info.size(), mesh, weights.data(), weight_info.data() ); m_meshes[ num_meshes ] = mesh; @@ -333,9 +334,8 @@ } -bool md5_loader::prepare_mesh( mesh_node_data* nodes, uint32 vtx_count, mesh_data* mdata, md5_weight* weights, md5_weight_info* weight_info ) +bool md5_loader::prepare_mesh( md5_vtx_pntiw* vtx_data, mesh_node_data* nodes, uint32 vtx_count, mesh_data* mdata, md5_weight* weights, md5_weight_info* weight_info ) { assert( m_type == MESH ); md5_vtx_pnt* vtcs = reinterpret_cast< md5_vtx_pnt* >( mdata->get_channel< md5_vtx_pnt >()->data ); - md5_vtx_pntiw* vtx_data = reinterpret_cast< md5_vtx_pntiw* >( mdata->get_channel< md5_vtx_pntiw >()->data ); for ( uint32 i = 0; i < vtx_count; ++i ) @@ -486,5 +486,5 @@ const transform* ptv = reinterpret_cast< const transform* >( pjoint.data->get_channel(0)->data ); transform ptr; - if ( pjoint.data->get_channel(0)->count > index ) ptr = ptv[ index ]; + if ( pjoint.data->get_channel(0)->element_count() > index ) ptr = ptv[ index ]; vec3 rot_pos = ptr.get_orientation() * pos; Index: trunk/src/formats/nmd_loader.cc =================================================================== --- trunk/src/formats/nmd_loader.cc (revision 411) +++ trunk/src/formats/nmd_loader.cc (revision 412) @@ -129,5 +129,5 @@ source.read( &cheader, sizeof( cheader ), 1 ); raw_data_channel* channel = raw_data_channel::create( cheader.format, cheader.count ); - source.read( channel->data, channel->desc.element_size(), channel->count ); + source.read( channel->data, channel->element_size(), channel->element_count() ); kdata->add_channel( channel ); } @@ -168,5 +168,5 @@ { size += sizeof( nmd_element_header ) + sizeof( nmd_stream_header ); - size += chan->size(); + size += chan->raw_size(); } @@ -184,12 +184,12 @@ cheader.type = nmd_type::STREAM; cheader.children = 0; - cheader.size = chan->size() + sizeof( nmd_stream_header ); + cheader.size = chan->raw_size() + sizeof( nmd_stream_header ); stream_out.write( &cheader, sizeof( cheader ), 1 ); nmd_stream_header sheader; - sheader.format = chan->desc; - sheader.count = chan->count; + sheader.format = chan->descriptor(); + sheader.count = chan->element_count(); stream_out.write( &sheader, sizeof( sheader ), 1 ); - stream_out.write( chan->data, chan->desc.element_size(), chan->count ); + stream_out.write( chan->raw_data(), chan->element_size(), chan->element_count() ); } } @@ -206,5 +206,5 @@ { total += sizeof( nmd_element_header ) + sizeof( nmd_stream_header ); - total += node->data->get_channel(c)->size(); + total += node->data->get_channel(c)->raw_size(); } } @@ -231,5 +231,5 @@ { chan_size += sizeof( nmd_element_header ) + sizeof( nv::nmd_stream_header ); - chan_size += node->data->get_channel(c)->size(); + chan_size += node->data->get_channel(c)->raw_size(); } @@ -252,12 +252,12 @@ eheader.type = nmd_type::KEY_CHANNEL; eheader.children = 0; - eheader.size = sizeof( nmd_stream_header ) + channel->size(); + eheader.size = sizeof( nmd_stream_header ) + channel->raw_size(); stream_out.write( &eheader, sizeof( eheader ), 1 ); nmd_stream_header cheader; - cheader.format = channel->desc; - cheader.count = channel->count; + cheader.format = channel->descriptor(); + cheader.count = channel->element_count(); stream_out.write( &cheader, sizeof( cheader ), 1 ); - stream_out.write( channel->data, channel->desc.element_size(), channel->count ); + stream_out.write( channel->raw_data(), channel->element_size(), channel->element_count() ); } } Index: trunk/src/formats/obj_loader.cc =================================================================== --- trunk/src/formats/obj_loader.cc (revision 411) +++ trunk/src/formats/obj_loader.cc (revision 412) @@ -324,15 +324,9 @@ } - raw_data_channel* channel = new raw_data_channel(); - nv::uint8* data = nullptr; - - if ( reader->raw_size() > 0 ) - { - data = new uint8[ reader->raw_size() ]; - raw_copy_n( reader->raw_pointer(), reader->raw_size(), data ); - } - channel->data = data; - channel->desc = m_descriptor; - channel->count = reader->size * 3; + raw_data_channel* channel = raw_data_channel::create( m_descriptor, reader->size * 3 ); + if ( reader->raw_size() > 0 ) + { + raw_copy_n( reader->raw_pointer(), reader->raw_size(), channel->data ); + } mesh_data* mesh = new mesh_data(reader->name); Index: trunk/src/gfx/keyframed_mesh.cc =================================================================== --- trunk/src/gfx/keyframed_mesh.cc (revision 411) +++ trunk/src/gfx/keyframed_mesh.cc (revision 412) @@ -23,6 +23,6 @@ , m_active( false ) { - m_index_count = m_mesh_data->get_index_channel()->count; - m_vertex_count = m_mesh_data->get_channel()->count; + m_index_count = m_mesh_data->get_index_channel()->element_count(); + m_vertex_count = m_mesh_data->get_channel()->element_count(); m_vchannel = m_mesh_data->get_channel(); m_vsize = sizeof( vertex_pnt ); @@ -34,5 +34,5 @@ m_vsize = sizeof( vertex_pn ); } - m_frame_count = m_vchannel->count / m_vertex_count; + m_frame_count = m_vchannel->element_count() / m_vertex_count; m_pbuffer = buffer(); } @@ -190,7 +190,8 @@ m_context->add_vertex_buffers( m_va, vb, m_mesh_data->get_channel() ); - buffer ib = m_context->get_device()->create_buffer( INDEX_BUFFER, STATIC_DRAW, m_mesh_data->get_index_channel()->size(), m_mesh_data->get_index_channel()->data ); - - m_context->set_index_buffer( m_va, ib, m_mesh_data->get_index_channel()->desc[0].etype, true ); + const raw_data_channel* index_channel = m_mesh_data->get_index_channel(); + buffer ib = m_context->get_device()->create_buffer( INDEX_BUFFER, STATIC_DRAW, index_channel->raw_size(), index_channel->raw_data() ); + + m_context->set_index_buffer( m_va, ib, m_mesh_data->get_index_channel()->descriptor()[0].etype, true ); m_data = new uint8[ m_vertex_count * m_vsize ]; Index: trunk/src/gfx/mesh_creator.cc =================================================================== --- trunk/src/gfx/mesh_creator.cc (revision 411) +++ trunk/src/gfx/mesh_creator.cc (revision 412) @@ -57,11 +57,11 @@ size_t chan_count = old_keys->get_channel_count(); if ( chan_count == 1 - && old_keys->get_channel(0)->desc.slot_count() == 1 - && old_keys->get_channel(0)->desc[0].etype == TRANSFORM ) continue; + && old_keys->get_channel(0)->descriptor().slot_count() == 1 + && old_keys->get_channel(0)->descriptor()[0].etype == TRANSFORM ) continue; size_t max_keys = 0; for ( size_t c = 0; c < chan_count; ++c ) { - max_keys = nv::max( max_keys, old_keys->get_channel(c)->count ); + max_keys = nv::max( max_keys, old_keys->get_channel(c)->element_count() ); } @@ -79,5 +79,5 @@ for ( uint16 c = 0; c < chan_count; ++c ) { - size_t idx = nv::min( old_keys->get_channel(c)->count - 1, n ); + size_t idx = nv::min( old_keys->get_channel(c)->element_count() - 1, n ); pkey += old_keys->get_raw( old_keys->get_channel(c), idx, pkey ); } @@ -107,8 +107,8 @@ { const raw_data_channel* channel = kdata->get_channel(c); - size_t key_size = channel->desc.element_size(); - for ( size_t n = 0; n < channel->count; ++n ) - { - transform_key_raw( channel->desc, channel->data + n * key_size, scale, r33, ri33 ); + 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 ); } } @@ -126,5 +126,5 @@ { const raw_data_channel* channel = m_data->get_channel(c); - const data_descriptor& desc = channel->desc; + const data_descriptor& desc = channel->descriptor(); uint8* raw_data = channel->data; uint32 vtx_size = desc.element_size(); @@ -142,5 +142,5 @@ if ( p_offset != -1 ) - for ( uint32 i = 0; i < channel->count; i++) + for ( uint32 i = 0; i < channel->element_count(); 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->count; i++) + for ( uint32 i = 0; i < channel->element_count(); 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->count; i++) + for ( uint32 i = 0; i < channel->element_count(); i++) { vec4& t = *reinterpret_cast(raw_data + vtx_size*i + t_offset ); @@ -174,5 +174,5 @@ if ( ch_n == -1 ) return; raw_data_channel* channel = m_data->m_channels[ unsigned( ch_n ) ]; - for ( const auto& cslot : channel->desc ) + for ( const auto& cslot : channel->descriptor() ) if ( cslot.vslot == slot::NORMAL ) { @@ -180,7 +180,7 @@ } - for ( uint32 i = 0; i < channel->count; ++i ) - { - vec3& normal = *reinterpret_cast( channel->data + channel->desc.element_size() * i + n_offset ); + for ( uint32 i = 0; i < channel->element_count(); ++i ) + { + vec3& normal = *reinterpret_cast( channel->data + channel->element_size() * i + n_offset ); normal = -normal; } @@ -205,5 +205,5 @@ const raw_data_channel* channel = m_data->get_channel(c); - for ( const auto& cslot : channel->desc ) + for ( const auto& cslot : channel->descriptor() ) switch ( cslot.vslot ) { @@ -242,15 +242,17 @@ if ( !p_channel || !n_channel || !t_channel ) return; - if ( p_channel->count != n_channel->count || p_channel->count % t_channel->count != 0 || ( i_type != UINT && i_type != USHORT && i_type != NONE ) ) + if ( p_channel->element_count() != n_channel->element_count() + || p_channel->element_count() % t_channel->element_count() != 0 + || ( i_type != UINT && i_type != USHORT && i_type != NONE ) ) { return; } - raw_data_channel* g_channel = raw_data_channel::create( p_channel->count ); + raw_data_channel* g_channel = raw_data_channel::create( p_channel->element_count() ); vec4* tangents = reinterpret_cast( g_channel->data ); - vec3* tangents2 = new vec3[ p_channel->count ]; - uint32 tri_count = i_channel ? i_channel->count / 3 : t_channel->count / 3; - uint32 vtx_count = p_channel->count; - uint32 sets = p_channel->count / t_channel->count; + vec3* tangents2 = new vec3[ p_channel->element_count() ]; + uint32 tri_count = i_channel ? i_channel->element_count() / 3 : t_channel->element_count() / 3; + uint32 vtx_count = p_channel->element_count(); + uint32 sets = p_channel->element_count() / t_channel->element_count(); for ( unsigned int i = 0; i < tri_count; ++i ) @@ -280,7 +282,7 @@ } - const vec2& w1 = *reinterpret_cast(t_channel->data + t_channel->desc.element_size()*ti0 + t_offset ); - const vec2& w2 = *reinterpret_cast(t_channel->data + t_channel->desc.element_size()*ti1 + t_offset ); - const vec2& w3 = *reinterpret_cast(t_channel->data + t_channel->desc.element_size()*ti2 + t_offset ); + 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 ); vec2 st1 = w3 - w1; vec2 st2 = w2 - w1; @@ -290,10 +292,10 @@ for ( uint32 set = 0; set < sets; ++set ) { - uint32 nti0 = t_channel->count * set + ti0; - uint32 nti1 = t_channel->count * set + ti1; - uint32 nti2 = t_channel->count * set + ti2; - vec3 v1 = *reinterpret_cast(p_channel->data + p_channel->desc.element_size()*nti0 + p_offset ); - vec3 v2 = *reinterpret_cast(p_channel->data + p_channel->desc.element_size()*nti1 + p_offset ); - vec3 v3 = *reinterpret_cast(p_channel->data + p_channel->desc.element_size()*nti2 + p_offset ); + uint32 nti0 = t_channel->element_count() * set + ti0; + 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 ); vec3 xyz1 = v3 - v1; vec3 xyz2 = v2 - v1; @@ -319,5 +321,5 @@ for ( unsigned int i = 0; i < vtx_count; ++i ) { - const vec3 n = *reinterpret_cast( n_channel->data + n_channel->desc.element_size()*i + n_offset ); + const vec3 n = *reinterpret_cast( n_channel->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 ) ) @@ -336,23 +338,18 @@ nv::raw_data_channel* nv::mesh_data_creator::merge_channels( raw_data_channel* a, raw_data_channel* b ) { - NV_ASSERT( a->count == b->count, "merge_channel - bad channels!" ); - data_descriptor adesc = a->desc; - data_descriptor bdesc = b->desc; - uint32 count = a->count; - - data_descriptor desc = a->desc; - for ( auto bslot : bdesc ) - { - desc.push_slot( bslot.etype, bslot.vslot ); - } - uint8* data = new uint8[ count * desc.element_size() ]; - for ( uint32 i = 0; i < count; ++i ) - { - raw_copy_n( a->data + i * adesc.element_size(), adesc.element_size(), data + i*desc.element_size() ); - raw_copy_n( b->data + i * bdesc.element_size(), bdesc.element_size(), data + i*desc.element_size() + adesc.element_size() ); - } + NV_ASSERT( a->element_count() == b->element_count(), "merge_channel - bad channels!" ); + data_descriptor desc = a->descriptor(); + desc.append( b->descriptor() ); + + uint8* data = new uint8[a->element_count() * desc.element_size() ]; + 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->count = count; - result->desc = desc; + result->m_count = a->element_count(); + result->m_desc = desc; result->data = data; return result; @@ -361,22 +358,22 @@ nv::raw_data_channel* nv::mesh_data_creator::append_channels( raw_data_channel* a, raw_data_channel* b, uint32 frame_count ) { - if ( a->desc != b->desc ) return nullptr; - if ( a->count % frame_count != 0 ) return nullptr; - if ( b->count % frame_count != 0 ) return nullptr; - size_t vtx_size = a->desc.element_size(); - - uint8* data = new uint8[ ( a->count + b->count ) * vtx_size ]; + if ( a->descriptor() != b->descriptor() ) return nullptr; + if ( a->element_count() % frame_count != 0 ) return nullptr; + if ( b->element_count() % frame_count != 0 ) return nullptr; + size_t vtx_size = a->element_size(); + + uint8* data = new uint8[ ( a->element_count() + b->element_count() ) * vtx_size ]; if ( frame_count == 1 ) { - size_t a_size = vtx_size * a->count; + 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->count, data + a_size ); + raw_copy_n( b->data, vtx_size * b->element_count(), data + a_size ); } else { - size_t frame_size_a = ( a->count / frame_count ) * vtx_size; - size_t frame_size_b = ( b->count / frame_count ) * vtx_size; + size_t frame_size_a = ( a->element_count() / frame_count ) * vtx_size; + size_t frame_size_b = ( b->element_count() / frame_count ) * vtx_size; size_t pos_a = 0; size_t pos_b = 0; @@ -392,6 +389,6 @@ raw_data_channel* result = new raw_data_channel; - result->count = a->element_count() + b->element_count(); - result->desc = a->descriptor(); + result->m_count = a->element_count() + b->element_count(); + result->m_desc = a->descriptor(); result->data = data; return result; @@ -429,10 +426,11 @@ { raw_data_channel* old = m_data->m_channels[c]; - size_t frame_count = ( old->get_buffer_type() == INDEX_BUFFER ? 1 : old->element_count() / size ); + bool old_is_index = old->element_count() > 0 && old->descriptor()[0].vslot == slot::INDEX; + size_t frame_count = ( old_is_index ? 1 : old->element_count() / size ); m_data->m_channels[c] = append_channels( old, other->m_channels[c], frame_count ); NV_ASSERT( m_data->m_channels[c], "Merge problem!" ); - if ( old->get_buffer_type() == INDEX_BUFFER ) - { - switch ( old->desc[0].etype ) + if ( old_is_index ) + { + switch ( old->descriptor()[0].etype ) { case USHORT : Index: trunk/src/gfx/skeletal_mesh.cc =================================================================== --- trunk/src/gfx/skeletal_mesh.cc (revision 411) +++ trunk/src/gfx/skeletal_mesh.cc (revision 412) @@ -13,8 +13,9 @@ nv::skeletal_mesh_cpu::skeletal_mesh_cpu( context* a_context, const mesh_data* a_mesh_data, const mesh_nodes_data* bones ) : skeletal_mesh( a_context ) - , m_data( a_mesh_data ) -{ - const raw_data_channel* pnt_chan = a_mesh_data->get_channel(); - m_pntdata.assign( reinterpret_cast( pnt_chan->data ), pnt_chan->count ); +{ + const raw_data_channel* pnt_chan = a_mesh_data->get_channel(); + const raw_data_channel* pntiw_chan = a_mesh_data->get_channel(); + + m_pntdata.assign( reinterpret_cast( pnt_chan->data ), pnt_chan->element_count() ); m_bone_offset.resize( bones->get_count() ); m_transform.resize( bones->get_count() ); @@ -24,8 +25,29 @@ m_bone_offset[i] = transform( bones->get_node(i)->transform ); } + m_vtx_data = a_mesh_data->get_channel_data(); m_indices = a_mesh_data->get_count(); - m_va = a_context->create_vertex_array( a_mesh_data, -STREAM_DRAW ); + m_va = a_context->create_vertex_array(); + + array_view< raw_data_channel* > channels = a_mesh_data->get_raw_channels(); + for ( uint32 ch = 0; ch < channels.size(); ++ch ) + { + const raw_data_channel* channel = channels[ch]; + if ( channel->element_count() > 0 && channel != pntiw_chan ) + { + const data_descriptor& desc = channel->descriptor(); + if ( desc[0].vslot == slot::INDEX ) + { + buffer b = a_context->get_device()->create_buffer( INDEX_BUFFER, STREAM_DRAW, channel->raw_size(), channel->raw_data() ); + a_context->set_index_buffer( m_va, b, desc[0].etype, true ); + } + else + { + buffer b = a_context->get_device()->create_buffer( VERTEX_BUFFER, STREAM_DRAW, channel->raw_size(), channel->raw_data() ); + a_context->add_vertex_buffers( m_va, b, channel ); + } + } + } + m_pbuffer = a_context->find_buffer( m_va, slot::POSITION ); }