Changeset 198 for trunk


Ignore:
Timestamp:
08/11/13 17:19:03 (12 years ago)
Author:
epyon
Message:
  • warning cleanup for clang and gcc
Location:
trunk
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/formats/md2_loader.hh

    r189 r198  
    3434//              virtual const md3_tag* get_tag( const std::string& name ) const;
    3535//              virtual mat4 get_tag( sint32 frame, const std::string& name ) const;
    36                 sint32 get_max_frames() const;
     36                size_t get_max_frames() const;
    3737//              void load_tag_names( std::vector< std::string >& tags );
    3838//              void load_tags( std::vector<mat4>& t, const std::string& tag );

  • trunk/nv/formats/md3_loader.hh

    r190 r198  
    3131        {
    3232        public:
    33                 virtual sint32 get_max_frames() const = 0;
     33                virtual size_t get_max_frames() const = 0;
    3434                virtual void load_positions( std::vector<vec3>& p, sint32 frame =-1 ) = 0;
    3535                virtual void load_normals( std::vector<vec3>& n, sint32 frame =-1 ) = 0;
    … …  
    5050                virtual const md3_tag* get_tag( const std::string& name ) const;
    5151                virtual mat4 get_tag( sint32 frame, const std::string& name ) const;
    52                 sint32 get_max_frames() const;
     52                size_t get_max_frames() const;
    5353                void load_tag_names( std::vector< std::string >& tags );
    5454                void load_tags( std::vector<mat4>& t, const std::string& tag );
    … …  
    7070
    7171                keyframed_mesh_data( keyframed_loader* loader );
    72                 size_t get_frame_count() const { return m_frames; };
    73                 size_t get_index_count() const { return m_indices.size(); };
    74                 size_t get_vertex_count() const { return m_texcoords.size(); };
     72                size_t get_frame_count() const { return m_frames; }
     73                size_t get_index_count() const { return m_indices.size(); }
     74                size_t get_vertex_count() const { return m_texcoords.size(); }
    7575                const std::vector< vec3 >& get_positions() { return m_positions; }
    7676                const std::vector< vec3 >& get_normals() { return m_normals; }

  • trunk/nv/formats/md5_loader.hh

    r191 r198  
    8686                }
    8787
    88                 int get_num_joints() const
     88                size_t get_num_joints() const
    8989                {
    9090                        return m_num_joints;
    … …  
    111111
    112112        private:
    113                 int m_md5_version;
    114                 int m_num_frames;
    115                 int m_num_joints;
    116                 int m_frame_rate;
    117                 int m_num_animated_components;
     113                size_t m_md5_version;
     114                size_t m_num_frames;
     115                size_t m_num_joints;
     116                size_t m_frame_rate;
     117                size_t m_num_animated_components;
    118118
    119119                float m_anim_duration;
    … …  
    126126        {
    127127        public:
    128                 md5_loader() {};
    129                 virtual ~md5_loader() {};
     128                md5_loader() {}
     129                virtual ~md5_loader() {}
    130130                virtual bool load( stream& source );
    131131                virtual size_t get_size();
    132132                virtual mesh* release_mesh();
    133                 virtual mesh* get_frame( sint32 frame ) { return nullptr; }
     133                virtual mesh* get_frame( sint32 /*frame*/ ) { return nullptr; }
    134134                bool check_animation( const md5_animation& animation ) const;
    135135                void apply( const md5_animation& animation );
    136136//              virtual const md3_tag* get_tag( const std::string& name ) const;
    137137//              virtual mat4 get_tag( sint32 frame, const std::string& name ) const;
    138 //              sint32 get_max_frames() const;
     138//              size_t get_max_frames() const;
    139139//              void load_tag_names( std::vector< std::string >& tags );
    140140//              void load_tags( std::vector<mat4>& t, const std::string& tag );
    … …  
    154154                        glm::vec3 tangent;
    155155                        glm::vec2 texcoord;
    156                         int       start_weight;
    157                         int       weight_count;
     156                        size_t    start_weight;
     157                        size_t    weight_count;
    158158                };
    159159

  • trunk/nv/interface/audio.hh

    r194 r198  
    3535                virtual channel* play_sound( sound* a_sound ) = 0;
    3636                virtual sound* load_sound( const std::string& a_path ) = 0;
    37                 virtual void update() {};
     37                virtual void update() {}
    3838                virtual ~audio() {}
    3939        };

  • trunk/nv/interface/map_area.hh

    r179 r198  
    2626                virtual uint32 get_cell( const position& p ) const = 0;
    2727                virtual void set_cell( const position& p, uint32 value ) = 0;
    28                 virtual uint32 string_to_id( const nv::string& ) const { return 0; };
    29                 virtual nv::string id_to_string( uint32 ) const { return nv::string(); };
     28                virtual uint32 string_to_id( const nv::string& ) const { return 0; }
     29                virtual nv::string id_to_string( uint32 ) const { return nv::string(); }
    3030                virtual dimension get_size() const = 0;
    3131                virtual position get_shift() const { return position(); }
    … …  
    4343                virtual dimension get_size() const { return m_area.get_size(); }
    4444                virtual position get_shift() const { return m_area.ul + m_map_area->get_shift(); }
    45                 virtual uint32 string_to_id( const nv::string& s ) const { return m_map_area->string_to_id( s ); };
    46                 virtual nv::string id_to_string( uint32 id ) const { return m_map_area->id_to_string( id ); };
     45                virtual uint32 string_to_id( const nv::string& s ) const { return m_map_area->string_to_id( s ); }
     46                virtual nv::string id_to_string( uint32 id ) const { return m_map_area->id_to_string( id ); }
    4747        private:
    4848                map_area* m_map_area;

  • trunk/nv/interface/stream.hh

    r148 r198  
    3333                virtual size_t read( void* buffer, size_t size, size_t count ) = 0;
    3434                virtual size_t write( void* buffer, size_t size, size_t count ) = 0;
    35                 virtual bool seek( size_t offset, origin orig ) = 0;
     35                virtual bool seek( long offset, origin orig ) = 0;
    3636                virtual size_t tell() = 0;
    3737                virtual size_t size() = 0;

  • trunk/nv/io/c_stream.hh

    r134 r198  
    3030                virtual size_t read( void* buffer, size_t size, size_t count );
    3131                virtual size_t write( void* buffer, size_t size, size_t count );
    32                 virtual bool seek( size_t offset, origin orig );
     32                virtual bool seek( long offset, origin orig );
    3333                virtual size_t tell();
    3434                virtual size_t size();

  • trunk/nv/lib/lua.hh

    r172 r198  
    367367extern int LUA_VERSION_NUM;
    368368#define lua_upvalueindex(i)    (LUA_UPVALUEINDEX-(i))
    369 #define lua_tounsigned(L,idx) (lua_Number)lua_tointeger(L,idx)
     369#define lua_tounsigned(L,idx) (lua_Unsigned)lua_tointeger(L,idx)
    370370#define lua_pushunsigned(L,u) lua_pushinteger(L,(lua_Integer)u)
    371371#define lua_objlen lua_rawlen

  • trunk/nv/lib/sdl.hh

    r171 r198  
    876876    SDL_HINT_OVERRIDE
    877877} SDL_HintPriority;
    878 #endif;
     878#endif
    879879
    880880#if NV_SDL_VERSION == NV_SDL_20

  • trunk/nv/lua/lua_function.hh

    r185 r198  
    2525                {
    2626                public:
    27                         function_base( lua_State* L, const path& a_path, bool global = true );
     27                        function_base( lua_State* a_L, const path& a_path, bool a_global = true );
    2828                        function_base( const function_base& func );
    2929                        function_base& operator=( const function_base& func );
    … …  
    4242                {
    4343                public:
    44                         function( lua_State *L, const path& a_path, bool global = true )
    45                                 : function_base( L, a_path, global )
     44                        function( lua_State *a_L, const path& a_path, bool a_global = true )
     45                                : function_base( a_L, a_path, a_global )
    4646                        {
    4747                        }

  • trunk/nv/lua/lua_map_area.hh

    r179 r198  
    1818void nlua_register_map_area( lua_State* L );
    1919void nlua_register_map_area_interface( lua_State* L, int index );
     20bool nlua_is_map_area( lua_State* L, int index );
     21nv::map_area* nlua_to_map_area( lua_State* L, int index );
     22void nlua_push_map_area( lua_State* L, nv::map_area* c );
    2023
    2124

  • trunk/nv/lua/lua_path.hh

    r188 r198  
    3232                        path( nv::string p );
    3333                        path( const char* p );
    34                         path( int i );
     34                        path( unsigned i );
    3535
    3636                        template < typename T1, typename T2 >

  • trunk/nv/lua/lua_raw.hh

    r162 r198  
    1313#include <map>
    1414
    15 void nlua_toflags_flat( lua_State *L, int index, nv::uint8* data, nv::uint32 count );
     15void nlua_toflags_set( lua_State *L, int index, nv::uint8* data, nv::uint32 count );
    1616void nlua_toflags_array( lua_State *L, int index, nv::uint8* data, nv::uint32 count );
    1717void nlua_toflags( lua_State *L, int index, nv::uint8* data, nv::uint32 count );

  • trunk/src/formats/md2_loader.cc

    r189 r198  
    1717
    1818// assuming low-endian
    19 #define MD2_MAGIC         "IDP2"
    2019#define MD2_MAX_FRAMES    512
    2120#define MD2_MAX_SKINS     32
    … …  
    7574struct md2_vertex_t
    7675{
    77         unsigned char v[3];
    78         unsigned char n;
     76        uint8 v[3];
     77        uint8 n;
    7978};
    8079
    … …  
    127126}
    128127
    129 static bool read_md2_frame( md2_frame_t* frame, int vcount, nv::stream& source )
     128static bool read_md2_frame( md2_frame_t* frame, unsigned vcount, nv::stream& source )
    130129{
    131130        frame->vertices = new md2_vertex_t[ vcount ];
    … …  
    170169       
    171170        source.seek( md2->header.offset_skins, origin::SET );
    172         source.read( md2->skins, sizeof(md2_skin_t), md2->header.num_skins );
     171        source.read( md2->skins, sizeof(md2_skin_t), static_cast<size_t>( md2->header.num_skins ) );
    173172
    174173        source.seek( md2->header.offset_st, origin::SET );
    175         source.read( md2->texcoords, sizeof(md2_texcoord_t), md2->header.num_st );
     174        source.read( md2->texcoords, sizeof(md2_texcoord_t), static_cast<size_t>( md2->header.num_st ) );
    176175
    177176        source.seek( md2->header.offset_tris, origin::SET );
    178         source.read( md2->triangles, sizeof(md2_triangle_t), md2->header.num_tris );
     177        source.read( md2->triangles, sizeof(md2_triangle_t), static_cast<size_t>( md2->header.num_tris ) );
    179178
    180179        source.seek( md2->header.offset_glcmds, origin::SET);
    181         source.read( md2->glcmds, sizeof(int), md2->header.num_glcmds );
     180        source.read( md2->glcmds, sizeof(int), static_cast<size_t>( md2->header.num_glcmds ) );
    182181
    183182        md2->frames    = new md2_frame_t   [ md2->header.num_frames ];
    … …  
    185184        for ( int i = 0; i < md2->header.num_frames; ++i )
    186185        {
    187                 if (!read_md2_frame( &(md2->frames[i]), md2->header.num_vertices, source ) ) return false;
     186                if (!read_md2_frame( &(md2->frames[i]), static_cast<unsigned>( md2->header.num_vertices ), source ) ) return false;
    188187        }
    189188
    … …  
    197196}
    198197
    199 static inline vec3 md2_normal( char normal )
     198static inline vec3 md2_normal( uint8 normal )
    200199{
    201200        return md2_vec3( md2_normal_table[normal] );
    … …  
    269268}
    270269
    271 sint32 md2_loader::get_max_frames() const
    272 {
    273         return ((md2_t*)m_md2)->header.num_frames;
     270size_t md2_loader::get_max_frames() const
     271{
     272        return static_cast< size_t >( ((md2_t*)m_md2)->header.num_frames );
    274273}
    275274
    … …  
    277276{
    278277        md2_t* md2 = (md2_t*)m_md2;
    279         sint32 num_frames = md2->header.num_frames;
    280         sint32 num_verts  = m_new_vindexes.size();
     278        size_t num_frames = static_cast< size_t >( md2->header.num_frames );
     279        size_t num_verts  =     m_new_vindexes.size();
    281280        p.clear();
    282         sint32 current_frame = ( frame == -1 ? 0 : frame );
    283         sint32 frame_count   = ( frame == -1 ? num_frames : 1 );
     281        size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t >( frame ) );
     282        size_t frame_count   = ( frame == -1 ? num_frames : 1 );
    284283
    285284        p.reserve( num_verts * frame_count );
    … …  
    287286        while ( frame_count > 0 )
    288287        {
    289                 const md2_frame_t& frame = md2->frames[current_frame];
    290                 NV_LOG( LOG_INFO, "FrameID = " << frame.name );
    291 
    292                 vec3 scale     = md2_vec3( frame.scale );
    293                 vec3 translate = md2_vec3( frame.translate );
    294 
    295                 for (sint32 i = 0; i < num_verts; ++i )
     288                const md2_frame_t& cframe = md2->frames[current_frame];
     289                NV_LOG( LOG_INFO, "FrameID = " << cframe.name );
     290
     291                vec3 scale     = md2_vec3( cframe.scale );
     292                vec3 translate = md2_vec3( cframe.translate );
     293
     294                for (size_t i = 0; i < num_verts; ++i )
    296295                {
    297                         const md2_vertex_t& v = frame.vertices[ m_new_vindexes[ i ] ];
     296                        const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
    298297                        p.push_back( vec3( v.v[0], v.v[2], v.v[1] ) * scale + translate );
    299298                }
    … …  
    306305{
    307306        md2_t* md2 = (md2_t*)m_md2;
    308         sint32 num_frames = md2->header.num_frames;
    309         sint32 num_verts  =     m_new_vindexes.size();
     307        size_t num_frames = static_cast< size_t >( md2->header.num_frames );
     308        size_t num_verts  =     m_new_vindexes.size();
    310309        n.clear();
    311         sint32 current_frame = ( frame == -1 ? 0 : frame );
    312         sint32 frame_count   = ( frame == -1 ? num_frames : 1 );
     310        size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t>( frame ) );
     311        size_t frame_count   = ( frame == -1 ? num_frames : 1 );
    313312
    314313        n.reserve( num_verts * frame_count );
    … …  
    316315        while ( frame_count > 0 )
    317316        {
    318                 const md2_frame_t& frame = md2->frames[current_frame];
    319 
    320                 for (sint32 i = 0; i < num_verts; ++i )
     317                const md2_frame_t& cframe = md2->frames[current_frame];
     318
     319                for (size_t i = 0; i < num_verts; ++i )
    321320                {
    322                         const md2_vertex_t& v = frame.vertices[ m_new_vindexes[ i ] ];
     321                        const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
    323322                        n.push_back( s_md2_normal_cache[ v.n ] );
    324323                }
    … …  
    331330{
    332331        md2_t* md2 = (md2_t*)m_md2;
    333         sint32 num_verts  = m_new_vindexes.size();
     332        size_t num_verts  = m_new_vindexes.size();
    334333
    335334        t.clear();
    … …  
    338337        vec2 scale( 1.0f / (float) md2->header.skinwidth, 1.0f / (float) md2->header.skinheight );
    339338
    340         for (sint32 i = 0; i < num_verts; ++i )
     339        for (size_t i = 0; i < num_verts; ++i )
    341340        {
    342341                const md2_texcoord_t& st = md2->texcoords[ m_new_tindexes[ i ] ];
    … …  
    354353{
    355354        md2_t* md2 = (md2_t*)m_md2;
    356         uint32 num_indexes = md2->header.num_tris * 3;
     355        uint32 num_indexes = static_cast< uint32 >( md2->header.num_tris * 3 );
    357356
    358357        uint32 stats_reuse      = 0;
    … …  
    373372                for ( int j = 0; j < 3; ++j )
    374373                {
    375                         short index  = t.vertex[j];
    376                         short tindex = t.st[j];
     374                        uint16 index  = t.vertex[j];
     375                        uint16 tindex = t.st[j];
    377376
    378377                        if ( index_translation[ index ] != -1 )
    379378                        {
    380                                 uint16 prev = index_translation[ index ];
     379                                uint16 prev = static_cast< uint16 >( index_translation[ index ] );
    381380                                if ( m_new_tindexes[ prev ] == tindex )
    382381                                {

  • trunk/src/formats/md3_loader.cc

    r189 r198  
    1717
    1818// assuming low-endian
    19 #define MD3_MAGIC         "IDP3"
    2019#define MD3_MAX_FRAMES    1024
    2120#define MD3_MAX_TAGS      16
    … …  
    149148static bool read_surface( md3_surface_t * surface, nv::stream& source )
    150149{
    151         sint32 pos = source.tell();
     150        sint32 pos = static_cast< sint32 >( source.tell() );
    152151        source.read( &surface->header, sizeof(md3_surface_header_t), 1 );
    153152
    … …  
    164163
    165164        source.seek( pos + surface->header.ofs_shaders, origin::SET );
    166         source.read( surface->shaders, sizeof( md3_shader_t ), surface->header.num_shaders );
     165        source.read( surface->shaders, sizeof( md3_shader_t ), static_cast<size_t>( surface->header.num_shaders ) );
    167166
    168167        source.seek( pos + surface->header.ofs_triangles, origin::SET );
    169         source.read( surface->triangles, sizeof( md3_triangle_t ), surface->header.num_triangles );
     168        source.read( surface->triangles, sizeof( md3_triangle_t ), static_cast<size_t>( surface->header.num_triangles ) );
    170169
    171170        source.seek( pos + surface->header.ofs_st, origin::SET );
    172         source.read( surface->st, sizeof( md3_texcoord_t ), surface->header.num_verts );
     171        source.read( surface->st, sizeof( md3_texcoord_t ), static_cast<size_t>( surface->header.num_verts ) );
    173172
    174173        source.seek( pos + surface->header.ofs_xyznormal, origin::SET );
    175         source.read( surface->vertices, sizeof( md3_vertex_t ), surface->header.num_verts * surface->header.num_frames );
     174        source.read( surface->vertices, sizeof( md3_vertex_t ), static_cast<size_t>( surface->header.num_verts * surface->header.num_frames ) );
    176175
    177176        if ( source.tell() != static_cast<std::size_t>( pos + surface->header.ofs_end ) ) return false;
    … …  
    201200        md3->tags     = new md3_tag_t    [ md3->header.num_tags * md3->header.num_frames ];
    202201        md3->surfaces = new md3_surface_t[ md3->header.num_surfaces ];
    203         std::memset( md3->surfaces, 0, md3->header.num_surfaces * sizeof(md3_surface_t) );
     202        std::memset( md3->surfaces, 0, static_cast< size_t >( md3->header.num_surfaces ) * sizeof(md3_surface_t) );
    204203
    205204        source.seek( md3->header.ofs_frames, origin::SET );
    206         source.read( md3->frames, sizeof( md3_frame_t ), md3->header.num_frames );
     205        source.read( md3->frames, sizeof( md3_frame_t ), static_cast<size_t>( md3->header.num_frames ) );
    207206
    208207        source.seek( md3->header.ofs_tags, origin::SET );
    209         source.read( md3->tags, sizeof( md3_tag_t ), md3->header.num_tags * md3->header.num_frames );
     208        source.read( md3->tags, sizeof( md3_tag_t ), static_cast<size_t>( md3->header.num_tags * md3->header.num_frames ) );
    210209
    211210        source.seek( md3->header.ofs_surfaces, origin::SET );
    … …  
    351350}
    352351
    353 sint32 md3_loader::get_max_frames() const
    354 {
    355         return ((md3_t*)m_md3)->header.num_frames;
     352size_t md3_loader::get_max_frames() const
     353{
     354        return static_cast< size_t >( ((md3_t*)m_md3)->header.num_frames );
    356355}
    357356
    … …  
    401400        sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
    402401
    403         p.reserve( md3->vertices_per_frame * frame_count );
     402        p.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
    404403
    405404        while ( frame_count > 0 )
    … …  
    430429        sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
    431430
    432         n.reserve( md3->vertices_per_frame * frame_count );
     431        n.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
    433432
    434433        while ( frame_count > 0 )
    … …  
    476475        {
    477476                const md3_surface_t& surface = md3->surfaces[i];
    478                 const sint32         tcount  = surface.header.num_triangles;
     477                const size_t         tcount  = static_cast< size_t >( surface.header.num_triangles );
    479478
    480479                idx.reserve( idx.size() + tcount * 3 );
    481                 for (sint32 j = 0; j < tcount; ++j )
     480                for (size_t j = 0; j < tcount; ++j )
    482481                {
    483482                        const md3_triangle_t& t = surface.triangles[j];

  • trunk/src/formats/md5_loader.cc

    r197 r198  
    3636}
    3737
    38 void unit_quat_w( glm::quat& quat )
     38static void unit_quat_w( glm::quat& quat )
    3939{
    4040        float t = 1.0f - ( quat.x * quat.x ) - ( quat.y * quat.y ) - ( quat.z * quat.z );
    … …  
    354354                {
    355355                        discard( sstream, "{" );
    356                         for ( int i = 0; i < m_num_joints; ++i )
     356                        for ( size_t i = 0; i < m_num_joints; ++i )
    357357                        {
    358358                                md5_joint_info joint;
    … …  
    368368                        discard( sstream, "{" );
    369369                        next_line( sstream );
    370                         for ( int i = 0; i < m_num_frames; ++i )
     370                        for ( size_t i = 0; i < m_num_frames; ++i )
    371371                        {
    372372                                md5_bound bound;
    … …  
    390390                        next_line( sstream );
    391391
    392                         for ( int i = 0; i < m_num_joints; ++i )
     392                        for ( size_t i = 0; i < m_num_joints; ++i )
    393393                        {
    394394                                md5_base_frame base_frame;
    … …  
    412412                        next_line( sstream );
    413413
    414                         for ( int i = 0; i < m_num_animated_components; ++i )
     414                        for ( size_t i = 0; i < m_num_animated_components; ++i )
    415415                        {
    416416                                float frameData;
    … …  
    436436        m_anim_time = 0.0f;
    437437
    438         assert( m_joint_infos.size() == (size_t)m_num_joints );
    439         assert( m_bounds.size()      == (size_t)m_num_frames );
    440         assert( m_base_frames.size() == (size_t)m_num_joints );
    441         assert( m_frames.size()      == (size_t)m_num_frames );
    442         assert( m_skeletons.size()   == (size_t)m_num_frames );
     438        assert( m_joint_infos.size() == m_num_joints );
     439        assert( m_bounds.size()      == m_num_frames );
     440        assert( m_base_frames.size() == m_num_joints );
     441        assert( m_frames.size()      == m_num_frames );
     442        assert( m_skeletons.size()   == m_num_frames );
    443443
    444444        return true;
    … …  
    506506void md5_animation::interpolate_skeletons( md5_frame_skeleton& final_skeleton, const md5_frame_skeleton& skeleton0, const md5_frame_skeleton& skeleton1, float interpolate )
    507507{
    508         for ( int i = 0; i < m_num_joints; ++i )
     508        for ( size_t i = 0; i < m_num_joints; ++i )
    509509        {
    510510                md5_skeleton_joint& final_joint = final_skeleton.joints[i];

  • trunk/src/formats/obj_loader.cc

    r161 r198  
    119119struct mesh_obj_reader : public obj_reader
    120120{
    121         mesh_obj_reader( mesh* m ) : m_mesh( m ), m_position( nullptr ), m_normal( nullptr ), m_tex_coord( nullptr ), m_tangent( nullptr ) {}
     121        mesh_obj_reader( mesh* m ) : m_position( nullptr ), m_normal( nullptr ), m_tex_coord( nullptr ), m_tangent( nullptr ), m_mesh( m ) {}
    122122        virtual std::size_t add_face( uint32* v, uint32* t, uint32* n, size_t count );
    123123        virtual void calculate_tangents();
    … …  
    206206                vec3 xyz1 = v2 - v1;
    207207                vec3 xyz2 = v3 - v1;
    208                 vec2 st1  = w2 - w1;
    209                 vec2 st2  = w3 - w1;
     208                //vec2 st1  = w2 - w1;
     209                //vec2 st2  = w3 - w1;
    210210
    211211                float s1 = w2.x - w1.x;

  • trunk/src/gfx/texture_atlas.cc

    r146 r198  
    1515        : image( size, depth ), m_used( 0 ), m_border( border )
    1616{
    17         m_nodes.push_back( glm::ivec3( m_border, m_border, m_size.x - 2 * m_border ) );
     17        m_nodes.push_back( glm::ivec3( m_border, m_border, m_size.x - 2 * static_cast<int>( m_border ) ) );
    1818        fill( 0 );
    1919}

  • trunk/src/gl/gl_context.cc

    r171 r198  
    363363#else
    364364        NV_UNUSED( a_win_handle );
     365        NV_UNUSED( m_handle );
    365366#endif
    366367

  • trunk/src/io/c_stream.cc

    r125 r198  
    4646}
    4747
    48 bool c_stream::seek( size_t offset, origin orig )
     48bool c_stream::seek( long offset, origin orig )
    4949{
    5050        return m_file != nullptr && ( ::fseek( (FILE*)m_file, (long)offset, static_cast<int>(orig) ) == 0 );
    … …  
    5353size_t c_stream::tell()
    5454{
    55         return m_file != nullptr ? ::ftell( (FILE*)m_file ) : 0;
     55        return m_file != nullptr ? static_cast< size_t >( ::ftell( (FILE*)m_file ) ) : 0;
    5656}
    5757

  • trunk/src/io/std_stream.cc

    r138 r198  
    1515        : m_stream( source )
    1616        , m_owner( owner )
     17        , m_buffer( std::max(bsize, put_back) + put_back )
    1718        , m_put_back( std::max( put_back, std::size_t( 1 ) ) )
    18         , m_buffer( std::max(bsize, put_back) + put_back )
    1919{
    2020        char *end = &m_buffer.front() + m_buffer.size();
    … …  
    4949
    5050        // start is now the start of the buffer, proper.
    51         size_t n = m_stream->read( start, 1, m_buffer.size() - (start - base) );
     51        size_t n = m_stream->read( start, 1, m_buffer.size() - static_cast<size_t>(start - base) );
    5252        if (n == 0)
    5353        {

  • trunk/src/lib/lua.cc

    r173 r198  
    6666
    6767// only loaded in 5.1 mode to implement lua_compare
    68 int    (*lua_equal)        (lua_State *L, int idx1, int idx2) = nullptr;
    69 int    (*lua_lessthan)     (lua_State *L, int idx1, int idx2) = nullptr;
     68static int    (*lua_equal)        (lua_State *L, int idx1, int idx2) = nullptr;
     69static int    (*lua_lessthan)     (lua_State *L, int idx1, int idx2) = nullptr;
    7070
    7171
    … …  
    7575
    7676#       define NV_LUA_COMPAT_FUN( rt, fn, fp, rt2, fn2, fp2,arg,ret ) \
    77                 rt call_##fn2##_compat fp { ret fn2##_compat arg; }
     77                static rt call_##fn2##_compat fp { ret fn2##_compat arg; }
    7878#       include <nv/lib/detail/lua_functions_compat.inc>
    7979#       undef NV_LUA_COMPAT_FUN
    … …  
    8585#       define LUA_GLOBALSINDEX_52      2
    8686#       define LUA_REGISTRYINDEX_51     (-10000)
    87 #       define lua_upvalueindex_51(i)   (LUA_GLOBALSINDEX_51-(i))
    88 #       define lua_upvalueindex_52(i)   (LUA_REGISTRYINDEX_52-(i))
    89 
    90 int lua_absindex_51 (lua_State *L, int idx) { return (idx > 0 ? idx : idx + lua_gettop(L) + 1); };
    91 void lua_getglobal_51 (lua_State *L, const char *var) { lua_getfield(L, LUA_GLOBALSINDEX_51, var ); };
    92 void lua_setglobal_51 (lua_State *L, const char *var) { lua_setfield(L, LUA_GLOBALSINDEX_51, var ); };
    93 void luaL_requiref_51 (lua_State *L, const char *modname, lua_CFunction openf, int glb)
     87
     88static int lua_absindex_51 (lua_State *L, int idx) { return (idx > 0 ? idx : idx + lua_gettop(L) + 1); };
     89static void lua_getglobal_51 (lua_State *L, const char *var) { lua_getfield(L, LUA_GLOBALSINDEX_51, var ); };
     90static void lua_setglobal_51 (lua_State *L, const char *var) { lua_setfield(L, LUA_GLOBALSINDEX_51, var ); };
     91static void luaL_requiref_51 (lua_State *L, const char *modname, lua_CFunction openf, int glb)
    9492{
    9593        lua_pushcfunction(L, openf);
    … …  
    105103}
    106104
    107 void luaL_setmetatable_51 (lua_State *L, const char *tname)
     105static void luaL_setmetatable_51 (lua_State *L, const char *tname)
    108106{
    109107        luaL_getmetatable(L, tname);
    … …  
    111109}
    112110
    113 void *luaL_testudata_51 (lua_State *L, int ud, const char *tname)
     111static void *luaL_testudata_51 (lua_State *L, int ud, const char *tname)
    114112{
    115113        void *p = lua_touserdata(L, ud);
    … …  
    128126}
    129127
    130 const lua_Number *lua_version_51 (lua_State*)
     128static const lua_Number *lua_version_51 (lua_State*)
    131129{
    132130        static const lua_Number version = (lua_Number)LUA_VERSION_NUM;
    … …  
    134132}
    135133
    136 void lua_copy_51 (lua_State *L, int fromidx, int toidx)
     134static void lua_copy_51 (lua_State *L, int fromidx, int toidx)
    137135{
    138136        toidx = lua_absindex( L, toidx );
    … …  
    141139}
    142140
    143 int lua_compare_51(lua_State *L, int idx1, int idx2, int op)
     141static int lua_compare_51(lua_State *L, int idx1, int idx2, int op)
    144142{
    145143        switch (op)
    … …  
    153151}
    154152
    155 void lua_rawgetp_51(lua_State *L, int idx, const void *p)
     153static void lua_rawgetp_51(lua_State *L, int idx, const void *p)
    156154{
    157155        idx = lua_absindex( L, idx );
    … …  
    161159}
    162160
    163 void lua_rawsetp_51(lua_State *L, int idx, const void *p)
     161static void lua_rawsetp_51(lua_State *L, int idx, const void *p)
    164162{
    165163        idx = lua_absindex( L, idx );
    … …  
    170168}
    171169
    172 int luaL_getsubtable_51(lua_State *L, int idx, const char *fname)
     170static int luaL_getsubtable_51(lua_State *L, int idx, const char *fname)
    173171{
    174172        lua_getfield(L, idx, fname);
    … …  
    184182}
    185183
    186 void luaL_setfuncs_51(lua_State *L, const luaL_Reg *l, int nup)
     184static void luaL_setfuncs_51(lua_State *L, const luaL_Reg *l, int nup)
    187185{
    188186        luaL_checkstack(L, nup, "too many upvalues");
    … …  
    199197}
    200198
    201 void lua_pushglobaltable_51(lua_State* L)
     199static void lua_pushglobaltable_51(lua_State* L)
    202200{
    203201        lua_pushvalue( L, LUA_GLOBALSINDEX_51 );
    204202}
    205203
    206 void lua_pushglobaltable_52(lua_State* L)
     204static void lua_pushglobaltable_52(lua_State* L)
    207205{
    208206        lua_rawgeti( L, LUA_REGISTRYINDEX_52, LUA_GLOBALSINDEX_52 );

  • trunk/src/lua/lua_area.cc

    r179 r198  
    3434}
    3535
    36 void nlua_area_construct( lua_State* L, int sidx )
     36static void nlua_area_construct( lua_State* L, int sidx )
    3737{
    3838        if ( nlua_is_coord( L, sidx ) )
    … …  
    412412
    413413
    414 int luaopen_area( lua_State * L )
     414static int luaopen_area( lua_State * L )
    415415{
    416416        static const struct luaL_Reg nlua_area_sf [] = {

  • trunk/src/lua/lua_aux.cc

    r180 r198  
    9595        if ( dice < 1 )  luaL_argerror( L, 1, "die count lower than 1!" );
    9696        if ( sides < 1 ) luaL_argerror( L, 2, "side count lower than 1!" );
    97         lua_pushnumber( L, nv::random::get().dice( dice, sides ) );
     97        lua_pushnumber( L, nv::random::get().dice( static_cast< nv::uint32 >( dice ), static_cast< nv::uint32 >( sides ) ) );
    9898        return 1;
    9999}
    … …  
    111111                        int arg1 = luaL_checkinteger( L, 1 );
    112112                        if ( arg1 < 1 ) arg1 = 1;
    113                         lua_pushunsigned( L, nv::random::get().urange( 1, arg1 ) );
     113                        lua_pushunsigned( L, nv::random::get().urange( 1, static_cast<nv::uint32>( arg1 ) ) );
    114114                }
    115115                else
    … …  
    126126static int nluaaux_math_randomseed( lua_State* L )
    127127{
    128         nv::random::get().set_seed( static_cast< nv::uint32 > ( L, 1 ) );
     128        nv::random::get().set_seed( lua_tounsigned( L, 1 ) );
    129129        return 0;
    130130}

  • trunk/src/lua/lua_function.cc

    r182 r198  
    1111using namespace nv;
    1212
    13 lua::function_base::function_base( lua_State* L, const path& a_path, bool global /*= true*/ ) : L(L)
     13lua::function_base::function_base( lua_State* a_L, const path& a_path, bool a_global /*= true*/ ) : L(a_L)
    1414{
    15         if ( !a_path.resolve( L, global ) )
     15        if ( !a_path.resolve( L, a_global ) )
    1616        {
    1717                lua_pop( L, 1 );
    … …  
    2727}
    2828
    29 lua::function_base::function_base( const function_base& func ) : L(L)
     29lua::function_base::function_base( const function_base& func ) : L(func.L)
    3030{
    3131        lua_rawgeti( L, LUA_REGISTRYINDEX, func.m_ref );

  • trunk/src/lua/lua_map_area.cc

    r179 r198  
    1515typedef nv::flags<512> cell_set;
    1616
    17 nv::uint32 nlua_to_cell_id( lua_State* L, int index, nv::map_area* map )
     17static nv::uint32 nlua_to_cell_id( lua_State* L, int index, nv::map_area* map )
    1818{
    1919        if ( lua_type( L, index ) == LUA_TSTRING )
    2020                return map->string_to_id( lua_tostring( L, index ) );
    2121        else
    22                 return (nv::uint32)lua_tointeger( L, index );
    23 }
    24 
    25 cell_set nlua_to_cell_set( lua_State* L, int index, nv::map_area* map )
    26 {
    27         cell_set result;
    28         switch ( lua_type( L, index ) )
    29         {
    30         case LUA_TTABLE :       
    31                 {
    32                         lua_pushnil( L );
    33                         while ( lua_next( L, index ) != 0 )
    34                         {
    35                                 if ( lua_type( L, -1 ) == LUA_TSTRING )
    36                                         result.set( map->string_to_id( lua_tostring( L, -1 ) ), true );
    37                                 else
    38                                         result.set( lua_tointeger( L, -1 ), true );
    39                                 lua_pop( L, 1 );
    40                         }
    41                 } break;
    42         case LUA_TSTRING : result.set( map->string_to_id( lua_tostring( L, index ) ), true ); break;
    43         case LUA_TNUMBER : result.set( lua_tointeger( L, index ), true ); break;
    44         }
    45         return result;
    46 }
     22                return lua_tounsigned( L, index );
     23}
     24
     25// static cell_set nlua_to_cell_set( lua_State* L, int index, nv::map_area* map )
     26// {
     27//      cell_set result;
     28//      switch ( lua_type( L, index ) )
     29//      {
     30//      case LUA_TTABLE :       
     31//              {
     32//                      lua_pushnil( L );
     33//                      while ( lua_next( L, index ) != 0 )
     34//                      {
     35//                              if ( lua_type( L, -1 ) == LUA_TSTRING )
     36//                                      result.set( map->string_to_id( lua_tostring( L, -1 ) ), true );
     37//                              else
     38//                                      result.set( lua_tounsigned( L, -1 ), true );
     39//                              lua_pop( L, 1 );
     40//                      }
     41//              } break;
     42//      case LUA_TSTRING : result.set( map->string_to_id( lua_tostring( L, index ) ), true ); break;
     43//      case LUA_TNUMBER : result.set( lua_tounsigned( L, index ), true ); break;
     44//      }
     45//      return result;
     46// }
    4747
    4848bool nlua_is_map_area( lua_State* L, int index )
    … …  
    118118{
    119119        nv::map_area* ma = nlua_to_map_area( L, 1 );
    120         lua_pushinteger( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
     120        lua_pushunsigned( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
    121121        return 1;
    122122}
    … …  
    125125{
    126126        nv::map_area* ma = nlua_to_map_area( L, 1 );
    127         ma->set_cell( nlua_to_coord( L, 2 ), lua_tointeger( L, 3 ) );
     127        ma->set_cell( nlua_to_coord( L, 2 ), lua_tounsigned( L, 3 ) );
    128128        return 0;
    129129}
    … …  
    140140        else
    141141        {
    142                 lua_pushinteger( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
     142                lua_pushunsigned( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
    143143        }
    144144        return 1;
    … …  
    148148{
    149149        nv::map_area* ma = nlua_to_map_area( L, 1 );
    150         ma->set_cell( nlua_to_coord( L, 2 ), lua_tointeger( L, 3 ) );
     150        ma->set_cell( nlua_to_coord( L, 2 ), lua_tounsigned( L, 3 ) );
    151151        return 0;
    152152}
    … …  
    179179};
    180180
    181 int luaopen_map_area( lua_State * L )
     181static int luaopen_map_area( lua_State * L )
    182182{
    183183        luaL_newmetatable( L, NLUA_MAP_AREA_METATABLE );

  • trunk/src/lua/lua_path.cc

    r181 r198  
    2323}
    2424
    25 lua::path::path( int i )
     25lua::path::path( unsigned i )
    2626        : m_count(0)
    2727{
    … …  
    8888                        else
    8989                        {
    90                                 lua_pushinteger( L, m_elements[i].value );
     90                                lua_pushunsigned( L, m_elements[i].value );
    9191                        }
    9292                        lua_gettable( L, -2 );

  • trunk/src/lua/lua_state.cc

    r188 r198  
    257257{
    258258        lua_getfield( L->L, -1, element.c_str() );
    259         int result = lua_type( L->L, -1 ) == LUA_TNUMBER ? lua_tounsigned( L->L, -1 ) : defval;
     259        unsigned result = lua_type( L->L, -1 ) == LUA_TNUMBER ? lua_tounsigned( L->L, -1 ) : defval;
    260260        lua_pop( L->L, 1 );
    261261        return result;

  • trunk/src/random.cc

    r175 r198  
    4747uint32 random::urand( uint32 val )
    4848{
    49         std::uniform_int_distribution<sint32> dist( 0, val - 1 );
     49        std::uniform_int_distribution<uint32> dist( 0, val - 1 );
    5050        return dist( rng );
    5151}
    … …  
    6565uint32 random::urange( uint32 min, uint32 max )
    6666{
    67         std::uniform_int_distribution<sint32> dist( min, max );
     67        std::uniform_int_distribution<uint32> dist( min, max );
    6868        return dist( rng );
    6969}
Note: See TracChangeset for help on using the changeset viewer.