Ignore:
Timestamp:
06/20/15 00:05:17 (10 years ago)
Author:
epyon
Message:
  • code compiles cleanly on maximum warning level
File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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;
Note: See TracChangeset for help on using the changeset viewer.