Changeset 376 for trunk/src


Ignore:
Timestamp:
05/28/15 10:21:10 (10 years ago)
Author:
epyon
Message:
  • stl/assert.hh, stl/capi.hh, size_t independent
  • GCC 4.8 compatibility
  • using template usage
  • various minor changes
Location:
trunk/src
Files:
2 added
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/core/logger.cc

    r368 r376  
    88#include "nv/core/time.hh"
    99#include <cstdio>
    10 #if NV_PLATFORM == NV_WINDOWS
     10#if NV_COMPILER == NV_MSVC
    1111#define WIN32_LEAN_AND_MEAN
    1212#include <Windows.h>
    … …  
    5151#define NV_LOG_LEVEL_NAME_PAD(level) (log_level_names_pad[ (level) / 10 ])
    5252
    53 #if NV_PLATFORM == NV_WINDOWS
     53#if NV_COMPILER == NV_MSVC
    5454static unsigned short log_color[] =
    5555{
    … …  
    145145        size_t ssize = timestamp( stamp );
    146146
    147 #if NV_PLATFORM == NV_WINDOWS
     147#if NV_COMPILER == NV_MSVC
    148148        if ( m_color ) SetConsoleTextAttribute( m_handle, FOREGROUND_INTENSITY );
    149149        WriteConsole( m_handle, stamp, ssize, nullptr, nullptr );
    … …  
    170170        else
    171171                fwrite( "] ", 2, 1, stdout );
    172         fwrite( stamp.data(), stamp.size(), 1, stdout );
     172        fwrite( message.data(), message.size(), 1, stdout );
    173173        fwrite( "\n", 1, 1, stdout );
    174174#endif
    … …  
    233233        : m_color( coloring )
    234234{
    235 #if NV_PLATFORM == NV_WINDOWS
     235#if NV_COMPILER == NV_MSVC
    236236        m_handle = GetStdHandle( STD_OUTPUT_HANDLE );
    237237#else
    … …  
    240240}
    241241
    242 size_t nv::log_sink::timestamp( char* buffer ) const
     242nv::size_t nv::log_sink::timestamp( char* buffer ) const
    243243{
    244244        uint32 ms = get_system_ms();
    … …  
    248248        unsigned int m    = (unsigned int)(secs / 60) % 60;
    249249        unsigned int s    = secs % 60;
    250 #if NV_PLATFORM == NV_WINDOWS
     250#if NV_COMPILER == NV_MSVC
    251251        sprintf_s( buffer, 16, "%02d:%02d:%02d.%02d", h, m, s, mm );
    252252#else

  • trunk/src/core/profiler.cc

    r371 r376  
    1212using namespace nv;
    1313
    14 #ifdef NV_MSVC
     14#if NV_COMPILER == NV_MSVC
    1515#define snprintf sprintf_s
    1616#endif

  • trunk/src/core/time.cc

    r319 r376  
    77#include "nv/core/logging.hh"
    88
     9#include <ctime>
     10
    911#if NV_COMPILER == NV_MSVC
    1012#define WIN32_LEAN_AND_MEAN
    … …  
    1315#pragma intrinsic(__rdtsc)
    1416#else
    15 #include <unistd.h>
     17#if NV_COMPILER == NV_GNUC && NV_PLATFORM == NV_WINDOWS
     18// mingw doesn't have usleep nor nanosleep...
     19#include <windows.h>
     20#endif
     21// #include <unistd.h>
     22// #include <time.h>
     23// #include <sys/time.h>
     24// #include <sys/types.h>
     25#include <stdio.h>
     26#include <time.h>
    1627#include <sys/time.h>
    1728#endif
    1829
    19 #include <ctime>
     30
    2031
    2132struct timer_impl
    … …  
    5869        Sleep( ms );
    5970#else
    60         usleep( ms * 1000 );
     71#if NV_COMPILER == NV_GNUC && NV_PLATFORM == NV_WINDOWS
     72        Sleep( ms );
     73#else
     74        struct timespec ts;
     75        ts.tv_sec = 0;
     76        ts.tv_nsec = ms * 1000000;
     77        nanosleep(&ts, NULL);
     78//      usleep( ms * 1000 );
     79#endif
    6180#endif
    6281}

  • trunk/src/formats/assimp_loader.cc

    r367 r376  
    479479}
    480480
    481 size_t nv::assimp_loader::get_nodes_data_count() const
     481nv::size_t nv::assimp_loader::get_nodes_data_count() const
    482482{
    483483        if ( m_scene == nullptr ) return 0;

  • trunk/src/formats/md2_loader.cc

    r374 r376  
    167167       
    168168        source.seek( md2->header.offset_skins, origin::SET );
    169         source.read( md2->skins, sizeof(md2_skin_t), static_cast<size_t>( md2->header.num_skins ) );
     169        source.read( md2->skins, sizeof( md2_skin_t ), static_cast<nv::size_t>( md2->header.num_skins ) );
    170170
    171171        source.seek( md2->header.offset_st, origin::SET );
    172         source.read( md2->texcoords, sizeof(md2_texcoord_t), static_cast<size_t>( md2->header.num_st ) );
     172        source.read( md2->texcoords, sizeof( md2_texcoord_t ), static_cast<nv::size_t>( md2->header.num_st ) );
    173173
    174174        source.seek( md2->header.offset_tris, origin::SET );
    175         source.read( md2->triangles, sizeof(md2_triangle_t), static_cast<size_t>( md2->header.num_tris ) );
     175        source.read( md2->triangles, sizeof( md2_triangle_t ), static_cast<nv::size_t>( md2->header.num_tris ) );
    176176
    177177        source.seek( md2->header.offset_glcmds, origin::SET);
    178         source.read( md2->glcmds, sizeof(int), static_cast<size_t>( md2->header.num_glcmds ) );
     178        source.read( md2->glcmds, sizeof( int ), static_cast<nv::size_t>( md2->header.num_glcmds ) );
    179179
    180180        md2->frames    = new md2_frame_t   [ md2->header.num_frames ];

  • trunk/src/formats/md3_loader.cc

    r374 r376  
    161161
    162162        source.seek( pos + surface->header.ofs_shaders, origin::SET );
    163         source.read( surface->shaders, sizeof( md3_shader_t ), static_cast<size_t>( surface->header.num_shaders ) );
     163        source.read( surface->shaders, sizeof( md3_shader_t ), static_cast<nv::size_t>( surface->header.num_shaders ) );
    164164
    165165        source.seek( pos + surface->header.ofs_triangles, origin::SET );
    166         source.read( surface->triangles, sizeof( md3_triangle_t ), static_cast<size_t>( surface->header.num_triangles ) );
     166        source.read( surface->triangles, sizeof( md3_triangle_t ), static_cast<nv::size_t>( surface->header.num_triangles ) );
    167167
    168168        source.seek( pos + surface->header.ofs_st, origin::SET );
    169         source.read( surface->st, sizeof( md3_texcoord_t ), static_cast<size_t>( surface->header.num_verts ) );
     169        source.read( surface->st, sizeof( md3_texcoord_t ), static_cast<nv::size_t>( surface->header.num_verts ) );
    170170
    171171        source.seek( pos + surface->header.ofs_xyznormal, origin::SET );
    172         source.read( surface->vertices, sizeof( md3_vertex_t ), static_cast<size_t>( surface->header.num_verts * surface->header.num_frames ) );
    173 
    174         if ( source.tell() != static_cast<size_t>( pos + surface->header.ofs_end ) ) return false;
     172        source.read( surface->vertices, sizeof( md3_vertex_t ), static_cast<nv::size_t>( surface->header.num_verts * surface->header.num_frames ) );
     173
     174        if ( source.tell() != static_cast<nv::size_t>( pos + surface->header.ofs_end ) ) return false;
    175175
    176176        return true;
    … …  
    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< size_t >( md3->header.num_surfaces ) * sizeof(md3_surface_t) );
     200        std::memset( md3->surfaces, 0, static_cast< nv::size_t >( md3->header.num_surfaces ) * sizeof( md3_surface_t ) );
    201201
    202202        source.seek( md3->header.ofs_frames, origin::SET );
    203         source.read( md3->frames, sizeof( md3_frame_t ), static_cast<size_t>( md3->header.num_frames ) );
     203        source.read( md3->frames, sizeof( md3_frame_t ), static_cast<nv::size_t>( md3->header.num_frames ) );
    204204
    205205        if ( md3->header.num_tags > 0 )
    206206        {
    207207                source.seek( md3->header.ofs_tags, origin::SET );
    208                 source.read( md3->tags, sizeof( md3_tag_t ), static_cast<size_t>( md3->header.num_tags * md3->header.num_frames ) );
     208                source.read( md3->tags, sizeof( md3_tag_t ), static_cast<nv::size_t>( md3->header.num_tags * md3->header.num_frames ) );
    209209        }
    210210
    … …  
    321321};
    322322
    323 mesh_data* nv::md3_loader::release_mesh_data( size_t index )
     323mesh_data* nv::md3_loader::release_mesh_data( nv::size_t index )
    324324{
    325325        mesh_data* data = new mesh_data;
    … …  
    417417}
    418418
    419 mesh_nodes_data* nv::md3_loader::release_mesh_nodes_data( size_t )
     419mesh_nodes_data* nv::md3_loader::release_mesh_nodes_data( nv::size_t )
    420420{
    421421        md3_t* md3 = (md3_t*)m_md3;
    … …  
    464464}
    465465
    466 size_t md3_loader::get_max_frames() const
     466nv::size_t md3_loader::get_max_frames() const
    467467{
    468468        return static_cast< size_t >( ((md3_t*)m_md3)->header.num_frames );

  • trunk/src/formats/md5_loader.cc

    r374 r376  
    2424static void remove_quotes( std::string& str )
    2525{
    26         size_t n;
     26        nv::size_t n;
    2727        while ( ( n = str.find('\"') ) != std::string::npos ) str.erase(n,1);
    2828}

  • trunk/src/formats/obj_loader.cc

    r374 r376  
    5353        std::string next_name;
    5454
    55         size_t size;
     55        nv::size_t size;
    5656        bool   eof;
    5757
    5858        obj_reader();
    5959        bool read_stream( std::istream& stream );
    60         virtual size_t add_face( uint32* vi, uint32* ti, uint32* ni, size_t count ) = 0;
    61         virtual size_t raw_size() const = 0;
     60        virtual nv::size_t add_face( uint32* vi, uint32* ti, uint32* ni, nv::size_t count ) = 0;
     61        virtual nv::size_t raw_size() const = 0;
    6262        virtual void reset() = 0;
    6363        virtual const uint8* raw_pointer() const = 0;
    … …  
    172172{
    173173        mesh_data_reader( bool normals ) : m_normals( normals ) {}
    174         virtual size_t add_face( uint32* vi, uint32* ti, uint32* ni, size_t count )
     174        virtual nv::size_t add_face( uint32* vi, uint32* ti, uint32* ni, nv::size_t count )
    175175        {
    176176                if ( count < 3 ) return 0; // TODO : report error?
    … …  
    178178                // TODO : support if normals not present;
    179179                vec3 nullvec;
    180                 size_t result = 0;
     180                nv::size_t result = 0;
    181181                // Simple triangulation - obj's shouldn't have more than quads anyway
    182182
    183183                if ( m_normals )
    184184                {
    185                         for ( size_t i = 2; i < count; ++i )
     185                        for ( nv::size_t i = 2; i < count; ++i )
    186186                        {
    187187                                result++;
    … …  
    193193                else
    194194                {
    195                         for ( size_t i = 2; i < count; ++i )
     195                        for ( nv::size_t i = 2; i < count; ++i )
    196196                        {
    197197                                result++;
    … …  
    206206        std::vector< VTX > m_data;
    207207        virtual void reset() { m_data.clear(); }
    208         virtual size_t raw_size() const { return m_data.size() * sizeof( VTX ); }
     208        virtual nv::size_t raw_size() const { return m_data.size() * sizeof( VTX ); }
    209209        virtual const uint8* raw_pointer() const { return (const uint8*)m_data.data(); }
    210210};
    … …  
    233233                //              std::vector< vec3 >& tg = m_mesh->get_tangents();
    234234
    235                 size_t count = m_data.size();
    236                 size_t tcount = count / 3;
     235                nv::size_t count = m_data.size();
     236                nv::size_t tcount = count / 3;
    237237
    238238                std::vector< vec3 > tan1( count );
    239239                std::vector< vec3 > tan2( count );
    240240
    241                 for (size_t a = 0; a < tcount; ++a )
    242                 {
    243                         size_t i1 = a * 3;
    244                         size_t i2 = a * 3 + 1;
    245                         size_t i3 = a * 3 + 2;
     241                for ( nv::size_t a = 0; a < tcount; ++a )
     242                {
     243                        nv::size_t i1 = a * 3;
     244                        nv::size_t i2 = a * 3 + 1;
     245                        nv::size_t i3 = a * 3 + 2;
    246246                        obj_vertex_vtnt& vtx1 = m_data[ i1 ];
    247247                        obj_vertex_vtnt& vtx2 = m_data[ i2 ];
    … …  
    278278                }
    279279
    280                 for (size_t a = 0; a < count; ++a )
     280                for ( nv::size_t a = 0; a < count; ++a )
    281281                {
    282282                        const vec3& n = m_data[a].normal;

  • trunk/src/gfx/image.cc

    r374 r376  
    77using namespace nv;
    88
    9 image::image( glm::ivec2 size, size_t depth )
     9image::image( glm::ivec2 size, nv::size_t depth )
    1010        : m_size( size ), m_depth( depth ), m_data( nullptr )
    1111{
    … …  
    2020
    2121
    22 image::image( glm::ivec2 size, size_t depth, const uint8 * data, bool reversed )
     22image::image( glm::ivec2 size, nv::size_t depth, const uint8 * data, bool reversed )
    2323        : m_size( size ), m_depth( depth ), m_data( nullptr )
    2424{

  • trunk/src/gfx/keyframed_mesh.cc

    r367 r376  
    3636}
    3737
    38 size_t keyframed_mesh::get_max_frames() const
     38nv::size_t keyframed_mesh::get_max_frames() const
    3939{
    4040        return m_frame_count;

  • trunk/src/gfx/texture_atlas.cc

    r367 r376  
    1111using namespace nv;
    1212
    13 texture_atlas::texture_atlas( glm::ivec2 size, size_t depth, size_t border /*= 1*/ )
     13texture_atlas::texture_atlas( glm::ivec2 size, nv::size_t depth, nv::size_t border /*= 1*/ )
    1414        : image( size, depth ), m_used( 0 ), m_border( border )
    1515{
    … …  
    8282}
    8383
    84 int texture_atlas::fit( size_t index, glm::ivec2 size )
     84int texture_atlas::fit( nv::size_t index, glm::ivec2 size )
    8585{
    8686        glm::ivec3 node = m_nodes[ index ];

  • trunk/src/gl/gl_context.cc

    r365 r376  
    329329}
    330330
    331 void gl_context::update( buffer b, const void* data, size_t offset, size_t size )
     331void gl_context::update( buffer b, const void* data, nv::size_t offset, nv::size_t size )
    332332{
    333333        const gl_buffer_info* info = static_cast< const gl_buffer_info* >( m_device->get_buffer_info( b ) );
    … …  
    748748}
    749749
    750 void gl_context::draw( primitive prim, const render_state& rs, program p, vertex_array va, size_t count )
     750void gl_context::draw( primitive prim, const render_state& rs, program p, vertex_array va, nv::size_t count )
    751751{
    752752        apply_render_state( rs );

  • trunk/src/gui/gui_gfx_renderer.cc

    r367 r376  
    107107{
    108108public:
    109         screen_render_data( context* actx, size_t initial_size )
     109        screen_render_data( context* actx, nv::size_t initial_size )
    110110                : buffer( actx, VERTEX_BUFFER, DYNAMIC_DRAW, initial_size ), ctx( actx ), varray(), shader()
    111111        {
    … …  
    175175}
    176176
    177 texture_font* gfx_renderer::get_font( size_t name ) const
     177texture_font* gfx_renderer::get_font( nv::size_t name ) const
    178178{
    179179        if ( name >= m_fonts.size() ) return nullptr;
    … …  
    181181}
    182182
    183 const image_info* gfx_renderer::get_image( size_t name ) const
     183const image_info* gfx_renderer::get_image( nv::size_t name ) const
    184184{
    185185        if ( name >= m_images.size() ) return nullptr;
    … …  
    187187}
    188188
    189 size_t gfx_renderer::load_font( const std::string& filename, size_t size )
     189nv::size_t gfx_renderer::load_font( const std::string& filename, nv::size_t size )
    190190{
    191191        std::string id_name( filename );
    … …  
    205205}
    206206
    207 size_t gfx_renderer::load_image( const std::string& filename )
     207nv::size_t gfx_renderer::load_image( const std::string& filename )
    208208{
    209209        auto i = m_image_names.find( filename );

  • trunk/src/io/c_stream.cc

    r374 r376  
    33// For conditions of distribution and use, see copyright notice in nv.hh
    44
     5#include "nv/io/c_stream.hh"
    56#include <cstdio>
    67#include <sys/stat.h>
    7 #include "nv/io/c_stream.hh"
    88
    99using namespace nv;
    … …  
    3333}
    3434
    35 size_t c_stream::read( void* buffer, size_t size, size_t count )
     35nv::size_t c_stream::read( void* buffer, nv::size_t size, nv::size_t count )
    3636{
    3737        NV_ASSERT( buffer != nullptr && size != 0 && count != 0, "Bad parameter passed to read!" );
    … …  
    3939}
    4040
    41 size_t c_stream::write( const void* buffer, size_t size, size_t count )
     41nv::size_t c_stream::write( const void* buffer, nv::size_t size, nv::size_t count )
    4242{
    4343        NV_ASSERT( buffer != nullptr && size != 0 && count != 0, "Bad parameter passed to write!" );
    … …  
    5050}
    5151
    52 size_t c_stream::tell()
     52nv::size_t c_stream::tell()
    5353{
    54         return m_file != nullptr ? static_cast< size_t >( ::ftell( (FILE*)m_file ) ) : 0;
     54        return m_file != nullptr ? static_cast< nv::size_t >( ::ftell( (FILE*)m_file ) ) : 0;
    5555}
    5656
    57 size_t c_stream::size()
     57nv::size_t c_stream::size()
    5858{
    5959        if ( m_file == nullptr || m_file_name == nullptr )

  • trunk/src/lua/lua_path.cc

    r360 r376  
    3232}
    3333
    34 void lua::path::push( size_t value )
     34void lua::path::push( nv::size_t value )
    3535{
    3636        m_elements[ m_count ].value  = value;

  • trunk/src/lua/lua_state.cc

    r368 r376  
    166166}
    167167
    168 size_t lua::table_guard::get_size()
     168nv::size_t lua::table_guard::get_size()
    169169{
    170170        return lua_rawlen( m_state, -1 );
Note: See TracChangeset for help on using the changeset viewer.