From 201522feb3666fc9640df392860b6a7c34de9248 Mon Sep 17 00:00:00 2001 From: Robert Osfield Date: Wed, 2 Jul 2008 09:25:08 +0000 Subject: [PATCH] Introduced support for UNSCPECIFIED and STATIC DataVariance of StateSet/Textures --- include/osgDB/SharedStateManager | 33 ++++++++-- src/osgDB/SharedStateManager.cpp | 101 +++++++++++++++++-------------- 2 files changed, 82 insertions(+), 52 deletions(-) diff --git a/include/osgDB/SharedStateManager b/include/osgDB/SharedStateManager index 10a3c1f58..77c5542a1 100644 --- a/include/osgDB/SharedStateManager +++ b/include/osgDB/SharedStateManager @@ -33,16 +33,23 @@ namespace osgDB { enum ShareMode { - SHARE_NONE = 0x00, - SHARE_TEXTURES = 0x01, - SHARE_STATESETS = 0x02, + SHARE_NONE = 0, + SHARE_STATIC_TEXTURES = 1<<0, + SHARE_UNSPECIFIED_TEXTURES = 1<<1, + SHARE_DYNAMIC_TEXTURES = 1<<2, + SHARE_STATIC_STATESETS = 1<<3, + SHARE_UNSPECIFIED_STATESETS = 1<<4, + SHARE_DYNAMIC_STATESETS = 1<<5, + SHARE_TEXTURES = SHARE_STATIC_TEXTURES | SHARE_UNSPECIFIED_TEXTURES, + SHARE_STATESETS = SHARE_STATIC_STATESETS | SHARE_UNSPECIFIED_STATESETS, SHARE_ALL = SHARE_TEXTURES | SHARE_STATESETS }; - SharedStateManager(); + SharedStateManager(unsigned int mode = SHARE_ALL); - void setShareMode(unsigned int mode) { _shareMode = mode; } + void setShareMode(unsigned int mode); + unsigned int getShareMode() { return _shareMode; } // Call right after each unload and before Registry cache prune. @@ -59,6 +66,17 @@ namespace osgDB { bool isShared(osg::StateSet* stateSet); protected: + inline bool shareTexture(osg::Object::DataVariance variance) + { + return _shareTexture[variance]; + } + + inline bool shareStateSet(osg::Object::DataVariance variance) + { + return _shareStateSet[variance]; + } + + void process(osg::StateSet* ss, osg::Object* parent); osg::StateAttribute *find(osg::StateAttribute *sa); osg::StateSet *find(osg::StateSet *ss); @@ -99,8 +117,11 @@ namespace osgDB { typedef std::map StateSetStateSetSharePairMap; StateSetStateSetSharePairMap tmpSharedStateSetList; + unsigned int _shareMode; + bool _shareTexture[3]; + bool _shareStateSet[3]; + // Share connection mutex - unsigned int _shareMode; OpenThreads::Mutex *_mutex; // Mutex for doing isShared queries from other threads diff --git a/src/osgDB/SharedStateManager.cpp b/src/osgDB/SharedStateManager.cpp index 3e28f8888..e8a1c4e37 100644 --- a/src/osgDB/SharedStateManager.cpp +++ b/src/osgDB/SharedStateManager.cpp @@ -16,14 +16,26 @@ using namespace osgDB; -SharedStateManager::SharedStateManager(): +SharedStateManager::SharedStateManager(unsigned int mode): osg::NodeVisitor(osg::NodeVisitor::TRAVERSE_ALL_CHILDREN) { - _shareMode = SHARE_TEXTURES; - //_shareMode = SHARE_STATESETS; + setShareMode(mode); _mutex=0; } +void SharedStateManager::setShareMode(unsigned int mode) +{ + _shareMode = mode; + + _shareTexture[osg::Object::DYNAMIC] = (_shareMode & SHARE_DYNAMIC_TEXTURES)!=0; + _shareTexture[osg::Object::STATIC] = (_shareMode & SHARE_STATIC_TEXTURES)!=0; + _shareTexture[osg::Object::UNSPECIFIED] = (_shareMode & SHARE_UNSPECIFIED_TEXTURES)!=0; + + _shareStateSet[osg::Object::DYNAMIC] = (_shareMode & SHARE_DYNAMIC_STATESETS)!=0; + _shareStateSet[osg::Object::STATIC] = (_shareMode & SHARE_STATIC_STATESETS)!=0; + _shareStateSet[osg::Object::UNSPECIFIED] = (_shareMode & SHARE_UNSPECIFIED_STATESETS)!=0; +} + //---------------------------------------------------------------- // SharedStateManager::prune //---------------------------------------------------------------- @@ -98,7 +110,7 @@ void SharedStateManager::apply(osg::Geode& geode) bool SharedStateManager::isShared(osg::StateSet *ss) { - if ((_shareMode & SHARE_STATESETS) != 0) + if (shareStateSet(ss->getDataVariance())) { OpenThreads::ScopedLock lock(_listMutex); return find(ss) != 0; @@ -122,6 +134,7 @@ osg::StateSet *SharedStateManager::find(osg::StateSet *ss) else return result->get(); } + osg::StateAttribute *SharedStateManager::find(osg::StateAttribute *sa) { TextureSet::iterator result @@ -165,7 +178,7 @@ void SharedStateManager::shareTextures(osg::StateSet* ss) osg::StateAttribute *texture = ss->getTextureAttribute(unit, osg::StateAttribute::TEXTURE); // Valid Texture to be shared - if(texture && texture->getDataVariance()==osg::Object::STATIC) + if(texture && shareTexture(texture->getDataVariance())) { TextureTextureSharePairMap::iterator titr = tmpSharedTextureList.find(texture); if(titr==tmpSharedTextureList.end()) @@ -210,55 +223,51 @@ void SharedStateManager::shareTextures(osg::StateSet* ss) //---------------------------------------------------------------- void SharedStateManager::process(osg::StateSet* ss, osg::Object* parent) { - if(_shareMode & SHARE_STATESETS) + // Valid StateSet to be shared + if (shareStateSet(ss->getDataVariance())) { - // Valid StateSet to be shared - if(ss->getDataVariance()==osg::Object::STATIC) + StateSetStateSetSharePairMap::iterator sitr = tmpSharedStateSetList.find(ss); + if (sitr==tmpSharedStateSetList.end()) { - StateSetStateSetSharePairMap::iterator sitr = tmpSharedStateSetList.find(ss); - if(sitr==tmpSharedStateSetList.end()) + // StateSet is not in tmp list: + // First time it appears in this file, search StateSet in sharedObjectList + osg::StateSet *ssFromSharedList = find(ss); + if (ssFromSharedList) { - // StateSet is not in tmp list: - // First time it appears in this file, search StateSet in sharedObjectList - osg::StateSet *ssFromSharedList = find(ss); - if(ssFromSharedList) - { - // StateSet is in sharedStateSetList: - // Share now. Required to be shared all next times - if(_mutex) _mutex->lock(); - setStateSet(ssFromSharedList, parent); - if(_mutex) _mutex->unlock(); - tmpSharedStateSetList[ss] = StateSetSharePair(ssFromSharedList, true); - } - else - { - // StateSet is not in sharedStateSetList: - // Add to sharedStateSetList. Not needed to be shared all next times. - { - OpenThreads::ScopedLock lock(_listMutex); - _sharedStateSetList.insert(ss); - tmpSharedStateSetList[ss] - = StateSetSharePair(ss, false); - } - // Only in this case sharing textures is also required - if(_shareMode & SHARE_TEXTURES) - { - shareTextures(ss); - } - } + // StateSet is in sharedStateSetList: + // Share now. Required to be shared all next times + if (_mutex) _mutex->lock(); + setStateSet(ssFromSharedList, parent); + if (_mutex) _mutex->unlock(); + tmpSharedStateSetList[ss] = StateSetSharePair(ssFromSharedList, true); } - else if(sitr->second.second) + else { - // StateSet is in tmpSharedStateSetList and share flag is on: - // It should be shared - if(_mutex) _mutex->lock(); - setStateSet(sitr->second.first, parent); - if(_mutex) _mutex->unlock(); + // StateSet is not in sharedStateSetList: + // Add to sharedStateSetList. Not needed to be shared all next times. + { + OpenThreads::ScopedLock lock(_listMutex); + _sharedStateSetList.insert(ss); + tmpSharedStateSetList[ss] + = StateSetSharePair(ss, false); + } + // Only in this case sharing textures is also required + if (_shareMode & (SHARE_UNSPECIFIED_TEXTURES | SHARE_UNSPECIFIED_TEXTURES | SHARE_UNSPECIFIED_TEXTURES)) + { + shareTextures(ss); + } } } + else if (sitr->second.second) + { + // StateSet is in tmpSharedStateSetList and share flag is on: + // It should be shared + if(_mutex) _mutex->lock(); + setStateSet(sitr->second.first, parent); + if(_mutex) _mutex->unlock(); + } } - - else if(_shareMode & SHARE_TEXTURES) + else if (_shareMode & (SHARE_UNSPECIFIED_TEXTURES | SHARE_UNSPECIFIED_TEXTURES | SHARE_UNSPECIFIED_TEXTURES)) { shareTextures(ss); }