Changeset 413 for trunk/src/formats

Timestamp:

07/09/15 18:53:08 (10 years ago)

Author:

epyon

Message:

• data_descriptor creators ( buggy )

Location:

trunk/src/formats

Files:

• assimp_loader.cc (modified) (8 diffs)
• md2_loader.cc (modified) (3 diffs)
• md3_loader.cc (modified) (4 diffs)
• md5_loader.cc (modified) (8 diffs)
• nmd_loader.cc (modified) (2 diffs)
• obj_loader.cc (modified) (1 diff)

trunk/src/formats/assimp_loader.cc

@@ -7 +7 @@
 #include "nv/formats/assimp_loader.hh"
 #include "nv/stl/unordered_map.hh"
-#include "nv/gfx/mesh_creator.hh"
 #include "nv/lib/assimp.hh"
 
@@ -123 +122 @@
         else
                 channel = raw_data_channel::create< assimp_plain_vtx >( mesh->mNumVertices );
+        uint8* cdata = const_cast< uint8*>( channel->raw_data() );
 
         data->add_channel( channel );
@@ -139 +139 @@
                 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; m<mesh->mNumBones; m++)
                 {
@@ -169 +169 @@
         }
 
-        raw_data_channel* ichannel = raw_data_channel::create< index_u16 >( mesh->mNumFaces * 3 );
-        data->add_channel( ichannel );
-        uint16* indices = reinterpret_cast<uint16*>( ichannel->data );
+        data_channel_creator< index_u16 > ichannel( mesh->mNumFaces * 3 );
+        uint16* indices = reinterpret_cast<uint16*>( ichannel.raw_data() );
         for (unsigned int i=0; i<mesh->mNumFaces; i++)
         {
@@ -180 +179 @@
                 }
         }
+        data->add_channel( ichannel.release() );
 }
 
@@ -315 +315 @@
                         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 +417 @@
 
         data->data = new key_data;
-        raw_data_channel* raw_pchannel = raw_data_channel::create<assimp_key_p>( node->mNumPositionKeys );
-        raw_data_channel* raw_rchannel = raw_data_channel::create<assimp_key_r>( node->mNumRotationKeys );
-        //raw_data_channel* raw_schannel = raw_data_channel::create<assimp_key_s>( 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 +454 @@
 //              }
 //      }
-
+        data->data->add_channel( pchannel_creator.release() );
+        data->data->add_channel( rchannel_creator.release() );
+//      data->data->add_channel( schannel_creator.release() );
 }
 

trunk/src/formats/md2_loader.cc

@@ -324 +324 @@
         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 +347 @@
         }
 
-        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<float>( md2->header.skinwidth ), 1.0f / static_cast<float>( md2->header.skinheight ) );
@@ -357 +357 @@
         }
 
-        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() );
 }
 

trunk/src/formats/md3_loader.cc

@@ -289 +289 @@
 {
         md3_t* md3 = reinterpret_cast< md3_t* >( m_md3 );
-        raw_data_channel* result = raw_data_channel::create<md3_key>( 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 +303 @@
                                 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 +352 @@
                 }
 
-        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 +413 @@
 
         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() );
 }
 

trunk/src/formats/md5_loader.cc

@@ -160 +160 @@
                                         md5_vtx_t* tdata = nullptr;
                                         {
-                                                raw_data_channel* ch_pnt = raw_data_channel::create<md5_vtx_pnt>( num_verts );
-                                                raw_data_channel* ch_t   = raw_data_channel::create<md5_vtx_t>( num_verts );
+                                                data_channel_creator<md5_vtx_pnt> ch_pnt( num_verts );
+                                                data_channel_creator<md5_vtx_t>   ch_t( num_verts );
                                                 ch_pntiw = raw_data_channel::create<md5_vtx_pntiw>( 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 +191 @@
                                         sstream >> num_tris;
 
-                                        raw_data_channel* ch_i = raw_data_channel::create<index_u32>( 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 +210 @@
                                                 vtx_i[idx++] = ti2;
                                         }              
+
+                                        mesh->add_channel( ch_i.release() );
                                 }
                                 else if ( command == "numweights" )
@@ -235 +236 @@
                         }
 
-                        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 +338 @@
 {
         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 +398 @@
         }
 
-        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<md5_vtx_t>();
 
@@ -484 +486 @@
                 {
                         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 +497 @@
                 }
 
-                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 );
         }
 }

trunk/src/formats/nmd_loader.cc

@@ -43 +43 @@
                 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 +128 @@
                                 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() );
                         }
                 }

trunk/src/formats/obj_loader.cc

@@ -324 +324 @@
                 }
         
-                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 );