Changeset 13575

Show
Ignore:
Timestamp:
04/24/14 12:49:57 (less than one hour ago)
Author:
robert
Message:

From Mattias Helsing, "Seems I was only half right given what you asked for. CMP0017 only
says that modules that are found and ran from cmake modules dir should
prefer cmake-provided modules. find_package() and include() still look
in CMAKE_MODULE_PATH first.

After some investigating I've come up with a proposal examplified in
the attached FindGDAL.cmake script. It simply calls the cmake provided
FindGDAL.cmake if it exists and returns if it succeeds in finding GDAL
using that, otherwise continue with our local cmake code.
Pro: Wont clutter our root CMakeLists.txt
Con: If we begin to write more advanced Findxxx modules (using
COMPONENTS, REQUIRED etc.) we may have to revise this scheme.
"

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/applications/osgconv/osgconv.cpp

    r12462 r13575  
    5252            { 
    5353                osg::notify(osg::NOTICE)<<"Failed to create pbuffer, failing back to normal graphics window."<<std::endl; 
    54                  
     54 
    5555                traits->pbuffer = false; 
    5656                _gc = osg::GraphicsContext::createGraphicsContext(traits.get()); 
    5757            } 
    5858 
    59             if (_gc.valid())  
     59            if (_gc.valid()) 
    6060            { 
    6161                _gc->realize(); 
     
    7171            } 
    7272        } 
    73          
     73 
    7474        bool valid() const { return _gc.valid() && _gc->isRealized(); } 
    75          
     75 
    7676    private: 
    7777        osg::ref_ptr<osg::GraphicsContext> _gc; 
     
    9696                osg::ref_ptr< osg::Vec3Array > newnormals = new osg::Vec3Array; 
    9797                newnormals->push_back( osg::Z_AXIS ); 
    98                 geometry->setNormalArray( newnormals.get() ); 
    99                 geometry->setNormalBinding( osg::Geometry::BIND_OVERALL ); 
     98                geometry->setNormalArray( newnormals.get(), osg::Array::BIND_OVERALL ); 
    10099            } 
    101100        } 
     
    122121        traverse(node); 
    123122    } 
    124      
     123 
    125124    virtual void apply(osg::Geode& node) 
    126125    { 
    127126        if (node.getStateSet()) apply(*node.getStateSet()); 
    128          
     127 
    129128        for(unsigned int i=0;i<node.getNumDrawables();++i) 
    130129        { 
     
    132131            if (drawable && drawable->getStateSet()) apply(*drawable->getStateSet()); 
    133132        } 
    134          
     133 
    135134        traverse(node); 
    136135    } 
    137      
     136 
    138137    virtual void apply(osg::StateSet& stateset) 
    139138    { 
     
    148147        } 
    149148    } 
    150      
     149 
    151150    void compress() 
    152151    { 
     
    165164        { 
    166165            osg::Texture* texture = const_cast<osg::Texture*>(itr->get()); 
    167              
     166 
    168167            osg::Texture2D* texture2D = dynamic_cast<osg::Texture2D*>(texture); 
    169168            osg::Texture3D* texture3D = dynamic_cast<osg::Texture3D*>(texture); 
    170              
     169 
    171170            osg::ref_ptr<osg::Image> image = texture2D ? texture2D->getImage() : (texture3D ? texture3D->getImage() : 0); 
    172             if (image.valid() &&  
     171            if (image.valid() && 
    173172                (image->getPixelFormat()==GL_RGB || image->getPixelFormat()==GL_RGBA) && 
    174173                (image->s()>=32 && image->t()>=32)) 
    175174            { 
    176175                texture->setInternalFormatMode(_internalFormatMode); 
    177                  
     176 
    178177                // need to disable the unref after apply, other the image could go out of scope. 
    179178                bool unrefImageDataAfterApply = texture->getUnRefImageDataAfterApply(); 
    180179                texture->setUnRefImageDataAfterApply(false); 
    181                  
     180 
    182181                // get OpenGL driver to create texture from image. 
    183182                texture->apply(*state); 
     
    200199        { 
    201200            osg::Texture* texture = const_cast<osg::Texture*>(itr->get()); 
    202              
     201 
    203202            osg::Texture2D* texture2D = dynamic_cast<osg::Texture2D*>(texture); 
    204203            osg::Texture3D* texture3D = dynamic_cast<osg::Texture3D*>(texture); 
    205              
     204 
    206205            osg::ref_ptr<osg::Image> image = texture2D ? texture2D->getImage() : (texture3D ? texture3D->getImage() : 0); 
    207206            if (image.valid()) 
     
    216215        } 
    217216    } 
    218      
     217 
    219218    typedef std::set< osg::ref_ptr<osg::Texture> > TextureSet; 
    220219    TextureSet                          _textureSet; 
    221220    osg::Texture::InternalFormatMode    _internalFormatMode; 
    222      
     221 
    223222}; 
    224223 
     
    244243        std::cout<<"Running FixTransparencyVisitor..."<<std::endl; 
    245244    } 
    246          
     245 
    247246    ~FixTransparencyVisitor() 
    248247    { 
     
    257256        traverse(node); 
    258257    } 
    259      
     258 
    260259    virtual void apply(osg::Geode& node) 
    261260    { 
    262261        if (node.getStateSet()) isTransparent(*node.getStateSet()); 
    263          
     262 
    264263        for(unsigned int i=0;i<node.getNumDrawables();++i) 
    265264        { 
     
    267266            if (drawable && drawable->getStateSet()) isTransparent(*drawable->getStateSet()); 
    268267        } 
    269          
     268 
    270269        traverse(node); 
    271270    } 
    272      
     271 
    273272    virtual bool isTransparent(osg::StateSet& stateset) 
    274273    { 
     
    290289                { 
    291290                    osg::Image* image = texture->getImage(im); 
    292                     if (image && image->isImageTranslucent()) hasTranslucentTexture = true;    
     291                    if (image && image->isImageTranslucent()) hasTranslucentTexture = true; 
    293292                } 
    294293            } 
    295294        } 
    296          
     295 
    297296        if (hasTranslucentTexture || hasBlendFunc || hasTransparentRenderingHint || hasDepthSortBin) 
    298297        { 
    299298            ++_numTransparent; 
    300              
     299 
    301300            bool makeNonTransparent = false; 
    302301 
     
    316315                break; 
    317316            } 
    318          
     317 
    319318            if (makeNonTransparent) 
    320319            { 
     
    336335 
    337336    unsigned int _numTransparent; 
    338     unsigned int _numOpaque;     
     337    unsigned int _numOpaque; 
    339338    unsigned int _numTransparentMadeOpaque; 
    340339    FixTransparencyMode _mode; 
     
    351350        std::cout<<"Running PruneStateSet..."<<std::endl; 
    352351    } 
    353          
     352 
    354353    ~PruneStateSetVisitor() 
    355354    { 
     
    366365        traverse(node); 
    367366    } 
    368      
     367 
    369368    virtual void apply(osg::Geode& node) 
    370369    { 
     
    374373            ++_numStateSetRemoved; 
    375374        } 
    376          
     375 
    377376        for(unsigned int i=0;i<node.getNumDrawables();++i) 
    378377        { 
     
    384383            } 
    385384        } 
    386          
     385 
    387386        traverse(node); 
    388387    } 
    389      
     388 
    390389    unsigned int _numStateSetRemoved; 
    391390}; 
     
    409408                    osg::Vec4Array* colours = new osg::Vec4Array(1); 
    410409                    (*colours)[0].set(1.0f,1.0f,1.0f,1.0f); 
    411                     geometry->setColorArray(colours); 
    412                     geometry->setColorBinding(osg::Geometry::BIND_OVERALL); 
     410                    geometry->setColorArray(colours, osg::Array::BIND_OVERALL); 
    413411                } 
    414412            } 
     
    546544    // use an ArgumentParser object to manage the program arguments. 
    547545    osg::ArgumentParser arguments(&argc,argv); 
    548      
     546 
    549547    // set up the usage document, in case we need to print out how to use this program. 
    550548    arguments.getApplicationUsage()->setApplicationName(arguments.getApplicationName()); 
     
    559557    // if user request help write it out to cout. 
    560558    if (arguments.read("-h") || arguments.read("--help")) 
    561     {  
     559    { 
    562560        usage( arguments.getApplicationName().c_str(), 0 ); 
    563561        //arguments.getApplicationUsage()->write(std::cout); 
    564562        return 1; 
    565563    } 
    566      
     564 
    567565    if (arguments.read("--help-env")) 
    568     {  
     566    { 
    569567        arguments.getApplicationUsage()->write(std::cout, osg::ApplicationUsage::ENVIRONMENTAL_VARIABLE); 
    570568        return 1; 
    571569    } 
    572      
     570 
    573571    if (arguments.read("--plugins")) 
    574572    { 
     
    581579        } 
    582580        return 0; 
    583     }     
    584      
     581    } 
     582 
    585583    std::string plugin; 
    586584    if (arguments.read("--plugin", plugin)) 
     
    588586        osgDB::outputPluginDetails(std::cout, plugin); 
    589587        return 0; 
    590     }     
    591      
     588    } 
     589 
    592590    std::string ext; 
    593591    if (arguments.read("--format", ext)) 
     
    596594        osgDB::outputPluginDetails(std::cout, plugin); 
    597595        return 0; 
    598     }     
    599      
     596    } 
     597 
    600598    if (arguments.read("--formats")) 
    601599    { 
     
    608606        } 
    609607        return 0; 
    610     }     
    611      
     608    } 
     609 
    612610    if (arguments.argc()<=1) 
    613611    { 
     
    638636        osgDB::Registry::instance()->loadLibrary(libName); 
    639637    } 
    640      
     638 
    641639    std::string libName; 
    642640    while (arguments.read("-l",libName)) 
     
    673671            do_convert = true; 
    674672        } 
    675     }     
     673    } 
    676674 
    677675    while (arguments.read("-s",str)) 
     
    718716    } 
    719717 
    720      
     718 
    721719    FixTransparencyVisitor::FixTransparencyMode fixTransparencyMode = FixTransparencyVisitor::NO_TRANSPARANCY_FIXING; 
    722720    std::string fixString; 
     
    727725         if (fixString=="MAKE_ALL_STATESET_OPAQUE") fixTransparencyMode = FixTransparencyVisitor::MAKE_ALL_STATESET_OPAQUE; 
    728726    }; 
    729      
     727 
    730728    bool pruneStateSet = false; 
    731729    while(arguments.read("--prune-StateSet")) pruneStateSet = true; 
     
    740738    bool smooth = false; 
    741739    while(arguments.read("--smooth")) { smooth = true; } 
    742      
     740 
    743741    bool addMissingColours = false; 
    744742    while(arguments.read("--addMissingColours") || arguments.read("--addMissingColors")) { addMissingColours = true; } 
     
    806804    if ( root.valid() ) 
    807805    { 
    808      
     806 
    809807        if (smooth) 
    810808        { 
    811809            osgUtil::SmoothingVisitor sv; 
    812810            root->accept(sv); 
    813         }     
    814      
     811        } 
     812 
    815813        if (addMissingColours) 
    816814        { 
     
    822820        osgUtil::Optimizer optimizer; 
    823821        optimizer.optimize(root.get()); 
    824          
     822 
    825823        if( do_convert ) 
    826824            root = oc.convert( root.get() ); 
    827              
     825 
    828826        if (internalFormatMode != osg::Texture::USE_IMAGE_DATA_FORMAT) 
    829827        {