Changeset 398 for trunk/src

Timestamp:

06/13/15 11:20:22 (10 years ago)

Author:

epyon

Message:

• cleanup of glm usage

Location:

trunk/src

Files:

• formats/md5_loader.cc (modified) (6 diffs)
• gfx/image.cc (modified) (2 diffs)
• gfx/mesh_creator.cc (modified) (6 diffs)
• gfx/texture_atlas.cc (modified) (5 diffs)
• gfx/texture_font.cc (modified) (3 diffs)
• gl/gl_context.cc (modified) (1 diff)
• gl/gl_device.cc (modified) (2 diffs)
• rogue/fov_recursive_shadowcasting.cc (modified) (1 diff)

trunk/src/formats/md5_loader.cc

@@ -31 +31 @@
 }
 
-static void unit_quat_w( glm::quat& quat )
+static void unit_quat_w( nv::quat& quat )
 {
         float t = 1.0f - ( quat.x * quat.x ) - ( quat.y * quat.y ) - ( quat.z * quat.z );
@@ -343 +343 @@
                 md5_vtx_pnt& vtc = vtcs[i];
 
-                vtc.position = glm::vec3(0);
-                vtc.normal   = glm::vec3(0);
-                vtc.tangent  = glm::vec3(0);
+                vtc.position = vec3(0);
+                vtc.normal   = vec3(0);
+                vtc.tangent  = vec3(0);
 
                 stable_sort( weights + start_weight, weights + start_weight + weight_count, [] ( const md5_weight& a, const md5_weight& b ) -> bool { return a.bias > b.bias; } );
@@ -386 +386 @@
                                 const mesh_node_data&  joint = nodes[weight.joint_id];
                                 const transform tr = transform( joint.transform ).inverse();
-                                glm::vec3 rot_pos = tr.get_orientation() * weight.pos;
+                                vec3 rot_pos = tr.get_orientation() * weight.pos;
 
                                 vtc.position += ( tr.get_position() + rot_pos ) * weight.bias;
@@ -404 +404 @@
                 uint32 ti2 = idata[ i * 3 + 2 ];
  
-                glm::vec3 v1 = vtcs[ ti0 ].position;
-                glm::vec3 v2 = vtcs[ ti1 ].position;
-                glm::vec3 v3 = vtcs[ ti2 ].position;
-                glm::vec3 xyz1 = v3 - v1;
-                glm::vec3 xyz2 = v2 - v1;
-
-                glm::vec3 normal = glm::cross( xyz1, xyz2 );
+                vec3 v1 = vtcs[ ti0 ].position;
+                vec3 v2 = vtcs[ ti1 ].position;
+                vec3 v3 = vtcs[ ti2 ].position;
+                vec3 xyz1 = v3 - v1;
+                vec3 xyz2 = v2 - v1;
+
+                vec3 normal = glm::cross( xyz1, xyz2 );
 
                 vtcs[ ti0 ].normal += normal;
@@ -436 +436 @@
                 md5_vtx_pntiw& vdata = vtx_data[i];
 
-                glm::vec3 normal  = glm::normalize( vtcs[i].normal );
-                glm::vec3 tangent = glm::normalize( vtcs[i].tangent );
+                vec3 normal  = glm::normalize( vtcs[i].normal );
+                vec3 tangent = glm::normalize( vtcs[i].tangent );
                 vtcs[i].normal   = normal;
                 vtcs[i].tangent  = tangent;
 
                 vdata.position = vtcs[i].position;
-                vdata.normal   = glm::vec3(0);
-                vdata.tangent  = glm::vec3(0);
+                vdata.normal   = vec3(0);
+                vdata.tangent  = vec3(0);
  
                 for ( size_t j = 0; j < 4; ++j )
@@ -484 +484 @@
                         transform ptr;
                         if ( pjoint.data->get_channel(0)->count > index ) ptr = ptv[ index ];
-                        glm::vec3 rot_pos = ptr.get_orientation() * pos;
+                        vec3 rot_pos = ptr.get_orientation() * pos;
 
                         pos    = ptr.get_position() + rot_pos;

trunk/src/gfx/image.cc

@@ -10 +10 @@
 using namespace nv;
 
-image::image( glm::ivec2 size, nv::size_t depth )
+image::image( ivec2 size, nv::size_t depth )
         : m_size( size ), m_depth( depth ), m_data( nullptr )
 {
@@ -23 +23 @@
 
 
-image::image( glm::ivec2 size, nv::size_t depth, const uint8 * data, bool reversed )
+image::image( ivec2 size, nv::size_t depth, const uint8 * data, bool reversed )
         : m_size( size ), m_depth( depth ), m_data( nullptr )
 {

trunk/src/gfx/mesh_creator.cc

@@ -21 +21 @@
                 size_t count     = ( keys ? keys->get_channel(0)->count : 0 );
                 size_t pcount    = ( pkeys ? pkeys->get_channel(0)->count : 0 );
-                max_frames = glm::max<uint32>( count, max_frames );
+                max_frames = nv::max<uint32>( count, max_frames );
                 if ( pkeys && pkeys->get_channel_count() > 0 && keys && keys->get_channel_count() > 0 )
                 {
@@ -28 +28 @@
                         for ( unsigned n = 0; n < count; ++n )
                         {
-                                channel[n].tform = pchannel[ glm::min( n, pcount-1 ) ].tform * channel[n].tform;
+                                channel[n].tform = pchannel[ nv::min( n, pcount-1 ) ].tform * channel[n].tform;
                         }
                 }
@@ -63 +63 @@
                         for ( size_t c = 0; c < chan_count; ++c )
                         {
-                                max_keys = glm::max( max_keys, old_keys->get_channel(c)->count );
+                                max_keys = nv::max( max_keys, old_keys->get_channel(c)->count );
                         }
 
@@ -79 +79 @@
                                 for ( uint16 c = 0; c < chan_count; ++c )
                                 {
-                                        size_t idx = glm::min( old_keys->get_channel(c)->count - 1, n );
+                                        size_t idx = nv::min( old_keys->get_channel(c)->count - 1, n );
                                         pkey += old_keys->get_channel(c)->get_raw( idx, pkey );
                                 }
@@ -119 +119 @@
 void nv::mesh_data_creator::transform( float scale, const mat3& r33 )
 {
-        vec3 vertex_offset     = glm::vec3(); 
+        vec3 vertex_offset     = vec3(); 
         mat3 vertex_transform  = scale * r33;
         mat3 normal_transform  = r33;
@@ -297 +297 @@
                         vec3 xyz2 = v2 - v1;
 
-                        //glm::vec3 normal = glm::cross( xyz1, xyz2 );
+                        //vec3 normal = glm::cross( xyz1, xyz2 );
                         //
                         //vtcs[ ti0 ].normal += normal;

trunk/src/gfx/texture_atlas.cc

@@ -11 +11 @@
 using namespace nv;
 
-texture_atlas::texture_atlas( glm::ivec2 size, nv::size_t depth, nv::size_t border /*= 1*/ )
+texture_atlas::texture_atlas( ivec2 size, nv::size_t depth, nv::size_t border /*= 1*/ )
         : image( size, depth ), m_used( 0 ), m_border( border )
 {
-        m_nodes.push_back( glm::ivec3( m_border, m_border, m_size.x - 2 * static_cast<int>( m_border ) ) );
+        m_nodes.push_back( ivec3( m_border, m_border, m_size.x - 2 * static_cast<int>( m_border ) ) );
         fill( 0 );
 }
 
-region texture_atlas::get_region( glm::ivec2 size )
+region texture_atlas::get_region( ivec2 size )
 {
-        region r ( glm::ivec2(0,0), size );
+        region r ( ivec2(0,0), size );
 
         int best_height = INT_MAX;
@@ -31 +31 @@
                 if ( y >= 0 )
                 {
-                        glm::ivec3 node = m_nodes[ i ];
+                        ivec3 node = m_nodes[ i ];
                         if ( ( (y + size.y) < best_height ) ||
                                 ( ((y + size.y) == best_height) && (node.z < best_width)) )
@@ -46 +46 @@
         if ( best_index == -1 )
         {
-                return region( glm::ivec2( -1, -1 ), glm::ivec2( 0, 0 ) );
+                return region( ivec2( -1, -1 ), ivec2( 0, 0 ) );
         }
 
-        m_nodes.insert( m_nodes.begin() + best_index, glm::ivec3( r.pos.x, r.pos.y + size.y, size.x ) );
+        m_nodes.insert( m_nodes.begin() + best_index, ivec3( r.pos.x, r.pos.y + size.y, size.x ) );
 
         for( size_t i = static_cast<size_t>( best_index )+1; i < m_nodes.size(); ++i )
         {
-                glm::ivec3 node = m_nodes[ i ];
-                glm::ivec3 prev = m_nodes[ i-1 ];
+                ivec3 node = m_nodes[ i ];
+                ivec3 prev = m_nodes[ i-1 ];
 
                 if ( node.x < prev.x + prev.z )
@@ -82 +82 @@
 }
 
-int texture_atlas::fit( nv::size_t index, glm::ivec2 size )
+int texture_atlas::fit( nv::size_t index, ivec2 size )
 {
-        glm::ivec3 node = m_nodes[ index ];
+        ivec3 node = m_nodes[ index ];
 
         if ( node.x + size.x > m_size.x - static_cast<int>( m_border ) ) 
@@ -128 +128 @@
         m_nodes.clear();
         m_used = 0;
-        m_nodes.push_back( glm::ivec3( 1, 1, m_size.x - 2 ) );
+        m_nodes.push_back( ivec3( 1, 1, m_size.x - 2 ) );
         fill( 0 );
 }

trunk/src/gfx/texture_font.cc

@@ -94 +94 @@
 bool texture_font::load_glyphs( string_ref codes )
 {
-        FT_Face face     = (FT_Face)(m_rface);
-        size_t depth     = m_atlas->get_depth();
-        glm::ivec2 asize = m_atlas->get_size();
+        FT_Face face = (FT_Face)(m_rface);
+        size_t depth = m_atlas->get_depth();
+        ivec2 asize  = m_atlas->get_size();
         FT_Int32 flags = 0; 
         flags |= FT_LOAD_RENDER; 
@@ -137 +137 @@
                 int reg_width       = ft_bitmap_width / (depth > 3 ? 3 : (int)depth);
 
-                glm::ivec2 gsize( reg_width + 1, ft_bitmap_rows + 1 ); 
+                ivec2 gsize( reg_width + 1, ft_bitmap_rows + 1 ); 
                 region r = m_atlas->get_region( gsize );
                 if ( r.pos.x < 0 ) 
@@ -164 +164 @@
                 g->charcode = c;
                 g->size     = gsize;
-                g->offset   = glm::ivec2( ft_glyph_left, ft_glyph_top );
-                g->tl       = glm::vec2( r.pos.x/(float)asize.x, r.pos.y/(float)asize.y );
-                g->br       = glm::vec2( ( r.pos.x + gsize.x )/(float)asize.x, (r.pos.y + gsize.y )/(float)asize.y );
+                g->offset   = ivec2( ft_glyph_left, ft_glyph_top );
+                g->tl       = vec2( r.pos.x/(float)asize.x, r.pos.y/(float)asize.y );
+                g->br       = vec2( ( r.pos.x + gsize.x )/(float)asize.x, (r.pos.y + gsize.y )/(float)asize.y );
 
                 // Discard hinting to get advance
                 FT_Load_Glyph( face, glyph_index, FT_LOAD_RENDER | FT_LOAD_NO_HINTING);
                 slot = face->glyph;
-                g->advance = glm::ivec2( slot->advance.x/64.0, slot->advance.y/64.0 );
+                g->advance = ivec2( slot->advance.x/64.0, slot->advance.y/64.0 );
         }
         generate_kerning();

trunk/src/gl/gl_context.cc

@@ -731 +731 @@
         }
         unsigned int buffers[8];
-        count = glm::min<uint32>( count, 8 );
+        count = nv::min<uint32>( count, 8 );
         for ( uint32 i = 0; i < count; ++i )
         {

trunk/src/gl/gl_device.cc

@@ -53 +53 @@
         assert( image->format->BytesPerPixel > 2 );
         image_format format(image->format->BytesPerPixel == 3 ? RGB : RGBA, UBYTE );
-        image_data* data = new image_data( format, glm::ivec2( image->w, image->h ), (nv::uint8*)image->pixels );
+        image_data* data = new image_data( format, ivec2( image->w, image->h ), (nv::uint8*)image->pixels );
         return data;
 }
@@ -71 +71 @@
         assert( image->format->BytesPerPixel > 2 );
         image_format format( image->format->BytesPerPixel == 3 ? RGB : RGBA, UBYTE );
-        image_data* idata = new image_data( format, glm::ivec2( image->w, image->h ), ( nv::uint8* )image->pixels );
+        image_data* idata = new image_data( format, ivec2( image->w, image->h ), ( nv::uint8* )image->pixels );
         return idata;
 }

trunk/src/rogue/fov_recursive_shadowcasting.cc

@@ -24 +24 @@
         {
                 position max_radius = m_size-m_position;
-                max_radius.x=glm::max(max_radius.x,m_position.x);
-                max_radius.y=glm::max(max_radius.y,m_position.y);
-                m_radius = (int)glm::length((glm::vec2)max_radius)+1;
+                max_radius = glm::max(max_radius,m_position);
+                m_radius = (int)glm::length((vec2)max_radius)+1;
         }
         m_radius2 = m_radius * m_radius;