Changeset 406 for trunk/src

Timestamp:

06/20/15 00:05:17 (10 years ago)

Author:

epyon

Message:

• code compiles cleanly on maximum warning level

Location:

trunk/src

Files:

• curses/curses_terminal.cc (modified) (2 diffs)
• engine/particle_engine.cc (modified) (10 diffs)
• fmod/fmod_audio.cc (modified) (7 diffs)
• formats/assimp_loader.cc (modified) (21 diffs)
• formats/md2_loader.cc (modified) (8 diffs)
• formats/md3_loader.cc (modified) (13 diffs)
• formats/md5_loader.cc (modified) (11 diffs)
• formats/nmd_loader.cc (modified) (3 diffs)
• formats/obj_loader.cc (modified) (1 diff)
• gfx/image.cc (modified) (1 diff)
• gfx/keyframed_mesh.cc (modified) (8 diffs)
• gfx/mesh_creator.cc (modified) (22 diffs)
• gfx/skeletal_mesh.cc (modified) (6 diffs)
• gl/gl_context.cc (modified) (10 diffs)
• gl/gl_device.cc (modified) (11 diffs)
• gl/gl_window.cc (modified) (4 diffs)
• gui/gui_ascii_renderer.cc (modified) (6 diffs)
• gui/gui_gfx_renderer.cc (modified) (7 diffs)
• gui/gui_style.cc (modified) (1 diff)
• io/c_stream.cc (modified) (5 diffs)
• io/string_table.cc (modified) (2 diffs)
• lib/assimp.cc (modified) (1 diff)
• lib/curses.cc (modified) (1 diff)
• lib/fmod.cc (modified) (1 diff)
• lib/freetype2.cc (modified) (1 diff)
• lib/gl.cc (modified) (8 diffs)
• lib/lua.cc (modified) (4 diffs)
• lib/sdl.cc (modified) (1 diff)
• lib/sdl_image.cc (modified) (1 diff)
• lib/sdl_mixer.cc (modified) (1 diff)
• lua/lua_function.cc (modified) (4 diffs)
• lua/lua_glm.cc (modified) (10 diffs)
• lua/lua_handle.cc (modified) (3 diffs)
• lua/lua_map_area.cc (modified) (3 diffs)
• lua/lua_map_tile.cc (modified) (11 diffs)
• lua/lua_raw.cc (modified) (1 diff)
• lua/lua_state.cc (modified) (1 diff)
• rogue/fov_recursive_shadowcasting.cc (modified) (1 diff)
• sdl/sdl_audio.cc (modified) (4 diffs)
• sdl/sdl_input.cc (modified) (2 diffs)
• sdl/sdl_window.cc (modified) (1 diff)
• stl/assert.cc (modified) (1 diff)

trunk/src/curses/curses_terminal.cc

@@ -20 +20 @@
         noecho();
 
-        nodelay  ( (WINDOW*)m_screen, true );
-        intrflush( (WINDOW*)m_screen, false );
-        keypad   ( (WINDOW*)m_screen, true );
+        nodelay  ( static_cast<WINDOW*>( m_screen ), true );
+        intrflush( static_cast<WINDOW*>( m_screen ), false );
+        keypad   ( static_cast<WINDOW*>( m_screen ), true );
 
         start_color();
@@ -89 +89 @@
 
         // Get value from curses
-        int result = wgetch((WINDOW*)m_screen);
+        int result = wgetch( static_cast<WINDOW*>( m_screen ) );
 
         // If value is err, return none event

trunk/src/engine/particle_engine.cc

