Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgPlugins/obj/ReaderWriterOBJ.cpp

    r13006 r13041  
    99 * texture coord arrays, bug fixes, and support for texture mapping. 
    1010 * 
    11  * Writing support added 2007 by Stephan Huber, http://digitalmind.de,  
     11 * Writing support added 2007 by Stephan Huber, http://digitalmind.de, 
    1212 * some ideas taken from the dae-plugin 
    1313 * 
    14  * The Open Scene Graph (OSG) is a cross platform C++/OpenGL library for  
    15  * real-time rendering of large 3D photo-realistic models.  
     14 * The Open Scene Graph (OSG) is a cross platform C++/OpenGL library for 
     15 * real-time rendering of large 3D photo-realistic models. 
    1616 * The OSG homepage is http://www.openscenegraph.org/ 
    1717 */ 
     
    7979 
    8080    virtual ReadResult readNode(std::istream& fin, const Options* options) const; 
    81      
    82     virtual WriteResult writeObject(const osg::Object& obj,const std::string& fileName,const Options* options=NULL) const  
     81 
     82    virtual WriteResult writeObject(const osg::Object& obj,const std::string& fileName,const Options* options=NULL) const 
    8383    { 
    8484        const osg::Node* node = dynamic_cast<const osg::Node*>(&obj); 
    8585        if (node) 
    8686            return writeNode(*node, fileName, options); 
    87         else  
    88             return WriteResult(WriteResult::FILE_NOT_HANDLED);  
    89     } 
    90      
    91     virtual WriteResult writeNode(const osg::Node& node,const std::string& fileName,const Options* options =NULL) const  
    92     {  
     87        else 
     88            return WriteResult(WriteResult::FILE_NOT_HANDLED); 
     89    } 
     90 
     91    virtual WriteResult writeNode(const osg::Node& node,const std::string& fileName,const Options* options =NULL) const 
     92    { 
    9393        if (!acceptsExtension(osgDB::getFileExtension(fileName))) 
    94             return WriteResult(WriteResult::FILE_NOT_HANDLED);  
    95              
     94            return WriteResult(WriteResult::FILE_NOT_HANDLED); 
     95 
    9696        osgDB::ofstream f(fileName.c_str()); 
    9797        std::string materialFile = osgDB::getNameLessExtension(fileName) + ".mtl"; 
    9898        OBJWriterNodeVisitor nv(f, osgDB::getSimpleFileName(materialFile)); 
    99          
     99 
    100100        // we must cast away constness 
    101101        (const_cast<osg::Node*>(&node))->accept(nv); 
    102          
     102 
    103103        osgDB::ofstream mf(materialFile.c_str()); 
    104104        nv.writeMaterials(mf); 
    105           
    106         return WriteResult(WriteResult::FILE_SAVED);  
    107     } 
    108  
    109      
    110     virtual WriteResult writeObject(const osg::Object& obj,std::ostream& fout,const Options* options=NULL) const  
     105 
     106        return WriteResult(WriteResult::FILE_SAVED); 
     107    } 
     108 
     109 
     110    virtual WriteResult writeObject(const osg::Object& obj,std::ostream& fout,const Options* options=NULL) const 
    111111    { 
    112112        const osg::Node* node = dynamic_cast<const osg::Node*>(&obj); 
    113113        if (node) 
    114114            return writeNode(*node, fout, options); 
    115         else  
    116             return WriteResult(WriteResult::FILE_NOT_HANDLED);  
    117     } 
    118  
    119     virtual WriteResult writeNode(const osg::Node& node,std::ostream& fout,const Options* =NULL) const  
    120     {  
     115        else 
     116            return WriteResult(WriteResult::FILE_NOT_HANDLED); 
     117    } 
     118 
     119    virtual WriteResult writeNode(const osg::Node& node,std::ostream& fout,const Options* =NULL) const 
     120    { 
    121121        // writing to a stream does not support materials 
    122          
     122 
    123123        OBJWriterNodeVisitor nv(fout); 
    124          
     124 
    125125        // we must cast away constness 
    126126        (const_cast<osg::Node*>(&node))->accept(nv); 
    127      
    128         return WriteResult(WriteResult::FILE_SAVED);  
     127 
     128        return WriteResult(WriteResult::FILE_SAVED); 
    129129    } 
    130130 
     
    146146 
    147147    typedef std::map< std::string, osg::ref_ptr<osg::StateSet> > MaterialToStateSetMap; 
    148      
     148 
    149149    void buildMaterialToStateSetMap(obj::Model& model, MaterialToStateSetMap& materialToSetSetMapObj, ObjOptionsStruct& localOptions, const Options* options) const; 
    150      
     150 
    151151    osg::Geometry* convertElementListToGeometry(obj::Model& model, obj::Model::ElementList& elementList, ObjOptionsStruct& localOptions) const; 
    152      
     152 
    153153    osg::Node* convertModelToSceneGraph(obj::Model& model, ObjOptionsStruct& localOptions, const Options* options) const; 
    154154 
    155155    inline osg::Vec3 transformVertex(const osg::Vec3& vec, const bool rotate) const ; 
    156156    inline osg::Vec3 transformNormal(const osg::Vec3& vec, const bool rotate) const ; 
    157   
     157 
    158158    ObjOptionsStruct parseOptions(const Options* options) const; 
    159159 
     
    199199    { 
    200200        osg::ref_ptr< osg::Image > image; 
    201         if ( !model.getDatabasePath().empty() )  
    202         { 
    203             // first try with database path of parent.  
     201        if ( !model.getDatabasePath().empty() ) 
     202        { 
     203            // first try with database path of parent. 
    204204            image = osgDB::readRefImageFile(model.getDatabasePath()+'/'+filename, options); 
    205205        } 
    206          
     206 
    207207        if ( !image.valid() ) 
    208208        { 
     
    231231            texture->setWrap(osg::Texture2D::WRAP_T, textureWrapMode); 
    232232            stateset->setTextureAttributeAndModes( texture_unit, texture,osg::StateAttribute::ON ); 
    233              
     233 
    234234            if ( map.type == obj::Material::Map::REFLECTION ) 
    235235            { 
     
    238238                stateset->setTextureAttributeAndModes( texture_unit,texgen,osg::StateAttribute::ON ); 
    239239            } 
    240              
     240 
    241241            if  ( image->isImageTranslucent()) 
    242242            { 
     
    293293            } 
    294294        } 
    295          
     295 
    296296        if (numNotBlack==0 && numBlack!=0) 
    297297        { 
     
    310310        } 
    311311    } 
    312      
     312 
    313313    for(obj::Model::MaterialMap::iterator itr = model.materialMap.begin(); 
    314314        itr != model.materialMap.end(); 
     
    316316    { 
    317317        obj::Material& material = itr->second; 
    318         
     318 
    319319        osg::ref_ptr< osg::StateSet > stateset = new osg::StateSet; 
    320320 
     
    338338            } 
    339339            osg_material->setShininess(osg::Material::FRONT_AND_BACK,(material.Ns/1000.0f)*128.0f ); // note OBJ shiniess is 0..1000. 
    340              
     340 
    341341            if (material.ambient[3]!=1.0 || 
    342342                material.diffuse[3]!=1.0 || 
     
    348348            } 
    349349        } 
    350          
    351         // If the user has explicitly set the required texture type to unit map via the options  
     350 
     351        // If the user has explicitly set the required texture type to unit map via the options 
    352352        // string, then we load ONLY those textures that are in the map. 
    353353        if(localOptions.textureUnitAllocation.size()>0) 
     
    396396            } 
    397397        } 
    398        
     398 
    399399        if (isTransparent) 
    400400        { 
     
    409409osg::Geometry* ReaderWriterOBJ::convertElementListToGeometry(obj::Model& model, obj::Model::ElementList& elementList, ObjOptionsStruct& localOptions) const 
    410410{ 
    411      
     411 
    412412    unsigned int numVertexIndices = 0; 
    413413    unsigned int numNormalIndices = 0; 
    414414    unsigned int numTexCoordIndices = 0; 
    415      
     415 
    416416    unsigned int numPointElements = 0; 
    417417    unsigned int numPolylineElements = 0; 
     
    419419 
    420420    obj::Model::ElementList::iterator itr; 
    421          
     421 
    422422    if (localOptions.generateFacetNormals == true) { 
    423423        for(itr=elementList.begin(); 
     
    428428            if (element.dataType==obj::Element::POINTS || element.dataType==obj::Element::POLYLINE) 
    429429                continue; 
    430                          
     430 
    431431            if (element.normalIndices.size() == 0) { 
    432432                // fill in the normals 
     
    451451        } 
    452452    } 
    453          
    454          
    455          
     453 
     454 
     455 
    456456    for(itr=elementList.begin(); 
    457457        itr!=elementList.end(); 
     
    471471 
    472472    if (numVertexIndices==0) return 0; 
    473      
     473 
    474474    if (numNormalIndices!=0 && numNormalIndices!=numVertexIndices) 
    475475    { 
     
    477477        numNormalIndices = 0; 
    478478    } 
    479      
     479 
    480480    if (numTexCoordIndices!=0 && numTexCoordIndices!=numVertexIndices) 
    481481    { 
     
    483483        numTexCoordIndices = 0; 
    484484    } 
    485      
     485 
    486486    osg::Vec3Array* vertices = numVertexIndices ? new osg::Vec3Array : 0; 
    487487    osg::Vec3Array* normals = numNormalIndices ? new osg::Vec3Array : 0; 
    488488    osg::Vec2Array* texcoords = numTexCoordIndices ? new osg::Vec2Array : 0; 
    489      
     489 
    490490    if (vertices) vertices->reserve(numVertexIndices); 
    491491    if (normals) normals->reserve(numNormalIndices); 
    492492    if (texcoords) texcoords->reserve(numTexCoordIndices); 
    493      
     493 
    494494    osg::Geometry* geometry = new osg::Geometry; 
    495495    if (vertices) geometry->setVertexArray(vertices); 
     
    503503        geometry->setTexCoordArray(0,texcoords); 
    504504    } 
    505      
     505 
    506506 
    507507    if (numPointElements>0) 
     
    547547        geometry->addPrimitiveSet(drawArrays); 
    548548    } 
    549      
     549 
    550550    if (numPolylineElements>0) 
    551551    { 
     
    598598    { 
    599599        unsigned int startPos = vertices->size(); 
    600          
     600 
    601601        #ifdef USE_DRAWARRAYLENGTHS 
    602602            osg::DrawArrayLengths* drawArrayLengths = new osg::DrawArrayLengths(GL_POLYGON,startPos); 
     
    612612            { 
    613613 
    614                  
     614 
    615615 
    616616 
     
    634634                #endif 
    635635 
    636              
     636 
    637637                if (model.needReverse(element)) 
    638638                { 
     
    698698 
    699699    } 
    700      
     700 
    701701    return geometry; 
    702702} 
     
    718718        ++itr) 
    719719    { 
    720      
     720 
    721721        const obj::ElementState& es = itr->first; 
    722722        obj::Model::ElementList& el = itr->second; 
     
    734734            osg::StateSet* stateset = materialToStateSetMap[es.materialName].get(); 
    735735            geometry->setStateSet(stateset); 
    736          
     736 
    737737            // tesseleate any large polygons 
    738738            if (!localOptions.noTesselateLargePolygons) 
     
    741741                tessellator.retessellatePolygons(*geometry); 
    742742            } 
    743              
     743 
    744744            // tri strip polygons to improve graphics peformance 
    745745            if (!localOptions.noTriStripPolygons) 
     
    748748                tsv.stripify(*geometry); 
    749749            } 
    750              
     750 
    751751            // if no normals present add them. 
    752752            if (localOptions.generateFacetNormals==false && (!geometry->getNormalArray() || geometry->getNormalArray()->getNumElements()==0)) 
     
    759759            osg::Geode* geode = new osg::Geode; 
    760760            geode->addDrawable(geometry); 
    761              
     761 
    762762            if (es.objectName.empty()) 
    763763            { 
     
    805805                pre_equals = opt.substr(0,found); 
    806806                post_equals = opt.substr(found+1); 
    807             }  
     807            } 
    808808            else 
    809809            { 
     
    814814            { 
    815815                localOptions.rotate = false; 
    816             }                 
     816            } 
    817817            else if (pre_equals == "noTesselateLargePolygons") 
    818818            { 
    819819                localOptions.noTesselateLargePolygons = true; 
    820             }                 
     820            } 
    821821            else if (pre_equals == "noTriStripPolygons") 
    822822            { 
     
    828828            } 
    829829            else if (post_equals.length()>0) 
    830             {     
    831                 obj::Material::Map::TextureMapType type = obj::Material::Map::UNKNOWN;                         
     830            { 
     831                obj::Material::Map::TextureMapType type = obj::Material::Map::UNKNOWN; 
    832832                // Now we check to see if we have anything forcing a texture allocation 
    833833                if        (pre_equals == "DIFFUSE")            type = obj::Material::Map::DIFFUSE; 
     
    839839                else if (pre_equals == "DISPLACEMENT")        type = obj::Material::Map::DISPLACEMENT; 
    840840                else if (pre_equals == "REFLECTION")        type = obj::Material::Map::REFLECTION; 
    841                  
     841 
    842842                if (type!=obj::Material::Map::UNKNOWN) 
    843843                { 
     
    861861    std::string fileName = osgDB::findDataFile( file, options ); 
    862862    if (fileName.empty()) return ReadResult::FILE_NOT_FOUND; 
    863      
    864      
     863 
     864 
    865865    osgDB::ifstream fin(fileName.c_str()); 
    866866    if (fin) 
    867867    { 
    868      
    869         // code for setting up the database path so that internally referenced file are searched for on relative paths.  
     868 
     869        // code for setting up the database path so that internally referenced file are searched for on relative paths. 
    870870        osg::ref_ptr<Options> local_opt = options ? static_cast<Options*>(options->clone(osg::CopyOp::SHALLOW_COPY)) : new Options; 
    871871        local_opt->setDatabasePath(osgDB::getFilePath(fileName)); 
     
    880880        return node; 
    881881    } 
    882      
     882 
    883883    return ReadResult::FILE_NOT_HANDLED; 
    884884} 
     
    892892        obj::Model model; 
    893893        model.readOBJ(fin, options); 
    894          
     894 
    895895        ObjOptionsStruct localOptions = parseOptions(options); 
    896          
     896 
    897897        osg::Node* node = convertModelToSceneGraph(model, localOptions, options); 
    898898        return node; 
    899899    } 
    900      
     900 
    901901    return ReadResult::FILE_NOT_HANDLED; 
    902902}