Changeset 534 for trunk/src


Ignore:
Timestamp:
01/12/17 14:41:17 (8 years ago)
Author:
epyon
Message:

CONTINUED:

  • getting rid of size_t
  • datatypes now restricted to uint32 size
  • 64-bit compatibility
  • copyright updates where modified
Location:
trunk/src
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/bullet/bullet_helper.hh

    r520 r534  
    1 // Copyright (C) 2016 ChaosForge Ltd
     1// Copyright (C) 2016-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//

  • trunk/src/core/logger.cc

    r533 r534  
    1 // Copyright (C) 2011-2015 ChaosForge Ltd
     1// Copyright (C) 2011-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//

  • trunk/src/core/profiler.cc

    r533 r534  
    1 // Copyright (C) 2012-2014 ChaosForge Ltd
     1// Copyright (C) 2012-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//

  • trunk/src/core/random.cc

    r533 r534  
    1 // Copyright (C) 2012-2014 ChaosForge Ltd
     1// Copyright (C) 2012-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//

  • trunk/src/engine/mesh_manager.cc

    r522 r534  
    3535        nv::string_view sub_mesh_name;
    3636        nv::string128 base_mesh_name( path );
    37         nv::size_t sub_mesh_pos = path.find( ":" );
    38         nv::size_t dot_pos = path.find( "." );
     37        nv::uint32 sub_mesh_pos = path.find( ":" );
     38        nv::uint32 dot_pos = path.find( "." );
    3939        if ( sub_mesh_pos != nv::string_view::npos )
    4040        {

  • trunk/src/engine/particle_engine.cc

    r532 r534  
    196196        datap->plane_normal = normalize_safe( datap->plane_normal, vec3(0.0f,1.0f,0.0f) );
    197197        datap->bounce       = table->get<float>("bounce", 0.0f );
    198         datap->distance     = -math::dot( datap->plane_normal, datap->plane_point ) / math::sqrt( math::dot( datap->plane_normal, datap->plane_normal ) );
     198        datap->distance     = -math::dot( datap->plane_normal, datap->plane_point ) / static_cast<float>( math::sqrt( math::dot( datap->plane_normal, datap->plane_normal ) ) );
    199199        return true;
    200200}

  • trunk/src/engine/program_manager.cc

    r505 r534  
    5050        stream* fstream = open_stream( fs, path );
    5151        if ( !fstream ) return const_string();
    52         uint32 size = fstream->size();
     52        uint32 size = static_cast< uint32 >( fstream->size() );
    5353        const_string result( nullptr, size );
    5454        fstream->read( const_cast<char*>( result.data() ), size, 1 );

  • trunk/src/formats/assimp_loader.cc

    r491 r534  
    1 // Copyright (C) 2014-2015 ChaosForge Ltd
     1// Copyright (C) 2014-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
    … …  
    107107        m_mesh_count = 0;
    108108        NV_LOG_NOTICE( "AssImp loading file..." );
    109         size_t size = source.size();
     109        uint32 size = static_cast< uint32 >( source.size() );
    110110        char* data  = new char[ size ];
    111111        source.read( data, size, 1 );
    … …  
    143143}
    144144
    145 data_channel_set* nv::assimp_loader::release_mesh_data( size_t index, data_node_info& info )
     145data_channel_set* nv::assimp_loader::release_mesh_data( uint32 index, data_node_info& info )
    146146{
    147147        if ( index >= m_mesh_count ) return nullptr;
    … …  
    149149        return m_meshes[index];
    150150}
    151 void nv::assimp_loader::load_mesh_data( data_channel_set* data, size_t index, data_node_info& info )
     151void nv::assimp_loader::load_mesh_data( data_channel_set* data, uint32 index, data_node_info& info )
    152152{
    153153        const aiMesh*  mesh  = m_data->scene->mMeshes[ index ];
    … …  
    161161                desc.initialize< assimp_plain_vtx >();
    162162        data_channel_set_creator maccess( data );
    163         string64 name( mesh->mName.data, mesh->mName.length );
     163        string64 name( mesh->mName.data, static_cast< uint32 >( mesh->mName.length ) );
    164164        if ( mesh->mName.length == 0 )
    165165        {
    … …  
    170170                                        if ( node->mMeshes[i] == index )
    171171                                        {
    172                                                 name.assign( node->mName.data, node->mName.length );
     172                                                name.assign( node->mName.data, static_cast< uint32 >( node->mName.length ) );
    173173                                                if ( i != 0 )
    174174                                                {
    … …  
    215215                {
    216216                        aiBone* bone  = mesh->mBones[m];
    217                         for ( size_t w=0; w<bone->mNumWeights; w++)
     217                        for ( uint32 w=0; w<bone->mNumWeights; w++)
    218218                        {
    219219                                assimp_skinned_vtx& v = vtx[ bone->mWeights[w].mVertexId ];
    220220                                bool found = false;
    221                                 for ( size_t i = 0 ; i < 4; ++i )
     221                                for ( uint32 i = 0 ; i < 4; ++i )
    222222                                {
    223223                                        if ( v.boneweight[i] <= 0.0f )
    … …  
    281281                        aiMesh* mesh = m_data->scene->mMeshes[mc];
    282282
    283                         NV_LOG_NOTICE( "Mesh #", mc, "   - ", string_view( static_cast<char*>( mesh->mName.data ), mesh->mName.length ) );
     283                        NV_LOG_NOTICE( "Mesh #", mc, "   - ", string_view( static_cast<char*>( mesh->mName.data ), static_cast< uint32 >( mesh->mName.length ) ) );
    284284                        NV_LOG_NOTICE( "  bones   - ", mesh->mNumBones );
    285285                        NV_LOG_NOTICE( "  uvs     - ", mesh->mNumUVComponents[0] );
    … …  
    303303        for ( auto node : m_data->nodes )
    304304        {
    305                 NV_LOG_NOTICE( "Node : ", string_view( node->mName.data, node->mName.length ) );
     305                NV_LOG_NOTICE( "Node : ", string_view( node->mName.data, static_cast< uint32 >( node->mName.length ) ) );
    306306        }
    307307
    308308        for ( auto skeleton : m_data->skeletons )
    309309        {
    310                 NV_LOG_NOTICE( "Skeleton : ", string_view( skeleton->mName.data, skeleton->mName.length ) );
     310                NV_LOG_NOTICE( "Skeleton : ", string_view( skeleton->mName.data, static_cast< uint32 >( skeleton->mName.length ) ) );
    311311        }
    312312
    … …  
    353353        }
    354354
    355         string_view name( ainode->mName.data, ainode->mName.length );
     355        string_view name( ainode->mName.data, static_cast< uint32 >( ainode->mName.length ) );
    356356        if ( name.starts_with( '_' ) ) return;
    357357
    … …  
    409409                        {
    410410                                assimp_skinned_vtx& vertex = channel.data()[v];
    411                                 for ( size_t i = 0; i < 4; ++i )
     411                                for ( uint32 i = 0; i < 4; ++i )
    412412                                {
    413413                                        if ( vertex.boneweight[i] > 0.0f )
    … …  
    430430                        int pid = bone_data[i].parent_id;
    431431                        if ( pid >= 0 )
    432                                 bone_data[i].transform = tr * bone_data[ size_t( pid ) ].transform;
     432                                bone_data[i].transform = tr * bone_data[uint32( pid ) ].transform;
    433433                        else
    434434                                bone_data[i].transform = tr;
    … …  
    447447}
    448448
    449 mesh_nodes_data* nv::assimp_loader::release_mesh_nodes_data( size_t index /*= 0*/ )
     449mesh_nodes_data* nv::assimp_loader::release_mesh_nodes_data( uint32 index /*= 0*/ )
    450450{
    451451        if ( m_data->scene == nullptr ) return nullptr;
    … …  
    484484}
    485485
    486 data_node_list* nv::assimp_loader::release_data_node_list( size_t /*= 0 */ )
     486data_node_list* nv::assimp_loader::release_data_node_list( uint32 /*= 0 */ )
    487487{
    488488        return release_merged_bones();
    489489}
    490490
    491 bool nv::assimp_loader::is_animated( size_t /*= 0 */ )
     491bool nv::assimp_loader::is_animated( uint32 /*= 0 */ )
    492492{
    493493        int this_is_incorrect;
    … …  
    623623//      bool has_bones = false;
    624624//      data_channel_set* meshes = data_channel_set_creator::create_set_array( m_mesh_count, 2 );
    625 //      for ( size_t m = 0; m < m_mesh_count; ++m )
     625//      for ( uint32 m = 0; m < m_mesh_count; ++m )
    626626//      {
    627627//              const aiMesh* mesh = scene->mMeshes[ m ];
    … …  
    635635// }
    636636
    637 nv::size_t nv::assimp_loader::get_nodes_data_count() const
     637uint32 nv::assimp_loader::get_nodes_data_count() const
    638638{
    639639        if ( m_data->scene == nullptr ) return 0;

  • trunk/src/formats/nmd_loader.cc

    r487 r534  
    1 // Copyright (C) 2014-2015 ChaosForge Ltd
     1// Copyright (C) 2014-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
    … …  
    4545}
    4646
    47 data_channel_set* nv::nmd_loader::release_mesh_data( size_t index, data_node_info& info )
     47data_channel_set* nv::nmd_loader::release_mesh_data( uint32 index, data_node_info& info )
    4848{
    4949        data_channel_set* result = m_meshes[ index ];
    … …  
    158158}
    159159
    160 mesh_nodes_data* nv::nmd_loader::release_mesh_nodes_data( size_t )
     160mesh_nodes_data* nv::nmd_loader::release_mesh_nodes_data( uint32 )
    161161{
    162162        return nullptr;
    163163}
    164164
    165 data_node_list* nv::nmd_loader::release_data_node_list( size_t )
     165data_node_list* nv::nmd_loader::release_data_node_list( uint32 )
    166166{
    167167        data_node_list* result = m_bone_data;
    … …  
    170170}
    171171
    172 bool nv::nmd_loader::is_animated( size_t /*= 0 */ )
     172bool nv::nmd_loader::is_animated( uint32 /*= 0 */ )
    173173{
    174174        return m_pose_data_set != nullptr;

  • trunk/src/formats/obj_loader.cc

    r482 r534  
    1 // Copyright (C) 2012-2015 ChaosForge Ltd
     1// Copyright (C) 2012-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
    … …  
    5252        string32 next_name;
    5353
    54         nv::size_t size;
     54        uint32 size;
    5555        bool   eof;
    5656
    5757        obj_reader();
    5858        bool read_stream( stream& str );
    59         virtual nv::size_t add_face( uint32* vi, uint32* ti, uint32* ni, nv::size_t count ) = 0;
    60         virtual nv::size_t raw_size() const = 0;
     59        virtual uint32 add_face( uint32* vi, uint32* ti, uint32* ni, uint32 count ) = 0;
     60        virtual uint32 raw_size() const = 0;
    6161        virtual void reset() = 0;
    6262        virtual const uint8* raw_pointer() const = 0;
    … …  
    126126                        string_view scan( cline );
    127127                        scan.remove_prefix( 2 );
    128                         size_t pos = 0;
     128                        uint32 pos = 0;
    129129                        while ( pos != string_view::npos )
    130130                        {
    … …  
    176176{
    177177        mesh_data_reader( bool normals ) : m_normals( normals ) {}
    178         virtual nv::size_t add_face( uint32* vi, uint32* ti, uint32* ni, nv::size_t count )
     178        virtual uint32 add_face( uint32* vi, uint32* ti, uint32* ni, uint32 count )
    179179        {
    180180                if ( count < 3 ) return 0; // TODO : report error?
    … …  
    182182                // TODO : support if normals not present;
    183183                vec3 nullvec;
    184                 nv::size_t result = 0;
     184                uint32 result = 0;
    185185                // Simple triangulation - obj's shouldn't have more than quads anyway
    186186
    187187                if ( m_normals )
    188188                {
    189                         for ( nv::size_t i = 2; i < count; ++i )
     189                        for ( uint32 i = 2; i < count; ++i )
    190190                        {
    191191                                result++;
    … …  
    197197                else
    198198                {
    199                         for ( nv::size_t i = 2; i < count; ++i )
     199                        for ( uint32 i = 2; i < count; ++i )
    200200                        {
    201201                                result++;
    … …  
    210210        vector< VTX > m_data;
    211211        virtual void reset() { m_data.clear(); }
    212         virtual nv::size_t raw_size() const { return m_data.size() * sizeof( VTX ); }
     212        virtual uint32 raw_size() const { return m_data.size() * sizeof( VTX ); }
    213213        virtual const uint8* raw_pointer() const { return reinterpret_cast< const uint8* >( m_data.data() ); }
    214214};
    … …  
    232232        void calculate_tangents()
    233233        {
    234                 nv::size_t count = m_data.size();
    235                 nv::size_t tcount = count / 3;
     234                uint32 count = m_data.size();
     235                uint32 tcount = count / 3;
    236236
    237237                vector< vec3 > tan1( count );
    238238                vector< vec3 > tan2( count );
    239239
    240                 for ( nv::size_t a = 0; a < tcount; ++a )
    241                 {
    242                         nv::size_t i1 = a * 3;
    243                         nv::size_t i2 = a * 3 + 1;
    244                         nv::size_t i3 = a * 3 + 2;
     240                for ( uint32 a = 0; a < tcount; ++a )
     241                {
     242                        uint32 i1 = a * 3;
     243                        uint32 i2 = a * 3 + 1;
     244                        uint32 i3 = a * 3 + 2;
    245245                        obj_vertex_vtnt& vtx1 = m_data[ i1 ];
    246246                        obj_vertex_vtnt& vtx2 = m_data[ i2 ];
    … …  
    277277                }
    278278
    279                 for ( nv::size_t a = 0; a < count; ++a )
     279                for ( uint32 a = 0; a < count; ++a )
    280280                {
    281281                        const vec3& nv = m_data[a].normal;
    … …  
    347347}
    348348
    349 data_channel_set* nv::obj_loader::release_mesh_data( size_t index, data_node_info& info )
     349data_channel_set* nv::obj_loader::release_mesh_data( uint32 index, data_node_info& info )
    350350{
    351351        data_channel_set* result = m_meshes[ index ];

  • trunk/src/gfx/image.cc

    r505 r534  
    1 // Copyright (C) 2011-2015 ChaosForge Ltd
     1// Copyright (C) 2011-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
    … …  
    1010using namespace nv;
    1111
    12 image::image( ivec2 size, nv::size_t depth )
     12image::image( ivec2 size, uint32 depth )
    1313        : m_size( size ), m_depth( depth ), m_data( nullptr )
    1414{
    … …  
    2323
    2424
    25 image::image( ivec2 size, nv::size_t depth, const uint8 * data, bool reversed )
     25image::image( ivec2 size, uint32 depth, const uint8 * data, bool reversed )
    2626        : m_size( size ), m_depth( depth ), m_data( nullptr )
    2727{
    2828        NV_ASSERT( size.x >= 0 && size.y >= 0, "bad parameters passed to image!" );
    2929        sint32 bsize = m_size.x * m_size.y * static_cast<sint32>( m_depth );
    30         m_data = new uint8[ size_t( bsize ) ];
     30        m_data = new uint8[ uint32( bsize ) ];
    3131
    3232        if ( reversed )
    … …  
    9797        uint32 rsizey     = static_cast< uint32 >( r.size.y );
    9898        const uint8* data = idata->get_data();
    99         size_t depth      = idata->get_depth();
    100         size_t cdepth     = m_depth > depth ? depth : m_depth;
     99        uint32 depth      = idata->get_depth();
     100        uint32 cdepth     = m_depth > depth ? depth : m_depth;
    101101        uint32 dstride    = rsizex * depth;
    102102
    … …  
    107107                {
    108108                        uint32 xy = pos + x * m_depth;
    109                         for( size_t e = 0; e < cdepth; ++e )
     109                        for( uint32 e = 0; e < cdepth; ++e )
    110110                        {
    111111                                m_data[ xy + e ] = data[ y*dstride + x * depth + e ];

  • trunk/src/gfx/mesh_creator.cc

    r532 r534  
    1515void nv::mesh_nodes_creator::merge_keys()
    1616{
    17         for ( size_t i = 0; i < m_data->size(); ++i )
     17        for ( uint32 i = 0; i < m_data->size(); ++i )
    1818        {
    1919                data_channel_set* old_keys = m_data->m_data[i];
    2020                if ( old_keys && old_keys->size() > 0 )
    2121                {
    22                         size_t chan_count = old_keys->size();
     22                        uint32 chan_count = old_keys->size();
    2323                        if ( chan_count == 1
    2424                                && old_keys->get_channel(0)->descriptor().size() == 1
    … …  
    516516        NV_ASSERT( a.size() % frame_count == 0, "Merge - append first mesh empty!" );
    517517        NV_ASSERT( b.size() % frame_count == 0, "Merge - append second mesh empty!" );
    518         size_t vtx_size = a.element_size();
     518        uint32 vtx_size = a.element_size();
    519519
    520520        raw_data_channel result = data_channel_creator::create( a.descriptor(), a.size() + b.size() );
    … …  
    523523        if ( frame_count == 1 )
    524524        {
    525                 size_t a_size = vtx_size * a.size();
     525                uint32 a_size = vtx_size * a.size();
    526526                raw_copy_n( a.raw_data(), a_size, rdata );
    527527                raw_copy_n( b.raw_data(), vtx_size * b.size(), rdata + a_size );
    … …  
    529529        else
    530530        {
    531                 size_t frame_size_a = ( a.size() / frame_count ) * vtx_size;
    532                 size_t frame_size_b = ( b.size() / frame_count ) * vtx_size;
    533                 size_t pos_a = 0;
    534                 size_t pos_b = 0;
    535                 size_t pos   = 0;
    536                 for ( size_t i = 0; i < frame_count; ++i )
     531                uint32 frame_size_a = ( a.size() / frame_count ) * vtx_size;
     532                uint32 frame_size_b = ( b.size() / frame_count ) * vtx_size;
     533                uint32 pos_a = 0;
     534                uint32 pos_b = 0;
     535                uint32 pos   = 0;
     536                for ( uint32 i = 0; i < frame_count; ++i )
    537537                {
    538538                        raw_copy_n( a.raw_data() + pos_a, frame_size_a, rdata + pos );

  • trunk/src/gfx/skeleton_instance.cc

    r520 r534  
    1 // Copyright (C) 2011-2015 ChaosForge Ltd
     1// Copyright (C) 2011-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//

  • trunk/src/gfx/texture_atlas.cc

    r533 r534  
    1 // Copyright (C) 2012-2015 ChaosForge Ltd
     1// Copyright (C) 2012-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//

  • trunk/src/gl/gl_context.cc

    r523 r534  
    1 // Copyright (C) 2012-2015 ChaosForge Ltd
     1// Copyright (C) 2012-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
    … …  
    311311}
    312312
    313 void nv::gl_context::bind( buffer b, uint32 index, size_t offset /*= 0*/, size_t size /*= 0 */ )
     313void nv::gl_context::bind( buffer b, uint32 index, uint32 offset /*= 0*/, uint32 size /*= 0 */ )
    314314{
    315315        const gl_buffer_info* info = static_cast< const gl_buffer_info* >( m_device->get_buffer_info( b ) );
    … …  
    465465}
    466466
    467 void* nv::gl_context::map_buffer( buffer b, buffer_access ba, size_t offset, size_t length )
     467void* nv::gl_context::map_buffer( buffer b, buffer_access ba, uint32 offset, uint32 length )
    468468{
    469469        const gl_buffer_info* info = static_cast<const gl_buffer_info*>( m_device->get_buffer_info( b ) );
    … …  
    492492}
    493493
    494 // void nv::gl_context::update( buffer b, uint32 index, const void* data, size_t offset, size_t size )
     494// void nv::gl_context::update( buffer b, uint32 index, const void* data, uint32 offset, uint32 size )
    495495// {
    496496//      const gl_buffer_info* info = static_cast<const gl_buffer_info*>( m_device->get_buffer_info( b ) );
    … …  
    506506// }
    507507
    508 void gl_context::update( buffer b, const void* data, nv::size_t offset, nv::size_t size )
     508void gl_context::update( buffer b, const void* data, nv::uint32 offset, nv::uint32 size )
    509509{
    510510        const gl_buffer_info* info = static_cast< const gl_buffer_info* >( m_device->get_buffer_info( b ) );
    … …  
    10201020}
    10211021
    1022 nv::buffer nv::gl_context::create_buffer( buffer_type type, buffer_hint hint, size_t size, const void* source /*= nullptr */ )
     1022nv::buffer nv::gl_context::create_buffer( buffer_type type, buffer_hint hint, uint32 size, const void* source /*= nullptr */ )
    10231023{
    10241024        buffer result = static_cast<gl_device*>( m_device )->create_buffer( type, hint );
    … …  
    10271027}
    10281028
    1029 void nv::gl_context::create_buffer( buffer b, size_t size, const void* source /*= nullptr */ )
     1029void nv::gl_context::create_buffer( buffer b, uint32 size, const void* source /*= nullptr */ )
    10301030{
    10311031        gl_buffer_info* info = static_cast<gl_device*>( m_device )->get_full_buffer_info( b );
    … …  
    10671067}
    10681068
    1069 void gl_context::draw( primitive prim, const render_state& rs, program p, vertex_array va, nv::size_t count, nv::size_t first )
     1069void gl_context::draw( primitive prim, const render_state& rs, program p, vertex_array va, nv::uint32 count, nv::uint32 first )
    10701070{
    10711071        apply_render_state( rs );
    … …  
    10771077                if ( info->index.is_valid() )
    10781078                {
    1079                         glDrawElements( primitive_to_enum(prim), static_cast<GLsizei>( count ), datatype_to_gl_enum( info->index_type ), reinterpret_cast< const void* >( get_datatype_info( info->index_type ).size * first ) );
     1079                        glDrawElements( primitive_to_enum(prim), static_cast<GLsizei>( count ), datatype_to_gl_enum( info->index_type ), reinterpret_cast< const void* >( size_t( get_datatype_info( info->index_type ).size * first ) ) );
    10801080                }
    10811081                else
    … …  
    10881088}
    10891089
    1090 void nv::gl_context::draw_instanced( primitive prim, const render_state& rs, program p, size_t instances, vertex_array va, size_t count, size_t first /*= 0 */ )
     1090void nv::gl_context::draw_instanced( primitive prim, const render_state& rs, program p, uint32 instances, vertex_array va, uint32 count, uint32 first /*= 0 */ )
    10911091{
    10921092        apply_render_state( rs );
    … …  
    10981098                if ( info->index.is_valid() )
    10991099                {
    1100                         glDrawElementsInstanced( primitive_to_enum( prim ), static_cast<GLsizei>( count ), datatype_to_gl_enum( info->index_type ), reinterpret_cast<const void*>( get_datatype_info( info->index_type ).size * first ), instances );
     1100                        glDrawElementsInstanced( primitive_to_enum( prim ), static_cast<GLsizei>( count ), datatype_to_gl_enum( info->index_type ), reinterpret_cast<const void*>( size_t( get_datatype_info( info->index_type ).size * first ) ), instances );
    11011101                }
    11021102                else

  • trunk/src/gl/gl_device.cc

    r533 r534  
    1 // Copyright (C) 2012-2015 ChaosForge Ltd
     1// Copyright (C) 2012-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//

  • trunk/src/gui/gui_gfx_renderer.cc

    r501 r534  
    109109{
    110110public:
    111         screen_render_data( context* actx, nv::size_t initial_size )
     111        screen_render_data( context* actx, nv::uint32 initial_size )
    112112                : buffer( actx, VERTEX_BUFFER, DYNAMIC_DRAW, initial_size ), ctx( actx ), varray(), shader()
    113113        {
    … …  
    147147        m_area.dim( dimension( w->get_width(), w->get_height() ) );
    148148        region white = m_atlas.get_region( ivec2( 3, 3 ) );
    149         size_t wsize = m_atlas.get_depth() * 4 * 4;
     149        uint32 wsize = m_atlas.get_depth() * 4 * 4;
    150150        uint8* wfill = new uint8[m_atlas.get_depth() * 4 * 4];
    151151        raw_fill( wfill, wfill + wsize, 255 );
    … …  
    178178}
    179179
    180 texture_font* gfx_renderer::get_font( nv::size_t name ) const
     180texture_font* gfx_renderer::get_font( nv::uint32 name ) const
    181181{
    182182        if ( name >= m_fonts.size() ) return nullptr;
    … …  
    184184}
    185185
    186 const image_info* gfx_renderer::get_image( nv::size_t name ) const
     186const image_info* gfx_renderer::get_image( nv::uint32 name ) const
    187187{
    188188        if ( name >= m_images.size() ) return nullptr;
    … …  
    190190}
    191191
    192 nv::size_t gfx_renderer::load_font( const string_view& filename, nv::size_t size )
     192nv::uint32 gfx_renderer::load_font( const string_view& filename, nv::uint32 size )
    193193{
    194194        string128 id( filename );
    … …  
    199199                return i->second;
    200200        }
    201         size_t result = m_fonts.size();
     201        uint32 result = m_fonts.size();
    202202        texture_font* f = new texture_font( &m_atlas, filename.data(), static_cast<float>( size ) );
    203203        f->load_glyphs( "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ " );
    … …  
    208208}
    209209
    210 nv::size_t gfx_renderer::load_image( const string_view& filename )
     210nv::uint32 gfx_renderer::load_image( const string_view& filename )
    211211{
    212212        auto i = m_image_names.find( filename );
    … …  
    215215                return i->second;
    216216        }
    217         size_t result = m_images.size();
     217        uint32 result = m_images.size();
    218218        image_data* data = m_window->get_device()->create_image_data( filename );
    219219        // TODO: Repitching
    … …  
    236236        }
    237237        element_render_data* er = reinterpret_cast< element_render_data* >( e->m_render_data );
    238         size_t size_before = er->buffer.data().size();
     238        uint32 size_before = er->buffer.data().size();
    239239
    240240        vector< gui_quad >& qvec = er->buffer.lock();
    … …  
    254254                if ( m_style.get( e, "skin", selector, path ) )
    255255                {
    256                         size_t image_id = load_image( path );
     256                        uint32 image_id = load_image( path );
    257257                        const image_info* image = get_image( image_id );
    258258                        if ( image )
    … …  
    319319                        if ( m_style.get( e, "text_color", selector, color ) && m_style.get( e, "text_font", selector, path ) && m_style.get( e, "text_size", selector, border ) )
    320320                        {
    321                                 size_t font_id = load_font( path, size_t( border ) );
     321                                uint32 font_id = load_font( path, uint32( border ) );
    322322                                texture_font* font = get_font( font_id );
    323323                                position p = abs.ul + position( 0, border );

  • trunk/src/gui/gui_style.cc

    r487 r534  
    3333        if ( !resolve( e->m_id, e->m_class, cselector, centry, LUA_TTABLE ) ) return false;
    3434        vec = vec4();
    35         for ( size_t i = 0; i < 4; ++i )
     35        for ( uint32 i = 0; i < 4; ++i )
    3636        {
    3737                lua_rawgeti( m_lua, -1, int(i+1) );

  • trunk/src/image/miniz.cc

    r533 r534  
    11661166                        TINFL_GET_BYTE( 1, r->m_zhdr0 ); TINFL_GET_BYTE( 2, r->m_zhdr1 );
    11671167                        counter = ( ( ( r->m_zhdr0 * 256 + r->m_zhdr1 ) % 31 != 0 ) || ( r->m_zhdr1 & 32 ) || ( ( r->m_zhdr0 & 15 ) != 8 ) );
    1168                         if ( !( decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF ) ) counter |= ( ( ( 1U << ( 8U + ( r->m_zhdr0 >> 4 ) ) ) > 32768U ) || ( ( out_buf_size_mask + 1 ) < (size_t)( 1U << ( 8U + ( r->m_zhdr0 >> 4 ) ) ) ) );
     1168                        if ( !( decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF ) ) counter |= ( ( ( 1U << ( 8U + ( r->m_zhdr0 >> 4 ) ) ) > 32768U ) || ( ( out_buf_size_mask + 1 ) < (uint32)( 1U << ( 8U + ( r->m_zhdr0 >> 4 ) ) ) ) );
    11691169                        if ( counter ) { TINFL_CR_RETURN_FOREVER( 36, TINFL_STATUS_FAILED ); }
    11701170                }

  • trunk/src/image/png_loader.cc

    r487 r534  
    1 // Copyright (C) 2015-2015 ChaosForge Ltd
     1// Copyright (C) 2015-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
    … …  
    251251        int remaining()
    252252        {
    253                 return m_img_buffer_end - m_img_buffer;
     253                return (int)( m_img_buffer_end - m_img_buffer );
    254254        }
    255255
    … …  
    865865
    866866                case STBI__PNG_TYPE( 'I', 'E', 'N', 'D' ): {
    867                         uint32 raw_len, bpl;
     867                        size_t raw_len;
     868                        uint32 bpl;
    868869                        if ( first ) return stbi__err( "first not IHDR", "Corrupt PNG" );
    869870                        if ( scan != STBI__SCAN_load ) return 1;
    … …  
    882883                        else
    883884                                s->img_out_n = s->img_n;
    884                         if ( !stbi__create_png_image( z, z->expanded, raw_len, s->img_out_n, depth, color, interlace ) ) return 0;
     885                        if ( !stbi__create_png_image( z, z->expanded, int( raw_len ), s->img_out_n, depth, color, interlace ) ) return 0;
    885886                        if ( has_trans )
    886887                                if ( !stbi__compute_transparency( z, tc, s->img_out_n ) ) return 0;
    … …  
    977978static int stbi__stream_read( void *user, char *data, int size )
    978979{
    979         return reinterpret_cast<stream*>( user )->read( data, 1, size );
     980        return (int)reinterpret_cast<stream*>( user )->read( data, 1, size );
    980981}
    981982
    … …  
    10221023        if ( stbi__png_info( &s, &x, &y, &comp ) == 1 )
    10231024        {
    1024                 str.seek( pos, origin::SET );
     1025                str.seek( (long)pos, origin::SET );
    10251026                format.type = UBYTE;
    10261027                switch ( comp )

  • trunk/src/image/png_writer.cc

    r529 r534  
    372372        ivec2 sz = data->get_size();
    373373        int len = 0;
    374         unsigned char* out = stbi_write_png_to_mem( data->get_data(), 0, sz.x, sz.y, data->get_depth(), &len );
     374        unsigned char* out = stbi_write_png_to_mem( data->get_data(), 0, sz.x, sz.y, (int)data->get_depth(), &len );
    375375        if ( !out ) return false;
    376376        s.write( out, 1, len );

  • trunk/src/io/c_file_system.cc

    r533 r534  
    1 // Copyright (C) 2012-2015 ChaosForge Ltd
     1// Copyright (C) 2012-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//

  • trunk/src/lua/lua_math.cc

    r529 r534  
    1111#include "nv/stl/type_traits/common.hh"
    1212
    13 static size_t nlua_swizzel_lookup[256];
     13using nv::uint32;
     14static nv::uint32 nlua_swizzel_lookup[256];
    1415
    1516using nv::lua::detail::is_vec;
    … …  
    1819using nv::lua::detail::push_vec;
    1920
    20 inline bool nlua_is_swizzel( const unsigned char* str, size_t max )
     21inline bool nlua_is_swizzel( const unsigned char* str, nv::uint32 max )
    2122{
    2223        while (*str)
    … …  
    229230{
    230231        T v = to_vec<T>( L, 1 );
    231         for ( size_t i = 0; i < v.size(); ++i )
     232        for ( uint32 i = 0; i < v.size(); ++i )
    232233        {
    233234                lua_pushnumber( L, v[i] );
    … …  
    241242        T* v = to_pvec<T>( L, 1 );
    242243        size_t len  = 0;
    243         size_t vlen = v->size();
     244        uint32 vlen = v->size();
    244245        const unsigned char * key = reinterpret_cast<const unsigned char *>( lua_tolstring( L, 2, &len ) );
    245         size_t idx = 255;
     246        uint32 idx = 255;
    246247
    247248        if ( len == 1 )
    … …  
    279280        T* v = to_pvec<T>( L, 1 );
    280281        size_t len  = 0;
    281         size_t vlen = v->size();
     282        uint32 vlen = v->size();
    282283        const unsigned char * key = reinterpret_cast<const unsigned char *>( lua_tolstring( L, 2, &len ) );
    283         size_t idx = 255;
     284        uint32 idx = 255;
    284285        if( len == 1 )
    285286        {
    … …  
    294295        {
    295296                switch (len) {
    296                 case 2 : { vec2 v2 = to_vec<vec2>(L,3); for ( size_t i = 0; i< len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v2[i]; } return 0;
    297                 case 3 : { vec3 v3 = to_vec<vec3>(L,3); for ( size_t i = 0; i< len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v3[i]; } return 0;
    298                 case 4 : { vec4 v4 = to_vec<vec4>(L,3); for ( size_t i = 0; i< len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v4[i]; } return 0;
     297                case 2 : { vec2 v2 = to_vec<vec2>(L,3); for ( uint32 i = 0; i< len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v2[i]; } return 0;
     298                case 3 : { vec3 v3 = to_vec<vec3>(L,3); for ( uint32 i = 0; i< len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v3[i]; } return 0;
     299                case 4 : { vec4 v4 = to_vec<vec4>(L,3); for ( uint32 i = 0; i< len; ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v4[i]; } return 0;
    299300                default: break;
    300301                }
    … …  
    405406void nv::lua::register_math( lua::state* state )
    406407{
    407         for (size_t i = 0; i < 256; ++i ) nlua_swizzel_lookup[i] = 255;
     408        for (uint32 i = 0; i < 256; ++i ) nlua_swizzel_lookup[i] = 255;
    408409        using nv::uchar8;
    409410        nlua_swizzel_lookup[uchar8( 'x' )] = 0;

  • trunk/src/lua/lua_nova.cc

    r490 r534  
    9191                if (lua_tointeger( L, itype ) != lua_type( L, ivalue ) && lua_tointeger( L, itype ) > 0)
    9292                {
    93                         luaL_error( L, "lua.nova - \"%s.%s\" - type mismatch, %s expected, %s found!", lua_tolstring( L, iid, 0 ), lua_tolstring( L, ifield, 0 ), lua_typename( L, lua_tointeger( L, itype ) ), lua_typename( L, lua_type( L, ivalue ) ) );
     93                        luaL_error( L, "lua.nova - \"%s.%s\" - type mismatch, %s expected, %s found!", lua_tolstring( L, iid, 0 ), lua_tolstring( L, ifield, 0 ), lua_typename( L, (int)lua_tointeger( L, itype ) ), lua_typename( L, lua_type( L, ivalue ) ) );
    9494                }
    9595                break;
    … …  
    296296        lua_rawget( L, 1 );
    297297        int count = 0;
    298         if ( !lua_isnil( L, -1 ) ) count = lua_tointeger( L, -1 );
     298        if ( !lua_isnil( L, -1 ) ) count = (int)lua_tointeger( L, -1 );
    299299        lua_pop( L, 1 );
    300300        count++;
    … …  
    358358static int nova_create_seq_function_closure( lua_State * L )
    359359{
    360         int fc   = lua_tointeger( L, lua_upvalueindex( 1 ) );
     360        int fc   = (int)lua_tointeger( L, lua_upvalueindex( 1 ) );
    361361        int args = lua_gettop( L );
    362362        for ( int fi = 1; fi <= fc; fi++ )

  • trunk/src/lua/lua_path.cc

    r490 r534  
    1616        string_view spath( m_elements[0].str, m_elements[0].length );
    1717        m_count = 0;
    18         size_t point = spath.find( '.' );
     18        uint32 point = spath.find( '.' );
    1919
    2020        while ( point != string_view::npos )

  • trunk/src/lua/lua_raw.cc

    r494 r534  
    331331int nlua_rawlen( lua_State* L, int index )
    332332{
    333         return lua_objlen( L, index );
     333        return static_cast<int>( lua_objlen( L, index ) );
    334334}
    335335

  • trunk/src/lua/lua_state.cc

    r533 r534  
    911911        if ( lua_type( state->get_raw(), index ) == LUA_TBOOLEAN )
    912912        {
    913                 *value = bool( lua_toboolean( state->get_raw(), index ) );
     913                *value = lua_toboolean( state->get_raw(), index ) != 0;
    914914                return true;
    915915        }

  • trunk/src/lua/lua_types.cc

    r503 r534  
    1 // Copyright (C) 2016-2016 ChaosForge Ltd
     1// Copyright (C) 2016-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
    … …  
    8585                {
    8686                        int error; // proper type instead of sint32?
    87                         *(sint32*)object = lua_tointeger( lstate, index );
     87                        *(sint32*)object = (sint32)lua_tointeger( lstate, index );
    8888                        return true;
    8989                }

  • trunk/src/lua/lua_values.cc

    r533 r534  
    1 // Copyright (C) 2012-2015 ChaosForge Ltd
     1// Copyright (C) 2012-2017 ChaosForge Ltd
    22// http://chaosforge.org/
    33//
Note: See TracChangeset for help on using the changeset viewer.