Changeset 383 for trunk/src


Ignore:
Timestamp:
06/02/15 20:56:15 (10 years ago)
Author:
epyon
Message:
  • more work on stl
  • fully working vectors!
  • copy & copy_n
  • removal of a lot of std code!
Location:
trunk/src
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/formats/assimp_loader.cc

    r382 r383  
    188188}
    189189
    190 bool nv::assimp_loader::load_bones( size_t index, std::vector< mesh_node_data >& bones )
     190bool nv::assimp_loader::load_bones( size_t index, array_ref< mesh_node_data > bones )
    191191{
    192192        if ( m_scene == nullptr ) return false;
    … …  
    285285{
    286286        const aiScene* scene = (const aiScene*)m_scene;
    287         std::vector< mesh_node_data > final_bones;
     287        vector< mesh_node_data > final_bones;
    288288        std::unordered_map< std::string, uint16 > names;
    289289        for ( unsigned int m = 0; m < m_mesh_count; ++m )
    290290        {
    291291                uint16 translate[MAX_BONES];
    292                 std::vector< mesh_node_data > bones;
     292                vector< mesh_node_data > bones;
    293293                const aiMesh*  mesh  = scene->mMeshes[ m ];
    294294                if ( mesh->mNumBones != 0 )
    … …  
    334334        }
    335335        mesh_node_data* bones = new mesh_node_data[ final_bones.size() ];
    336         std::copy( final_bones.begin(), final_bones.end(), bones );
     336        nv::raw_copy( final_bones.begin(), final_bones.end(), bones );
    337337        return new mesh_nodes_data( "bones", final_bones.size(), bones );
    338338}

  • trunk/src/formats/md2_loader.cc

    r376 r383  
    251251        uint32 stats_collision  = 0;
    252252
    253         std::vector< sint32 > index_translation( static_cast< uint32 >( md2->header.num_vertices ), -1 );
     253        vector< sint32 > index_translation( static_cast< uint32 >( md2->header.num_vertices ), -1 );
    254254
    255255        m_new_indexes.clear();
    … …  
    364364        {
    365365                uint16* icp = (uint16*)ic->data;
    366                 std::copy_n( m_new_indexes.data(), m_new_indexes.size(), icp );
     366                raw_copy_n( m_new_indexes.data(), m_new_indexes.size(), icp );
    367367        }
    368368

  • trunk/src/formats/md3_loader.cc

    r376 r383  
    198198        md3->tags     = new md3_tag_t    [ md3->header.num_tags * md3->header.num_frames ];
    199199        md3->surfaces = new md3_surface_t[ md3->header.num_surfaces ];
    200         std::memset( md3->surfaces, 0, static_cast< nv::size_t >( md3->header.num_surfaces ) * sizeof( md3_surface_t ) );
     200        nv::raw_zero_n( md3->surfaces, static_cast< nv::size_t >( md3->header.num_surfaces ) );
    201201
    202202        source.seek( md3->header.ofs_frames, origin::SET );
    … …  
    285285}
    286286
    287 nv::key_raw_channel* nv::md3_loader::load_tags( const std::string& tag )
     287nv::key_raw_channel* nv::md3_loader::load_tags( const string_ref& tag )
    288288{
    289289        md3_t* md3 = (md3_t*)m_md3;
    … …  
    295295                {
    296296                        const md3_tag_t& rtag = md3->tags[i + md3->header.num_tags * f];
    297                         std::string rname((char*)(rtag.name));
     297                        string_ref rname((char*)(rtag.name));
    298298                        if (rname == tag)
    299299                        {
    … …  
    421421        md3_t* md3 = (md3_t*)m_md3;
    422422        uint32 node_count = (uint32)md3->header.num_tags;
    423         if ( node_count == 0 ) return nullptr;;
     423        if ( node_count == 0 ) return nullptr;
    424424        mesh_node_data* nodes = new mesh_node_data[ node_count ];
    425425        for ( uint32 i = 0; i < node_count; ++i )
    426426        {
    427427                const md3_tag_t& rtag = md3->tags[i];
    428                 std::string name( (char*)(rtag.name) );
     428                string_ref name( (char*)(rtag.name) );
    429429
    430430                nodes[i].transform = mat4();
    431                 nodes[i].name      = name;
     431                nodes[i].name      = name.to_string();
    432432                nodes[i].parent_id = -1;
    433433                nodes[i].target_id = -1;

  • trunk/src/formats/md5_loader.cc

    r376 r383  
    4848
    4949        // MESH data
    50         std::vector<md5_joint_info> joint_infos;
    51         std::vector<transform>      base_frames;
     50        dynamic_array< md5_joint_info > joint_infos;
     51        vector< transform >             base_frames;
    5252        size_t num_animated_components = 0;
    5353        size_t frame_rate = 0;
    … …  
    301301                else if ( command == "frame" )
    302302                {
    303                         std::vector<float> frame;
     303                        vector<float> frame;
    304304                        uint32 frame_id;
    305305                        sstream >> frame_id;
    … …  
    454454}
    455455
    456 void md5_loader::build_frame_skeleton( mesh_node_data* nodes, uint32 index, const std::vector<md5_joint_info>& joint_infos, const std::vector<transform>& base_frames, const std::vector<float>& frame_data )
     456void md5_loader::build_frame_skeleton( mesh_node_data* nodes, uint32 index, const const_array_ref<md5_joint_info>& joint_infos, const const_array_ref<transform>& base_frames, const const_array_ref<float>& frame_data )
    457457{
    458458        assert( m_type == ANIMATION );

  • trunk/src/formats/nmd_loader.cc

    r368 r383  
    162162static void nmd_dump_mesh( const mesh_data* mesh, stream& stream_out )
    163163{
    164         const std::vector< mesh_raw_channel* >& data  = mesh->get_raw_channels();
     164        const_array_ref< mesh_raw_channel* > data  = mesh->get_raw_channels();
    165165
    166166        uint32 size = sizeof( nmd_element_header );

  • trunk/src/formats/obj_loader.cc

    r382 r383  
    4444struct obj_reader
    4545{
    46         std::vector< vec3 > v;
    47         std::vector< vec3 > n;
    48         std::vector< vec2 > t;
     46        vector< vec3 > v;
     47        vector< vec3 > n;
     48        vector< vec2 > t;
    4949
    5050        std::string line;
    … …  
    204204        }
    205205        bool m_normals;
    206         std::vector< VTX > m_data;
     206        vector< VTX > m_data;
    207207        virtual void reset() { m_data.clear(); }
    208208        virtual nv::size_t raw_size() const { return m_data.size() * sizeof( VTX ); }
    … …  
    228228        void calculate_tangents()
    229229        {
    230                 //              const std::vector< vec3 >& vp = m_mesh->get_positions();
    231                 //              const std::vector< vec2 >& vt = m_mesh->get_texcoords();
    232                 //              const std::vector< vec3 >& vn = m_mesh->get_normals();
    233                 //              std::vector< vec3 >& tg = m_mesh->get_tangents();
    234 
    235230                nv::size_t count = m_data.size();
    236231                nv::size_t tcount = count / 3;
    237232
    238                 std::vector< vec3 > tan1( count );
    239                 std::vector< vec3 > tan2( count );
     233                vector< vec3 > tan1( count );
     234                vector< vec3 > tan2( count );
    240235
    241236                for ( nv::size_t a = 0; a < tcount; ++a )
    … …  
    335330                {
    336331                        data = new uint8[ reader->raw_size() ];
    337                         std::copy_n( reader->raw_pointer(), reader->raw_size(), data );
     332                        raw_copy_n( reader->raw_pointer(), reader->raw_size(), data );
    338333                }
    339334                channel->data  = data;

  • trunk/src/gfx/image.cc

    r376 r383  
    44
    55#include "nv/gfx/image.hh"
     6#include "nv/stl/algorithm.hh"
    67
    78using namespace nv;
    … …  
    3132                for( int i = 0; i < m_size.y; ++i )
    3233                {
    33                         std::copy( data + i * bline, data + (i + 1) * bline, m_data + bsize - ( i + 1 ) * bline );
     34                        raw_copy( data + i * bline, data + (i + 1) * bline, m_data + bsize - ( i + 1 ) * bline );
    3435                }
    3536
    … …  
    3738        else
    3839        {
    39                 std::copy( data, data + bsize, m_data );
     40                raw_copy( data, data + bsize, m_data );
    4041        }
    4142}
    … …  
    4344void image::fill( uint8 value )
    4445{
    45         std::fill( m_data, m_data + m_size.x * m_size.y * (int)m_depth, value );
     46        raw_fill( m_data, m_data + m_size.x * m_size.y * (int)m_depth, value );
    4647}
    4748
    … …  
    5657        {
    5758                // TODO: test
    58                 std::fill( m_data + bpos + bline * i, m_data + bpos + bline * i + stride, value );
     59                raw_fill( m_data + bpos + bline * i, m_data + bpos + bline * i + stride, value );
    5960        }
    6061}
    … …  
    7374//              memcpy( m_data+((r.pos.y+i)*m_size.x + r.pos.x ) * m_depth,
    7475//                      data + (i*stride), r.size.x * m_depth );
    75                 std::copy( data + i*stride, data + (i+1)*stride, m_data + bpos + bline * i );
     76                raw_copy( data + i*stride, data + (i+1)*stride, m_data + bpos + bline * i );
    7677        }
    7778}

  • trunk/src/gfx/mesh_creator.cc

    r323 r383  
    350350        for ( uint32 i = 0; i < count; ++i )
    351351        {
    352                 std::copy_n( a->data + i * adesc.size, adesc.size, data + i*desc.size );
    353                 std::copy_n( b->data + i * bdesc.size, bdesc.size, data + i*desc.size + adesc.size );
     352                raw_copy_n( a->data + i * adesc.size, adesc.size, data + i*desc.size );
     353                raw_copy_n( b->data + i * bdesc.size, bdesc.size, data + i*desc.size + adesc.size );
    354354        }
    355355        mesh_raw_channel* result = new mesh_raw_channel;
    … …  
    373373        {
    374374                size_t a_size = vtx_size * a->count;
    375                 std::copy_n( a->data, a_size, data );
    376                 std::copy_n( b->data, vtx_size * b->count, data + a_size );             
     375                raw_copy_n( a->data, a_size, data );
     376                raw_copy_n( b->data, vtx_size * b->count, data + a_size );
    377377        }
    378378        else
    … …  
    385385                for ( size_t i = 0; i < frame_count; ++i )
    386386                {
    387                         std::copy_n( a->data + pos_a, frame_size_a, data + pos );
    388                         std::copy_n( b->data + pos_b, frame_size_b, data + pos + frame_size_a );                                pos_a += frame_size_a;
     387                        raw_copy_n( a->data + pos_a, frame_size_a, data + pos );
     388                        raw_copy_n( b->data + pos_b, frame_size_b, data + pos + frame_size_a );                         pos_a += frame_size_a;
    389389                        pos_b += frame_size_b;
    390390                        pos   += frame_size_a + frame_size_b;

  • trunk/src/gfx/skeletal_mesh.cc

    r367 r383  
    4343                        }
    4444
    45                         std::fill( m_pntdata.raw_data(), m_pntdata.raw_data() + m_pntdata.raw_size(), 0 );
     45                        fill( m_pntdata.raw_data(), m_pntdata.raw_data() + m_pntdata.raw_size(), 0 );
    4646                        for ( unsigned int i = 0; i < vertex_count; ++i )
    4747                        {

  • trunk/src/gl/gl_device.cc

    r380 r383  
    221221        const gl_program_info* info = m_programs.get( p );
    222222        {
    223                 uniform_map::const_iterator i = info->m_uniform_map.find( name );
     223                nv::uniform_map::const_iterator i = info->m_uniform_map.find( name );
    224224                if ( i != info->m_uniform_map.end() )
    225225                {

  • trunk/src/io/string_table.cc

    r281 r383  
    66
    77#include "nv/io/string_table.hh"
     8#include <array>
    89
    910nv::string_table_creator::string_table_creator()

  • trunk/src/lua/lua_map_tile.cc

    r378 r383  
    118118                new_tile->ascii = new nv::uchar8[ size ];
    119119        }
    120         std::copy( old_tile->data, old_tile->data + size, new_tile->data );
    121         if ( old_tile->ascii ) std::copy( old_tile->ascii, old_tile->ascii + size, new_tile->ascii );
     120        nv::raw_copy_n( old_tile->data, size, new_tile->data );
     121        if ( old_tile->ascii ) nv::raw_copy_n( old_tile->ascii, size, new_tile->ascii );
    122122
    123123        luaL_getmetatable( L, NLUA_MAP_TILE_METATABLE );
    … …  
    237237        map_tile* tile = nlua_to_pmap_tile( L, 1 );
    238238        // assert( tile^.ascii == nullptr );
    239         std::vector< nv::uint8 > sizes_x = nlua_tobytearray( L, 2 );
    240         std::vector< nv::uint8 > sizes_y = ( lua_istable( L, 3 ) ? nlua_tobytearray( L, 3 ) : sizes_x );
     239        nv::vector< nv::uint8 > sizes_x = nlua_tobytearray( L, 2 );
     240        nv::vector< nv::uint8 > sizes_y;
     241        if ( lua_istable( L, 3 ) )
     242                sizes_y = nlua_tobytearray( L, 2 );
     243        else
     244                sizes_y.assign( sizes_x );
    241245
    242246        nv::uint16 org_x = tile->size_x;

  • trunk/src/lua/lua_raw.cc

    r380 r383  
    262262}
    263263
    264 std::vector<nv::uint8> nlua_tobytearray( lua_State *L, int index )
    265 {
    266         index = lua_absindex( L, index );
    267         std::vector<nv::uint8> result;
     264nv::vector<nv::uint8> nlua_tobytearray( lua_State *L, int index )
     265{
     266        index = lua_absindex( L, index );
     267        nv::vector<nv::uint8> result;
    268268        if ( lua_istable( L, index ) )
    269269        {
Note: See TracChangeset for help on using the changeset viewer.