Index: trunk/src/formats/md2_loader.cc
===================================================================
--- trunk/src/formats/md2_loader.cc	(revision 197)
+++ trunk/src/formats/md2_loader.cc	(revision 198)
@@ -17,5 +17,4 @@
 
 // assuming low-endian
-#define MD2_MAGIC         "IDP2"
 #define MD2_MAX_FRAMES    512
 #define MD2_MAX_SKINS     32
@@ -75,6 +74,6 @@
 struct md2_vertex_t
 {
-	unsigned char v[3];
-	unsigned char n;
+	uint8 v[3];
+	uint8 n;
 };
 
@@ -127,5 +126,5 @@
 }
 
-static bool read_md2_frame( md2_frame_t* frame, int vcount, nv::stream& source )
+static bool read_md2_frame( md2_frame_t* frame, unsigned vcount, nv::stream& source )
 {
 	frame->vertices = new md2_vertex_t[ vcount ];
@@ -170,14 +169,14 @@
 	
 	source.seek( md2->header.offset_skins, origin::SET );
-	source.read( md2->skins, sizeof(md2_skin_t), md2->header.num_skins );
+	source.read( md2->skins, sizeof(md2_skin_t), static_cast<size_t>( md2->header.num_skins ) );
 
 	source.seek( md2->header.offset_st, origin::SET );
-	source.read( md2->texcoords, sizeof(md2_texcoord_t), md2->header.num_st );
+	source.read( md2->texcoords, sizeof(md2_texcoord_t), static_cast<size_t>( md2->header.num_st ) );
 
 	source.seek( md2->header.offset_tris, origin::SET );
-	source.read( md2->triangles, sizeof(md2_triangle_t), md2->header.num_tris );
+	source.read( md2->triangles, sizeof(md2_triangle_t), static_cast<size_t>( md2->header.num_tris ) );
 
 	source.seek( md2->header.offset_glcmds, origin::SET);
-	source.read( md2->glcmds, sizeof(int), md2->header.num_glcmds );
+	source.read( md2->glcmds, sizeof(int), static_cast<size_t>( md2->header.num_glcmds ) );
 
 	md2->frames    = new md2_frame_t   [ md2->header.num_frames ];
@@ -185,5 +184,5 @@
 	for ( int i = 0; i < md2->header.num_frames; ++i )
 	{
-		if (!read_md2_frame( &(md2->frames[i]), md2->header.num_vertices, source ) ) return false;
+		if (!read_md2_frame( &(md2->frames[i]), static_cast<unsigned>( md2->header.num_vertices ), source ) ) return false;
 	}
 
@@ -197,5 +196,5 @@
 }
 
-static inline vec3 md2_normal( char normal )
+static inline vec3 md2_normal( uint8 normal )
 {
 	return md2_vec3( md2_normal_table[normal] );
@@ -269,7 +268,7 @@
 }
 
