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; m<mesh->mNumBones; 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<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,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<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,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<float>( md2->header.skinwidth ), 1.0f / static_cast<float>( 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<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,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<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,8 +191,7 @@
 					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,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<md5_vtx_t>();
 
@@ -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 );