Changeset 486 for trunk/src


Ignore:
Timestamp:
02/24/16 18:47:54 (9 years ago)
Author:
epyon
Message:
  • mass update once again...
Location:
trunk/src
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/engine/material_manager.cc

    r485 r486  
    1212using namespace nv;
    1313
     14
     15nv::gpu_material_manager::gpu_material_manager( context* context, material_manager* matmgr, image_manager* imgmgr )
     16        : m_context( context )
     17        , m_material_manager( matmgr )
     18        , m_image_manager( imgmgr )
     19{
     20        uint8 data[2 * 2 * 3];
     21        nv::raw_fill_n( data, 2 * 2 * 3, 0 );
     22        m_default = m_context->get_device()->create_texture( ivec2(2,2), nv::image_format( nv::RGB ), nv::sampler(), data );
     23}
     24
    1425bool gpu_material_manager::load_resource( const string_view& id )
    1526{
    … …  
    2031                for ( uint32 i = 0; i < size( mat->paths ); ++i )
    2132                        if ( !mat->paths[i].empty() )
     33                        {
    2234                                if ( auto data = m_image_manager->get( mat->paths[i] ).lock() )
    2335                                {
    2436                                        result->textures[i] = m_context->get_device()->create_texture( &*data, smp );
    2537                                }
     38                        }
     39
     40                // HACK
     41                for ( uint32 i = 0; i < 5; ++i )
     42                        if ( result->textures[i].is_nil() )
     43                                result->textures[i] = m_default;
     44                       
    2645                add( id, result );
    2746                return true;
    … …  
    4463        m->paths[ TEX_SPECULAR ] = table.get_string128( "specular" );
    4564        m->paths[ TEX_NORMAL ]   = table.get_string128( "normal" );
     65        m->paths[ TEX_EMISSIVE ] = table.get_string128( "emissive" );
    4666        m->paths[ TEX_GLOSS ]    = table.get_string128( "gloss" );
    4767        add( id, m );

  • trunk/src/engine/resource_system.cc

    r485 r486  
    2323}
    2424
    25 void nv::lua_resource_manager_base::load_all()
     25void nv::lua_resource_manager_base::load_all( bool do_clear )
    2626{
    27         clear();
     27        if ( do_clear ) clear();
    2828        lua::table_guard table( m_lua, get_storage_name() );
    2929        uint32 count = table.get_unsigned( "__counter" );

  • trunk/src/formats/assimp_loader.cc

    r485 r486  
    133133        {
    134134                data_node_info info;
    135                 data_channel_set* data = data_channel_set_creator::create_set( 2 );
    136                 load_mesh_data( data, i, info );
    137                 m_meshes.push_back( data );
     135                data_channel_set* mdata = data_channel_set_creator::create_set( 2 );
     136                load_mesh_data( mdata, i, info );
     137                m_meshes.push_back( mdata );
    138138                m_mesh_info.push_back( info );
    139139        }
    … …  
    184184        int hack_for_node_anim;
    185185        if ( is_node_animated() )
    186                 info.parent_id = index;
     186                info.parent_id = sint16( index );
    187187
    188188
    … …  
    339339}
    340340
    341 void nv::assimp_loader::build_skeleton( vector< data_node_info >& skeleton, const void* node, int parent_id )
     341void nv::assimp_loader::build_skeleton( vector< data_node_info >& skeleton, const void* node, sint16 parent_id )
    342342{
    343343        const aiNode* ainode = reinterpret_cast<const aiNode*>( node );
    … …  
    360360        info.parent_id = parent_id;
    361361
    362         int this_id = skeleton.size();
     362        sint16 this_id = sint16( skeleton.size() );
    363363        skeleton.push_back( info );
    364364        for ( unsigned i = 0; i < ainode->mNumChildren; ++i )
    … …  
    428428                {
    429429                        mat4 tr = nv::math::inverse( assimp_mat4_cast( m_data->node_by_name[bone_data[i].name]->mTransformation ) );
    430                         bone_data[i].transform = tr * bone_data[bone_data[i].parent_id].transform;
     430                        int pid = bone_data[i].parent_id;
     431                        if ( pid != -1 )
     432                                bone_data[i].transform = tr * bone_data[pid].transform;
     433                        else
     434                                bone_data[i].transform = tr;
    431435                }
    432436//              list->append( bone_data[i] );
    … …  
    449453        if ( scene->mRootNode == nullptr || scene->mAnimations == nullptr || scene->mAnimations[index] == nullptr) return nullptr;
    450454
    451         const aiNode*      root = scene->mRootNode;
    452455        const aiAnimation* anim = scene->mAnimations[index];
    453456
    … …  
    481484}
    482485
    483 data_node_list* nv::assimp_loader::release_data_node_list( size_t index /*= 0 */ )
     486data_node_list* nv::assimp_loader::release_data_node_list( size_t /*= 0 */ )
    484487{
    485488        return release_merged_bones();

  • trunk/src/formats/nmd_loader.cc

    r485 r486  
    261261        nmd_element_header pheader;
    262262        pheader.type       = nv::nmd_type::POSES;
    263         pheader.children   = poses.size();
     263        pheader.children   = uint16( poses.size() );
    264264        pheader.size       = sizeof( transform ) * poses.size() * ( poses.size() > 0 ? poses[0]->size() : 0 )
    265265                               + sizeof( uint32 ) * poses.size();

  • trunk/src/gfx/skeleton_instance.cc

    r485 r486  
    88
    99#include "nv/core/profiler.hh"
     10#include "nv/interface/interpolate.hh"
    1011
    1112void nv::skeleton_binding::assign( const skeleton_binding& other )
    … …  
    7879}
    7980
    80 
    81 void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const skeleton_binding& binding, const bone_transforms& bones )
    82 {
    83         if ( bones.size() != m_matrix.size() )
    84                 m_matrix.resize( bones.size() );
    85         const transform* transforms = skeleton.xforms();
    86         for ( uint32 n = 0; n < skeleton.size(); ++n )
    87         {
    88                 sint16 bone_id = binding.m_indices[n];
    89                 if ( bone_id >= 0 )
    90                 {
    91                         int too_complex;
    92                         transform tr( bones.m_offsets[bone_id] );
    93                         tr.set_orientation( normalize( tr.get_orientation() ) );
    94                         m_matrix[bone_id] = ( transforms[n] * tr ).extract();
    95                 }
    96         }
    97 }
    98 
    99 
    100 void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const bone_transforms& bones )
    101 {
    102         if ( bones.size() != m_matrix.size() )
    103                 m_matrix.resize( bones.size() );
    104         const transform* transforms = skeleton.xforms();
    105         for ( uint32 n = 0; n < skeleton.size(); ++n )
    106         {
    107                 transform tr( bones.m_offsets[n] );
    108                 tr.set_orientation( normalize( tr.get_orientation() ) );
    109                 m_matrix[n] = ( transforms[n] * tr ).extract();
    110         //      m_matrix[n] = transforms[n].extract() * bones.m_offsets[n];
    111         }
    112 }
    113 
    114 void nv::skeleton_instance::assign( const bone_transforms& bones )
    115 {
    116         if ( bones.size() != m_matrix.size() )
    117                 m_matrix.resize( bones.size() );
    118 }
    119 
    12081void nv::skeleton_transforms::assign( const data_node_list* node_data )
    12182{
    … …  
    12586        for ( uint32 n = 0; n < node_data->size(); ++n )
    12687        {
    127                 const data_node_info& info = (*node_data)[ n ];
    128                 m_transforms[n] = transform( info.transform );
     88                m_transforms[n] = transform( ( *node_data )[n].transform );
    12989        }
    13090}
    13191
    132 void nv::skeleton_transforms::interpolate_linear( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     92void nv::skeleton_transforms::assign( const skeleton_transforms& other, const array_view< bool >& mask )
     93{
     94        if ( m_transforms.size() != other.size() ) m_transforms.resize( other.size() );
     95        if ( mask.size() == 0 )
     96                m_transforms.assign( other.m_transforms );
     97        else
     98                for ( uint32 i = 0; i < other.size(); ++i )
     99                        if ( mask[i] )
     100                                m_transforms[i] = other.m_transforms[i];
     101}
     102
     103void nv::skeleton_transforms::interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i )
     104{
     105        if ( m_transforms.size() != a.size() ) m_transforms.resize( a.size() );
     106        ::nv::interpolate( m_transforms, t, i, a.m_transforms, b.m_transforms );
     107}
     108
     109void nv::skeleton_transforms::interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, const array_view< bool >& mask )
     110{
     111        if ( m_transforms.size() != a.size() ) m_transforms.resize( a.size() );
     112        if ( mask.size() > 0 )
     113                ::nv::interpolate( m_transforms, t, i, mask, a.m_transforms, b.m_transforms );
     114        else
     115                ::nv::interpolate( m_transforms, t, i, a.m_transforms, b.m_transforms );
     116}
     117
     118void nv::skeleton_transforms::interpolate( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i )
     119{
     120        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
     121        ::nv::interpolate( m_transforms, t, i, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
     122}
     123
     124void nv::skeleton_transforms::interpolate( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, const array_view< bool >& mask )
     125{
     126        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
     127        if ( mask.size() > 0 )
     128                ::nv::interpolate( m_transforms, t, i, mask, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
     129        else
     130                ::nv::interpolate( m_transforms, t, i, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
     131}
     132
     133void nv::skeleton_transforms::blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi )
    133134{
    134135        NV_ASSERT( a.size() == b.size(), "!!!" );
    135136        if ( m_transforms.size() != a.size() )
    136137                m_transforms.resize( a.size() );
    137         for ( uint32 n = 0; n < a.size(); ++n )
    138         {
    139                 m_transforms[n] = transform(
    140                         math::mix( a.m_transforms[n].get_position(), b.m_transforms[n].get_position(), t ),
    141                         math::lerp( a.m_transforms[n].get_orientation(), b.m_transforms[n].get_orientation(), t )
    142                         );
    143         }
    144 
    145 //      if ( m_transforms.size() > 0 )
    146 //              m_transforms[0] = nv::interpolate( a.m_transforms[0], b.m_transforms[0], t, interpolation::SPHERICAL );
     138        ::nv::interpolate( m_transforms, t, i, blend, bi, a.m_transforms, b.m_transforms );
    147139}
    148140
    149 void nv::skeleton_transforms::interpolate_nlerp( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     141void nv::skeleton_transforms::blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi, const array_view< bool >& mask )
    150142{
    151143        NV_ASSERT( a.size() == b.size(), "!!!" );
    152144        if ( m_transforms.size() != a.size() )
    153145                m_transforms.resize( a.size() );
    154 
    155         for ( uint32 n = 0; n < a.size(); ++n )
    156         {
    157                 m_transforms[n] = transform(
    158                         math::mix( a.m_transforms[n].get_position(), b.m_transforms[n].get_position(), t ),
    159                         math::nlerp( a.m_transforms[n].get_orientation(), b.m_transforms[n].get_orientation(), t )
    160                         );
    161         }
     146        if ( mask.size() > 0 )
     147                ::nv::interpolate( m_transforms, t, i, blend, bi, mask, a.m_transforms, b.m_transforms );
     148        else
     149                ::nv::interpolate( m_transforms, t, i, blend, bi, a.m_transforms, b.m_transforms );
    162150}
    163151
    164 
    165 void nv::skeleton_transforms::interpolate_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     152void nv::skeleton_transforms::blend( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, float blend, interpolation bi )
    166153{
    167         NV_ASSERT( a.size() == b.size(), "!!!" );
    168         if ( m_transforms.size() != a.size() )
    169                 m_transforms.resize( a.size() );
    170         for ( uint32 n = 0; n < a.size(); ++n )
    171         {
    172                 m_transforms[n] = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t, interpolation::SPHERICAL );
    173         }
     154        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
     155        ::nv::interpolate( m_transforms, t, i, blend, bi, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
    174156}
    175157
    176 void nv::skeleton_transforms::blend_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t, float blend )
     158void nv::skeleton_transforms::blend( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, float blend, interpolation bi, const array_view< bool >& mask )
    177159{
    178         NV_ASSERT( a.size() == b.size(), "!!!" );
    179         if ( m_transforms.size() != a.size() )
    180                 m_transforms.resize( a.size() );
    181         for ( uint32 n = 0; n < a.size(); ++n )
    182         {
    183                 transform tr    = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t, interpolation::SPHERICAL );
    184                 m_transforms[n] = nv::interpolate( m_transforms[n], tr, blend, interpolation::SPHERICAL );
    185         }
    186 }
    187 
    188 
    189 
    190 void nv::skeleton_transforms::interpolate4( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
    191 {
    192         NV_ASSERT( s1.size() == s2.size(), "!!!" );
    193         NV_ASSERT( v1.size() == v2.size(), "!!!" );
    194         NV_ASSERT( s1.size() == v1.size(), "!!!" );
    195         if ( m_transforms.size() != s1.size() )
    196                 m_transforms.resize( s1.size() );
    197         float interp_squared = t*t;
    198         float interp_cubed = interp_squared*t;
    199         float weights[4];
    200         weights[0] = 0.5f * ( -interp_cubed + 2.0f * interp_squared - t );
    201         weights[1] = 0.5f * ( 3.0f * interp_cubed - 5.0f * interp_squared + 2.0f );
    202         weights[2] = 0.5f * ( -3.0f * interp_cubed + 4.0f * interp_squared + t );
    203         weights[3] = 0.5f * ( interp_cubed - interp_squared );
    204 
    205         for ( uint32 n = 0; n < s1.size(); ++n )
    206         {
    207                 quat qs1 = s1.m_transforms[n].get_orientation();
    208                 quat qs2 = s2.m_transforms[n].get_orientation();
    209                 quat qv1 = v1.m_transforms[n].get_orientation();
    210                 quat qv2 = v2.m_transforms[n].get_orientation();
    211 
    212                 float a = dot( qv1, qv2 ) > 0.0f ? 1.0f : -1.0f;
    213 
    214                 quat qr = weights[0] * qs1
    215                                 + weights[1] * (a * qv1 )
    216                                 + weights[2] * qv2
    217                                 + weights[3] * qs2;
    218 
    219                 qr = normalize( qr );
    220 
    221                 m_transforms[n] = transform(
    222                         weights[0] * s1.m_transforms[n].get_position() +
    223                         weights[1] * v1.m_transforms[n].get_position() +
    224                         weights[2] * v2.m_transforms[n].get_position() +
    225                         weights[3] * s2.m_transforms[n].get_position(),
    226                         qr
    227                 );
    228         }
    229 }
    230 
    231 
    232 void nv::skeleton_transforms::interpolate_squad( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
    233 {
    234         NV_ASSERT( s1.size() == s2.size(), "!!!" );
    235         NV_ASSERT( v1.size() == v2.size(), "!!!" );
    236         NV_ASSERT( s1.size() == v1.size(), "!!!" );
    237         if ( m_transforms.size() != s1.size() )
    238                 m_transforms.resize( s1.size() );
    239 
    240         for ( uint32 n = 0; n < s1.size(); ++n )
    241         {
    242                 nv::quat ss1 = s1.m_transforms[n].get_orientation();
    243                 nv::quat ss2 = s2.m_transforms[n].get_orientation();
    244                 nv::quat sv1 = v1.m_transforms[n].get_orientation();
    245                 nv::quat sv2 = v2.m_transforms[n].get_orientation();
    246 
    247                 nv::quat q = normalize( nv::math::squad(
    248                         sv1, sv2,
    249                         nv::math::intermediate( ss1, sv1, sv2 ),
    250                         nv::math::intermediate( sv1, sv2, ss2 ),
    251                         t ) );
    252 
    253                 m_transforms[n] = transform(
    254                         mix( v1.m_transforms[n].get_position(), v2.m_transforms[n].get_position(), t ),
    255                         q
    256                         );
    257         }
    258        
     160        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
     161        if ( mask.size() > 0 )
     162                ::nv::interpolate( m_transforms, t, i, blend, bi, mask, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
     163        else
     164                ::nv::interpolate( m_transforms, t, i, blend, bi, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
    259165}
    260166
    … …  
    264170}
    265171
    266 // void nv::skeleton_transforms::blend_local( const mesh_nodes_data* node_data, float frame, float blend )
    267 // {
    268 //      if ( m_transforms.size() != node_data->size() )
    269 //              m_transforms.resize( node_data->size() );
    270 //      for ( uint32 n = 0; n < node_data->size(); ++n )
    271 //      {
    272 //              const data_channel_set* node = ( *node_data )[n];
    273 //              int inefficient_store_key;
    274 //
    275 //              transform tr = node->size() > 0 ? raw_channel_interpolator( node ).get< transform >( frame ) : transform( /*node->get_transform()*/ ); int confirm_that_not_needed;
    276 //              m_transforms[n] = nv::interpolate( m_transforms[n], tr, blend, interpolation::SPHERICAL );
    277 //      }
    278 // }
    279 //
    280 // void nv::skeleton_transforms::animate_local( const mesh_nodes_data* node_data, float frame )
    281 // {
    282 //      if ( m_transforms.size() != node_data->size() )
    283 //              m_transforms.resize( node_data->size() );
    284 //      for ( uint32 n = 0; n < node_data->size(); ++n )
    285 //      {
    286 //              const data_channel_set* node = ( *node_data )[n];
    287 //              if ( node->size() > 0 )
    288 //              {
    289 //                      int inefficient_store_key;
    290 //                      m_transforms[n] = raw_channel_interpolator( node ).get< transform >( frame );
    291 //              }
    292 //      }
    293 // }
    294172
    295173void nv::skeleton_transforms::delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent )
    … …  
    304182}
    305183
    306 // void nv::skeleton_transforms::blend_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local, float blend )
    307 // {
    308 //      const data_channel_set* node = ( *node_data )[id];
    309 //      int confirm_that_not_needed;
    310 //      transform node_mat/*( node->get_transform() )*/;
    311 //
    312 //      if ( node->size() > 0 )
    313 //      {
    314 //              int inefficient_store_key;
    315 //
    316 //              raw_channel_interpolator interpolator( node );
    317 //              node_mat = interpolator.get< transform >( frame );
    318 //      }
    319 //      transform global_mat = parent * node_mat;
    320 //      m_transforms[id] = nv::interpolate( m_transforms[id], local ? node_mat : global_mat, blend, interpolation::SPHERICAL );
    321 //      for ( auto child : node_data->children( id ) )
    322 //      {
    323 //              blend_rec( node_data, frame, child, global_mat, local, blend );
    324 //      }
    325 //
    326 // }
    327 //
    328 // void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local )
    329 // {
    330 //      const data_channel_set* node = ( *node_data )[id];
    331 //      transform node_mat;
    332 //      int inefficient_store_key;
    333 //
    334 //      if ( node->size() > 0 )
    335 //              node_mat = raw_channel_interpolator( node ).get< transform >( frame );
    336 //      int confirm_that_not_needed;
    337 //      //      else
    338 //      //              node_mat = transform( node->get_transform() );
    339 //      transform global_mat = parent * node_mat;
    340 //      m_transforms[id] = local ? node_mat : global_mat;
    341 //      for ( auto child : node_data->children( id ) )
    342 //      {
    343 //              animate_rec( node_data, frame, child, global_mat, local );
    344 //      }
    345 //
    346 // }
    347 
    348 void nv::bone_transforms::prepare( const data_node_list& bone_data )
    349 {
    350         m_offsets.resize( bone_data.size() );
    351 
    352         for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi )
    353                 m_offsets[bi] = bone_data[bi].transform;
    354 }

  • trunk/src/image/miniz.cc

    r484 r486  
    813813        static void *def_alloc_func( void *opaque, size_t items, size_t size ) { (void)opaque, (void)items, (void)size; return MZ_MALLOC( items * size ); }
    814814        static void def_free_func( void *opaque, void *address ) { (void)opaque, (void)address; MZ_FREE( address ); }
    815         static void *def_realloc_func( void *opaque, void *address, size_t items, size_t size ) { (void)opaque, (void)address, (void)items, (void)size; return MZ_REALLOC( address, items * size ); }
     815//      static void *def_realloc_func( void *opaque, void *address, size_t items, size_t size ) { (void)opaque, (void)address, (void)items, (void)size; return MZ_REALLOC( address, items * size ); }
    816816
    817817        const char *mz_version( void )

  • trunk/src/image/png_loader.cc

    r484 r486  
    665665}
    666666
     667
    667668static int stbi__unpremultiply_on_load = 0;
    668669static int stbi__de_iphone_flag = 0;
    669670
     671/*
    670672static void stbi_set_unpremultiply_on_load( int flag_true_if_should_unpremultiply )
    671673{
    … …  
    677679        stbi__de_iphone_flag = flag_true_if_should_convert;
    678680}
     681*/
    679682
    680683static void stbi__de_iphone( stbi__png *z )
    … …  
    10211024}
    10221025
     1026bool nv::png_loader::test( stream& str )
     1027{
     1028        stbi__context s( &stbi__callbacks, (void *)&str );
     1029        return stbi__png_test( &s ) != 0;
     1030}
     1031
    10231032image_data* nv::png_loader::load( stream& s )
    10241033{

  • trunk/src/io/c_stream.cc

    r484 r486  
    9898        if ( m_file != nullptr )
    9999        {
    100                 return ::feof( reinterpret_cast<FILE*>( m_file ) );
     100                return ::feof( reinterpret_cast<FILE*>( m_file ) ) != 0;
    101101        }
     102        return true;
    102103}

  • trunk/src/lua/lua_state.cc

    r440 r486  
    194194                str = lua_tolstring( m_state, -1, &l );
    195195                result = hash_string< uint64 >( str, l );
     196                //NV_LOG_DEBUG( str );
    196197        }
    197198        lua_pop( m_state, 1 );
    … …  
    204205        size_t l = 0;
    205206        const char* str = nullptr;
    206         uint64 result = defval;
     207        shash64 result = shash64( defval );
    207208        if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    208209        {
    209210                str = lua_tolstring( m_state, -1, &l );
    210                 result = table.insert( string_view( str, l ) ).value();
    211         }
    212         lua_pop( m_state, 1 );
    213         return shash64( result );
     211                result = table.insert( string_view( str, l ) );
     212        }
     213        lua_pop( m_state, 1 );
     214        return result;
     215}
     216
     217nv::shash64 nv::lua::table_guard::get_string( string_view element, string_table* table, uint64 defval /*= 0 */ )
     218{
     219        lua_getfield( m_state, -1, element.data() );
     220        size_t l = 0;
     221        const char* str = nullptr;
     222        shash64 result = shash64( defval );
     223        if ( lua_type( m_state, -1 ) == LUA_TSTRING )
     224        {
     225                str = lua_tolstring( m_state, -1, &l );
     226                string_view sv( str, l );
     227                result = table ? table->insert( sv ) : shash64( sv );
     228        }
     229        lua_pop( m_state, 1 );
     230        return result;
    214231}
    215232

  • trunk/src/sdl/sdl_window.cc

    r440 r486  
    4545        }
    4646
    47         //      NV_LOG( LOG_INFO, "Joystick count : " << SDL_NumJoysticks() );
    48         //      SDL_Joystick* j = SDL_JoystickOpen(0);
    49         //      if (j)
    50         //      {
    51         //              NV_LOG( LOG_INFO, "Joystick Name: " << SDL_JoystickNameForIndex(0) );
    52         //              NV_LOG( LOG_INFO, "Joystick Number of Axes: " << SDL_JoystickNumAxes(j));
    53         //              NV_LOG( LOG_INFO, "Joystick Number of Buttons: " << SDL_JoystickNumButtons(j));
    54         //              NV_LOG( LOG_INFO, "Joystick Number of Balls: " << SDL_JoystickNumBalls(j));
    55         //      }
     47//      NV_LOG_INFO( "Joystick count : ", SDL_NumJoysticks() );
     48//      SDL_Joystick* j = SDL_JoystickOpen(0);
     49//      if ( j )
     50//      {
     51//              NV_LOG_INFO( "Joystick Name: ", SDL_JoystickNameForIndex( 0 ) );
     52//              NV_LOG_INFO( "Joystick Number of Axes: ", SDL_JoystickNumAxes( j ) );
     53//              NV_LOG_INFO( "Joystick Number of Buttons: ", SDL_JoystickNumButtons( j ) );
     54//              NV_LOG_INFO( "Joystick Number of Balls: ", SDL_JoystickNumBalls( j ) );
     55//      }
     56
     57        NV_LOG_INFO( "Joystick count : ", SDL_NumJoysticks() );
     58        SDL_GameController *controller = NULL;
     59        int controller_index = 0;
     60        for ( int i = 0; i < SDL_NumJoysticks(); ++i )
     61        {
     62                if ( SDL_IsGameController( i ) )
     63                {
     64                        controller = SDL_GameControllerOpen( i );
     65                        controller_index = i;
     66                        if ( controller ) break;
     67                        NV_LOG_ERROR( "Could not open gamecontroller ", i, ": ", SDL_GetError() );
     68                }
     69        }
     70
     71        if ( controller )
     72        {
     73                SDL_Joystick* j = SDL_GameControllerGetJoystick( controller );
     74                NV_LOG_INFO( "Controller Name: ", SDL_GameControllerNameForIndex( controller_index ) );
     75                NV_LOG_INFO( "Controller Number of Axes: ", SDL_JoystickNumAxes( j ) );
     76                NV_LOG_INFO( "Controller Number of Buttons: ", SDL_JoystickNumButtons( j ) );
     77                NV_LOG_INFO( "Controller Number of Balls: ", SDL_JoystickNumBalls( j ) );
     78        }
     79
     80
    5681
    5782        void* ctx_handle = SDL_GL_CreateContext( static_cast<SDL_Window*>( m_handle ) );
Note: See TracChangeset for help on using the changeset viewer.