-sint32 md2_loader::get_max_frames() const
-{
-	return ((md2_t*)m_md2)->header.num_frames;
+size_t md2_loader::get_max_frames() const
+{
+	return static_cast< size_t >( ((md2_t*)m_md2)->header.num_frames );
 }
 
@@ -277,9 +276,9 @@
 {
 	md2_t* md2 = (md2_t*)m_md2;
-	sint32 num_frames = md2->header.num_frames;
-	sint32 num_verts  = m_new_vindexes.size();
+	size_t num_frames = static_cast< size_t >( md2->header.num_frames );
+	size_t num_verts  =	m_new_vindexes.size();
 	p.clear();
-	sint32 current_frame = ( frame == -1 ? 0 : frame );
-	sint32 frame_count   = ( frame == -1 ? num_frames : 1 );
+	size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t >( frame ) );
+	size_t frame_count   = ( frame == -1 ? num_frames : 1 );
 
 	p.reserve( num_verts * frame_count );
@@ -287,13 +286,13 @@
 	while ( frame_count > 0 )
 	{
-		const md2_frame_t& frame = md2->frames[current_frame];
-		NV_LOG( LOG_INFO, "FrameID = " << frame.name );
-
-		vec3 scale     = md2_vec3( frame.scale );
-		vec3 translate = md2_vec3( frame.translate );
-
-		for (sint32 i = 0; i < num_verts; ++i )
+		const md2_frame_t& cframe = md2->frames[current_frame];
+		NV_LOG( LOG_INFO, "FrameID = " << cframe.name );
+
+		vec3 scale     = md2_vec3( cframe.scale );
+		vec3 translate = md2_vec3( cframe.translate );
+
+		for (size_t i = 0; i < num_verts; ++i )
 		{
-			const md2_vertex_t& v = frame.vertices[ m_new_vindexes[ i ] ];
+			const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
 			p.push_back( vec3( v.v[0], v.v[2], v.v[1] ) * scale + translate );
 		}
@@ -306,9 +305,9 @@
 {
 	md2_t* md2 = (md2_t*)m_md2;
-	sint32 num_frames = md2->header.num_frames;
-	sint32 num_verts  =	m_new_vindexes.size();
+	size_t num_frames = static_cast< size_t >( md2->header.num_frames );
+	size_t num_verts  =	m_new_vindexes.size();
 	n.clear();
-	sint32 current_frame = ( frame == -1 ? 0 : frame );
-	sint32 frame_count   = ( frame == -1 ? num_frames : 1 );
+	size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t>( frame ) );
+	size_t frame_count   = ( frame == -1 ? num_frames : 1 );
 
 	n.reserve( num_verts * frame_count );
@@ -316,9 +315,9 @@
 	while ( frame_count > 0 )
 	{
-		const md2_frame_t& frame = md2->frames[current_frame];
-
-		for (sint32 i = 0; i < num_verts; ++i )
+		const md2_frame_t& cframe = md2->frames[current_frame];
+
+		for (size_t i = 0; i < num_verts; ++i )
 		{
-			const md2_vertex_t& v = frame.vertices[ m_new_vindexes[ i ] ];
+			const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
 			n.push_back( s_md2_normal_cache[ v.n ] );
 		}
@@ -331,5 +330,5 @@
 {
 	md2_t* md2 = (md2_t*)m_md2;
-	sint32 num_verts  = m_new_vindexes.size();
+	size_t num_verts  = m_new_vindexes.size();
 
 	t.clear();
@@ -338,5 +337,5 @@
 	vec2 scale( 1.0f / (float) md2->header.skinwidth, 1.0f / (float) md2->header.skinheight );
 
-	for (sint32 i = 0; i < num_verts; ++i )
+	for (size_t i = 0; i < num_verts; ++i )
 	{
 		const md2_texcoord_t& st = md2->texcoords[ m_new_tindexes[ i ] ];
@@ -354,5 +353,5 @@
 {
 	md2_t* md2 = (md2_t*)m_md2;
-	uint32 num_indexes = md2->header.num_tris * 3;
+	uint32 num_indexes = static_cast< uint32 >( md2->header.num_tris * 3 );
 
 	uint32 stats_reuse      = 0;
@@ -373,10 +372,10 @@
 		for ( int j = 0; j < 3; ++j )
 		{
-			short index  = t.vertex[j];
-			short tindex = t.st[j];
+			uint16 index  = t.vertex[j];
+			uint16 tindex = t.st[j];
 
 			if ( index_translation[ index ] != -1 )
 			{
-				uint16 prev = index_translation[ index ];
+				uint16 prev = static_cast< uint16 >( index_translation[ index ] );
 				if ( m_new_tindexes[ prev ] == tindex )
 				{
Index: trunk/src/formats/md3_loader.cc
===================================================================
--- trunk/src/formats/md3_loader.cc	(revision 197)
+++ trunk/src/formats/md3_loader.cc	(revision 198)
@@ -17,5 +17,4 @@
 
 // assuming low-endian
-#define MD3_MAGIC         "IDP3"
 #define MD3_MAX_FRAMES    1024
 #define MD3_MAX_TAGS      16
@@ -149,5 +148,5 @@
 static bool read_surface( md3_surface_t * surface, nv::stream& source )
 {
-	sint32 pos = source.tell();
+	sint32 pos = static_cast< sint32 >( source.tell() );
 	source.read( &surface->header, sizeof(md3_surface_header_t), 1 );
 
@@ -164,14 +163,14 @@
 
 	source.seek( pos + surface->header.ofs_shaders, origin::SET );
-	source.read( surface->shaders, sizeof( md3_shader_t ), surface->header.num_shaders );
+	source.read( surface->shaders, sizeof( md3_shader_t ), static_cast<size_t>( surface->header.num_shaders ) );
 
 	source.seek( pos + surface->header.ofs_triangles, origin::SET );
-	source.read( surface->triangles, sizeof( md3_triangle_t ), surface->header.num_triangles );
+	source.read( surface->triangles, sizeof( md3_triangle_t ), static_cast<size_t>( surface->header.num_triangles ) );
 
 	source.seek( pos + surface->header.ofs_st, origin::SET );
-	source.read( surface->st, sizeof( md3_texcoord_t ), surface->header.num_verts );
+	source.read( surface->st, sizeof( md3_texcoord_t ), static_cast<size_t>( surface->header.num_verts ) );
 
 	source.seek( pos + surface->header.ofs_xyznormal, origin::SET );
-	source.read( surface->vertices, sizeof( md3_vertex_t ), surface->header.num_verts * surface->header.num_frames );
+	source.read( surface->vertices, sizeof( md3_vertex_t ), static_cast<size_t>( surface->header.num_verts * surface->header.num_frames ) );
 
 	if ( source.tell() != static_cast<std::size_t>( pos + surface->header.ofs_end ) ) return false;
@@ -201,11 +200,11 @@
 	md3->tags     = new md3_tag_t    [ md3->header.num_tags * md3->header.num_frames ];
 	md3->surfaces = new md3_surface_t[ md3->header.num_surfaces ];
-	std::memset( md3->surfaces, 0, md3->header.num_surfaces * sizeof(md3_surface_t) );
+	std::memset( md3->surfaces, 0, static_cast< size_t >( md3->header.num_surfaces ) * sizeof(md3_surface_t) );
 
 	source.seek( md3->header.ofs_frames, origin::SET );
-	source.read( md3->frames, sizeof( md3_frame_t ), md3->header.num_frames );
+	source.read( md3->frames, sizeof( md3_frame_t ), static_cast<size_t>( md3->header.num_frames ) );
 
 	source.seek( md3->header.ofs_tags, origin::SET );
-	source.read( md3->tags, sizeof( md3_tag_t ), md3->header.num_tags * md3->header.num_frames );
+	source.read( md3->tags, sizeof( md3_tag_t ), static_cast<size_t>( md3->header.num_tags * md3->header.num_frames ) );
 
 	source.seek( md3->header.ofs_surfaces, origin::SET );
@@ -351,7 +350,7 @@
 }
 
-sint32 md3_loader::get_max_frames() const
-{
-	return ((md3_t*)m_md3)->header.num_frames;
+size_t md3_loader::get_max_frames() const
+{
+	return static_cast< size_t >( ((md3_t*)m_md3)->header.num_frames );
 }
 
@@ -401,5 +400,5 @@
 	sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
 
-	p.reserve( md3->vertices_per_frame * frame_count );
+	p.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
 
 	while ( frame_count > 0 )
@@ -430,5 +429,5 @@
 	sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
 
-	n.reserve( md3->vertices_per_frame * frame_count );
+	n.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
 
 	while ( frame_count > 0 )
@@ -476,8 +475,8 @@
 	{
 		const md3_surface_t& surface = md3->surfaces[i];
-		const sint32         tcount  = surface.header.num_triangles;
+		const size_t         tcount  = static_cast< size_t >( surface.header.num_triangles );
 
 		idx.reserve( idx.size() + tcount * 3 );
-		for (sint32 j = 0; j < tcount; ++j )
+		for (size_t j = 0; j < tcount; ++j )
 		{
 			const md3_triangle_t& t = surface.triangles[j];
Index: trunk/src/formats/md5_loader.cc
===================================================================
--- trunk/src/formats/md5_loader.cc	(revision 197)
+++ trunk/src/formats/md5_loader.cc	(revision 198)
@@ -36,5 +36,5 @@
 }
 
-void unit_quat_w( glm::quat& quat )
+static void unit_quat_w( glm::quat& quat )
 {
 	float t = 1.0f - ( quat.x * quat.x ) - ( quat.y * quat.y ) - ( quat.z * quat.z );
@@ -354,5 +354,5 @@
 		{
 			discard( sstream, "{" );
-			for ( int i = 0; i < m_num_joints; ++i )
+			for ( size_t i = 0; i < m_num_joints; ++i )
 			{
 				md5_joint_info joint;
@@ -368,5 +368,5 @@
 			discard( sstream, "{" );
 			next_line( sstream ); 
-			for ( int i = 0; i < m_num_frames; ++i ) 
+			for ( size_t i = 0; i < m_num_frames; ++i ) 
 			{
 				md5_bound bound;
@@ -390,5 +390,5 @@
 			next_line( sstream ); 
 
-			for ( int i = 0; i < m_num_joints; ++i )
+			for ( size_t i = 0; i < m_num_joints; ++i )
 			{
 				md5_base_frame base_frame;
@@ -412,5 +412,5 @@
 			next_line( sstream ); 
 
-			for ( int i = 0; i < m_num_animated_components; ++i )
+			for ( size_t i = 0; i < m_num_animated_components; ++i )
 			{
 				float frameData;
@@ -436,9 +436,9 @@
 	m_anim_time = 0.0f;
 
-	assert( m_joint_infos.size() == (size_t)m_num_joints );
-	assert( m_bounds.size()      == (size_t)m_num_frames );
-	assert( m_base_frames.size() == (size_t)m_num_joints );
-	assert( m_frames.size()      == (size_t)m_num_frames );
-	assert( m_skeletons.size()   == (size_t)m_num_frames );
+	assert( m_joint_infos.size() == m_num_joints );
+	assert( m_bounds.size()      == m_num_frames );
+	assert( m_base_frames.size() == m_num_joints );
+	assert( m_frames.size()      == m_num_frames );
+	assert( m_skeletons.size()   == m_num_frames );
 
 	return true;
@@ -506,5 +506,5 @@
 void md5_animation::interpolate_skeletons( md5_frame_skeleton& final_skeleton, const md5_frame_skeleton& skeleton0, const md5_frame_skeleton& skeleton1, float interpolate )
 {
-	for ( int i = 0; i < m_num_joints; ++i )
+	for ( size_t i = 0; i < m_num_joints; ++i )
 	{
 		md5_skeleton_joint& final_joint = final_skeleton.joints[i];
Index: trunk/src/formats/obj_loader.cc
===================================================================
--- trunk/src/formats/obj_loader.cc	(revision 197)
+++ trunk/src/formats/obj_loader.cc	(revision 198)
@@ -119,5 +119,5 @@
 struct mesh_obj_reader : public obj_reader
 {
-	mesh_obj_reader( mesh* m ) : m_mesh( m ), m_position( nullptr ), m_normal( nullptr ), m_tex_coord( nullptr ), m_tangent( nullptr ) {}
+	mesh_obj_reader( mesh* m ) : m_position( nullptr ), m_normal( nullptr ), m_tex_coord( nullptr ), m_tangent( nullptr ), m_mesh( m ) {}
 	virtual std::size_t add_face( uint32* v, uint32* t, uint32* n, size_t count );
 	virtual void calculate_tangents();
@@ -206,6 +206,6 @@
 		vec3 xyz1 = v2 - v1;
 		vec3 xyz2 = v3 - v1;
-		vec2 st1  = w2 - w1;
-		vec2 st2  = w3 - w1;
+		//vec2 st1  = w2 - w1;
+		//vec2 st2  = w3 - w1;
 
 		float s1 = w2.x - w1.x;