Changeset 424 for trunk


Ignore:
Timestamp:
07/16/15 21:21:19 (10 years ago)
Author:
epyon
Message:
  • refactoring WIP! (compiles though - warnings on purpose)
Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv/interface/data_channel.hh

    r421 r424  
    8383                friend class data_channel_set_creator;
    8484                friend class raw_data_channel_access;
     85                friend class mesh_nodes_creator;
    8586
    8687                typedef const raw_data_channel* const_iterator;
    … …  
    9091                        for ( uint32 c = 0; c < other.m_size; ++c )
    9192                                m_channels[c] = move( other.m_channels[c] );
    92                         m_size = other.m_size;
     93                        m_size      = other.m_size;
     94                        m_parent_id = other.m_parent_id;
     95                        m_transform = other.m_transform;
     96                        m_name      = other.m_name;
    9397                        other.m_size = 0;
    9498                }
    … …  
    100104                                for ( uint32 c = 0; c < other.m_size; ++c )
    101105                                        m_channels[c] = move( other.m_channels[c] );
    102                                 m_size = other.m_size;
     106                                m_size      = other.m_size;
     107                                m_parent_id = other.m_parent_id;
     108                                m_transform = other.m_transform;
     109                                m_name      = other.m_name;
    103110                                other.m_size = 0;
    104111                        }
    … …  
    201208                const_iterator begin() const { return &m_channels[0]; }
    202209                const_iterator end()   const { return &m_channels[ m_size ]; }
     210
     211                uint64 get_name() const { return m_name; }
     212                sint16 get_parent_id() const { return m_parent_id; }
     213                const mat4& get_transform() const { return m_transform; }
     214
    203215        protected:
    204216
    205217                data_channel_set()
    206218                {
    207                         m_size = 0;
    208                 }
     219                        m_size      = 0;
     220                        m_name      = 0;
     221                        m_parent_id = -1;
     222                }
     223
    209224                raw_data_channel m_channels[4];
     225
    210226                uint32 m_size;
     227                uint64 m_name;
     228                sint16 m_parent_id;
     229                mat4   m_transform;
    211230        };
    212231

  • trunk/nv/interface/data_channel_access.hh

    r419 r424  
    101101        public:
    102102
    103                 static data_channel_set* create( size_t )
     103                static data_channel_set* create_set( size_t )
    104104                {
    105105                        return new data_channel_set;
    106106                }
    107107
    108                 static data_channel_set* create_array( size_t size, size_t )
     108                static data_channel_set* create_set_array( size_t size, size_t )
    109109                {
    110110                        return new data_channel_set[ size ];
    … …  
    146146                void move_to( data_channel_set& other )
    147147                {
     148                        int change_to_move;
    148149                        //                      other.m_name          = m_name;
    149150                        for ( uint32 c = 0; c < m_set->m_size; ++c )
    … …  
    152153                                other.m_channels[c] = move( m_set->m_channels[c] );
    153154                        }
     155                        other.m_name = m_set->m_name;
     156                        other.m_parent_id = m_set->m_parent_id;
     157                        other.m_transform = m_set->m_transform;
    154158                        other.m_size = m_set->m_size;
    155159                        m_set->m_size = 0;
    156160                }
    157161
     162                void set_transform( const mat4& tr ) { m_set->m_transform = tr; }
     163                const mat4& get_transform() const { return m_set->m_transform; }
     164
     165                void set_name( uint64 name ) {  m_set->m_name = name; }
     166                uint64 get_name() const { return m_set->m_name; }
     167
     168                void set_parent_id( sint16 name ) { m_set->m_parent_id = name; }
     169                sint16 get_parent_id() const { return m_set->m_parent_id; }
    158170        protected:
    159171                data_channel_set* m_set;

  • trunk/nv/interface/mesh_data.hh

    r423 r424  
    2222        using mesh_data = data_channel_set;
    2323
     24#pragma warning TODO_LIST!
     25        // TODO :
     26        //  * get rid of mesh_node_data, optimize further
     27        //  * properly write and read strings from nmd's
     28        //  * mesh_loader string_table support
     29        //  * properly write strings in other loaders
     30        //  * attribute/property implementation and read/write on every nmd::command
    2431        struct mesh_node_data
    2532        {
    26                 uint64    name;
    27                 sint16    parent_id;
    28                 mat4      transform;
    2933                data_channel_set* data;
    3034        };
    … …  
    4852                size_t get_count() const { return m_count; }
    4953
     54                bool is_animated( size_t i ) const
     55                {
     56                        if ( i >= m_count ) return false;
     57                        return ( m_nodes[i].data && m_nodes[i].data->size() > 0 );
     58                }
     59
    5060                const mesh_node_data* get_node( size_t i ) const
    5161                {
    … …  
    5868                        for ( uint32 i = 0; i < m_count; ++i )
    5969                        {
    60                                 if ( m_nodes[ i ].name == h )
     70                                NV_ASSERT( m_nodes[i].data, "data!" );
     71                                if ( m_nodes[ i ].data->get_name() == h )
    6172                                        return &m_nodes[ i ];
    6273                        }
    … …  
    6879                        for ( uint32 i = 0; i < m_count; ++i )
    6980                        {
    70                                 if ( m_nodes[ i ].name == h )
     81                                NV_ASSERT( m_nodes[i].data, "data!" );
     82                                if ( m_nodes[ i ].data->get_name() == h )
    7183                                        return int( i );
    7284                        }

  • trunk/src/formats/assimp_loader.cc

    r423 r424  
    108108{
    109109        if ( index >= m_mesh_count ) return nullptr;
    110         data_channel_set* result = data_channel_set_creator::create( 2 );
     110        data_channel_set* result = data_channel_set_creator::create_set( 2 );
    111111        load_mesh_data( result, index );
    112112        return result;
    … …  
    199199                aiBone* bone   = mesh->mBones[m];
    200200                mat4    offset = assimp_mat4_cast( bone->mOffsetMatrix );
    201 //              bones[m].name = bone->mName.data;
    202                 bones[m].name = hash_string< uint64 >( bone->mName.data );
    203                 bones[m].data = nullptr;
    204                 bones[m].parent_id = -1;
    205 //              bones[m].target_id = -1;
    206                 bones[m].transform = offset;
     201                bones[m].data = data_channel_set_creator::create_set( 0 );
     202                data_channel_set_creator access( bones[m].data );
     203                access.set_name( hash_string< uint64 >( bone->mName.data ) );
     204                access.set_transform( offset );
    207205        }
    208206        return true;
    … …  
    302300
    303301                                mesh_node_data& bone = bones[b];
    304                                 auto iname = names.find( bone.name );
     302                                auto iname = names.find( bone.data->get_name() );
    305303                                if ( iname == names.end() )
    306304                                {
    … …  
    308306                                        uint16 index = uint16( final_bones.size() );
    309307                                        final_bones.push_back( bone );
    310                                         names[ bone.name] = index;
     308                                        names[ bone.data->get_name() ] = index;
    311309                                        translate[b] = index;
    312310                                }
    … …  
    390388        mesh_node_data& a_data = nodes[ this_id ];
    391389
    392 //      a_data.name      = name;
    393         a_data.name = hash_string< uint64 >( name.c_str() );
    394         a_data.parent_id = parent_id;
     390        if (anode)
     391                create_keys( &a_data, anode );
     392        else
     393                a_data.data = data_channel_set_creator::create_set( 0 );
     394
     395        data_channel_set_creator access( a_data.data );
     396        access.set_name( hash_string< uint64 >( name.c_str() ) );
     397        access.set_parent_id( parent_id );
    395398        // This value is ignored by the create_transformed_keys, but needed by create_direct_keys!
    396399        // TODO: find a common solution!
    397400        //       This is bad because create_transformed_keys never uses node-transformations for
    398401        //       node's without keys
    399         a_data.transform = nv::assimp_mat4_cast( node->mTransformation );
    400         if (this_id == 0)
    401                 a_data.transform = mat4();
    402         a_data.data = nullptr;
    403 
    404         if (anode) create_keys( &a_data, anode );
     402        access.set_transform( nv::assimp_mat4_cast( node->mTransformation ) );
     403        if ( this_id == 0 ) access.set_transform( mat4() );
    405404
    406405        nv::sint16 next = this_id + 1;
    … …  
    421420        }
    422421
    423         data->data = data_channel_set_creator::create( 2 );
     422        data->data = data_channel_set_creator::create_set( 2 );
    424423        data_channel_set_creator key_set( data->data );
    425424
    … …  
    465464        const aiScene* scene = reinterpret_cast<const aiScene*>( m_scene );
    466465        bool has_bones = false;
    467         data_channel_set* meshes = data_channel_set_creator::create_array( m_mesh_count, 2 );
     466        data_channel_set* meshes = data_channel_set_creator::create_set_array( m_mesh_count, 2 );
    468467        for ( size_t m = 0; m < m_mesh_count; ++m )
    469468        {

  • trunk/src/formats/md2_loader.cc

    r417 r424  
    313313data_channel_set* nv::md2_loader::release_mesh_data( size_t )
    314314{
    315         data_channel_set* data = data_channel_set_creator::create( 3 );
     315        data_channel_set* data = data_channel_set_creator::create_set( 3 );
    316316        release_mesh_frame( data, -1 );
    317317        return data;
    … …  
    367367mesh_data_pack* nv::md2_loader::release_mesh_data_pack()
    368368{
    369         data_channel_set* data = data_channel_set_creator::create_array( 1, 3 );
     369        data_channel_set* data = data_channel_set_creator::create_set_array( 1, 3 );
    370370        release_mesh_frame( &data[0], -1 );
    371371        return new mesh_data_pack( 1, data );

  • trunk/src/formats/md3_loader.cc

    r423 r424  
    324324data_channel_set* nv::md3_loader::release_mesh_data( nv::size_t index )
    325325{
    326         data_channel_set* data = data_channel_set_creator::create(3);
     326        data_channel_set* data = data_channel_set_creator::create_set(3);
    327327        release_mesh_frame( data, -1, static_cast< sint32 >( index ) );
    328328        return data;
    … …  
    424424                const md3_tag_t& rtag = md3->tags[i];
    425425                string_view name( reinterpret_cast< const char* >(rtag.name) );
    426 
    427                 nodes[i].transform = mat4();
    428                 nodes[i].name = hash_string< uint64 >( name.data() );
    429                 nodes[i].parent_id = -1;
    430                 nodes[i].data      = data_channel_set_creator::create( 1 );
    431                 load_tags( data_channel_set_creator( nodes[i].data ).add_channel<md3_key>( uint32( md3->header.num_frames ) ).channel(), name );
     426                nodes[i].data      = data_channel_set_creator::create_set( 1 );
     427                data_channel_set_creator access( nodes[i].data );
     428                access.set_name( hash_string< uint64 >( name.data() ) );
     429                load_tags( access.add_channel<md3_key>( uint32( md3->header.num_frames ) ).channel(), name );
    432430        }
    433431        int name_;
    … …  
    442440        if ( m_merge_all )
    443441        {
    444                 data = data_channel_set_creator::create_array(1,3);
     442                data = data_channel_set_creator::create_set_array(1,3);
    445443                release_mesh_frame( &data[0], -1, -1 );
    446444                data_channel_set_creator( &data[0] ).set_name( reinterpret_cast< char* >( md3->header.name ) );
    … …  
    449447        {
    450448                count = md3->header.num_surfaces;
    451                 data = data_channel_set_creator::create_array( count, 3 );
     449                data = data_channel_set_creator::create_set_array( count, 3 );
    452450                for ( int i = 0; i < count; ++i )
    453451                {

  • trunk/src/formats/md5_loader.cc

    r423 r424  
    118118                        {
    119119                                std::string name;
    120                                 sstream >> name >> nodes[i].parent_id;
     120                                sint16 parent_id;
     121                                sstream >> name >> parent_id;
    121122                                vec3 pos;
    122123                                quat orient;
    … …  
    128129                                unit_quat_w( orient );
    129130                                remove_quotes( name );
    130 //                              nodes[i].name = name;
    131                                 nodes[i].name = hash_string< uint64 >( name.c_str() );
    132 //                              nodes[i].target_id       = -1;
    133                                 nodes[i].parent_id       = -1;
    134                                 nodes[i].transform       = transform( pos, orient ).inverse().extract();
    135                                 nodes[i].data            = nullptr;
     131                                nodes[i].data       = data_channel_set_creator::create_set( 0 );
     132                                data_channel_set_creator access( nodes[i].data );
     133                                access.set_parent_id( parent_id );
     134                                access.set_transform( transform( pos, orient ).inverse().extract() );
     135                                access.set_name( hash_string< uint64 >( name.c_str() ) );
    136136                                next_line( sstream );
    137137                        }
    … …  
    141141                {
    142142                        assert( m_type == MESH );
    143                         data_channel_set* mesh = data_channel_set_creator::create( 4 );
     143                        data_channel_set* mesh = data_channel_set_creator::create_set( 4 );
    144144                        data_channel_set_creator maccess( mesh );
    145145
    … …  
    251251                        {
    252252                                std::string    name;
    253                                 sstream >> name >> nodes[i].parent_id >> joint_infos[i].flags >> joint_infos[i].start_index;
     253                                sint16 parent_id;
     254                                sstream >> name >> parent_id >> joint_infos[i].flags >> joint_infos[i].start_index;
    254255                                remove_quotes( name );
    255 //                              nodes[i].name = name;
    256                                 nodes[i].name = hash_string< uint64 >( name.c_str() );
    257                                 nodes[i].transform = mat4();
    258                                 nodes[i].data = data_channel_set_creator::create( 1 );
    259                                 data_channel_set_creator( nodes[i].data ).add_channel< md5_key_t >( num_frames );
     256                                nodes[i].data = data_channel_set_creator::create_set( 1 );
     257                                data_channel_set_creator access( nodes[i].data );
     258                                access.add_channel< md5_key_t >( num_frames );
     259                                access.set_name( hash_string< uint64 >( name.c_str() ) );
     260                                access.set_parent_id( parent_id );
    260261                                next_line( sstream );
    261262                        }
    … …  
    391392                                md5_weight& weight           = weights[start_weight + j];
    392393                                const mesh_node_data&  joint = nodes[weight.joint_id];
    393                                 const transform tr = transform( joint.transform ).inverse();
     394                                const transform tr = transform( joint.data->get_transform() ).inverse();
    394395                                vec3 rot_pos = tr.get_orientation() * weight.pos;
    395396
    … …  
    454455                {
    455456                        const mesh_node_data&  joint = nodes[vdata.boneindex[j]];
    456                         const transform tr = transform( joint.transform ).inverse();
     457                        const transform tr = transform( joint.data->get_transform() ).inverse();
    457458                        vdata.normal  += ( normal  * tr.get_orientation() ) * vdata.boneweight[j];
    458459                        vdata.tangent += ( tangent * tr.get_orientation() ) * vdata.boneweight[j];
    … …  
    472473                const md5_joint_info& jinfo = joint_infos[i];
    473474                mesh_node_data& joint = nodes[i];
    474                 int parent_id         = joint.parent_id;
     475                int parent_id         = joint.data->get_parent_id();
    475476
    476477                vec3 pos    = base_frames[i].get_position();
    … …  
    519520{
    520521        uint32 size = m_meshes.size();
    521         data_channel_set* meshes = data_channel_set_creator::create_array( size, 4 );
     522        data_channel_set* meshes = data_channel_set_creator::create_set_array( size, 4 );
    522523        for ( uint32 i = 0; i < size; ++i )
    523524        {

  • trunk/src/formats/nmd_loader.cc

    r423 r424  
    3737bool nv::nmd_loader::load_mesh( stream& source, const nmd_element_header& e )
    3838{
    39         data_channel_set* mesh = data_channel_set_creator::create( e.children );
     39        data_channel_set* mesh = data_channel_set_creator::create_set( e.children );
    4040        load_channel_set( source, mesh, e );
    4141//      m_mesh_names.push_back( e.name );
    … …  
    5555{
    5656        uint32 size = m_meshes.size();
    57         data_channel_set* meshes = data_channel_set_creator::create_array( size, 0 );
     57        data_channel_set* meshes = data_channel_set_creator::create_set_array( size, 0 );
    5858        for ( uint32 i = 0; i < size; ++i )
    5959        {
    … …  
    119119bool nv::nmd_loader::load_node( stream& source, mesh_node_data* data, const nmd_element_header& e )
    120120{
    121         data->name = e.name;
    122         data->parent_id = e.parent_id;
    123         data->transform = e.transform;
    124         data->data = nullptr;
     121        data->data = data_channel_set_creator::create_set( e.children );
    125122        if ( e.children > 0 )
    126123        {
    127                 data->data = data_channel_set_creator::create( e.children );
    128124                load_channel_set( source, data->data, e );
    129125        }
     126        data_channel_set_creator access( data->data );
     127        access.set_name( e.name );
     128        access.set_parent_id( e.parent_id );
     129        access.set_transform( e.transform );
    130130        return true;
    131131}
    … …  
    206206        eheader.children   = static_cast<uint16>( chan_count );
    207207        eheader.size       = chan_size;
    208         eheader.name       = node->name;
    209         eheader.parent_id  = node->parent_id;
    210         eheader.transform  = node->transform;
     208        eheader.name       = node->data->get_name();
     209        eheader.parent_id  = node->data->get_parent_id();
     210        eheader.transform  = node->data->get_transform();
    211211        eheader.attributes = 0;
    212212        stream_out.write( &eheader, sizeof( eheader ), 1 );
    213         if ( node->data ) nmd_dump_channel_set( node->data, stream_out );
     213        if ( chan_count > 0 ) nmd_dump_channel_set( node->data, stream_out );
    214214}
    215215
    … …  
    238238        eheader.children   = static_cast<uint16>( mesh.size() );
    239239        eheader.size       = size;
    240         int uncomment;
    241 //      eheader.name       = mesh.get_name();
    242 //      eheader.transform  = mesh.get_transform();
    243 //      eheader.parent_id  = mesh.get_parent_id();
    244         eheader.name       = 0;
    245         eheader.transform  = mat4();
    246         eheader.parent_id  = -1;
     240        eheader.name       = mesh.get_name();
     241        eheader.transform  = mesh.get_transform();
     242        eheader.parent_id  = mesh.get_parent_id();
    247243        eheader.attributes = 0;
    248244        stream_out.write( &eheader, sizeof( eheader ), 1 );

  • trunk/src/formats/obj_loader.cc

    r417 r424  
    326326                }
    327327       
    328                 data_channel_set* result = data_channel_set_creator::create( 1 );
     328                data_channel_set* result = data_channel_set_creator::create_set( 1 );
    329329                data_channel_set_creator raccess( result );// ( reader->name );
    330330                uint8* rdata = raccess.add_channel( m_descriptor, reader->size * 3 ).raw_data();
    … …  
    359359{
    360360        uint32 size = m_meshes.size();
    361         data_channel_set* meshes = data_channel_set_creator::create_array( size, 1 );
     361        data_channel_set* meshes = data_channel_set_creator::create_set_array( size, 1 );
    362362        for ( uint32 i = 0; i < size; ++i )
    363363        {

  • trunk/src/gfx/keyframed_mesh.cc

    r419 r424  
    5656        NV_ASSERT( node_id < m_tag_map->get_count(), "TAGMAP FAIL" );
    5757        const data_channel_set* data = m_tag_map->get_node( node_id )->data;
    58         NV_ASSERT( data, "TAG FAIL" );
     58        NV_ASSERT( data && data->size() > 0, "TAG FAIL" );
    5959        raw_channel_interpolator interpolator( data, m_interpolation_key );
    6060        return interpolator.get< transform >( m_last_frame, m_next_frame, m_interpolation );

  • trunk/src/gfx/mesh_creator.cc

    r419 r424  
    1818        for ( size_t i = 0; i < m_data->get_count(); ++i )
    1919        {
    20                 sint16 parent_id = m_data->m_nodes[i].parent_id;
     20                sint16 parent_id = m_data->m_nodes[i].data->get_parent_id();
    2121                data_channel_set* keys   = m_data->m_nodes[i].data;
    2222                data_channel_set* pkeys  = ( parent_id != -1 ? m_data->m_nodes[parent_id].data : nullptr );
    … …  
    6565                        }
    6666
    67                         data_channel_set* new_keys = data_channel_set_creator::create( 1 );
     67                        data_channel_set* new_keys = data_channel_set_creator::create_set( 1 );
    6868                        data_channel_set_creator nk_access( new_keys );
     69                        nk_access.set_name( old_keys->get_name() );
     70                        nk_access.set_parent_id( old_keys->get_parent_id() );
     71                        nk_access.set_transform( old_keys->get_transform() );
    6972                        data_channel_access< nv_key_transform > kt_channel( nk_access.add_channel<nv_key_transform>( max_keys ) );
    7073
    … …  
    100103        {
    101104                mesh_node_data& node = m_data->m_nodes[i];
    102                 node.transform = pre_transform * node.transform * post_transform;
     105                node.data->m_transform = pre_transform * node.data->m_transform * post_transform;
    103106                if ( node.data )
    104107                {

  • trunk/src/gfx/skeletal_mesh.cc

    r423 r424  
    2323        for ( uint32 i = 0; i < bones->get_count(); ++i )
    2424        {
    25                 m_bone_offset[i] = transform( bones->get_node(i)->transform );
     25                m_bone_offset[i] = transform( bones->get_node(i)->data->get_transform() );
    2626        }
    2727
    … …  
    9595        for ( size_t i = 0; i < m_node_data->get_count(); ++i )
    9696        {
    97                 if ( m_node_data->get_node( i )->data )
     97                if ( m_node_data->is_animated( i ) )
    9898                {
    9999                        m_interpolation_key = m_node_data->get_node( i )->data->get_interpolation_key();
    … …  
    133133                {
    134134                        const mesh_node_data* node = m_node_data->get_node(n);
    135                         if ( node->parent_id != -1 )
    136                         {
    137                                 m_children[ node->parent_id ].push_back( n );
     135                        if ( node->data->get_parent_id() != -1 )
     136                        {
     137                                m_children[ node->data->get_parent_id()].push_back( n );
    138138                        }
    139139                }
    … …  
    157157                {
    158158                        const mesh_node_data* node = m_node_data->get_node(n);
    159                         nv::mat4 node_mat( node->transform );
    160 
    161                         if ( node->data )
     159                        nv::mat4 node_mat( node->data->get_transform() );
     160
     161                        if ( node->data && node->data->size() > 0 )
    162162                        {
    163163                                raw_channel_interpolator interpolator( node->data, m_interpolation_key );
    … …  
    178178        {
    179179                const mesh_node_data* bone = bones->get_node(bi);
    180                 bone_names[ bone->name ] = bi;
    181                 m_offsets[bi] = bone->transform;
     180                bone_names[ bone->data->get_name() ] = bi;
     181                m_offsets[bi] = bone->data->get_transform();
    182182        }
    183183
    … …  
    187187                sint16 bone_id = -1;
    188188
    189                 auto bi = bone_names.find( node->name );
     189                auto bi = bone_names.find( node->data->get_name() );
    190190                if ( bi != bone_names.end() )
    191191                {
    … …  
    194194                m_bone_ids[n] = bone_id;
    195195
    196                 if ( m_interpolation_key.size() == 0 && node->data )
     196                if ( m_interpolation_key.size() == 0 && node->data->size() > 0 )
    197197                        m_interpolation_key = node->data->get_interpolation_key();
    198198
    … …  
    206206        //       see note in assimp_loader.cc:load_node
    207207        const mesh_node_data* node = m_node_data->get_node( node_id );
    208         mat4 node_mat( node->transform );
    209 
    210         if ( node->data )
     208        mat4 node_mat( node->data->get_transform() );
     209
     210        if ( node->data && node->data->size() > 0 )
    211211        {
    212212                raw_channel_interpolator interpolator( node->data, m_interpolation_key );
Note: See TracChangeset for help on using the changeset viewer.