@@ -194 +194 @@
 static bool nv_particle_affector_linear_force_init( lua::table_guard* table, particle_affector_data* data )
 {
-        nvpe_linear_force_data* datap = ((nvpe_linear_force_data*)data->paramters);
+        nvpe_linear_force_data* datap = reinterpret_cast<nvpe_linear_force_data*>( data->paramters );
         datap->force_vector = table->get<vec3>("force_vector", vec3() );
         datap->average      = table->get<bool>("average", false );
@@ -202 +202 @@
 static void nv_particle_affector_linear_force( const particle_affector_data* data, particle* p, float factor, uint32 count )
 {
-        nvpe_linear_force_data* datap = ((nvpe_linear_force_data*)data->paramters);
+        const nvpe_linear_force_data* datap = reinterpret_cast<const nvpe_linear_force_data*>( data->paramters );
         if ( datap->average )
         {
@@ -226 +226 @@
 static bool nv_particle_affector_deflector_plane_init( lua::table_guard* table, particle_affector_data* data )
 {
-        nvpe_deflector_plane_data* datap = ((nvpe_deflector_plane_data*)data->paramters);
+        nvpe_deflector_plane_data* datap = reinterpret_cast<nvpe_deflector_plane_data*>( data->paramters );
         datap->plane_point  = table->get<vec3>("plane_point",  vec3() );
         datap->plane_normal = table->get<vec3>("plane_normal", vec3(0.0f,1.0f,0.0f) );
@@ -237 +237 @@
 static void nv_particle_affector_deflector_plane( const particle_affector_data* data, particle* p, float factor, uint32 count )
 {
-        nvpe_deflector_plane_data* datap = ((nvpe_deflector_plane_data*)data->paramters);
+        const nvpe_deflector_plane_data* datap = reinterpret_cast<const nvpe_deflector_plane_data*>( data->paramters );
         for ( uint32 i = 0; i < count; ++i )
         {
@@ -262 +262 @@
 static bool nv_particle_affector_color_fader_init( lua::table_guard* table, particle_affector_data* data )
 {
-        nvpe_color_fader_data* datap = ((nvpe_color_fader_data*)data->paramters);
+        nvpe_color_fader_data* datap = reinterpret_cast<nvpe_color_fader_data*>( data->paramters );
         datap->adjustment = table->get<vec4>("adjustment",  vec4() );
         return true;
@@ -269 +269 @@
 static void nv_particle_affector_color_fader( const particle_affector_data* data, particle* p, float factor, uint32 count )
 {
-        nvpe_color_fader_data* datap = ((nvpe_color_fader_data*)data->paramters);
+        const nvpe_color_fader_data* datap = reinterpret_cast<const nvpe_color_fader_data*>( data->paramters );
         vec4 adjustment = datap->adjustment * factor;
         for ( uint32 i = 0; i < count; ++i )
@@ -284 +284 @@
 static bool nv_particle_affector_scaler_init( lua::table_guard* table, particle_affector_data* data )
 {
-        nvpe_scaler_data* datap = ((nvpe_scaler_data*)data->paramters);
+        nvpe_scaler_data* datap = reinterpret_cast<nvpe_scaler_data*>( data->paramters );
         float rate        = table->get<float>("rate", 0.0f );
         datap->adjustment = table->get<vec2>("adjustment",  vec2(rate,rate) );
@@ -292 +292 @@
 static void nv_particle_affector_scaler( const particle_affector_data* data, particle* p, float factor, uint32 count )
 {
-        nvpe_scaler_data* datap = ((nvpe_scaler_data*)data->paramters);
+        const nvpe_scaler_data* datap = reinterpret_cast<const nvpe_scaler_data*>( data->paramters );
         vec2 adjustment = datap->adjustment * factor;
         for ( uint32 i = 0; i < count; ++i )
@@ -496 +496 @@
         info->particles = new particle[ data->quota ];
         info->quads     = new particle_quad[ data->quota ];
-        info->vtx_array = m_context->create_vertex_array<particle_vtx>( 
-                (particle_vtx*)info->quads, data->quota*6, STREAM_DRAW );
+        info->vtx_array = m_context->create_vertex_array<particle_vtx>( info->quads[0].data, data->quota*6, STREAM_DRAW );
         info->vtx_buffer = m_context->find_buffer( info->vtx_array, slot::POSITION );
         info->last_update = m_last_update;
@@ -691 +690 @@
 {
         if ( info->count > 0 )
-                for ( sint32 i = (sint32)info->count-1; i >= 0; --i )
+                for ( sint32 i = sint32( info->count ) - 1; i >= 0; --i )
                 {
                         particle& pinfo = info->particles[i];

trunk/src/fmod/fmod_audio.cc

@@ -41 +41 @@
         if ( info )
         {
-                FMOD_SYSTEM* system   = (FMOD_SYSTEM*)m_system;
-                FMOD_SOUND* sample    = (FMOD_SOUND*)( info->fmod_sound );
+                FMOD_SYSTEM* system   = static_cast<FMOD_SYSTEM*>( m_system );
+                FMOD_SOUND* sample    = static_cast<FMOD_SOUND*>( info->fmod_sound );
                 FMOD_CHANNEL* channel = nullptr;
                 FMOD_RESULT result    = FMOD_System_PlaySound( system, FMOD_CHANNEL_FREE, sample, true, &channel );
@@ -64 +64 @@
         if ( info )
         {
-                FMOD_SYSTEM* system   = (FMOD_SYSTEM*)m_system;
-                FMOD_SOUND* sample    = (FMOD_SOUND*)( info->fmod_sound );
+                FMOD_SYSTEM* system   = static_cast<FMOD_SYSTEM*>( m_system );
+                FMOD_SOUND* sample    = static_cast<FMOD_SOUND*>( info->fmod_sound );
                 FMOD_CHANNEL* channel = nullptr;
                 FMOD_RESULT result    = FMOD_System_PlaySound( system, FMOD_CHANNEL_FREE, sample, true, &channel );
@@ -90 +90 @@
 nv::sound fmod::audio::load_sound( const string_view& a_path )
 {
-        FMOD_SYSTEM* system = (FMOD_SYSTEM*)m_system;
+        FMOD_SYSTEM* system = static_cast<FMOD_SYSTEM*>( m_system );
         FMOD_SOUND* sample;
         FMOD_RESULT fm_result = FMOD_System_CreateSound( system, a_path.data(), FMOD_3D, 0, &sample );
@@ -109 +109 @@
         if ( info )
         {
-                FMOD_Sound_Release( (FMOD_SOUND*)info->fmod_sound );
+                FMOD_Sound_Release( static_cast<FMOD_SOUND*>( info->fmod_sound ) );
                 m_sounds.destroy( a_sound );
         }
@@ -125 +125 @@
         fmod_up.z = up.z;
         // TODO: we also need to setup orientation!
-        FMOD_System_Set3DListenerAttributes( (FMOD_SYSTEM*)m_system, 0, 0, 0, &fmod_forward, &fmod_up );
+        FMOD_System_Set3DListenerAttributes( static_cast<FMOD_SYSTEM*>( m_system ), 0, 0, 0, &fmod_forward, &fmod_up );
 }
 
@@ -140 +140 @@
 //      fmod_up.z = 0.0f;
         // TODO: we also need to setup orientation!
-        FMOD_System_Set3DListenerAttributes( (FMOD_SYSTEM*)m_system, 0, &fmod_position, 0, 0, 0 );
-        FMOD_System_Update( (FMOD_SYSTEM*)m_system );
+        FMOD_System_Set3DListenerAttributes( static_cast<FMOD_SYSTEM*>( m_system ), 0, &fmod_position, 0, 0, 0 );
+        FMOD_System_Update( static_cast<FMOD_SYSTEM*>( m_system ) );
 }
 
@@ -148 +148 @@
         while ( m_sounds.size() > 0 )
                 release( m_sounds.get_handle(0) );
-        FMOD_System_Release( (FMOD_SYSTEM*)m_system );
+        FMOD_System_Release( static_cast<FMOD_SYSTEM*>( m_system ) );
 }
 

trunk/src/formats/assimp_loader.cc

@@ -84 +84 @@
 {
         load_assimp_library();
-        if ( m_scene != nullptr ) aiReleaseImport( (const aiScene*)m_scene );
+        if ( m_scene != nullptr ) aiReleaseImport( reinterpret_cast<const aiScene*>( m_scene ) );
         m_scene = nullptr;
         m_mesh_count = 0;
@@ -113 +113 @@
 void nv::assimp_loader::load_mesh_data( mesh_data* data, size_t index )
 {
-        const aiScene* scene = (const aiScene*)m_scene;
+        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
         const aiMesh*  mesh  = scene->mMeshes[ index ];
         data->set_name( mesh->mName.data );
@@ -139 +139 @@
                 nv::vec4 vt ( t_i[0], t_i[1], t_i[2], det );
                 if ( skinned )
-                        ((assimp_skinned_vtx*)channel->data)[i] = assimp_skinned_vtx( v, s, n, vt );
+                        reinterpret_cast< assimp_skinned_vtx* >(channel->data)[i] = assimp_skinned_vtx( v, s, n, vt );
                 else
-                        ((assimp_plain_vtx*)channel->data)[i] = assimp_plain_vtx( v, s, n, vt );
+                        reinterpret_cast< assimp_plain_vtx* >(channel->data)[i] = assimp_plain_vtx( v, s, n, vt );
         }
 
         if ( skinned )
         {
-                assimp_skinned_vtx* vtx = (assimp_skinned_vtx*)channel->data;
+                assimp_skinned_vtx* vtx = reinterpret_cast< assimp_skinned_vtx* >( channel->data );
                 for (unsigned int m=0; m<mesh->mNumBones; m++)
                 {
@@ -154 +154 @@
                                 assimp_skinned_vtx& v = vtx[ bone->mWeights[w].mVertexId ];
                                 bool found = false;
-                                for (nv::uint32 i = 0 ; i < 4; ++i)
+                                for ( int i = 0 ; i < 4; ++i )
                                 {
                                         if ( v.boneweight[i] <= 0.0f ) 
                                         {
-                                                v.boneindex[i]  = (int)m;
+                                                v.boneindex[i]  = int( m );
                                                 v.boneweight[i] = bone->mWeights[w].mWeight;
                                                 found = true;
@@ -171 +171 @@
         mesh_raw_channel* ichannel = mesh_raw_channel::create_index( USHORT, mesh->mNumFaces * 3 );
         data->add_channel( ichannel );
-        uint16* indices = (uint16*)ichannel->data;
+        uint16* indices = reinterpret_cast<uint16*>( ichannel->data );
         for (unsigned int i=0; i<mesh->mNumFaces; i++)
         {
@@ -177 +177 @@
                 for (unsigned int j=0; j<face->mNumIndices; j++)
                 {
-                        indices[ i*3 + j ] = (uint16)face->mIndices[j];
+                        indices[ i*3 + j ] = uint16( face->mIndices[j] );
                 }
         }
@@ -184 +184 @@
 nv::assimp_loader::~assimp_loader()
 {
-        if ( m_scene != nullptr ) aiReleaseImport( (const aiScene*)m_scene );
+        if ( m_scene != nullptr ) aiReleaseImport( reinterpret_cast<const aiScene*>( m_scene ) );
 }
 
@@ -190 +190 @@
 {
         if ( m_scene == nullptr ) return false;
-        const aiScene* scene = (const aiScene*)m_scene;
+        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
         const aiMesh*  mesh  = scene->mMeshes[ index ];
 
@@ -208 +208 @@
 void nv::assimp_loader::scene_report() const
 {
-        const aiScene* scene = (const aiScene*)m_scene;
+        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
         if ( scene == nullptr ) return;
 
@@ -237 +237 @@
                         aiMesh* mesh = scene->mMeshes[mc];
 
-                        NV_LOG_NOTICE( "Mesh #", mc, "   - ", string_view( (char*)mesh->mName.data ) );
+                        NV_LOG_NOTICE( "Mesh #", mc, "   - ", string_view( static_cast<char*>( mesh->mName.data ) ) );
                         NV_LOG_NOTICE( "  bones   - ", mesh->mNumBones );
                         NV_LOG_NOTICE( "  uvs     - ", mesh->mNumUVComponents[0] );
@@ -283 +283 @@
 mesh_nodes_data* nv::assimp_loader::release_merged_bones( mesh_data* meshes )
 {
-        const aiScene* scene = (const aiScene*)m_scene;
+        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
         vector< mesh_node_data > final_bones;
         unordered_map< std::string, uint16 > names;
@@ -303 +303 @@
                                 {
                                         NV_ASSERT( final_bones.size() < MAX_BONES, "Too many bones to merge!" );
-                                        uint16 index = (uint16)final_bones.size();
+                                        uint16 index = uint16( final_bones.size() );
                                         final_bones.push_back( bone );
                                         names[ bone.name ] = index;
@@ -316 +316 @@
                         {
                                 mesh_raw_channel* channel = meshes[m].get_raw_channels()[0];
-                                assimp_skinned_vtx* va = (assimp_skinned_vtx*)channel->data;
+                                assimp_skinned_vtx* va = reinterpret_cast< assimp_skinned_vtx* >( channel->data );
                                 for ( unsigned v = 0; v < channel->count; ++v )
                                 {
                                         assimp_skinned_vtx& vertex = va[v];
 
-                                        for (uint32 i = 0 ; i < 4; ++i)
+                                        for ( int i = 0 ; i < 4; ++i)
                                         {
                                                 if ( vertex.boneweight[i] > 0.0f ) 
                                                 {
-                                                        vertex.boneindex[i] = (int)translate[vertex.boneindex[i]];
+                                                        vertex.boneindex[i] = int( translate[vertex.boneindex[i]] );
                                                 }
                                         }
@@ -340 +340 @@
 {
         if ( m_scene == nullptr ) return nullptr;
-        const aiScene* scene = (const aiScene*)m_scene;
+        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
         if ( scene->mRootNode == nullptr || scene->mAnimations == nullptr || scene->mAnimations[index] == nullptr) return nullptr;
 
@@ -349 +349 @@
         mesh_node_data* data    = new mesh_node_data[count];
 
-        uint16 frame_rate     = (uint16)anim->mTicksPerSecond;
-        float  duration       = (float)anim->mDuration;
+        uint16 frame_rate     = static_cast<uint16>( anim->mTicksPerSecond );
+        float  duration       = static_cast<float>( anim->mDuration );
         bool   flat           = false;
 
@@ -360 +360 @@
 nv::uint32 nv::assimp_loader::count_nodes( const void* node ) const
 {
-        const aiNode* ainode = (const aiNode*)node;
+        const aiNode* ainode = reinterpret_cast< const aiNode* >( node );
         nv::uint32 count = 1;
         for ( unsigned i = 0; i < ainode->mNumChildren; ++i )
@@ -371 +371 @@
 nv::sint16 nv::assimp_loader::load_node( uint32 anim_id, mesh_node_data* nodes, const void* vnode, sint16 this_id, sint16 parent_id )
 {
-        const aiScene* scene = (const aiScene*)m_scene;
-        const aiNode*  node  = (const aiNode*)vnode;
+        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
+        const aiNode*  node  = reinterpret_cast<const aiNode*>( vnode );
         std::string name( node->mName.data );
         const aiAnimation* anim  = scene->mAnimations[anim_id];
@@ -411 +411 @@
 void nv::assimp_loader::create_keys( mesh_node_data* data, const void* vnode )
 {
-        const aiNodeAnim* node = (const aiNodeAnim*)vnode;
+        const aiNodeAnim* node = reinterpret_cast< const aiNodeAnim* >( vnode );
         if ( node->mNumPositionKeys == 0 && node->mNumRotationKeys == 0 && node->mNumScalingKeys == 0 )
         {
@@ -424 +424 @@
         data->data->add_channel( raw_rchannel );
         //data->data->add_channel( raw_schannel );
-        assimp_key_p* pchannel = ((assimp_key_p*)(raw_pchannel->data));
-        assimp_key_r* rchannel = ((assimp_key_r*)(raw_rchannel->data));
+        assimp_key_p* pchannel = reinterpret_cast< assimp_key_p* >( raw_pchannel->data );
+        assimp_key_r* rchannel = reinterpret_cast< assimp_key_r* >( raw_rchannel->data );
         //assimp_key_s* schannel = ((assimp_key_s*)(raw_schannel->data));
 
         for ( unsigned np = 0; np < node->mNumPositionKeys; ++np )
         {
-                pchannel[np].time     = (float)node->mPositionKeys[np].mTime;
+                pchannel[np].time     = static_cast<float>( node->mPositionKeys[np].mTime );
                 pchannel[np].position = assimp_vec3_cast(node->mPositionKeys[np].mValue);
         }
         for ( unsigned np = 0; np < node->mNumRotationKeys; ++np )
         {
-                rchannel[np].time     = (float)node->mRotationKeys[np].mTime;
+                rchannel[np].time     = static_cast<float>( node->mRotationKeys[np].mTime );
                 rchannel[np].rotation = assimp_quat_cast(node->mRotationKeys[np].mValue );
         }
@@ -463 +463 @@
 {
         if ( m_scene == nullptr || m_mesh_count == 0 ) return nullptr;
-        const aiScene* scene = (const aiScene*)m_scene;
+        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
         bool has_bones = false;
         mesh_data* meshes = new mesh_data[ m_mesh_count ];
@@ -481 +481 @@
 {
         if ( m_scene == nullptr ) return 0;
-        const aiScene* scene = (const aiScene*)m_scene;
+        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
         return scene->mNumAnimations;   
 }

trunk/src/formats/md2_loader.cc

@@ -192 +192 @@
         //      return vec3( v[0], v[1], v[2] );
         return vec3( v[0], v[2], v[1] );
-}
-
-static inline vec3 md2_normal( uint8 normal )
-{
-        return md2_vec3( md2_normal_table[normal] );
 }
 
@@ -220 +215 @@
 md2_loader::~md2_loader()
 {
-        if (m_md2 != nullptr)
-        {
-                free_md2( (md2_t*)(m_md2) );
-                delete (md2_t*)m_md2;
+        md2_t* md2 = reinterpret_cast< md2_t* >( m_md2 );
+        if ( md2 != nullptr)
+        {
+                free_md2( md2 );
+                delete md2;
         }
 }
@@ -229 +225 @@
 bool md2_loader::load( stream& source )
 {
-        m_md2 = (void*)(new md2_t);
-        if ( !read_md2( (md2_t*)m_md2, source ) )
+        md2_t* md2 = new md2_t; 
+        m_md2 = md2;
+        if ( !read_md2( md2, source ) )
         {
                 return false;
@@ -240 +237 @@
 nv::size_t md2_loader::get_max_frames() const
 {
-        return static_cast< size_t >( ((md2_t*)m_md2)->header.num_frames );
+        return static_cast<size_t>( reinterpret_cast<md2_t*>( m_md2 )->header.num_frames );
 }
 
 void nv::md2_loader::reindex()
 {
-        md2_t* md2 = (md2_t*)m_md2;
+        md2_t* md2 = reinterpret_cast< md2_t* >( m_md2 );
         uint32 num_indexes = static_cast< uint32 >( md2->header.num_tris * 3 );
 
@@ -321 +318 @@
 void nv::md2_loader::release_mesh_frame( mesh_data* data, sint32 frame )
 {
-        md2_t* md2 = (md2_t*)m_md2;
+        md2_t* md2 = reinterpret_cast< md2_t* >( m_md2 );
         size_t num_frames = static_cast< size_t >( md2->header.num_frames );
         size_t num_verts  =     m_new_vindexes.size();
@@ -328 +325 @@
 
         mesh_raw_channel* mc_pn = mesh_raw_channel::create< vtx_md2_pn >( num_verts * frame_count );
-        vtx_md2_pn* vtx_pn = (vtx_md2_pn*)mc_pn->data;
+        vtx_md2_pn* vtx_pn = reinterpret_cast< vtx_md2_pn* >( mc_pn->data );
 
         uint32 index = 0;
@@ -351 +348 @@
 
         mesh_raw_channel* mc_t = mesh_raw_channel::create< vtx_md2_t >( num_verts );
-        vtx_md2_t* vtx_t = (vtx_md2_t*)mc_t->data;
-
-        vec2 scale( 1.0f / (float) md2->header.skinwidth, 1.0f / (float) md2->header.skinheight );
+        vtx_md2_t* vtx_t = reinterpret_cast< vtx_md2_t* >( mc_t->data );
+
+        vec2 scale( 1.0f / static_cast<float>( md2->header.skinwidth ), 1.0f / static_cast<float>( md2->header.skinheight ) );
         for (size_t i = 0; i < num_verts; ++i )
         {
@@ -363 +360 @@
         if ( m_new_indexes.size() > 0 )
         {
-                uint16* icp = (uint16*)ic->data;
+                uint16* icp = reinterpret_cast< uint16* >( ic->data );
                 raw_copy_n( m_new_indexes.data(), m_new_indexes.size(), icp );
         }

trunk/src/formats/md3_loader.cc

@@ -267 +267 @@
 nv::md3_loader::~md3_loader()
 {
-        if (m_md3 != nullptr)
-        {
-                free_md3( (md3_t*)(m_md3) );
-                delete (md3_t*)m_md3;
+        md3_t* md3 = reinterpret_cast< md3_t* >( m_md3 );
+        if ( md3 != nullptr )
+        {
+                free_md3( md3 );
+                delete md3;
         }
 }
@@ -276 +277 @@
 bool nv::md3_loader::load( stream& source )
 {
-        m_md3 = (void*)(new md3_t);
-        if ( !read_md3( (md3_t*)m_md3, source ) )
+        md3_t* md3 = new md3_t;
+        m_md3 = md3;
+        if ( !read_md3( md3, source ) )
         {
                 return false;
@@ -286 +288 @@
 nv::key_raw_channel* nv::md3_loader::load_tags( const string_view& tag )
 {
-        md3_t* md3 = (md3_t*)m_md3;
-        key_raw_channel* result = key_raw_channel::create<md3_key>( (uint32)md3->header.num_frames );
+        md3_t* md3 = reinterpret_cast< md3_t* >( m_md3 );
+        key_raw_channel* result = key_raw_channel::create<md3_key>( uint32( md3->header.num_frames ) );
         // TODO: is this brain damaged in efficiency (loop nest order) or what?
         for ( sint32 f = 0; f < md3->header.num_frames; ++f )
@@ -294 +296 @@
                 {
                         const md3_tag_t& rtag = md3->tags[i + md3->header.num_tags * f];
-                        string_view rname((char*)(rtag.name));
+                        string_view rname( reinterpret_cast< const char* >(rtag.name) );
                         if (rname == tag)
                         {
@@ -301 +303 @@
                                 vec3 axisy  ( md3_vec3( rtag.axis[2] ) );
                                 vec3 origin ( md3_vec3( rtag.origin )  );
-                                ((md3_key*)(result->data))[f].tform = transform( origin, quat( mat3( axisx, axisy, axisz ) ) );
+                                reinterpret_cast< md3_key*>(result->data)[f].tform = transform( origin, quat( mat3( axisx, axisy, axisz ) ) );
                         }
                 }
@@ -323 +325 @@
 {
         mesh_data* data = new mesh_data;
-        release_mesh_frame( data, -1, (sint32)index );
+        release_mesh_frame( data, -1, static_cast< sint32 >( index ) );
         return data;
 }
@@ -329 +331 @@
 void nv::md3_loader::release_mesh_frame( mesh_data* data, sint32 frame, sint32 surface )
 {
-        md3_t* md3 = (md3_t*)m_md3;
-        uint32 num_surfaces  = (uint32)md3->header.num_surfaces;
-        uint32 num_verts     = 0;
-        uint32 current_frame = ( frame == -1 ? 0 : (uint32)frame );
-        uint32 frame_count   = ( frame == -1 ? (uint32)md3->header.num_frames : 1 );
-        uint32 current_surf  = ( surface == -1 ? 0 : (uint32)surface );
-        uint32 surf_count    = ( surface == -1 ? (uint32)md3->header.num_surfaces : 1 );
-        uint32 index_count   = 0;
+        md3_t* md3 = reinterpret_cast< md3_t* >( m_md3 );
+        sint32 num_surfaces  = md3->header.num_surfaces;
+        sint32 num_verts     = 0;
+        sint32 current_frame = ( frame == -1 ? 0 : frame );
+        sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
+        sint32 current_surf  = ( surface == -1 ? 0 : surface );
+        sint32 surf_count    = ( surface == -1 ? md3->header.num_surfaces : 1 );
+        sint32 index_count   = 0;
 
         if ( surface >= 0 )
         {
-                index_count = (uint32)md3->surfaces[(uint32)surface].header.num_triangles * 3;
-                num_verts   = (uint32)md3->surfaces[(uint32)surface].header.num_verts;
+                index_count = md3->surfaces[surface].header.num_triangles * 3;
+                num_verts   = md3->surfaces[surface].header.num_verts;
         }
         else
-                for ( uint32 i = 0; i < num_surfaces; ++i )
-                {
-                        index_count += (uint32)md3->surfaces[i].header.num_triangles * 3;
-                        num_verts   += (uint32)md3->surfaces[i].header.num_verts;
-                }
-
-        mesh_raw_channel* mc_pn = mesh_raw_channel::create< vtx_md3_pn >( num_verts * frame_count );
-        mesh_raw_channel* mc_t  = mesh_raw_channel::create< vtx_md3_t >( num_verts );
-        mesh_raw_channel* ic = mesh_raw_channel::create_index< uint16 >( index_count );
-        vtx_md3_pn* vtx_pn = (vtx_md3_pn*)mc_pn->data;
-        vtx_md3_t*  vtx_t  = (vtx_md3_t*) mc_t->data;
-        uint16*     icp    = (uint16*)ic->data;
+                for ( sint32 i = 0; i < num_surfaces; ++i )
+                {
+                        index_count += md3->surfaces[i].header.num_triangles * 3;
+                        num_verts   += md3->surfaces[i].header.num_verts;
+                }
+
+        mesh_raw_channel* mc_pn = mesh_raw_channel::create< vtx_md3_pn >( uint32( num_verts * frame_count ) );
+        mesh_raw_channel* mc_t  = mesh_raw_channel::create< vtx_md3_t >( uint32( num_verts ) );
+        mesh_raw_channel* ic = mesh_raw_channel::create_index< uint16 >( uint32( index_count ) );
+        vtx_md3_pn* vtx_pn = reinterpret_cast< vtx_md3_pn* >( mc_pn->data );
+        vtx_md3_t*  vtx_t  = reinterpret_cast< vtx_md3_t* >( mc_t->data );
+        uint16*     icp    = reinterpret_cast< uint16* >( ic->data );
 
         uint32 index  = 0;
@@ -387 +389 @@
         while ( frame_count > 0 )
         {
-                current_surf  = ( surface == -1 ? 0 : (uint32)surface );
-                surf_count    = ( surface == -1 ? (uint32)md3->header.num_surfaces : 1 );
+                current_surf  = ( surface == -1 ? 0 : surface );
+                surf_count    = ( surface == -1 ? md3->header.num_surfaces : 1 );
 
                 while ( surf_count > 0 )
                 {
                         md3_surface_t& sface  = md3->surfaces[current_surf];
-                        uint32         vcount = (uint32)sface.header.num_verts;
-                        uint32         offset = vcount * current_frame;
-                        uint32         limit  = vcount + offset;
-                        for (uint32 j = offset; j < limit; ++j )
+                        sint32 vcount = sface.header.num_verts;
+                        sint32 offset = vcount * current_frame;
+                        sint32 limit  = vcount + offset;
+                        for ( sint32 j = offset; j < limit; ++j )
                         {
                                 md3_vertex_t& v = sface.vertices[j];
@@ -410 +412 @@
         }
 
-        data->set_name( (char*)md3->header.name );
+        data->set_name( reinterpret_cast< char* >( md3->header.name ) );
         data->add_channel( mc_pn );
         data->add_channel( mc_t );
@@ -418 +420 @@
 mesh_nodes_data* nv::md3_loader::release_mesh_nodes_data( nv::size_t )
 {
-        md3_t* md3 = (md3_t*)m_md3;
-        uint32 node_count = (uint32)md3->header.num_tags;
+        md3_t* md3 = reinterpret_cast< md3_t* >( m_md3 );
+        uint32 node_count = uint32( md3->header.num_tags );
         if ( node_count == 0 ) return nullptr;
         mesh_node_data* nodes = new mesh_node_data[ node_count ];
@@ -425 +427 @@
         {
                 const md3_tag_t& rtag = md3->tags[i];
-                string_view name( (char*)(rtag.name) );
+                string_view name( reinterpret_cast< const char* >(rtag.name) );
 
                 nodes[i].transform = mat4();
@@ -441 +443 @@
 mesh_data_pack* nv::md3_loader::release_mesh_data_pack()
 {
-        md3_t* md3 = (md3_t*)m_md3;
-        uint32 count = 1;
+        md3_t* md3 = reinterpret_cast<md3_t*>( m_md3 );
+        int count = 1;
         mesh_data* data = nullptr;
         if ( m_merge_all )
@@ -448 +450 @@
                 data = new mesh_data[1];
                 release_mesh_frame( &data[0], -1, -1 );
-                data[0].set_name( (char*)md3->header.name );
+                data[0].set_name( reinterpret_cast< char* >( md3->header.name ) );
         }
         else
         {
-                count = (uint32)md3->header.num_surfaces;
+                count = md3->header.num_surfaces;
                 data = new mesh_data[ count ];
-                for ( uint32 i = 0; i < count; ++i )
-                {
-                        release_mesh_frame( &data[i], -1, (sint32)i );
-                        data[i].set_name( (char*)md3->surfaces[i].header.name );
-                }
-        }
-        return new mesh_data_pack( count, data, release_mesh_nodes_data() );
+                for ( int i = 0; i < count; ++i )
+                {
+                        release_mesh_frame( &data[i], -1, i );
+                        data[i].set_name( reinterpret_cast< char* >( md3->surfaces[i].header.name ) );
+                }
+        }
+        return new mesh_data_pack( uint32( count ), data, release_mesh_nodes_data() );
 }
 
 nv::size_t md3_loader::get_max_frames() const
 {
-        return static_cast< size_t >( ((md3_t*)m_md3)->header.num_frames );
-}
+        return static_cast<size_t>( reinterpret_cast<md3_t*>( m_md3 )->header.num_frames );
+}

trunk/src/formats/md5_loader.cc

@@ -162 +162 @@
                                                 mesh_raw_channel* ch_t   = mesh_raw_channel::create<md5_vtx_t>( num_verts );
                                                 mesh_raw_channel* ch_pntiw = mesh_raw_channel::create<md5_vtx_pntiw>( num_verts );
-                                                tdata = (md5_vtx_t*)ch_t->data;
+                                                tdata = reinterpret_cast< md5_vtx_t* >( ch_t->data );
                                                 mesh->add_channel( ch_pnt );
                                                 mesh->add_channel( ch_t );
@@ -191 +191 @@
 
                                         mesh_raw_channel* ch_i = mesh_raw_channel::create_index<uint32>( num_tris * 3 );
-                                        uint32* vtx_i                = (uint32*)ch_i->data;
+                                        uint32* vtx_i                = reinterpret_cast< uint32* >( ch_i->data );
                                         uint32 idx = 0;
                                         mesh->add_channel( ch_i );
@@ -199 +199 @@
                                         for ( uint32 i = 0; i < num_tris; ++i )
                                         {
-                                                size_t ti0;
-                                                size_t ti1;
-                                                size_t ti2;
+                                                unsigned ti0;
+                                                unsigned ti1;
+                                                unsigned ti2;
 
                                                 std::getline( sstream, line );
                                                 sscanf( line.c_str(), "%*s %*u %u %u %u )", &(ti0), &(ti1), &(ti2));
 
-                                                vtx_i[idx++] = (uint32)ti0;
-                                                vtx_i[idx++] = (uint32)ti1;
-                                                vtx_i[idx++] = (uint32)ti2;
+                                                vtx_i[idx++] = ti0;
+                                                vtx_i[idx++] = ti1;
+                                                vtx_i[idx++] = ti2;
                                         }              
                                 }
@@ -244 +244 @@
                         assert( nodes == nullptr );
                         nodes = new mesh_node_data[ num_joints ];
-                        m_nodes = new mesh_nodes_data( "md5_animation", num_joints, nodes, (nv::uint16)frame_rate, (float)num_frames, true );
+                        m_nodes = new mesh_nodes_data( "md5_animation", num_joints, nodes, static_cast< nv::uint16 >( frame_rate ), static_cast< float >( num_frames ), true );
                         joint_infos.resize( num_joints );
 
@@ -318 +318 @@
                         {
                                 sstream >> buf;
-                                frame.push_back((float)atof(buf));
+                                frame.push_back( static_cast< float >( atof(buf) ) );
                         }
 
@@ -336 +336 @@
 {
         assert( m_type == MESH );
-        md5_vtx_pnt* vtcs = (md5_vtx_pnt*)mdata->get_channel< md5_vtx_pnt >()->data; 
-        md5_vtx_pntiw* vtx_data = (md5_vtx_pntiw*)mdata->get_channel< md5_vtx_pntiw >()->data; 
+        md5_vtx_pnt* vtcs       = reinterpret_cast< md5_vtx_pnt* >( mdata->get_channel< md5_vtx_pnt >()->data ); 
+        md5_vtx_pntiw* vtx_data = reinterpret_cast< md5_vtx_pntiw* >( mdata->get_channel< md5_vtx_pntiw >()->data );
 
         for ( uint32 i = 0; i < vtx_count; ++i )
@@ -368 +368 @@
                 }
 
-                for ( size_t j = 0; j < 4; ++j )
-                {
-                        if ( j < weight_count )
-                        {
-                                vdata.boneindex[j]  = (int)weights[start_weight + j].joint_id;
-                                vdata.boneweight[j] = weights[start_weight + j].bias;
+                for ( int j = 0; j < 4; ++j )
+                {
+                        if ( j < int(weight_count) )
+                        {
+                                vdata.boneindex[j]  = int( weights[int(start_weight) + j].joint_id );
+                                vdata.boneweight[j] = weights[int(start_weight) + j].bias;
                         }
                         else
@@ -396 +396 @@
         }
 
-        const uint32*    idata = (uint32*)mdata->get_index_channel()->data;
+        const uint32*    idata = reinterpret_cast< uint32* >( mdata->get_index_channel()->data );
         const md5_vtx_t* tdata = mdata->get_channel_data<md5_vtx_t>();
 
@@ -448 +448 @@
                 vdata.tangent  = vec3(0);
  
-                for ( size_t j = 0; j < 4; ++j )
+                for ( int j = 0; j < 4; ++j )
                 {
                         const mesh_node_data&  joint = nodes[vdata.boneindex[j]];
@@ -484 +484 @@
                 {
                         const mesh_node_data& pjoint = nodes[parent_id];
-                        const transform* ptv = (const transform*)pjoint.data->get_channel(0)->data;
+                        const transform* ptv = reinterpret_cast< const transform* >( pjoint.data->get_channel(0)->data );
                         transform ptr;
                         if ( pjoint.data->get_channel(0)->count > index ) ptr = ptv[ index ];
@@ -495 +495 @@
                 }
 
-                ((transform*)joint.data->get_channel(0)->data)[index] = transform( pos, orient );
+                reinterpret_cast< transform* >( joint.data->get_channel(0)->data )[index] = transform( pos, orient );
         }
 }

trunk/src/formats/nmd_loader.cc

@@ -174 +174 @@
         eheader.type     = nmd_type::MESH;
         eheader.name     = 0;
-        eheader.children = (uint16)data.size();
+        eheader.children = static_cast< uint16 >( data.size() );
         eheader.size     = size;
         stream_out.write( &eheader, sizeof( eheader ), 1 );
@@ -213 +213 @@
         header.name     = 0;
         header.type     = nmd_type::ANIMATION;
-        header.children = (uint16)nodes->get_count();
+        header.children = static_cast< uint16 >( nodes->get_count() );
         header.size     = total;
         stream_out.write( &header, sizeof( header ), 1 );
@@ -237 +237 @@
                 eheader.type     = nmd_type::NODE;
                 eheader.name     = strings->insert( node->name );
-                eheader.children = (uint16)chan_count;
+                eheader.children = static_cast< uint16 >( chan_count );
                 eheader.size     = sizeof( nmd_node_header ) + chan_size;
                 stream_out.write( &eheader, sizeof( eheader ), 1 );

trunk/src/formats/obj_loader.cc

@@ -207 +207 @@
         virtual void reset() { m_data.clear(); }
         virtual nv::size_t raw_size() const { return m_data.size() * sizeof( VTX ); }
-        virtual const uint8* raw_pointer() const { return (const uint8*)m_data.data(); }
+        virtual const uint8* raw_pointer() const { return reinterpret_cast< const uint8* >( m_data.data() ); }
 };
 

trunk/src/gfx/image.cc

@@ -46 +46 @@
 void image::fill( uint8 value )
 {
-        raw_fill( m_data, m_data + m_size.x * m_size.y * (int)m_depth, value );
+        raw_fill( m_data, m_data + m_size.x * m_size.y * static_cast<int>( m_depth ), value );
 }
 

trunk/src/gfx/keyframed_mesh.cc

@@ -71 +71 @@
         if ( m_active )
         {
-                float tick_time = ( (float)a_anim_time * 0.001f ) * anim->get_frame_rate();
+                float tick_time = ( static_cast<float>( a_anim_time ) * 0.001f ) * anim->get_frame_rate();
                 float duration  = anim->is_looping() ? anim->get_duration() + 1.0f : anim->get_duration();
                 if ( tick_time >= duration )
@@ -82 +82 @@
                         {
                                 m_active     = false;
-                                m_last_frame = (uint32)anim->get_end();
+                                m_last_frame = static_cast<uint32>( anim->get_end() );
                                 m_next_frame = m_last_frame;
                                 m_interpolation = 0.0f;
@@ -88 +88 @@
                         }
                 }
-                m_last_frame    = (uint32)( glm::floor( tick_time ) + anim->get_start() );
+                m_last_frame    = static_cast<uint32>( glm::floor( tick_time ) + anim->get_start() );
                 m_next_frame    = m_last_frame + 1;
-                if ( m_next_frame > (uint32)anim->get_end() ) m_next_frame = (uint32)anim->get_start();
+                if ( m_next_frame > static_cast<uint32>( anim->get_end() ) ) m_next_frame = static_cast<uint32>( anim->get_start() );
                 m_interpolation = tick_time - glm::floor( tick_time );
         }
@@ -152 +152 @@
         {
                 uint32 base_offset = m_next_frame * m_vertex_count * m_vsize; 
-                m_context->update_attribute_offset( m_va, (slot)m_loc_next_position, base_offset );
-                m_context->update_attribute_offset( m_va, (slot)m_loc_next_normal, base_offset + sizeof( vec3 ) );
+                m_context->update_attribute_offset( m_va, static_cast<slot>( m_loc_next_position ), base_offset );
+                m_context->update_attribute_offset( m_va, static_cast<slot>( m_loc_next_normal ), base_offset + sizeof( vec3 ) );
                 if ( m_has_tangent && m_loc_next_tangent != -1 )
                 {
-                        m_context->update_attribute_offset( m_va, (slot)m_loc_next_tangent, base_offset + 2*sizeof( vec3 ) );
+                        m_context->update_attribute_offset( m_va, static_cast<slot>( m_loc_next_tangent ), base_offset + 2*sizeof( vec3 ) );
                 }
                 m_gpu_next_frame = m_next_frame;
@@ -172 +172 @@
                         m_loc_next_tangent  = dev->get_attribute_location( a_program, "nv_next_tangent" );
 
-                m_context->add_vertex_buffer( m_va, (slot)m_loc_next_position, m_pbuffer, FLOAT, 3, 0, m_vsize, false );
-                m_context->add_vertex_buffer( m_va, (slot)m_loc_next_normal,   m_pbuffer, FLOAT, 3, sizeof( vec3 ), m_vsize, false );
+                m_context->add_vertex_buffer( m_va, static_cast<slot>( m_loc_next_position ), m_pbuffer, FLOAT, 3, 0, m_vsize, false );
+                m_context->add_vertex_buffer( m_va, static_cast<slot>( m_loc_next_normal ),   m_pbuffer, FLOAT, 3, sizeof( vec3 ), m_vsize, false );
                 if ( m_has_tangent )
-                        m_context->add_vertex_buffer( m_va, (slot)m_loc_next_tangent, m_pbuffer, FLOAT, 4, 2*sizeof( vec3 ), m_vsize, false );
+                        m_context->add_vertex_buffer( m_va, static_cast<slot>( m_loc_next_tangent ), m_pbuffer, FLOAT, 4, 2*sizeof( vec3 ), m_vsize, false );
         }
         keyframed_mesh::update( a_program );
@@ -184 +184 @@
 {
         m_va      = m_context->create_vertex_array();
-        m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, (void*)m_vchannel->data );
+        m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, m_vchannel->data );
         m_context->add_vertex_buffers( m_va, m_pbuffer, m_vchannel );
 
-        buffer  vb = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * sizeof( vec2 ), (void*)m_mesh_data->get_channel<vertex_t>()->data );
+        buffer  vb = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * sizeof( vec2 ), m_mesh_data->get_channel<vertex_t>()->data );
         m_context->add_vertex_buffers( m_va, vb, m_mesh_data->get_channel<vertex_t>() );
 
-        buffer  ib = m_context->get_device()->create_buffer( INDEX_BUFFER, STATIC_DRAW, m_mesh_data->get_index_channel()->size(), (void*)m_mesh_data->get_index_channel()->data );
+        buffer  ib = m_context->get_device()->create_buffer( INDEX_BUFFER, STATIC_DRAW, m_mesh_data->get_index_channel()->size(), m_mesh_data->get_index_channel()->data );
 
         m_context->set_index_buffer( m_va, ib, m_mesh_data->get_index_channel()->desc.slots[0].etype, true );
@@ -206 +206 @@
                 const vertex_pnt* prev = data + m_vertex_count * m_last_frame;
                 const vertex_pnt* next = data + m_vertex_count * m_next_frame;
-                      vertex_pnt* vtx  = (vertex_pnt*)m_data;
+                      vertex_pnt* vtx  = reinterpret_cast<vertex_pnt*>( m_data );
                 for ( size_t i = 0; i < m_vertex_count; ++i )
                 {
@@ -219 +219 @@
                 const vertex_pn* prev = data + m_vertex_count * m_last_frame;
                 const vertex_pn* next = data + m_vertex_count * m_next_frame;
-                      vertex_pn* vtx  = (vertex_pn*)m_data;
+                      vertex_pn* vtx  = reinterpret_cast<vertex_pn*>( m_data );
 
                 for ( size_t i = 0; i < m_vertex_count; ++i )

trunk/src/gfx/mesh_creator.cc

@@ -24 +24 @@
                 if ( pkeys && pkeys->get_channel_count() > 0 && keys && keys->get_channel_count() > 0 )
                 {
-                        nv_key_transform*  channel = ((nv_key_transform*)(keys->get_channel(0)->data));
-                        nv_key_transform* pchannel = ((nv_key_transform*)(pkeys->get_channel(0)->data));
+                        nv_key_transform*  channel = reinterpret_cast<nv_key_transform*>(keys->get_channel(0)->data);
+                        nv_key_transform* pchannel = reinterpret_cast<nv_key_transform*>(pkeys->get_channel(0)->data);
                         for ( unsigned n = 0; n < count; ++n )
                         {
@@ -37 +37 @@
         {
                 m_data->m_frame_rate = 32;
-                m_data->m_duration   = (float)max_frames;
+                m_data->m_duration   = static_cast<float>( max_frames );
         }
 
@@ -69 +69 @@
                         key_data* new_keys = new key_data;
                         new_keys->add_channel( raw_channel );
-                        nv_key_transform* channel = ((nv_key_transform*)(raw_channel->data));
+                        nv_key_transform* channel = reinterpret_cast<nv_key_transform*>(raw_channel->data);
                         key_descriptor final_key = old_keys->get_final_key();
 
@@ -110 +110 @@
                                 for ( size_t n = 0; n < channel->count; ++n )
                                 {
-                                        transform_key_raw( channel->desc, (uint8*)(channel->data + n * key_size), scale, r33, ri33 );
+                                        transform_key_raw( channel->desc, channel->data + n * key_size, scale, r33, ri33 );
                                 }
                         }
@@ -135 +135 @@
                         switch ( desc.slots[i].vslot )
                         {
-                                case slot::POSITION : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) p_offset = (int)desc.slots[i].offset; break;
-                                case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) n_offset = (int)desc.slots[i].offset; break;
-                                case slot::TANGENT  : if ( desc.slots[i].etype == FLOAT_VECTOR_4 ) t_offset = (int)desc.slots[i].offset; break;
+                                case slot::POSITION : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) p_offset = int(desc.slots[i].offset); break;
+                                case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) n_offset = int(desc.slots[i].offset); break;
+                                case slot::TANGENT  : if ( desc.slots[i].etype == FLOAT_VECTOR_4 ) t_offset = int(desc.slots[i].offset); break;
                                 default             : break;
                         }
@@ -144 +144 @@
                         for ( uint32 i = 0; i < channel->count; i++)
                         {
-                                vec3& p = *((vec3*)(raw_data + vtx_size*i + p_offset ));
+                                vec3& p = *reinterpret_cast<vec3*>( raw_data + vtx_size*i + p_offset );
                                 p = vertex_transform * p + vertex_offset;
                         }
@@ -151 +151 @@
                         for ( uint32 i = 0; i < channel->count; i++)
                         {
-                                vec3& n = *((vec3*)(raw_data + vtx_size*i + n_offset ));
+                                vec3& n = *reinterpret_cast<vec3*>( raw_data + vtx_size*i + n_offset );
                                 n = glm::normalize( normal_transform * n );
                         }
@@ -157 +157 @@
                         for ( uint32 i = 0; i < channel->count; i++)
                         {
-                                vec4& t = *((vec4*)(raw_data + vtx_size*i + t_offset ));
+                                vec4& t = *reinterpret_cast<vec4*>(raw_data + vtx_size*i + t_offset );
                                 t = vec4( glm::normalize( normal_transform * vec3(t) ), t[3] );
                         }
@@ -173 +173 @@
         size_t n_offset = 0;
         if ( ch_n == -1 ) return;
-        mesh_raw_channel* channel = m_data->m_channels[ (unsigned) ch_n ];
+        mesh_raw_channel* channel = m_data->m_channels[ unsigned( ch_n ) ];
         for ( uint32 i = 0; i < channel->desc.count; ++i )
                 if ( channel->desc.slots[i].vslot == slot::NORMAL )
@@ -182 +182 @@
         for ( uint32 i = 0; i < channel->count; ++i )
         {
-                vec3& normal = *(vec3*)(channel->data + channel->desc.size * i + n_offset);
+                vec3& normal = *reinterpret_cast<vec3*>( channel->data + channel->desc.size * i + n_offset );
                 normal = -normal;
         }
@@ -211 +211 @@
                                 if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) 
                                 {
-                                        p_offset  = (int)desc.slots[i].offset; 
+                                        p_offset  = int( desc.slots[i].offset );
                                         p_channel = channel;
                                 }
@@ -217 +217 @@
                         case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) 
                                 {
-                                        n_offset  = (int)desc.slots[i].offset; 
+                                        n_offset  = int( desc.slots[i].offset );
                                         n_channel = m_data->m_channels[ c ];
                                         n_channel_index = c;
@@ -224 +224 @@
                         case slot::TEXCOORD : if ( desc.slots[i].etype == FLOAT_VECTOR_2 ) 
                                 {
-                                        t_offset  = (int)desc.slots[i].offset; 
+                                        t_offset  = int( desc.slots[i].offset );
                                         t_channel = channel;
                                 }
@@ -246 +246 @@
 
         mesh_raw_channel* g_channel = mesh_raw_channel::create<vertex_g>( p_channel->count );
-        vec4* tangents              = (vec4*)g_channel->data;
+        vec4* tangents              = reinterpret_cast<vec4*>( g_channel->data );
         vec3* tangents2             = new vec3[ p_channel->count ];
         uint32 tri_count = i_channel ? i_channel->count / 3 : t_channel->count / 3;
@@ -259 +259 @@
                 if ( i_type == UINT )
                 {
-                        const uint32* idata = (const uint32*)i_channel->data;
+                        const uint32* idata = reinterpret_cast<const uint32*>( i_channel->data );
                         ti0 = idata[ i * 3 ];
                         ti1 = idata[ i * 3 + 1 ];
@@ -266 +266 @@
                 else if ( i_type == USHORT )
                 {
-                        const uint16* idata = (const uint16*)i_channel->data;
+                        const uint16* idata = reinterpret_cast<const uint16*>( i_channel->data );
                         ti0 = idata[ i * 3 ];
                         ti1 = idata[ i * 3 + 1 ];
@@ -278 +278 @@
                 }
 
-                const vec2& w1 = *((vec2*)(t_channel->data + t_channel->desc.size*ti0 + t_offset ));
-                const vec2& w2 = *((vec2*)(t_channel->data + t_channel->desc.size*ti1 + t_offset ));
-                const vec2& w3 = *((vec2*)(t_channel->data + t_channel->desc.size*ti2 + t_offset ));
+                const vec2& w1 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.size*ti0 + t_offset );
+                const vec2& w2 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.size*ti1 + t_offset );
+                const vec2& w3 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.size*ti2 + t_offset );
                 vec2 st1 = w3 - w1;
                 vec2 st2 = w2 - w1;
@@ -291 +291 @@
                         uint32 nti1 = t_channel->count * set + ti1;
                         uint32 nti2 = t_channel->count * set + ti2;
-                        vec3 v1 = *((vec3*)(p_channel->data + p_channel->desc.size*nti0 + p_offset ));
-                        vec3 v2 = *((vec3*)(p_channel->data + p_channel->desc.size*nti1 + p_offset ));
-                        vec3 v3 = *((vec3*)(p_channel->data + p_channel->desc.size*nti2 + p_offset ));
+                        vec3 v1 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.size*nti0 + p_offset );
+                        vec3 v2 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.size*nti1 + p_offset );
+                        vec3 v3 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.size*nti2 + p_offset );
                         vec3 xyz1 = v3 - v1;
                         vec3 xyz2 = v2 - v1;
@@ -317 +317 @@
         for ( unsigned int i = 0; i < vtx_count; ++i )
         {
-                const vec3 n = *((vec3*)(n_channel->data + n_channel->desc.size*i + n_offset ));
+                const vec3 n = *reinterpret_cast<vec3*>( n_channel->data + n_channel->desc.size*i + n_offset );
                 const vec3 t = vec3(tangents[i]);
                 if ( ! ( t.x == 0.0f && t.y == 0.0f && t.z == 0.0f ) )
@@ -420 +420 @@
         int och_ti = other->get_channel_index( slot::TEXCOORD );
         if ( ch_pi == -1 || ch_ti == -1 ) return;
-        size_t size   = m_data->m_channels[ (unsigned)ch_ti ]->count;
-        size_t osize  =  other->m_channels[ (unsigned)och_ti ]->count;
-        size_t count  = m_data->m_channels[ (unsigned)ch_pi ]->count;
-        size_t ocount =  other->m_channels[ (unsigned)och_pi ]->count;
+        size_t size   = m_data->m_channels[ unsigned(ch_ti) ]->count;
+        size_t osize  =  other->m_channels[ unsigned(och_ti) ]->count;
+        size_t count  = m_data->m_channels[ unsigned(ch_pi) ]->count;
+        size_t ocount =  other->m_channels[ unsigned(och_pi) ]->count;
         if ( count % size != 0 || ocount % osize != 0 ) return;
         if ( count / size != ocount / osize ) return;
@@ -440 +440 @@
                                 {
                                         NV_ASSERT( size + osize < uint16(-1), "Index out of range!" );
-                                        uint16* indexes = (uint16*)m_data->m_channels[c]->data;
-                                        for ( uint16 i = (uint16)old->count; i < m_data->m_channels[c]->count; ++i )
-                                                indexes[i] += (uint16)size;
+                                        uint16* indexes = reinterpret_cast<uint16*>( m_data->m_channels[c]->data );
+                                        for ( uint16 i = uint16( old->count ); i < m_data->m_channels[c]->count; ++i )
+                                                indexes[i] += uint16( size );
 
                                 }
@@ -448 +448 @@
                         case UINT   : 
                                 {
-                                        uint32* indexes = (uint32*)m_data->m_channels[c]->data;
+                                        uint32* indexes = reinterpret_cast<uint32*>( m_data->m_channels[c]->data );
                                         for ( uint32 i = old->count; i < m_data->m_channels[c]->count; ++i )
                                                 indexes[i] += size;

trunk/src/gfx/skeletal_mesh.cc

@@ -16 +16 @@
 {
         const mesh_raw_channel* pnt_chan = a_mesh_data->get_channel<md5_vtx_pnt>();
-        m_pntdata.assign( (const md5_vtx_pnt*)pnt_chan->data, pnt_chan->count );
+        m_pntdata.assign( reinterpret_cast<const md5_vtx_pnt*>( pnt_chan->data ), pnt_chan->count );
         m_bone_offset.resize( bones->get_count() );
         m_transform.resize( bones->get_count() );
@@ -35 +35 @@
         if ( a_anim )
         {
-                skeletal_animation_entry_cpu * anim = (skeletal_animation_entry_cpu*)a_anim;
-                anim->update_skeleton( m_transform.data(), (float)a_anim_time );
+                skeletal_animation_entry_cpu * anim = static_cast<skeletal_animation_entry_cpu*>( a_anim );
+                anim->update_skeleton( m_transform.data(), static_cast<float>( a_anim_time ) );
                 {
                         size_t skeleton_size = m_bone_offset.size();
@@ -51 +51 @@
                                 const md5_vtx_pntiw& vert = m_vtx_data[i];
 
-                                for ( size_t j = 0; j < 4; ++j )
+                                for ( int j = 0; j < 4; ++j )
                                 {
-                                        unsigned index = (unsigned)vert.boneindex[j];
+                                        unsigned index = unsigned( vert.boneindex[j] );
                                         float weight   = vert.boneweight[j];
                                         const quat& orient      = m_transform[index].get_orientation();
@@ -71 +71 @@
 void nv::skeletal_animation_entry_cpu::update_skeleton( transform* skeleton, float time ) const
 {
-        float frame_duration = 1000.f / (float)m_node_data->get_frame_rate();
+        float frame_duration = 1000.f / static_cast<float>( m_node_data->get_frame_rate() );
         float anim_duration = frame_duration * m_node_data->get_duration();
         float new_time = fmodf( time, anim_duration ) * 0.001f;
@@ -152 +152 @@
                 if ( bi != bone_names.end() )
                 {
-                        bone_id = (sint16)bi->second;
+                        bone_id = sint16( bi->second );
                 }
                 m_bone_ids[n] = bone_id;
@@ -207 +207 @@
         if ( m_bone_data && a_anim )
         {
-                skeletal_animation_entry_gpu * anim = (skeletal_animation_entry_gpu*)a_anim;
+                skeletal_animation_entry_gpu * anim = static_cast<skeletal_animation_entry_gpu*>( a_anim );
                 anim->prepare( m_bone_data );
                 anim->update_skeleton( m_transform, a_anim_time );

trunk/src/gl/gl_context.cc

@@ -91 +91 @@
         // TODO: support GL_READ_FRAMEBUFFER?
         const gl_framebuffer_info* info  = m_framebuffers.get( f );
-        const gl_texture_info*     tinfo = (gl_texture_info*)m_device->get_texture_info( t );
+        const gl_texture_info*     tinfo = static_cast< const gl_texture_info* >( m_device->get_texture_info( t ) );
         if ( info )
         {
@@ -101 +101 @@
                         //              if ( tinfo->size.y == 0 )
                                 //                      glFramebufferTexture1D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+(unsigned)slot, GL_TEXTURE_1D, tinfo->glid, 0 );
-                        glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+(unsigned)slot, gl_type, tinfo->glid, 0 );
+                        glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+unsigned( slot ), gl_type, tinfo->glid, 0 );
                 }
                 else
                 {
-                        glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+(unsigned)slot, gl_type, 0, 0 );
+                        glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+unsigned( slot ), gl_type, 0, 0 );
                 }
 
@@ -116 +116 @@
         // TODO: support GL_READ_FRAMEBUFFER?
         const gl_framebuffer_info* info  = m_framebuffers.get( f );
-        const gl_texture_info*     tinfo = (gl_texture_info*)m_device->get_texture_info( depth );
+        const gl_texture_info*     tinfo = static_cast< const gl_texture_info* >( m_device->get_texture_info( depth ) );
         if ( info )
         {
@@ -213 +213 @@
 void nv::gl_context::bind( program p )
 {
-        gl_program_info* info = ((gl_device*)m_device)->m_programs.get( p );
+        gl_device* gdevice    = static_cast<gl_device*>( m_device );
+        gl_program_info* info = gdevice->m_programs.get( p );
         if ( info )
         {
                 glUseProgram( info->glid );
-                ((gl_device*)m_device)->update_uniforms( info );
+                gdevice->update_uniforms( info );
         }
 }
@@ -248 +249 @@
                         }
 
-                        glVertexAttribPointer( 
-                                location, 
-                                static_cast<GLint>( vba.components ), 
+                        glVertexAttribPointer(
+                                location,
+                                static_cast<GLint>( vba.components ),
                                 nv::datatype_to_gl_enum( vba.dtype ),
                                 GL_FALSE,
                                 static_cast<GLsizei>( vba.stride ),
-                                (void*)vba.offset
+                                reinterpret_cast<void*>( vba.offset )
                                 );
                 }
@@ -317 +318 @@
 }
 
-void nv::gl_context::update( texture t, void* data )
+void nv::gl_context::update( texture t, const void* data )
 {
         const gl_texture_info* info = static_cast< const gl_texture_info* >( m_device->get_texture_info( t ) );
@@ -327 +328 @@
 
                 glBindTexture( gl_type, info->glid );
-                glTexImage2D( gl_type, 0, (GLint)nv::image_format_to_internal_enum(format.format), size.x, size.y, 0, nv::image_format_to_enum(format.format), nv::datatype_to_gl_enum(format.type), data );
+                glTexImage2D( gl_type, 0, static_cast<GLint>( nv::image_format_to_internal_enum(format.format) ), size.x, size.y, 0, nv::image_format_to_enum(format.format), nv::datatype_to_gl_enum(format.type), data );
         }
 }
@@ -338 +339 @@
                 GLenum glenum = buffer_type_to_enum( info->type );
                 glBindBuffer( glenum, info->glid );
-                glBufferSubData( glenum, (GLintptr)offset, (GLsizeiptr)size, data );
+                glBufferSubData( glenum, GLintptr( offset ), GLsizeiptr( size ), data );
         }
 }
@@ -700 +701 @@
 void nv::gl_context::apply_engine_uniforms( program p, const scene_state& s )
 {
-        gl_program_info* info = ((gl_device*)m_device)->m_programs.get( p );
+        gl_program_info* info = static_cast<gl_device*>( m_device )->m_programs.get( p );
         if ( info )
         {
@@ -725 +726 @@
                 if ( slots[i] > OUTPUT_7 ) buffers[i] = 0;
         }
-        glDrawBuffers( (GLsizei)count, buffers );
+        glDrawBuffers( GLsizei( count ), buffers );
 }
 

trunk/src/gl/gl_device.cc

@@ -53 +53 @@
         assert( image->format->BytesPerPixel > 2 );
         image_format format(image->format->BytesPerPixel == 3 ? RGB : RGBA, UBYTE );
-        image_data* data = new image_data( format, ivec2( image->w, image->h ), (nv::uint8*)image->pixels );
+        image_data* data = new image_data( format, ivec2( image->w, image->h ), static_cast<nv::uint8*>( image->pixels ) );
         return data;
 }
@@ -62 +62 @@
 {
         load_sdl_image_library();
-        SDL_Surface* image = IMG_LoadTyped_RW( SDL_RWFromMem( (void*)data, (int)size ), 1, "png" );
+        SDL_Surface* image = IMG_LoadTyped_RW( SDL_RWFromMem( const_cast<uint8*>( data ), int( size ) ), 1, "png" );
         if ( !image )
         {
@@ -71 +71 @@
         assert( image->format->BytesPerPixel > 2 );
         image_format format( image->format->BytesPerPixel == 3 ? RGB : RGBA, UBYTE );
-        image_data* idata = new image_data( format, ivec2( image->w, image->h ), ( nv::uint8* )image->pixels );
+        image_data* idata = new image_data( format, ivec2( image->w, image->h ), static_cast<nv::uint8*>( image->pixels ) );
         return idata;
 }
@@ -86 +86 @@
 }
 
-nv::texture nv::gl_device::create_texture( texture_type type, ivec2 size, image_format aformat, sampler asampler, void* data /*= nullptr */ )
+nv::texture nv::gl_device::create_texture( texture_type type, ivec2 size, image_format aformat, sampler asampler, const void* data /*= nullptr */ )
 {
         unsigned glid = 0;
@@ -106 +106 @@
         }
 
-        glTexParameteri( gl_type, GL_TEXTURE_MIN_FILTER, (int)nv::sampler_filter_to_enum( asampler.filter_min ) );
-        glTexParameteri( gl_type, GL_TEXTURE_MAG_FILTER, (int)nv::sampler_filter_to_enum( asampler.filter_max ) );
-        glTexParameteri( gl_type, GL_TEXTURE_WRAP_S, (int)nv::sampler_wrap_to_enum( asampler.wrap_s) );
-        glTexParameteri( gl_type, GL_TEXTURE_WRAP_T, (int)nv::sampler_wrap_to_enum( asampler.wrap_t) );
-
-        glTexImage2D( gl_type, 0, (GLint)nv::image_format_to_internal_enum(aformat.format), size.x, size.y, 0, nv::image_format_to_enum(aformat.format), nv::datatype_to_gl_enum(aformat.type), data );
+        glTexParameteri( gl_type, GL_TEXTURE_MIN_FILTER, GLint( nv::sampler_filter_to_enum( asampler.filter_min ) ) );
+        glTexParameteri( gl_type, GL_TEXTURE_MAG_FILTER, GLint( nv::sampler_filter_to_enum( asampler.filter_max ) ) );
+        glTexParameteri( gl_type, GL_TEXTURE_WRAP_S, GLint( nv::sampler_wrap_to_enum( asampler.wrap_s) ) );
+        glTexParameteri( gl_type, GL_TEXTURE_WRAP_T, GLint( nv::sampler_wrap_to_enum( asampler.wrap_t) ) );
+
+        glTexImage2D( gl_type, 0, GLint( nv::image_format_to_internal_enum(aformat.format) ), size.x, size.y, 0, nv::image_format_to_enum(aformat.format), nv::datatype_to_gl_enum(aformat.type), data );
 
         glBindTexture( gl_type, 0 );
@@ -163 +163 @@
 
         glBindBuffer( glenum, glid );
-        glBufferData( glenum, (GLsizeiptr)size, source, buffer_hint_to_enum( hint ) );
+        glBufferData( glenum, GLsizeiptr( size ), source, buffer_hint_to_enum( hint ) );
         glBindBuffer( glenum, 0 );
 
@@ -325 +325 @@
                         switch( ubase->get_type() )
                         {
-                        case FLOAT          : glUniform1fv( uloc, ubase->get_length(), ((uniform< enum_to_type< FLOAT >::type >*)( ubase ))->get_value() ); break;
-                        case INT            : glUniform1iv( uloc, ubase->get_length(), ((uniform< enum_to_type< INT >::type >*)( ubase ))->get_value() ); break;
-                        case FLOAT_VECTOR_2 : glUniform2fv( uloc, ubase->get_length(), (GLfloat*)((uniform< enum_to_type< FLOAT_VECTOR_2 >::type >*)( ubase ))->get_value()); break;
-                        case FLOAT_VECTOR_3 : glUniform3fv( uloc, ubase->get_length(), (GLfloat*)((uniform< enum_to_type< FLOAT_VECTOR_3 >::type >*)( ubase ))->get_value()); break;
-                        case FLOAT_VECTOR_4 : glUniform4fv( uloc, ubase->get_length(), (GLfloat*)((uniform< enum_to_type< FLOAT_VECTOR_4 >::type >*)( ubase ))->get_value()); break;
-                        case INT_VECTOR_2   : glUniform2iv( uloc, ubase->get_length(), (GLint*)((uniform< enum_to_type< INT_VECTOR_2 >::type >*)( ubase ))->get_value()); break;
-                        case INT_VECTOR_3   : glUniform3iv( uloc, ubase->get_length(), (GLint*)((uniform< enum_to_type< INT_VECTOR_3 >::type >*)( ubase ))->get_value()); break;
-                        case INT_VECTOR_4   : glUniform4iv( uloc, ubase->get_length(), (GLint*)((uniform< enum_to_type< INT_VECTOR_4 >::type >*)( ubase ))->get_value()); break;
-                        case FLOAT_MATRIX_2 : glUniformMatrix2fv( uloc, ubase->get_length(), GL_FALSE, (GLfloat*)((uniform< enum_to_type< FLOAT_MATRIX_2 >::type >*)( ubase ))->get_value()); break;
-                        case FLOAT_MATRIX_3 : glUniformMatrix3fv( uloc, ubase->get_length(), GL_FALSE, (GLfloat*)((uniform< enum_to_type< FLOAT_MATRIX_3 >::type >*)( ubase ))->get_value()); break;
-                        case FLOAT_MATRIX_4 : glUniformMatrix4fv( uloc, ubase->get_length(), GL_FALSE, (GLfloat*)((uniform< enum_to_type< FLOAT_MATRIX_4 >::type >*)( ubase ))->get_value()); break;
+                        case FLOAT          : glUniform1fv( uloc, ubase->get_length(), static_cast< uniform< enum_to_type< FLOAT >::type >*>( ubase )->get_value() ); break;
+                        case INT            : glUniform1iv( uloc, ubase->get_length(), static_cast< uniform< enum_to_type< INT >::type >*>( ubase )->get_value() ); break;
+                        case FLOAT_VECTOR_2 : glUniform2fv( uloc, ubase->get_length(), reinterpret_cast<const GLfloat*>( static_cast< uniform< enum_to_type< FLOAT_VECTOR_2 >::type >*>( ubase )->get_value())); break;
+                        case FLOAT_VECTOR_3 : glUniform3fv( uloc, ubase->get_length(), reinterpret_cast<const GLfloat*>( static_cast< uniform< enum_to_type< FLOAT_VECTOR_3 >::type >*>( ubase )->get_value())); break;
+                        case FLOAT_VECTOR_4 : glUniform4fv( uloc, ubase->get_length(), reinterpret_cast<const GLfloat*>( static_cast< uniform< enum_to_type< FLOAT_VECTOR_4 >::type >*>( ubase )->get_value())); break;
+                        case INT_VECTOR_2   : glUniform2iv( uloc, ubase->get_length(), reinterpret_cast<const GLint*>( static_cast< uniform< enum_to_type< INT_VECTOR_2 >::type >*>( ubase )->get_value())); break;
+                        case INT_VECTOR_3   : glUniform3iv( uloc, ubase->get_length(), reinterpret_cast<const GLint*>( static_cast< uniform< enum_to_type< INT_VECTOR_3 >::type >*>( ubase )->get_value())); break;
+                        case INT_VECTOR_4   : glUniform4iv( uloc, ubase->get_length(), reinterpret_cast<const GLint*>( static_cast< uniform< enum_to_type< INT_VECTOR_4 >::type >*>( ubase )->get_value())); break;
+                        case FLOAT_MATRIX_2 : glUniformMatrix2fv( uloc, ubase->get_length(), GL_FALSE, reinterpret_cast<const GLfloat*>( static_cast< uniform< enum_to_type< FLOAT_MATRIX_2 >::type >*>( ubase )->get_value())); break;
+                        case FLOAT_MATRIX_3 : glUniformMatrix3fv( uloc, ubase->get_length(), GL_FALSE, reinterpret_cast<const GLfloat*>( static_cast< uniform< enum_to_type< FLOAT_MATRIX_3 >::type >*>( ubase )->get_value())); break;
+                        case FLOAT_MATRIX_4 : glUniformMatrix4fv( uloc, ubase->get_length(), GL_FALSE, reinterpret_cast<const GLfloat*>( static_cast< uniform< enum_to_type< FLOAT_MATRIX_4 >::type >*>( ubase )->get_value())); break;
                         default : break; // error?
                         }
@@ -348 +348 @@
         glGetProgramiv( p->glid, GL_ACTIVE_ATTRIBUTES, &params );
 
-        for ( unsigned i = 0; i < (unsigned)params; ++i )
+        for ( unsigned i = 0; i < unsigned( params ); ++i )
         {
                 int attr_nlen;
@@ -377 +377 @@
         glGetProgramiv( p->glid, GL_ACTIVE_UNIFORMS, &params );
 
-        for ( unsigned i = 0; i < size_t(params); ++i )
+        for ( unsigned i = 0; i < unsigned( params ); ++i )
         {
                 int uni_nlen;
@@ -412 +412 @@
 
         const char* pc = shader_code.data();
-        int l = (int)shader_code.length();
+        int l = int( shader_code.length() );
 
         glShaderSource( glid, 1, &pc, &l );
@@ -428 +428 @@
                 if ( compile_ok == 0 )
                 {
-                        NV_LOG_ERROR( "Shader #", glid, " error: ", buffer );
+                        NV_LOG_ERROR( "Shader #", glid, " error: ", string_view( buffer, size_t( length ) ) );
                 }
                 else
                 {
-                        NV_LOG_INFO( "Shader #", glid, " compiled successfully: ", buffer );
+                        NV_LOG_INFO( "Shader #", glid, " compiled successfully: ", string_view( buffer, size_t( length ) ) );
                 }
         }

trunk/src/gl/gl_window.cc

@@ -15 +15 @@
 {
 #if NV_PLATFORM == NV_WINDOWS
-                ::SwapBuffers( (HDC)m_hwnd );
+                ::SwapBuffers( reinterpret_cast<HDC>( m_hwnd ) );
 #else
         NV_ASSERT( false, "Native GL context currently only working on Windows!" );
@@ -26 +26 @@
         {
 #if NV_PLATFORM == NV_WINDOWS
-                        dynwglDeleteContext( (HGLRC)m_context->get_native_handle() );
+                        dynwglDeleteContext( reinterpret_cast<HGLRC>( m_context->get_native_handle() ) );
 #endif
         }
@@ -40 +40 @@
         m_input = a_input;
 
-        m_handle = (void*)handle;
+        m_handle = handle;
 
         // TODO: error checking
-        HDC hdc = (HDC)dc;
+        HDC hdc = reinterpret_cast<HDC>( dc );
 
         const int wgl_attrib_list[] =
@@ -103 +103 @@
 //      m_height  = (uint16)rect.bottom;
         m_handle  = wm->adopt_window( handle );
-        m_hwnd    = ::GetDC( (HWND)handle );
+        m_hwnd    = ::GetDC( reinterpret_cast<HWND>( handle ) );
         m_context->set_viewport( nv::ivec4( 0, 0, m_width, m_height ) );
 #else

trunk/src/gui/gui_ascii_renderer.cc

@@ -18 +18 @@
         bool   clear;
         bool   border;
-        char   border_chars[8];
+        uchar8 border_chars[8];
         uint32 border_color;
         uint32 text_color;
@@ -42 +42 @@
         }
         else 
-                er = (ascii_render_data*)( e->m_render_data );
+                er = static_cast< ascii_render_data* >( e->m_render_data );
 
         rectangle abs = e->m_absolute;
@@ -68 +68 @@
                                 er->border_color = uint32( border_color );
                         for ( uint32 i = 0; i < 8 && i < path.length(); )
-                                er->border_chars[i] = path[i];
+                                er->border_chars[i] = static_cast< uchar8 >( path[i] );
                 }
         }
@@ -75 +75 @@
 void ascii_renderer::draw( element* e )
 {
-        ascii_render_data* er = (ascii_render_data*)( e->m_render_data );
+        ascii_render_data* er = static_cast< ascii_render_data* >( e->m_render_data );
         rectangle abs = e->m_absolute;
         if ( er->clear ) m_terminal->clear( abs );
@@ -82 +82 @@
                 for ( int x = 0; x < abs.get_width(); ++x )
                 {
-                        m_terminal->print( position( abs.ul.y, abs.ul.x + x ), er->border_color, (unsigned char)er->border_chars[0] );
-                        m_terminal->print( position( abs.lr.y, abs.ul.x + x ), er->border_color, (unsigned char)er->border_chars[1] );
+                        m_terminal->print( position( abs.ul.y, abs.ul.x + x ), er->border_color, er->border_chars[0] );
+                        m_terminal->print( position( abs.lr.y, abs.ul.x + x ), er->border_color, er->border_chars[1] );
                 }
 
                 for ( int y = 0; y < abs.get_height(); ++y )
                 {
-                        m_terminal->print( position( abs.ul.y + y, abs.ul.x ), er->border_color, (unsigned char)er->border_chars[2] );
-                        m_terminal->print( position( abs.ul.y + y, abs.lr.x ), er->border_color, (unsigned char)er->border_chars[3] );
+                        m_terminal->print( position( abs.ul.y + y, abs.ul.x ), er->border_color, er->border_chars[2] );
+                        m_terminal->print( position( abs.ul.y + y, abs.lr.x ), er->border_color, er->border_chars[3] );
                 }
 
-                m_terminal->print( abs.ul,   er->border_color, (unsigned char)er->border_chars[4] );
-                m_terminal->print( abs.ur(), er->border_color, (unsigned char)er->border_chars[5] );
-                m_terminal->print( abs.ll(), er->border_color, (unsigned char)er->border_chars[6] );
-                m_terminal->print( abs.lr,   er->border_color, (unsigned char)er->border_chars[7] );
+                m_terminal->print( abs.ul,   er->border_color, er->border_chars[4] );
+                m_terminal->print( abs.ur(), er->border_color, er->border_chars[5] );
+                m_terminal->print( abs.ll(), er->border_color, er->border_chars[6] );
+                m_terminal->print( abs.lr,   er->border_color, er->border_chars[7] );
         }
         if ( !e->m_text.empty() )
@@ -102 +102 @@
                 for ( char c : e->m_text )
                 {
-                        m_terminal->print( p, er->text_color, (unsigned char)c );
+                        m_terminal->print( p, er->text_color, static_cast< unsigned char >( c ) );
                         ++p.x;
                 }

trunk/src/gui/gui_gfx_renderer.cc

@@ -190 +190 @@
 {
         std::string id_name( filename );
-        char buffer[8]; size_t len = nv::sint32_to_buffer( (sint32)size, buffer );
+        char buffer[8]; size_t len = nv::sint32_to_buffer( sint32( size ), buffer );
         id_name.append( std::string( buffer, len ) );
         auto i = m_font_names.find( id_name );
@@ -197 +197 @@
                 return i->second;
         }
-        size_t result = (size_t)m_fonts.size();
-        texture_font* f = new texture_font( &m_atlas, filename.c_str(), (float)size );
+        size_t result = m_fonts.size();
+        texture_font* f = new texture_font( &m_atlas, filename.c_str(), static_cast<float>( size ) );
         f->load_glyphs( "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~ " );
         m_fonts.push_back( f );
@@ -228 +228 @@
 void gfx_renderer::redraw( element* e, uint32 )
 {
-        screen_render_data* sr = (screen_render_data*)m_render_data;
+        screen_render_data* sr = reinterpret_cast< screen_render_data* >( m_render_data );
         if ( e->m_render_data == nullptr )
         {
                 e->m_render_data = new element_render_data( &sr->buffer );
         }
-        element_render_data* er = (element_render_data*)( e->m_render_data );
+        element_render_data* er = reinterpret_cast< element_render_data* >( e->m_render_data );
         size_t size_before = er->buffer.data().size();
 
@@ -318 +318 @@
                         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 ) )
                         {
-                                size_t font_id = load_font( path, (uint16)border );
+                                size_t font_id = load_font( path, size_t( border ) );
                                 texture_font* font = get_font( font_id );
                                 position p = abs.ul + position( 0, border );
@@ -361 +361 @@
 void gfx_renderer::draw( element* e )
 {
-        element_render_data* er = (element_render_data*)( e->m_render_data );
+        element_render_data* er = reinterpret_cast< element_render_data* >( e->m_render_data );
         er->buffer.commit();
 }
@@ -367 +367 @@
 void gfx_renderer::draw()
 {
-        screen_render_data* sr = (screen_render_data*)m_render_data;
+        screen_render_data* sr = reinterpret_cast< screen_render_data* >( m_render_data );
 
         if ( m_reupload )
         {
-                m_context->update( sr->tex, (void*)m_atlas.get_data() );
+                m_context->update( sr->tex, m_atlas.get_data() );
                 m_reupload = false;
         }
@@ -392 +392 @@
         if ( m_render_data )
         {
-                m_context->get_device()->release( ( (screen_render_data*)m_render_data )->tex );
+                m_context->get_device()->release( reinterpret_cast< screen_render_data* >( m_render_data )->tex );
                 delete m_render_data;
         }

trunk/src/gui/gui_style.cc

@@ -34 +34 @@
         if ( !resolve( e->m_id.c_str(), e->m_class.c_str(), cselector, centry, LUA_TTABLE ) ) return false;
         vec = vec4();
-        for (size_t i = 0; i < 4; ++i )
+        for ( int i = 0; i < 4; ++i )
         {
-                lua_rawgeti( m_lua, -1, static_cast<int>( i+1 ) );
+                lua_rawgeti( m_lua, -1, i+1 );
                 if ( lua_isnil( m_lua, -1 ) ) return true;
-                vec[i] = (float)lua_tonumber( m_lua, -1 );
+                vec[i] = static_cast< float >( lua_tonumber( m_lua, -1 ) );
                 lua_pop( m_lua, 1 );
         }

trunk/src/io/c_stream.cc

@@ -31 +31 @@
         if ( m_file )
         {
-                ::fclose( (FILE*)m_file );
+                ::fclose( reinterpret_cast<FILE*>( m_file ) );
         }
 }
@@ -38 +38 @@
 {
         NV_ASSERT( buffer != nullptr && size != 0 && count != 0, "Bad parameter passed to read!" );
-        return m_file ? ::fread( buffer, size, count, (FILE*)m_file ) : 0;
+        return m_file ? ::fread( buffer, size, count, reinterpret_cast<FILE*>( m_file ) ) : 0;
 }
 
@@ -44 +44 @@
 {
         NV_ASSERT( buffer != nullptr && size != 0 && count != 0, "Bad parameter passed to write!" );
-        return m_file ? ::fwrite( buffer, size, count, (FILE*)m_file ) : 0;
+        return m_file ? ::fwrite( buffer, size, count, reinterpret_cast<FILE*>( m_file ) ) : 0;
 }
 
 bool c_stream::seek( long offset, origin orig )
 {
-        return m_file != nullptr && ( ::fseek( (FILE*)m_file, (long)offset, static_cast<int>(orig) ) == 0 );
+        return m_file != nullptr && ( ::fseek( reinterpret_cast<FILE*>( m_file ), offset, static_cast<int>(orig) ) == 0 );
 }
 
 nv::size_t c_stream::tell()
 {
-        return m_file != nullptr ? static_cast< nv::size_t >( ::ftell( (FILE*)m_file ) ) : 0;
+        return m_file != nullptr ? static_cast< nv::size_t >( ::ftell( reinterpret_cast<FILE*>( m_file ) ) ) : 0;
 }
 
@@ -72 +72 @@
                         return 0; 
                 }
-                m_file_size = (size_t) (fstat.st_size);                 
+                m_file_size = static_cast<size_t>(fstat.st_size);               
         }
 
@@ -82 +82 @@
         if ( m_file != nullptr )
         {
-                ::fflush( (FILE*)m_file );
+                ::fflush( reinterpret_cast<FILE*>( m_file ) );
         }
 }

trunk/src/io/string_table.cc

@@ -22 +22 @@
         uint32 cs_size = s.size() + 1;
         NV_ASSERT( m_offsets.size() < index(-1), "Too many strings!" );
-        index  result  = (index)m_offsets.size();
+        index  result = index( m_offsets.size() );
         size_t dsize = m_data.size();
         m_offsets.push_back( dsize );
@@ -37 +37 @@
         raw_copy( m_offsets.begin(), m_offsets.end(), offsets );
         raw_copy( m_data.begin(),    m_data.end(),    data );
-        return new string_table( data, m_data.size(), offsets, (index)m_offsets.size() );
+        return new string_table( data, m_data.size(), offsets, index( m_offsets.size() ) );
 }
 
 void nv::string_table_creator::dump( nv::stream* out ) const
 {
-        index  count = (index)m_offsets.size();
+        index  count = index( m_offsets.size() );
         uint32 size  = m_data.size();
         out->write( &count,  sizeof( count ), 1 );

trunk/src/lib/assimp.cc

@@ -35 +35 @@
         assimp_library.open( path );
 
-#       define NV_ASSIMP_FUN( rtype, fname, fparams ) *(void **) (&fname) = assimp_library.get(#fname);
+#       define NV_ASSIMP_FUN( rtype, fname, fparams ) void_assign( fname, assimp_library.get(#fname) );
 #       include <nv/lib/detail/assimp_functions.inc>
 #       undef NV_ASSIMP_FUN

trunk/src/lib/curses.cc

@@ -22 +22 @@
         curses_library.open( path );
 
-#       define NV_CURSES_FUN( rtype, fname, fparams ) *(void **) (&::fname) = curses_library.get(#fname);
+#       define NV_CURSES_FUN( rtype, fname, fparams ) void_assign( ::fname, curses_library.get(#fname) );
 #       include <nv/lib/detail/curses_functions.inc>
 #       undef NV_CURSES_FUN

trunk/src/lib/fmod.cc

@@ -125 +125 @@
         fmod_library.open( path );
 
-#       define NV_FMOD_FUN( rtype, fname, fparams ) *(void **) (&fname) = fmod_library.get(#fname);
+#       define NV_FMOD_FUN( rtype, fname, fparams ) void_assign( fname, fmod_library.get(#fname) );
 #       include <nv/lib/detail/fmod_functions.inc>
 #       undef NV_FMOD_FUN

trunk/src/lib/freetype2.cc

@@ -21 +21 @@
         freetype_library.open( path );
 
-#       define NV_FREETYPE_FUN( rtype, fname, fparams ) *(void **) (&fname) = freetype_library.get(#fname);
+#       define NV_FREETYPE_FUN( rtype, fname, fparams ) void_assign( fname, freetype_library.get(#fname) );
 #       include <nv/lib/detail/freetype2_functions.inc>
 #       undef NV_FREETYPE_FUN

trunk/src/lib/gl.cc

@@ -82 +82 @@
         if ( gl_library_loaded && !force_reload ) return true;
 #if defined( NV_SDL_GL )
-#               define NV_GL_LOAD( symbol ) *(void **) (&symbol) = SDL_GL_GetProcAddress(#symbol);
-#               define NV_GL_LOAD_EXT( symbol ) *(void **) (&symbol) = SDL_GL_GetProcAddress(#symbol);
-        *(void **) (&gl_ext_loader) = SDL_GL_GetProcAddress;
+#               define NV_GL_LOAD( symbol ) void_assign( symbol, SDL_GL_GetProcAddress(#symbol) );
+#               define NV_GL_LOAD_EXT( symbol ) void_assign( symbol, SDL_GL_GetProcAddress(#symbol) );
+        void_assign( gl_ext_loader, SDL_GL_GetProcAddress );
 #else
         if ( !gl_library.is_open() ) gl_library.open( path );
 
 #       if NV_PLATFORM == NV_WINDOWS 
-#               define NV_GL_LOAD( symbol ) *(void **) (&symbol) = gl_library.get(#symbol);
-                *(void **) (&gl_ext_loader) = gl_library.get("wglGetProcAddress");
-#               define NV_GL_LOAD_EXT( symbol ) *(void **) (&symbol) = gl_ext_loader(#symbol);
+#               define NV_GL_LOAD( symbol ) void_assign( symbol, gl_library.get(#symbol) );
+                void_assign( gl_ext_loader, gl_library.get( "wglGetProcAddress" ) );
+#               define NV_GL_LOAD_EXT( symbol ) void_assign( symbol, gl_ext_loader(#symbol) );
 #       elif (NV_PLATFORM == NV_LINUX || NV_PLATFORM == NV_APPLE)
-#               define NV_GL_LOAD( symbol ) *(void **) (&symbol) = gl_library.get(#symbol);
-                *(void **) (&gl_ext_loader) = gl_library.get("glXGetProcAddress");
-#               define NV_GL_LOAD_EXT( symbol ) *(void **) (&symbol) = gl_ext_loader(#symbol);
+#               define NV_GL_LOAD( symbol ) void_assign( symbol, gl_library.get(#symbol) );
+                void_assign( gl_ext_loader, gl_library.get("glXGetProcAddress") );
+#               define NV_GL_LOAD_EXT( symbol ) void_assign( symbol, gl_ext_loader(#symbol) );
 #       else
-#               define NV_GL_LOAD( symbol ) *(void **) (&symbol) = gl_library.get(#symbol);
-#               define NV_GL_LOAD_EXT( symbol ) *(void **) (&symbol) = gl_library.get(#symbol);
+#               define NV_GL_LOAD( symbol ) void_assign( symbol, gl_library.get(#symbol) );
+#               define NV_GL_LOAD_EXT( symbol ) void_assign( symbol, gl_library.get(#symbol) );
 #       endif
 #endif
@@ -114 +114 @@
 }
 
+
+
 bool nv::load_wgl_library( const char* path /*= NV_GL_PATH */, bool force_reload )
 {
@@ -119 +121 @@
 #if NV_PLATFORM == NV_WINDOWS 
 #if defined( NV_SDL_GL )
-#               define NV_GL_LOAD( symbol ) *(void **) (&symbol) = SDL_GL_GetProcAddress(#symbol);
-#               define NV_GL_LOAD_EXT( symbol ) *(void **) (&symbol) = SDL_GL_GetProcAddress(#symbol);
-#           define NV_GL_LOAD_REN( fname, rname )  *(void **) (&rname) = SDL_GL_GetProcAddress(#fname);
-        (void **) (&gl_ext_loader) = SDL_GL_GetProcAddress;
+#               define NV_GL_LOAD( symbol ) void_assign( symbol, SDL_GL_GetProcAddress(#symbol) );
+#               define NV_GL_LOAD_EXT( symbol ) void_assign( symbol, SDL_GL_GetProcAddress(#symbol) );
+#           define NV_GL_LOAD_REN( fname, rname )  void_assign( rname, SDL_GL_GetProcAddress(#fname) );
+        void_assign( gl_ext_loader, SDL_GL_GetProcAddress );
 #else // 
         if ( !gl_library.is_open() ) gl_library.open( path );
 
-        *(void **) (&gl_ext_loader) = gl_library.get("wglGetProcAddress");
-#define NV_GL_LOAD( symbol ) *(void **) (&symbol) = gl_library.get(#symbol);
-#define NV_GL_LOAD_EXT( symbol ) *(void **) (&symbol) = gl_ext_loader(#symbol);
-#define NV_GL_LOAD_REN( fname, rname ) *(void **) (&rname) = gl_library.get(#fname);
+        void_assign( gl_ext_loader, gl_library.get("wglGetProcAddress") );
+#define NV_GL_LOAD( symbol ) void_assign( symbol, gl_library.get(#symbol) );
+#define NV_GL_LOAD_EXT( symbol ) void_assign( symbol, gl_ext_loader(#symbol) );
+#define NV_GL_LOAD_REN( fname, rname ) void_assign( rname, gl_library.get(#fname) );
 #endif 
 #       define NV_GL_FUN( rtype, fname, fparams ) NV_GL_LOAD( fname )
@@ -161 +163 @@
         BOOL  (NV_GL_APIENTRY *wgl_deletecontext) (HGLRC)      = nullptr;
 
-        *(void **) &wgl_createcontext = gl_library.get("wglCreateContext");
-        *(void **) &wgl_makecurrent   = gl_library.get("wglMakeCurrent");
-        *(void **) &wgl_deletecontext = gl_library.get("wglDeleteContext");
+        void_assign( wgl_createcontext, gl_library.get("wglCreateContext") );
+        void_assign( wgl_makecurrent,   gl_library.get("wglMakeCurrent") );
+        void_assign( wgl_deletecontext, gl_library.get("wglDeleteContext") );
 
         WNDCLASS wndClass;
@@ -175 +177 @@
         wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
         wndClass.hInstance = hInstance;
-        wndClass.lpfnWndProc = (WNDPROC) DefWindowProc;
+        wndClass.lpfnWndProc = reinterpret_cast<WNDPROC>( DefWindowProc );
         wndClass.lpszClassName = TEXT("Dummy67789");
         wndClass.lpszMenuName = 0;
@@ -253 +255 @@
 
 #       define NV_GL_FUN_EXT( rtype, symbol, fparams ) \
-        *(void **) (&symbol) = load_gl_ext_symbol(#symbol, true, nullptr); \
+        void_assign( symbol, load_gl_ext_symbol(#symbol, true, nullptr) ); \
         count++; if ( !symbol ) fail_count++;
 
@@ -266 +268 @@
         default : {
                 NV_LOG_ERROR( "load_gl_extension - unknown extension \"", name, "\"!" );
-                return nullptr;
+                return false;
         }
         }
@@ -274 +276 @@
         {
                 NV_LOG_NOTICE( "load_gl_extension - extension \"", name, "\" loaded (", count, " symbols)" );
-                gl_loaded_extensions = (gl_extensions)( gl_loaded_extensions | (unsigned)extension );
+                gl_loaded_extensions = gl_extensions( gl_loaded_extensions | static_cast<unsigned>( extension ) );
                 return false;
         }

trunk/src/lib/lua.cc

@@ -128 +128 @@
 static const lua_Number *lua_version_51 (lua_State*) 
 {
-        static const lua_Number version = (lua_Number)LUA_VERSION_NUM;
+        static const lua_Number version = lua_Number( LUA_VERSION_NUM );
         return &version;
 }
@@ -227 +227 @@
 #endif
 
-#       define NV_LUA_FUN( rtype, fname, fparams ) *(void **) (&fname) = lua_library.get(#fname);
+#       define NV_LUA_FUN( rtype, fname, fparams ) void_assign( fname, lua_library.get(#fname) );
 #       if NV_LUA_VERSION == NV_LUA_52
 #               define NV_LUA_FUN_51( rtype, fname, fparams )
@@ -246 +246 @@
 
 #if NV_LUA_VERSION == NV_LUA_5C
-#       define NV_LUA_LOAD( fname ) *(void **) (&fname) = lua_library.get(#fname);
-#       define NV_LUA_LOAD_AS( fname,fname2 ) *(void **) (&fname) = lua_library.get(#fname2);
+#       define NV_LUA_LOAD( fname ) void_assign( fname, lua_library.get(#fname) );
+#       define NV_LUA_LOAD_AS( fname,fname2 ) void_assign( fname, lua_library.get(#fname2) );
         bool version_52 = lua_library.try_get("luaL_checkversion_") != nullptr;
         if (version_52)
         {
 #       define NV_LUA_COMPAT_FUN( u1, fn, u2, u3, fn2, u5, u6, u7 ) \
-        *(void **) (&(fn2##_compat)) = lua_library.get(#fn2); \
+        void_assign( fn2##_compat, lua_library.get(#fn2) ); \
         fn = call_##fn2##_compat; 
 #       include <nv/lib/detail/lua_functions_compat.inc>
@@ -280 +280 @@
         {
 #       define NV_LUA_COMPAT_FUN( u1, fn, u2, u3, u4, u5, u6, u7 ) \
-                *(void **) (&fn) = lua_library.get(#fn);
+                void_assign(fn, lua_library.get(#fn) );
 #       include <nv/lib/detail/lua_functions_compat.inc>
 #       undef NV_LUA_COMPAT_FUN

trunk/src/lib/sdl.cc

@@ -20 +20 @@
         if ( sdl_library.is_open() ) return true;
         sdl_library.open( path );
-#       define NV_SDL_FUN( rtype, fname, fparams ) *(void **) (&fname) = sdl_library.get(#fname);
+#       define NV_SDL_FUN( rtype, fname, fparams )void_assign( fname, sdl_library.get(#fname) );
 #       include <nv/lib/detail/sdl_functions.inc>
 #       undef NV_SDL_FUN

trunk/src/lib/sdl_image.cc

@@ -21 +21 @@
         sdl_image_library.open( path );
 
-#       define NV_SDL_FUN( rtype, fname, fparams ) *(void **) (&fname) = sdl_image_library.get(#fname);
+#       define NV_SDL_FUN( rtype, fname, fparams ) void_assign( fname, sdl_image_library.get(#fname) );
 #       include <nv/lib/detail/sdl_image_functions.inc>
 #       undef NV_SDL_FUN

trunk/src/lib/sdl_mixer.cc

@@ -21 +21 @@
         sdl_mixer_library.open( path );
 
-#       define NV_SDL_FUN( rtype, fname, fparams ) *(void **) (&fname) = sdl_mixer_library.get(#fname);
+#       define NV_SDL_FUN( rtype, fname, fparams ) void_assign( fname, sdl_mixer_library.get(#fname) );
 #       include <nv/lib/detail/sdl_mixer_functions.inc>
 #       undef NV_SDL_FUN

trunk/src/lua/lua_function.cc

@@ -5 +5 @@
 // For conditions of distribution and use, see copying.txt file in root folder.
 
-#include <nv/lua/lua_function.hh>
+#include "nv/lua/lua_function.hh"
 
-#include <nv/lua/lua_raw.hh>
+#include "nv/core/logging.hh"
+#include "nv/lua/lua_raw.hh"
 
 using namespace nv;
+
+#define NV_LUA_ABORT( func, ... ) \
+        NV_LOG_CRITICAL( "lua::" func " : ", __VA_ARGS__ ) \
+        NV_ABORT( "lua::" func " : critical error!" )
 
 lua::function_base::function_base( lua_State* a_L, const path& a_path, bool a_global /*= true*/ ) : L(a_L)
@@ -16 +21 @@
         {
                 lua_pop( L, 1 );
-                throw std::runtime_error("not a valid path - " + a_path.to_string() );
+                NV_LUA_ABORT( "function_base::function_base", "not a valid path - ", a_path.to_string() );
         }
 
@@ -22 +27 @@
         {
                 lua_pop( L, 1 );
-                throw std::runtime_error("not a valid function - " + a_path.to_string() );
+                NV_LUA_ABORT( "function_base::function_base", "not a valid function - ", a_path.to_string() );
         }
         m_ref = luaL_ref( L, LUA_REGISTRYINDEX );
@@ -61 +66 @@
                 std::string error = lua_tostring( L, -1 );
                 lua_pop( L, 1 );
-                throw std::runtime_error(error.c_str());
+                NV_LUA_ABORT( "function_base::call", "call failed - ", error.c_str() );
         }
 }

trunk/src/lua/lua_glm.cc

@@ -11 +11 @@
 #include "nv/stl/type_traits/common.hh"
 
-static size_t nlua_swizzel_lookup[256];
+static int nlua_swizzel_lookup[256];
 
 using nv::lua::detail::is_vec;
@@ -18 +18 @@
 using nv::lua::detail::push_vec;
 
-inline bool nlua_is_swizzel( const unsigned char* str, size_t max )
+inline bool nlua_is_swizzel( const unsigned char* str, int max )
 {
         while (*str)
@@ -155 +155 @@
 {
         if ( lua_type( L, 1 ) == LUA_TNUMBER )
-                push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) + to_vec<T>( L, 2 ) );
+                push_vec<T>( L, static_cast<typename T::value_type>(lua_tonumber( L, 1 )) + to_vec<T>( L, 2 ) );
         else
                 if ( lua_type( L, 2 ) == LUA_TNUMBER )
-                        push_vec<T>( L, to_vec<T>( L, 1 ) + (typename T::value_type)(lua_tonumber( L, 2 )) );
+                        push_vec<T>( L, to_vec<T>( L, 1 ) + static_cast<typename T::value_type>(lua_tonumber( L, 2 )) );
                 else
                         push_vec<T>( L, to_vec<T>( L, 1 ) + to_vec<T>( L, 2 ) );
@@ -168 +168 @@
 {
         if ( lua_type( L, 1 ) == LUA_TNUMBER )
-                push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) - to_vec<T>( L, 2 ) );
+                push_vec<T>( L, static_cast<typename T::value_type>(lua_tonumber( L, 1 )) - to_vec<T>( L, 2 ) );
         else
                 if ( lua_type( L, 2 ) == LUA_TNUMBER )
-                        push_vec<T>( L, to_vec<T>( L, 1 ) - (typename T::value_type)(lua_tonumber( L, 2 )) );
+                        push_vec<T>( L, to_vec<T>( L, 1 ) - static_cast<typename T::value_type>(lua_tonumber( L, 2 )) );
                 else
                         push_vec<T>( L, to_vec<T>( L, 1 ) - to_vec<T>( L, 2 ) );
@@ -181 +181 @@
 {
         if ( lua_type( L, 1 ) == LUA_TNUMBER )
-                push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) * to_vec<T>( L, 2 ) );
+                push_vec<T>( L, static_cast<typename T::value_type>(lua_tonumber( L, 1 )) * to_vec<T>( L, 2 ) );
         else
                 if ( lua_type( L, 2 ) == LUA_TNUMBER )
-                        push_vec<T>( L, to_vec<T>( L, 1 ) * (typename T::value_type)(lua_tonumber( L, 2 )) );
+                        push_vec<T>( L, to_vec<T>( L, 1 ) * static_cast<typename T::value_type>(lua_tonumber( L, 2 )) );
                 else
                         push_vec<T>( L, to_vec<T>( L, 1 ) * to_vec<T>( L, 2 ) );
@@ -194 +194 @@
 {
         if ( lua_type( L, 1 ) == LUA_TNUMBER )
-                push_vec<T>( L, (typename T::value_type)(lua_tonumber( L, 1 )) / to_vec<T>( L, 2 ) );
+                push_vec<T>( L, static_cast<typename T::value_type>(lua_tonumber( L, 1 )) / to_vec<T>( L, 2 ) );
         else
                 if ( lua_type( L, 2 ) == LUA_TNUMBER )
-                        push_vec<T>( L, to_vec<T>( L, 1 ) / (typename T::value_type)(lua_tonumber( L, 2 )) );
+                        push_vec<T>( L, to_vec<T>( L, 1 ) / static_cast<typename T::value_type>(lua_tonumber( L, 2 )) );
                 else
                         push_vec<T>( L, to_vec<T>( L, 1 ) / to_vec<T>( L, 2 ) );
@@ -226 +226 @@
         T* v = to_pvec<T>( L, 1 );
         size_t len  = 0;
-        size_t vlen = v->length();
-        const unsigned char * key = (const unsigned char *)( lua_tolstring( L, 2, &len ) );
-        size_t idx = 255;
+        int vlen = v->length();
+        const unsigned char * key = reinterpret_cast<const unsigned char *>( lua_tolstring( L, 2, &len ) );
+        int idx = 255;
 
         if ( len == 1 )
@@ -264 +264 @@
         T* v = to_pvec<T>( L, 1 );
         size_t len  = 0;
-        size_t vlen = v->length();
-        const unsigned char * key = (const unsigned char *)( lua_tolstring( L, 2, &len ) );
-        size_t idx = 255;
+        int vlen = v->length();
+        const unsigned char * key = reinterpret_cast<const unsigned char *>( lua_tolstring( L, 2, &len ) );
+        int idx = 255;
         if( len == 1 )
         {
@@ -272 +272 @@
                 if ( idx < vlen )
                 {
-                        (*v)[idx] = (typename T::value_type)luaL_checknumber( L, 3 );
+                        (*v)[idx] = static_cast<typename T::value_type>( luaL_checknumber( L, 3 ) );
                         return 0;
                 }
@@ -279 +279 @@
         {
                 switch (len) {
-                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;
-                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;
-                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;
+                case 2 : { vec2 v2 = to_vec<vec2>(L,3); for ( int i = 0; i<int( len ); ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v2[i]; } return 0;
+                case 3 : { vec3 v3 = to_vec<vec3>(L,3); for ( int i = 0; i<int( len ); ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v3[i]; } return 0;
+                case 4 : { vec4 v4 = to_vec<vec4>(L,3); for ( int i = 0; i<int( len ); ++i) (*v)[nlua_swizzel_lookup[key[i]]] = v4[i]; } return 0;
                 default: break;
                 }

trunk/src/lua/lua_handle.cc

@@ -16 +16 @@
         NV_LUA_STACK_ASSERT( L, +1 );
         lua_rawgeti( L, LUA_REGISTRYINDEX, pseudoindex ); // table
-        lua_rawgeti( L, -1, (int)index );                 // table, entry
+        lua_rawgeti( L, -1, int( index ) );                 // table, entry
         if ( !lua_istable( L, -1 ) )
         {
@@ -58 +58 @@
         lua_rawgeti( L, LUA_REGISTRYINDEX, pseudoindex );
         lua_insert( L, -2 );
-        lua_rawseti( L, -2, (int)index );
+        lua_rawseti( L, -2, int( index ) );
         lua_pop( L, 1 );
 }
@@ -67 +67 @@
         lua_rawgeti( L, LUA_REGISTRYINDEX, pseudoindex ); // table
         lua_pushinteger( L, 0 );
-        lua_rawseti( L, -2, (int)index );
+        lua_rawseti( L, -2, int( index ) );
         lua_pop( L, 1 );
 }

trunk/src/lua/lua_map_area.cc

@@ -67 +67 @@
         else
         {
-                return *(nv::map_area**)luaL_checkudata( L, index, NLUA_MAP_AREA_METATABLE );
+                return *reinterpret_cast<nv::map_area**>( luaL_checkudata( L, index, NLUA_MAP_AREA_METATABLE ) );
         }
         return o;
@@ -88 +88 @@
 void nv::lua::detail::push_map_area( lua_State* L, nv::map_area* c )
 {
-        nv::map_area** pm = (nv::map_area**) (lua_newuserdata(L, sizeof(nv::map_area*)));
+        nv::map_area** pm = reinterpret_cast<nv::map_area**>( lua_newuserdata(L, sizeof(nv::map_area*) ) );
         *pm = c;
         luaL_getmetatable( L, NLUA_MAP_AREA_METATABLE );
@@ -237 +237 @@
         lua_rawgeti( L, LUA_REGISTRYINDEX, object_index.get() );
         lua_pushliteral( L, "__map_area_ptr" );
-        lua_pushlightuserdata( L, (map_area*)area );
+        lua_pushlightuserdata( L, area );
         lua_rawset( L, -3 );
         lua_pop( L, 1 );

trunk/src/lua/lua_map_tile.cc

@@ -40 +40 @@
 static map_tile* nlua_to_pmap_tile( lua_State* L, int index )
 {
-        return (map_tile*)luaL_checkudata( L, index, NLUA_MAP_TILE_METATABLE );
+        return reinterpret_cast<map_tile*>( luaL_checkudata( L, index, NLUA_MAP_TILE_METATABLE ) );
 }
 
 static void nlua_push_map_tile( lua_State* L, const map_tile& tile )
 {
-        map_tile* result = (map_tile*)lua_newuserdata( L, sizeof(map_tile) );
+        map_tile* result = reinterpret_cast<map_tile*>( lua_newuserdata( L, sizeof(map_tile) ) );
         *result = tile;
         luaL_setmetatable( L, NLUA_MAP_TILE_METATABLE );
@@ -65 +65 @@
         map_tile tile;
 
-        tile.size_y = (nv::uint16)( nv::count( code.begin(), code.end(), '\n' ) + 1 );
-        tile.size_x = (nv::uint16)( code.find( '\n' ) );
+        tile.size_y = nv::uint16( nv::count( code.begin(), code.end(), '\n' ) + 1 );
+        tile.size_x = nv::uint16( code.find( '\n' ) );
         if ( tile.size_x == 0 )
         {
-                tile.size_x = (nv::uint16)code.length();
+                tile.size_x = nv::uint16( code.length() );
         }
         tile.data  = new nv::uint8[ tile.size_x * tile.size_y ];
@@ -85 +85 @@
                         if ( lua_isstring( L, -2 ) && lua_objlen( L, -2 ) == 1 )
                         {
-                                translation[ (nv::uint8)( lua_tostring( L, -2 )[0] ) ] = nv::uint8( map_area->string_to_id( lua_tostring( L, -1 ) ) );
+                                translation[ nv::uint8( lua_tostring( L, -2 )[0] ) ] = nv::uint8( map_area->string_to_id( lua_tostring( L, -1 ) ) );
                         }
                         // removes 'value'; keeps 'key' for next iteration */
@@ -95 +95 @@
                 for ( nv::uint16 row = 0; row < tile.size_y; row++ )
                 {
-                        nv::uchar8 gylph = (nv::uchar8)code[ row * ( tile.size_x + 1 ) + line ];
+                        nv::uchar8 gylph = nv::uchar8( code[ row * ( tile.size_x + 1 ) + line ] );
                         // TODO: check for errors
                         tile.data[ row * tile.size_x + line ] = translation[ gylph ];
@@ -108 +108 @@
 {
         map_tile* old_tile = nlua_to_pmap_tile( L, 1 );
-        map_tile* new_tile = (map_tile*) lua_newuserdata( L, sizeof( map_tile ) );
+        map_tile* new_tile = reinterpret_cast<map_tile*>( lua_newuserdata( L, sizeof( map_tile ) ) );
         new_tile->size_x = old_tile->size_x;
         new_tile->size_y = old_tile->size_y;
@@ -246 +246 @@
         nv::uint16 org_x = tile->size_x;
         nv::uint16 org_y = tile->size_y;
-        nv::uint16 new_x = ( nv::uint16 )nv::accumulate( sizes_x.begin(), sizes_x.end(), 0 );
-        nv::uint16 new_y = ( nv::uint16 )nv::accumulate( sizes_y.begin(), sizes_y.end(), 0 );
+        nv::uint16 new_x = nv::uint16( nv::accumulate( sizes_x.begin(), sizes_x.end(), 0 ) );
+        nv::uint16 new_y = nv::uint16( nv::accumulate( sizes_y.begin(), sizes_y.end(), 0 ) );
 
         nv::uint8* data = new nv::uint8[ new_x * new_y ];
@@ -274 +274 @@
 static int nlua_map_tile_raw_get( lua_State* L )
 {
-        map_tile* tile = (map_tile*)lua_touserdata( L, 1 );
+        map_tile* tile = reinterpret_cast<map_tile*>( lua_touserdata( L, 1 ) );
         if ( lua_type( L, 2 ) == LUA_TNUMBER )
         {
@@ -289 +289 @@
 static int nlua_map_tile_raw_set( lua_State* L )
 {
-        map_tile* tile = (map_tile*)lua_touserdata( L, 1 );
+        map_tile* tile = reinterpret_cast<map_tile*>( lua_touserdata( L, 1 ) );
         if ( lua_type( L, 2 ) == LUA_TNUMBER )
         {
-                tile->data[ ( lua_tointeger( L, 2 ) - 1 ) + ( lua_tointeger( L, 3 ) - 1 ) * tile->size_x ] = (nv::uint8)lua_tointeger( L, 3 );
+                tile->data[ ( lua_tointeger( L, 2 ) - 1 ) + ( lua_tointeger( L, 3 ) - 1 ) * tile->size_x ] = nv::uint8( lua_tointeger( L, 3 ) );
         }
         else
         {
                 nv::ivec2 coord = nv::lua::detail::to_coord( L, 2 );
-                tile->data[ ( coord.x - 1 ) + ( coord.y - 1 ) * tile->size_x ] = (nv::uint8)lua_tointeger( L, 3 );
+                tile->data[ ( coord.x - 1 ) + ( coord.y - 1 ) * tile->size_x ] = nv::uint8( lua_tointeger( L, 3 ) );
         }
         return 0;
@@ -304 +304 @@
 static int nlua_map_tile_ascii_get( lua_State* L )
 {
-        map_tile* tile = (map_tile*)lua_touserdata( L, 1 );
+        map_tile* tile = reinterpret_cast<map_tile*>( lua_touserdata( L, 1 ) );
         if ( lua_type( L, 2 ) == LUA_TNUMBER )
         {
@@ -319 +319 @@
 static int nlua_map_tile_ascii_set( lua_State* L )
 {
-        map_tile* tile = (map_tile*)lua_touserdata( L, 1 );
+        map_tile* tile = reinterpret_cast<map_tile*>( lua_touserdata( L, 1 ) );
         if ( lua_type( L, 2 ) == LUA_TNUMBER )
         {
-                tile->ascii[ ( lua_tointeger( L, 2 ) - 1 ) + ( lua_tointeger( L, 3 ) - 1 ) * tile->size_x ] = (nv::uint8)lua_tointeger( L, 3 );
+                tile->ascii[ ( lua_tointeger( L, 2 ) - 1 ) + ( lua_tointeger( L, 3 ) - 1 ) * tile->size_x ] = nv::uint8( lua_tointeger( L, 3 ) );
         }
         else
         {
                 nv::ivec2 coord = nv::lua::detail::to_coord( L, 2 );
-                tile->ascii[ ( coord.x - 1 ) + ( coord.y - 1 ) * tile->size_x ] = (nv::uint8)lua_tointeger( L, 3 );
+                tile->ascii[ ( coord.x - 1 ) + ( coord.y - 1 ) * tile->size_x ] = nv::uint8( lua_tointeger( L, 3 ) );
         }
         return 0;
@@ -334 +334 @@
 static int nlua_map_tile_gc( lua_State* L )
 {
-        map_tile* tile = (map_tile*)lua_touserdata( L, 1 );
+        map_tile* tile = reinterpret_cast<map_tile*>( lua_touserdata( L, 1 ) );
         if ( tile != nullptr )
         {

trunk/src/lua/lua_raw.cc

@@ -271 +271 @@
                 while ( lua_next( L, index ) != 0 )
                 {
-                        result.push_back( (nv::uint8) lua_tointeger( L, -1 ) );
+                        result.push_back( static_cast<nv::uint8>( lua_tointeger( L, -1 ) ) );
                         lua_pop( L, 1 );
                 }

trunk/src/lua/lua_state.cc

@@ -258 +258 @@
 {
         lua_getfield( m_state, -1, element.data() );
-        float result = lua_type( m_state, -1 ) == LUA_TNUMBER ? (float)lua_tonumber( m_state, -1 ) : defval;
+        float result = lua_type( m_state, -1 ) == LUA_TNUMBER ? static_cast<float>( lua_tonumber( m_state, -1 ) ) : defval;
         lua_pop( m_state, 1 );
         return result;

trunk/src/rogue/fov_recursive_shadowcasting.cc

@@ -25 +25 @@
                 position max_radius = m_size-m_position;
                 max_radius = glm::max(max_radius,m_position);
-                m_radius = (int)glm::length((vec2)max_radius)+1;
+                m_radius = static_cast<int>( glm::length( vec2( max_radius ) ) )+1;
         }
         m_radius2 = m_radius * m_radius;

trunk/src/sdl/sdl_audio.cc

@@ -36 +36 @@
         if ( info )
         {
-                int channel = Mix_PlayChannel(-1, (Mix_Chunk*)( info->sdl_sound), 0);
+                int channel = Mix_PlayChannel(-1, static_cast<Mix_Chunk*>( info->sdl_sound ), 0);
                 if ( channel == -1 )
                 {
@@ -43 +43 @@
                 else
                 {
-                        Mix_Volume( channel, int( volume * 128.0f ) );
+                        Mix_Volume( channel, static_cast<int>( volume * 128.0f ) );
                         if ( pan != 0.0f) 
                         {
-                                uint8 right = (uint8)( (pan + 1.0f) * 127.0f ); 
+                                uint8 right = static_cast<uint8>( (pan + 1.0f) * 127.0f ); 
                                 Mix_SetPanning( channel, 254-right, right );
                         }
@@ -63 +63 @@
         if ( info )
         {
-                int channel = Mix_PlayChannel(-1, (Mix_Chunk*)( info->sdl_sound), 0);
+                int channel = Mix_PlayChannel(-1, static_cast<Mix_Chunk*>( info->sdl_sound ), 0);
                 if ( channel == -1 )
                 {
@@ -123 +123 @@
         if ( info )
         {
-                Mix_FreeChunk( (Mix_Chunk*)info->sdl_sound );
+                Mix_FreeChunk( static_cast<Mix_Chunk*>( info->sdl_sound ) );
                 m_sounds.destroy( a_sound );
         }

trunk/src/sdl/sdl_input.cc

@@ -25 +25 @@
         kevent.key.code    = KEY_NONE;
 
-        uint32 ucode = (uint32)ke.keysym.sym;
+        uint32 ucode = static_cast<uint32>( ke.keysym.sym );
 
         // if result is a typable char place it into the structure
@@ -36 +36 @@
                         int capslock = !!(ke.keysym.mod & KMOD_CAPS);
                         if ((shifted ^ capslock) != 0) {
-                                kevent.key.ascii = (uchar8)SDL_toupper((int)ucode);
+                                kevent.key.ascii = static_cast<uchar8>( SDL_toupper( static_cast<int>( ucode ) ) );
                         }
                 }

trunk/src/sdl/sdl_window.cc

@@ -64 +64 @@
 
         nv::load_gl_library();
-        NV_LOG_INFO( "OpenGL Vendor       : ", (const char*)glGetString(GL_VENDOR) );
-        NV_LOG_INFO( "OpenGL Renderer     : ", (const char*)glGetString( GL_RENDERER ) );
-        NV_LOG_INFO( "OpenGL Version      : ", (const char*)glGetString( GL_VERSION ) );
-        NV_LOG_INFO( "OpenGL GLSL Version : ", (const char*)glGetString( GL_SHADING_LANGUAGE_VERSION ) );
+        NV_LOG_INFO( "OpenGL Vendor       : ", reinterpret_cast<const char*>( glGetString(GL_VENDOR) ) );
+        NV_LOG_INFO( "OpenGL Renderer     : ", reinterpret_cast<const char*>( glGetString( GL_RENDERER ) ) );
+        NV_LOG_INFO( "OpenGL Version      : ", reinterpret_cast<const char*>( glGetString( GL_VERSION ) ) );
+        NV_LOG_INFO( "OpenGL GLSL Version : ", reinterpret_cast<const char*>( glGetString( GL_SHADING_LANGUAGE_VERSION ) ) );
         SDL_GL_SetSwapInterval(1);
 

trunk/src/stl/assert.cc

@@ -64 +64 @@
         exit( 1 );
 }
+
+
+NV_NORETURN void nv::exit( int ret_val )
+{
+        ::exit( ret_val );
+}