Changeset 543

Show
Ignore:
Timestamp:
03/06/08 19:29:25 (10 months ago)
Author:
phill
Message:

o Now with shader grouping magic!

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/maya2q3/bsp.cpp

    r542 r543  
    2929public: 
    3030        BspImporter( void ); 
    31         void Import( std::istream &stm ); 
     31        void Import( std::istream &stm, const MObject &parentTransform ); 
    3232 
    3333private: 
    34         float m_unitScale; 
    3534        bool m_combineMeshes; 
    3635 
     
    5150 
    5251        MObjectArray m_meshes; 
     52        MDagPathArray m_meshPaths; 
    5353 
    5454        std::vector< std::pair< int, int > > m_shaderMap; 
     
    5656        MObjectArray m_shaders; 
    5757 
     58        MSelectionList m_miscLmapSels; 
     59        std::vector< MSelectionList > m_lmapSels; 
     60        std::vector< MSelectionList > m_shaderSels; 
     61 
    5862        q3::dheader_t m_fileHeader; 
    5963        BinaryReader *m_fileData; 
     
    7781                int firstVert = 0, int vertexCount = -1, int firstIndex = 0, int indexCount = -1 ); 
    7882 
    79         MObject CreateMesh(); 
     83        void CreateMesh(); 
    8084        void ClearStagingArea(); 
    8185 
     
    8387 
    8488        void ImportSurfaces(); 
     89        void CreateShaderQuickSelects(); 
     90        void CreateQuickSelect( const MSelectionList &sel, const MString &name ); 
     91 
     92        void GroupMeshNodes( const MObject &parentXform ); 
    8593}; 
    8694 
    8795#pragma warning( disable : 4100 ) //shut up unreferenced parameter warnings until dev of this file is done 
    8896 
     97template< size_t n > 
     98static void MangleShaderName( sstr< n > &ret, const char *src ) 
     99{ 
     100        for( char c = *src++; c; c = *src++ ) 
     101        { 
     102                switch( c ) 
     103                { 
     104                case '_': 
     105                        ret.Append( "__" ); 
     106                        break; 
     107 
     108                case '.': 
     109                case '/': 
     110                case '\\': 
     111                        ret.Append( "_" ); 
     112                        break; 
     113 
     114                default: 
     115                        ret.Append( "%c", c ); 
     116                        break; 
     117                } 
     118        } 
     119} 
     120 
    89121BspImporter::BspImporter( void ) 
    90122{ 
    91         m_unitScale = 0.01F; 
    92123        m_combineMeshes = false; 
    93124} 
     
    104135        } 
    105136 
     137        if( shaderNum >= (int)m_shaderSels.size() ) 
     138                m_shaderSels.resize( shaderNum + 1 ); 
     139        if( lightmapNum >= 0 && lightmapNum >= (int)m_lmapSels.size() ) 
     140                m_lmapSels.resize( lightmapNum + 1 ); 
     141 
    106142        const q3::dshader_t &shader = shaders[shaderNum]; 
    107143        sstr< 1024 > buf; 
    108144 
    109         size_t srcLen = shader.shader.Length(); 
    110         for( size_t i = 0; i < srcLen; i++ ) 
    111         { 
    112                 char c = shader.shader[i]; 
    113                 switch( c ) 
    114                 { 
    115                 case '_': 
    116                         buf.Append( "__" ); 
    117                         break; 
    118  
    119                 case '/': 
    120                 case '\\': 
    121                         buf.Append( "_" ); 
    122                         break; 
    123  
    124                 default: 
    125                         buf.Append( "%c", c ); 
    126                         break; 
    127                 } 
    128         } 
     145        MangleShaderName( buf, shader.shader ); 
    129146 
    130147        if( lightmapNum >= 0 ) 
     
    200217                const q3::drawVert_t &v = verts[firstVert + i]; 
    201218 
    202                 m_verts.append( MPoint( q3::Q3VecToMaya( v.xyz ) * m_unitScale ) ); 
     219                m_verts.append( MPoint( q3::Q3VecToMaya( v.xyz ) ) ); 
    203220                m_textureU.append( v.st.x ); 
    204221                m_textureV.append( v.st.y ); 
     
    327344                if( !m_combineMeshes && m_verts.length() ) 
    328345                { 
    329                         m_meshes.append( CreateMesh() ); 
     346                        CreateMesh(); 
    330347                        ClearStagingArea(); 
    331348                } 
     
    333350 
    334351        if( m_verts.length() ) 
    335                 m_meshes.append( CreateMesh() ); 
     352                CreateMesh(); 
    336353 
    337354        ClearStagingArea(); 
     
    340357} 
    341358 
    342 void BspImporter::Import( std::istream &stm ) 
    343 
    344         size_t base_pos = stm.tellg(); 
    345  
    346         BinaryReader in( stm ); 
    347  
    348         in >> m_fileHeader; 
    349         for( int i = 0; i < q3::HEADER_LUMPS; i++ ) 
    350                 m_fileHeader.lumps[i].fileofs += base_pos; 
    351  
    352         m_fileData = &in; 
    353  
    354         ImportSurfaces(); 
    355 
    356  
    357 MObject BspImporter::CreateMesh( void ) 
     359void BspImporter::CreateMesh( void ) 
    358360{ 
    359361        MStatus stat; 
     
    365367 
    366368        MString texCoordSetName( "map1" ); 
    367         //stat = mesh.createUVSet( texCoordSetName ); 
    368         //check_status( stat ); 
    369369        stat = mesh.setUVs( m_textureU, m_textureV, &texCoordSetName ); 
    370370        check_status( stat ); 
     
    405405                        continue; 
    406406 
     407                MSelectionList *pLmapSel = &m_miscLmapSels; 
     408                MSelectionList *pShaderSel = &m_shaderSels[m_shaderMap[i].first]; 
     409 
     410                if( m_shaderMap[i].second >= 0 ) 
     411                        pLmapSel = &m_lmapSels[m_shaderMap[i].second]; 
     412 
    407413                MFnSet fnSg( m_shaders[i], &stat ); 
    408414                check_status( stat ); 
    409415 
    410                 MItMeshPolygon polyIt( objPath, MObject::kNullObj, &stat ); 
    411                 check_status( stat ); 
    412  
    413                 MSelectionList sel; 
    414  
    415                 for( uint j = 0; j < map.size(); j++ ) 
    416                 { 
    417                         int prevIndex; 
    418                         stat = polyIt.setIndex( map[j], prevIndex ); 
    419                         check_status( stat ); 
    420  
    421                         MObject comp = polyIt.polygon( &stat ); 
    422                         check_status( stat ); 
    423  
    424                         stat = sel.add( objPath, comp ); 
    425                         check_status( stat ); 
    426                 } 
    427  
    428                 stat = fnSg.addMembers( sel ); 
    429                 check_status( stat ); 
    430         } 
    431  
    432         //MString cmd = MString( "sets -e -fe initialShadingGroup " ) + mesh.name(); 
    433         //stat = MGlobal::executeCommand( cmd ); 
    434         //check_status( stat ); 
    435  
    436         return ret; 
     416                if( m_combineMeshes ) 
     417                { 
     418                        MItMeshPolygon polyIt( objPath, MObject::kNullObj, &stat ); 
     419                        check_status( stat ); 
     420 
     421                        MSelectionList sel; 
     422 
     423                        for( uint j = 0; j < map.size(); j++ ) 
     424                        { 
     425                                int prevIndex; 
     426                                stat = polyIt.setIndex( map[j], prevIndex ); 
     427                                check_status( stat ); 
     428 
     429                                MObject comp = polyIt.polygon( &stat ); 
     430                                check_status( stat ); 
     431 
     432                                stat = sel.add( objPath, comp ); 
     433                                check_status( stat ); 
     434 
     435                                stat = pLmapSel->add( objPath, comp ); 
     436                                check_status( stat ); 
     437 
     438                                stat = pShaderSel->add( objPath, comp ); 
     439                                check_status( stat ); 
     440                        } 
     441 
     442                        stat = fnSg.addMembers( sel ); 
     443                        check_status( stat ); 
     444                } 
     445                else 
     446                { 
     447                        //mesh will be one shader only - this one 
     448                        stat = fnSg.addMember( objPath ); 
     449                        check_status( stat ); 
     450 
     451                        stat = pLmapSel->add( objPath ); 
     452                        check_status( stat ); 
     453 
     454                        stat = pShaderSel->add( objPath ); 
     455                        check_status( stat ); 
     456                } 
     457        } 
     458 
     459        m_meshPaths.append( objPath ); 
     460        m_meshes.append( ret ); 
    437461} 
    438462 
     
    458482} 
    459483 
     484void BspImporter::CreateShaderQuickSelects() 
     485{ 
     486        std::vector< q3::dshader_t > shaders = ReadLump< q3::dshader_t >( q3::LUMP_SHADERS ); 
     487 
     488        CreateQuickSelect( m_miscLmapSels, "lmap_none" ); 
     489 
     490        for( uint i = 0; i < m_lmapSels.size(); i++ ) 
     491        { 
     492                if( !m_lmapSels[i].length() ) 
     493                        continue; 
     494 
     495                sstr< 64 > buf; 
     496                buf.Append( "lmap_%i", i ); 
     497 
     498                CreateQuickSelect( m_lmapSels[i], MString( buf ) ); 
     499        } 
     500 
     501        for( uint i = 0; i < m_shaderSels.size(); i++ ) 
     502        { 
     503                if( !m_shaderSels[i].length() ) 
     504                        continue; 
     505 
     506                sstr< 1024 > buf; 
     507                buf.Append( "shader_" ); 
     508                MangleShaderName( buf, shaders[i].shader ); 
     509 
     510                CreateQuickSelect( m_shaderSels[i], MString( buf ) ); 
     511        } 
     512} 
     513 
     514void BspImporter::CreateQuickSelect( const MSelectionList &sel, const MString &name ) 
     515{ 
     516        MStatus stat; 
     517 
     518        MFnSet fnSet; 
     519        fnSet.create( sel, MFnSet::kNone, false, &stat ); 
     520        check_status( stat ); 
     521 
     522        fnSet.setName( name, &stat ); 
     523        check_status( stat ); 
     524} 
     525 
     526void BspImporter::GroupMeshNodes( const MObject &parentXform ) 
     527{ 
     528        /* 
     529        MStatus stat; 
     530 
     531        MFnDagNode fnParent( parentXform, &stat ); 
     532        check_status( stat ); 
     533 
     534        for( uint i = 0; i < m_meshPaths.length(); i++ ) 
     535        { 
     536                MObject obj = m_meshPaths[i].node(); 
     537                fnParent.addChild( obj ); 
     538        } 
     539        */ 
     540} 
     541 
     542void BspImporter::Import( std::istream &stm, const MObject &parentXform ) 
     543{ 
     544        size_t base_pos = stm.tellg(); 
     545 
     546        BinaryReader in( stm ); 
     547 
     548        in >> m_fileHeader; 
     549        for( int i = 0; i < q3::HEADER_LUMPS; i++ ) 
     550                m_fileHeader.lumps[i].fileofs += base_pos; 
     551 
     552        m_fileData = &in; 
     553 
     554        ImportSurfaces(); 
     555        CreateShaderQuickSelects(); 
     556} 
     557 
    460558class ImportBSP : public MPxFileTranslator 
    461559{ 
     
    490588 
    491589                std::ifstream file; 
    492                 file.open( filename.fullName().asChar(), std::ios::in | std::ios::binary ); 
     590                file.open( filename.resolvedFullName().asChar(), std::ios::in | std::ios::binary ); 
    493591 
    494592                try 
    495593                { 
     594                        MStatus stat; 
     595                        MFnTransform xform; 
     596                        MObject xformObj = xform.create( MObject::kNullObj, &stat ); 
     597                        check_status( stat ); 
     598 
     599                        filename.name(); 
     600                        xform.setName( MString( "bsp_" ) + filename.resolvedName(), &stat ); 
     601                        check_status( stat ); 
     602 
     603                        const double scale[] = { 0.01, 0.01, 0.01 }; 
     604                        stat = xform.setScale( scale ); 
     605                        check_status( stat ); 
     606 
    496607                        BspImporter imp; 
    497                         imp.Import( file ); 
     608                        imp.Import( file, xformObj ); 
    498609                } 
    499610                catch( std::exception &ex ) 
  • trunk/maya2q3/maya_entry.cpp

    r540 r543  
    2626 
    2727static const char *g_vendor = "HermitWorks"; 
    28 static const char *g_version = "3.3.1"; 
     28static const char *g_version = "3.3.2"; 
    2929static const char *g_reqVer = "Any"; 
    3030