Changeset 406 for trunk/src/gfx


Ignore:
Timestamp:
06/20/15 00:05:17 (10 years ago)
Author:
epyon
Message:
  • code compiles cleanly on maximum warning level
Location:
trunk/src/gfx
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gfx/image.cc

    r398 r406  
    4646void image::fill( uint8 value )
    4747{
    48         raw_fill( m_data, m_data + m_size.x * m_size.y * (int)m_depth, value );
     48        raw_fill( m_data, m_data + m_size.x * m_size.y * static_cast<int>( m_depth ), value );
    4949}
    5050

  • trunk/src/gfx/keyframed_mesh.cc

    r395 r406  
    7171        if ( m_active )
    7272        {
    73                 float tick_time = ( (float)a_anim_time * 0.001f ) * anim->get_frame_rate();
     73                float tick_time = ( static_cast<float>( a_anim_time ) * 0.001f ) * anim->get_frame_rate();
    7474                float duration  = anim->is_looping() ? anim->get_duration() + 1.0f : anim->get_duration();
    7575                if ( tick_time >= duration )
    … …  
    8282                        {
    8383                                m_active     = false;
    84                                 m_last_frame = (uint32)anim->get_end();
     84                                m_last_frame = static_cast<uint32>( anim->get_end() );
    8585                                m_next_frame = m_last_frame;
    8686                                m_interpolation = 0.0f;
    … …  
    8888                        }
    8989                }
    90                 m_last_frame    = (uint32)( glm::floor( tick_time ) + anim->get_start() );
     90                m_last_frame    = static_cast<uint32>( glm::floor( tick_time ) + anim->get_start() );
    9191                m_next_frame    = m_last_frame + 1;
    92                 if ( m_next_frame > (uint32)anim->get_end() ) m_next_frame = (uint32)anim->get_start();
     92                if ( m_next_frame > static_cast<uint32>( anim->get_end() ) ) m_next_frame = static_cast<uint32>( anim->get_start() );
    9393                m_interpolation = tick_time - glm::floor( tick_time );
    9494        }
    … …  
    152152        {
    153153                uint32 base_offset = m_next_frame * m_vertex_count * m_vsize;
    154                 m_context->update_attribute_offset( m_va, (slot)m_loc_next_position, base_offset );
    155                 m_context->update_attribute_offset( m_va, (slot)m_loc_next_normal, base_offset + sizeof( vec3 ) );
     154                m_context->update_attribute_offset( m_va, static_cast<slot>( m_loc_next_position ), base_offset );
     155                m_context->update_attribute_offset( m_va, static_cast<slot>( m_loc_next_normal ), base_offset + sizeof( vec3 ) );
    156156                if ( m_has_tangent && m_loc_next_tangent != -1 )
    157157                {
    158                         m_context->update_attribute_offset( m_va, (slot)m_loc_next_tangent, base_offset + 2*sizeof( vec3 ) );
     158                        m_context->update_attribute_offset( m_va, static_cast<slot>( m_loc_next_tangent ), base_offset + 2*sizeof( vec3 ) );
    159159                }
    160160                m_gpu_next_frame = m_next_frame;
    … …  
    172172                        m_loc_next_tangent  = dev->get_attribute_location( a_program, "nv_next_tangent" );
    173173
    174                 m_context->add_vertex_buffer( m_va, (slot)m_loc_next_position, m_pbuffer, FLOAT, 3, 0, m_vsize, false );
    175                 m_context->add_vertex_buffer( m_va, (slot)m_loc_next_normal,   m_pbuffer, FLOAT, 3, sizeof( vec3 ), m_vsize, false );
     174                m_context->add_vertex_buffer( m_va, static_cast<slot>( m_loc_next_position ), m_pbuffer, FLOAT, 3, 0, m_vsize, false );
     175                m_context->add_vertex_buffer( m_va, static_cast<slot>( m_loc_next_normal ),   m_pbuffer, FLOAT, 3, sizeof( vec3 ), m_vsize, false );
    176176                if ( m_has_tangent )
    177                         m_context->add_vertex_buffer( m_va, (slot)m_loc_next_tangent, m_pbuffer, FLOAT, 4, 2*sizeof( vec3 ), m_vsize, false );
     177                        m_context->add_vertex_buffer( m_va, static_cast<slot>( m_loc_next_tangent ), m_pbuffer, FLOAT, 4, 2*sizeof( vec3 ), m_vsize, false );
    178178        }
    179179        keyframed_mesh::update( a_program );
    … …  
    184184{
    185185        m_va      = m_context->create_vertex_array();
    186         m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, (void*)m_vchannel->data );
     186        m_pbuffer = m_context->get_device()->create_buffer( VERTEX_BUFFER, STATIC_DRAW, m_vertex_count * m_vsize, m_vchannel->data );
    187187        m_context->add_vertex_buffers( m_va, m_pbuffer, m_vchannel );
    188188
    189         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 );
     189        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 );
    190190        m_context->add_vertex_buffers( m_va, vb, m_mesh_data->get_channel<vertex_t>() );
    191191
    192         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 );
     192        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 );
    193193
    194194        m_context->set_index_buffer( m_va, ib, m_mesh_data->get_index_channel()->desc.slots[0].etype, true );
    … …  
    206206                const vertex_pnt* prev = data + m_vertex_count * m_last_frame;
    207207                const vertex_pnt* next = data + m_vertex_count * m_next_frame;
    208                       vertex_pnt* vtx  = (vertex_pnt*)m_data;
     208                      vertex_pnt* vtx  = reinterpret_cast<vertex_pnt*>( m_data );
    209209                for ( size_t i = 0; i < m_vertex_count; ++i )
    210210                {
    … …  
    219219                const vertex_pn* prev = data + m_vertex_count * m_last_frame;
    220220                const vertex_pn* next = data + m_vertex_count * m_next_frame;
    221                       vertex_pn* vtx  = (vertex_pn*)m_data;
     221                      vertex_pn* vtx  = reinterpret_cast<vertex_pn*>( m_data );
    222222
    223223                for ( size_t i = 0; i < m_vertex_count; ++i )

  • trunk/src/gfx/mesh_creator.cc

    r398 r406  
    2424                if ( pkeys && pkeys->get_channel_count() > 0 && keys && keys->get_channel_count() > 0 )
    2525                {
    26                         nv_key_transform*  channel = ((nv_key_transform*)(keys->get_channel(0)->data));
    27                         nv_key_transform* pchannel = ((nv_key_transform*)(pkeys->get_channel(0)->data));
     26                        nv_key_transform*  channel = reinterpret_cast<nv_key_transform*>(keys->get_channel(0)->data);
     27                        nv_key_transform* pchannel = reinterpret_cast<nv_key_transform*>(pkeys->get_channel(0)->data);
    2828                        for ( unsigned n = 0; n < count; ++n )
    2929                        {
    … …  
    3737        {
    3838                m_data->m_frame_rate = 32;
    39                 m_data->m_duration   = (float)max_frames;
     39                m_data->m_duration   = static_cast<float>( max_frames );
    4040        }
    4141
    … …  
    6969                        key_data* new_keys = new key_data;
    7070                        new_keys->add_channel( raw_channel );
    71                         nv_key_transform* channel = ((nv_key_transform*)(raw_channel->data));
     71                        nv_key_transform* channel = reinterpret_cast<nv_key_transform*>(raw_channel->data);
    7272                        key_descriptor final_key = old_keys->get_final_key();
    7373
    … …  
    110110                                for ( size_t n = 0; n < channel->count; ++n )
    111111                                {
    112                                         transform_key_raw( channel->desc, (uint8*)(channel->data + n * key_size), scale, r33, ri33 );
     112                                        transform_key_raw( channel->desc, channel->data + n * key_size, scale, r33, ri33 );
    113113                                }
    114114                        }
    … …  
    135135                        switch ( desc.slots[i].vslot )
    136136                        {
    137                                 case slot::POSITION : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) p_offset = (int)desc.slots[i].offset; break;
    138                                 case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) n_offset = (int)desc.slots[i].offset; break;
    139                                 case slot::TANGENT  : if ( desc.slots[i].etype == FLOAT_VECTOR_4 ) t_offset = (int)desc.slots[i].offset; break;
     137                                case slot::POSITION : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) p_offset = int(desc.slots[i].offset); break;
     138                                case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 ) n_offset = int(desc.slots[i].offset); break;
     139                                case slot::TANGENT  : if ( desc.slots[i].etype == FLOAT_VECTOR_4 ) t_offset = int(desc.slots[i].offset); break;
    140140                                default             : break;
    141141                        }
    … …  
    144144                        for ( uint32 i = 0; i < channel->count; i++)
    145145                        {
    146                                 vec3& p = *((vec3*)(raw_data + vtx_size*i + p_offset ));
     146                                vec3& p = *reinterpret_cast<vec3*>( raw_data + vtx_size*i + p_offset );
    147147                                p = vertex_transform * p + vertex_offset;
    148148                        }
    … …  
    151151                        for ( uint32 i = 0; i < channel->count; i++)
    152152                        {
    153                                 vec3& n = *((vec3*)(raw_data + vtx_size*i + n_offset ));
     153                                vec3& n = *reinterpret_cast<vec3*>( raw_data + vtx_size*i + n_offset );
    154154                                n = glm::normalize( normal_transform * n );
    155155                        }
    … …  
    157157                        for ( uint32 i = 0; i < channel->count; i++)
    158158                        {
    159                                 vec4& t = *((vec4*)(raw_data + vtx_size*i + t_offset ));
     159                                vec4& t = *reinterpret_cast<vec4*>(raw_data + vtx_size*i + t_offset );
    160160                                t = vec4( glm::normalize( normal_transform * vec3(t) ), t[3] );
    161161                        }
    … …  
    173173        size_t n_offset = 0;
    174174        if ( ch_n == -1 ) return;
    175         mesh_raw_channel* channel = m_data->m_channels[ (unsigned) ch_n ];
     175        mesh_raw_channel* channel = m_data->m_channels[ unsigned( ch_n ) ];
    176176        for ( uint32 i = 0; i < channel->desc.count; ++i )
    177177                if ( channel->desc.slots[i].vslot == slot::NORMAL )
    … …  
    182182        for ( uint32 i = 0; i < channel->count; ++i )
    183183        {
    184                 vec3& normal = *(vec3*)(channel->data + channel->desc.size * i + n_offset);
     184                vec3& normal = *reinterpret_cast<vec3*>( channel->data + channel->desc.size * i + n_offset );
    185185                normal = -normal;
    186186        }
    … …  
    211211                                if ( desc.slots[i].etype == FLOAT_VECTOR_3 )
    212212                                {
    213                                         p_offset  = (int)desc.slots[i].offset;
     213                                        p_offset  = int( desc.slots[i].offset );
    214214                                        p_channel = channel;
    215215                                }
    … …  
    217217                        case slot::NORMAL   : if ( desc.slots[i].etype == FLOAT_VECTOR_3 )
    218218                                {
    219                                         n_offset  = (int)desc.slots[i].offset;
     219                                        n_offset  = int( desc.slots[i].offset );
    220220                                        n_channel = m_data->m_channels[ c ];
    221221                                        n_channel_index = c;
    … …  
    224224                        case slot::TEXCOORD : if ( desc.slots[i].etype == FLOAT_VECTOR_2 )
    225225                                {
    226                                         t_offset  = (int)desc.slots[i].offset;
     226                                        t_offset  = int( desc.slots[i].offset );
    227227                                        t_channel = channel;
    228228                                }
    … …  
    246246
    247247        mesh_raw_channel* g_channel = mesh_raw_channel::create<vertex_g>( p_channel->count );
    248         vec4* tangents              = (vec4*)g_channel->data;
     248        vec4* tangents              = reinterpret_cast<vec4*>( g_channel->data );
    249249        vec3* tangents2             = new vec3[ p_channel->count ];
    250250        uint32 tri_count = i_channel ? i_channel->count / 3 : t_channel->count / 3;
    … …  
    259259                if ( i_type == UINT )
    260260                {
    261                         const uint32* idata = (const uint32*)i_channel->data;
     261                        const uint32* idata = reinterpret_cast<const uint32*>( i_channel->data );
    262262                        ti0 = idata[ i * 3 ];
    263263                        ti1 = idata[ i * 3 + 1 ];
    … …  
    266266                else if ( i_type == USHORT )
    267267                {
    268                         const uint16* idata = (const uint16*)i_channel->data;
     268                        const uint16* idata = reinterpret_cast<const uint16*>( i_channel->data );
    269269                        ti0 = idata[ i * 3 ];
    270270                        ti1 = idata[ i * 3 + 1 ];
    … …  
    278278                }
    279279
    280                 const vec2& w1 = *((vec2*)(t_channel->data + t_channel->desc.size*ti0 + t_offset ));
    281                 const vec2& w2 = *((vec2*)(t_channel->data + t_channel->desc.size*ti1 + t_offset ));
    282                 const vec2& w3 = *((vec2*)(t_channel->data + t_channel->desc.size*ti2 + t_offset ));
     280                const vec2& w1 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.size*ti0 + t_offset );
     281                const vec2& w2 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.size*ti1 + t_offset );
     282                const vec2& w3 = *reinterpret_cast<vec2*>(t_channel->data + t_channel->desc.size*ti2 + t_offset );
    283283                vec2 st1 = w3 - w1;
    284284                vec2 st2 = w2 - w1;
    … …  
    291291                        uint32 nti1 = t_channel->count * set + ti1;
    292292                        uint32 nti2 = t_channel->count * set + ti2;
    293                         vec3 v1 = *((vec3*)(p_channel->data + p_channel->desc.size*nti0 + p_offset ));
    294                         vec3 v2 = *((vec3*)(p_channel->data + p_channel->desc.size*nti1 + p_offset ));
    295                         vec3 v3 = *((vec3*)(p_channel->data + p_channel->desc.size*nti2 + p_offset ));
     293                        vec3 v1 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.size*nti0 + p_offset );
     294                        vec3 v2 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.size*nti1 + p_offset );
     295                        vec3 v3 = *reinterpret_cast<vec3*>(p_channel->data + p_channel->desc.size*nti2 + p_offset );
    296296                        vec3 xyz1 = v3 - v1;
    297297                        vec3 xyz2 = v2 - v1;
    … …  
    317317        for ( unsigned int i = 0; i < vtx_count; ++i )
    318318        {
    319                 const vec3 n = *((vec3*)(n_channel->data + n_channel->desc.size*i + n_offset ));
     319                const vec3 n = *reinterpret_cast<vec3*>( n_channel->data + n_channel->desc.size*i + n_offset );
    320320                const vec3 t = vec3(tangents[i]);
    321321                if ( ! ( t.x == 0.0f && t.y == 0.0f && t.z == 0.0f ) )
    … …  
    420420        int och_ti = other->get_channel_index( slot::TEXCOORD );
    421421        if ( ch_pi == -1 || ch_ti == -1 ) return;
    422         size_t size   = m_data->m_channels[ (unsigned)ch_ti ]->count;
    423         size_t osize  =  other->m_channels[ (unsigned)och_ti ]->count;
    424         size_t count  = m_data->m_channels[ (unsigned)ch_pi ]->count;
    425         size_t ocount =  other->m_channels[ (unsigned)och_pi ]->count;
     422        size_t size   = m_data->m_channels[ unsigned(ch_ti) ]->count;
     423        size_t osize  =  other->m_channels[ unsigned(och_ti) ]->count;
     424        size_t count  = m_data->m_channels[ unsigned(ch_pi) ]->count;
     425        size_t ocount =  other->m_channels[ unsigned(och_pi) ]->count;
    426426        if ( count % size != 0 || ocount % osize != 0 ) return;
    427427        if ( count / size != ocount / osize ) return;
    … …  
    440440                                {
    441441                                        NV_ASSERT( size + osize < uint16(-1), "Index out of range!" );
    442                                         uint16* indexes = (uint16*)m_data->m_channels[c]->data;
    443                                         for ( uint16 i = (uint16)old->count; i < m_data->m_channels[c]->count; ++i )
    444                                                 indexes[i] += (uint16)size;
     442                                        uint16* indexes = reinterpret_cast<uint16*>( m_data->m_channels[c]->data );
     443                                        for ( uint16 i = uint16( old->count ); i < m_data->m_channels[c]->count; ++i )
     444                                                indexes[i] += uint16( size );
    445445
    446446                                }
    … …  
    448448                        case UINT   :
    449449                                {
    450                                         uint32* indexes = (uint32*)m_data->m_channels[c]->data;
     450                                        uint32* indexes = reinterpret_cast<uint32*>( m_data->m_channels[c]->data );
    451451                                        for ( uint32 i = old->count; i < m_data->m_channels[c]->count; ++i )
    452452                                                indexes[i] += size;

  • trunk/src/gfx/skeletal_mesh.cc

    r395 r406  
    1616{
    1717        const mesh_raw_channel* pnt_chan = a_mesh_data->get_channel<md5_vtx_pnt>();
    18         m_pntdata.assign( (const md5_vtx_pnt*)pnt_chan->data, pnt_chan->count );
     18        m_pntdata.assign( reinterpret_cast<const md5_vtx_pnt*>( pnt_chan->data ), pnt_chan->count );
    1919        m_bone_offset.resize( bones->get_count() );
    2020        m_transform.resize( bones->get_count() );
    … …  
    3535        if ( a_anim )
    3636        {
    37                 skeletal_animation_entry_cpu * anim = (skeletal_animation_entry_cpu*)a_anim;
    38                 anim->update_skeleton( m_transform.data(), (float)a_anim_time );
     37                skeletal_animation_entry_cpu * anim = static_cast<skeletal_animation_entry_cpu*>( a_anim );
     38                anim->update_skeleton( m_transform.data(), static_cast<float>( a_anim_time ) );
    3939                {
    4040                        size_t skeleton_size = m_bone_offset.size();
    … …  
    5151                                const md5_vtx_pntiw& vert = m_vtx_data[i];
    5252
    53                                 for ( size_t j = 0; j < 4; ++j )
     53                                for ( int j = 0; j < 4; ++j )
    5454                                {
    55                                         unsigned index = (unsigned)vert.boneindex[j];
     55                                        unsigned index = unsigned( vert.boneindex[j] );
    5656                                        float weight   = vert.boneweight[j];
    5757                                        const quat& orient      = m_transform[index].get_orientation();
    … …  
    7171void nv::skeletal_animation_entry_cpu::update_skeleton( transform* skeleton, float time ) const
    7272{
    73         float frame_duration = 1000.f / (float)m_node_data->get_frame_rate();
     73        float frame_duration = 1000.f / static_cast<float>( m_node_data->get_frame_rate() );
    7474        float anim_duration = frame_duration * m_node_data->get_duration();
    7575        float new_time = fmodf( time, anim_duration ) * 0.001f;
    … …  
    152152                if ( bi != bone_names.end() )
    153153                {
    154                         bone_id = (sint16)bi->second;
     154                        bone_id = sint16( bi->second );
    155155                }
    156156                m_bone_ids[n] = bone_id;
    … …  
    207207        if ( m_bone_data && a_anim )
    208208        {
    209                 skeletal_animation_entry_gpu * anim = (skeletal_animation_entry_gpu*)a_anim;
     209                skeletal_animation_entry_gpu * anim = static_cast<skeletal_animation_entry_gpu*>( a_anim );
    210210                anim->prepare( m_bone_data );
    211211                anim->update_skeleton( m_transform, a_anim_time );
Note: See TracChangeset for help on using the changeset viewer.