mirror of
				https://github.com/OpenMW/openmw.git
				synced 2025-10-31 20:56:39 +00:00 
			
		
		
		
	
		
			
				
	
	
		
			543 lines
		
	
	
	
		
			19 KiB
		
	
	
	
		
			C++
		
	
	
	
	
	
			
		
		
	
	
			543 lines
		
	
	
	
		
			19 KiB
		
	
	
	
		
			C++
		
	
	
	
	
	
| #include "scenemanager.hpp"
 | |
| 
 | |
| #include <iostream>
 | |
| #include <osg/Node>
 | |
| #include <osg/UserDataContainer>
 | |
| 
 | |
| #include <osgParticle/ParticleSystem>
 | |
| 
 | |
| #include <osgUtil/IncrementalCompileOperation>
 | |
| 
 | |
| #include <osgDB/SharedStateManager>
 | |
| #include <osgDB/Registry>
 | |
| 
 | |
| #include <components/nifosg/nifloader.hpp>
 | |
| #include <components/nif/niffile.hpp>
 | |
| 
 | |
| #include <components/vfs/manager.hpp>
 | |
| 
 | |
| #include <components/sceneutil/clone.hpp>
 | |
| #include <components/sceneutil/util.hpp>
 | |
| #include <components/sceneutil/controller.hpp>
 | |
| 
 | |
| #include <components/shader/shadervisitor.hpp>
 | |
| #include <components/shader/shadermanager.hpp>
 | |
| 
 | |
| #include "imagemanager.hpp"
 | |
| #include "niffilemanager.hpp"
 | |
| #include "objectcache.hpp"
 | |
| #include "multiobjectcache.hpp"
 | |
| 
 | |
| namespace
 | |
| {
 | |
| 
 | |
|     /// @todo Do this in updateCallback so that animations are accounted for.
 | |
|     class InitWorldSpaceParticlesVisitor : public osg::NodeVisitor
 | |
|     {
 | |
|     public:
 | |
|         /// @param mask The node mask to set on ParticleSystem nodes.
 | |
|         InitWorldSpaceParticlesVisitor(unsigned int mask)
 | |
|             : osg::NodeVisitor(TRAVERSE_ALL_CHILDREN)
 | |
|             , mMask(mask)
 | |
|         {
 | |
|         }
 | |
| 
 | |
|         bool isWorldSpaceParticleSystem(osgParticle::ParticleSystem* partsys)
 | |
|         {
 | |
|             // HACK: ParticleSystem has no getReferenceFrame()
 | |
|             return (partsys->getUserDataContainer()
 | |
|                     && partsys->getUserDataContainer()->getNumDescriptions() > 0
 | |
|                     && partsys->getUserDataContainer()->getDescriptions()[0] == "worldspace");
 | |
|         }
 | |
| 
 | |
|         void apply(osg::Drawable& drw)
 | |
|         {
 | |
|             if (osgParticle::ParticleSystem* partsys = dynamic_cast<osgParticle::ParticleSystem*>(&drw))
 | |
|             {
 | |
|                 if (isWorldSpaceParticleSystem(partsys))
 | |
|                 {
 | |
|                     // HACK: Ignore the InverseWorldMatrix transform the particle system is attached to
 | |
|                     if (partsys->getNumParents() && partsys->getParent(0)->getNumParents())
 | |
|                         transformInitialParticles(partsys, partsys->getParent(0)->getParent(0));
 | |
|                 }
 | |
|                 partsys->setNodeMask(mMask);
 | |
|             }
 | |
|         }
 | |
| 
 | |
|         void transformInitialParticles(osgParticle::ParticleSystem* partsys, osg::Node* node)
 | |
|         {
 | |
|             osg::NodePathList nodepaths = node->getParentalNodePaths();
 | |
|             if (nodepaths.empty())
 | |
|                 return;
 | |
|             osg::Matrixf worldMat = osg::computeLocalToWorld(nodepaths[0]);
 | |
|             worldMat.orthoNormalize(worldMat); // scale is already applied on the particle node
 | |
|             for (int i=0; i<partsys->numParticles(); ++i)
 | |
|             {
 | |
|                 partsys->getParticle(i)->transformPositionVelocity(worldMat);
 | |
|             }
 | |
| 
 | |
|             // transform initial bounds to worldspace
 | |
|             osg::BoundingSphere sphere(partsys->getInitialBound());
 | |
|             SceneUtil::transformBoundingSphere(worldMat, sphere);
 | |
|             osg::BoundingBox box;
 | |
|             box.expandBy(sphere);
 | |
|             partsys->setInitialBound(box);
 | |
|         }
 | |
|     private:
 | |
|         unsigned int mMask;
 | |
|     };
 | |
| }
 | |
| 
 | |
| namespace Resource
 | |
| {
 | |
| 
 | |
|     /// Set texture filtering settings on textures contained in a FlipController.
 | |
|     class SetFilterSettingsControllerVisitor : public SceneUtil::ControllerVisitor
 | |
|     {
 | |
|     public:
 | |
|         SetFilterSettingsControllerVisitor(osg::Texture::FilterMode minFilter, osg::Texture::FilterMode magFilter, int maxAnisotropy)
 | |
|             : mMinFilter(minFilter)
 | |
|             , mMagFilter(magFilter)
 | |
|             , mMaxAnisotropy(maxAnisotropy)
 | |
|         {
 | |
|         }
 | |
| 
 | |
|         virtual void visit(osg::Node& node, SceneUtil::Controller& ctrl)
 | |
|         {
 | |
|             if (NifOsg::FlipController* flipctrl = dynamic_cast<NifOsg::FlipController*>(&ctrl))
 | |
|             {
 | |
|                 for (std::vector<osg::ref_ptr<osg::Texture2D> >::iterator it = flipctrl->getTextures().begin(); it != flipctrl->getTextures().end(); ++it)
 | |
|                 {
 | |
|                     osg::Texture* tex = *it;
 | |
|                     tex->setFilter(osg::Texture::MIN_FILTER, mMinFilter);
 | |
|                     tex->setFilter(osg::Texture::MAG_FILTER, mMagFilter);
 | |
|                     tex->setMaxAnisotropy(mMaxAnisotropy);
 | |
|                 }
 | |
|             }
 | |
|         }
 | |
| 
 | |
|     private:
 | |
|         osg::Texture::FilterMode mMinFilter;
 | |
|         osg::Texture::FilterMode mMagFilter;
 | |
|         int mMaxAnisotropy;
 | |
|     };
 | |
| 
 | |
|     /// Set texture filtering settings on textures contained in StateSets.
 | |
|     class SetFilterSettingsVisitor : public osg::NodeVisitor
 | |
|     {
 | |
|     public:
 | |
|         SetFilterSettingsVisitor(osg::Texture::FilterMode minFilter, osg::Texture::FilterMode magFilter, int maxAnisotropy)
 | |
|             : osg::NodeVisitor(TRAVERSE_ALL_CHILDREN)
 | |
|             , mMinFilter(minFilter)
 | |
|             , mMagFilter(magFilter)
 | |
|             , mMaxAnisotropy(maxAnisotropy)
 | |
|         {
 | |
|         }
 | |
| 
 | |
|         virtual void apply(osg::Node& node)
 | |
|         {
 | |
|             osg::StateSet* stateset = node.getStateSet();
 | |
|             if (stateset)
 | |
|                 applyStateSet(stateset);
 | |
| 
 | |
|             traverse(node);
 | |
|         }
 | |
| 
 | |
|         void applyStateSet(osg::StateSet* stateset)
 | |
|         {
 | |
|             const osg::StateSet::TextureAttributeList& texAttributes = stateset->getTextureAttributeList();
 | |
|             for(unsigned int unit=0;unit<texAttributes.size();++unit)
 | |
|             {
 | |
|                 osg::StateAttribute *texture = stateset->getTextureAttribute(unit, osg::StateAttribute::TEXTURE);
 | |
|                 if (texture)
 | |
|                     applyStateAttribute(texture);
 | |
|             }
 | |
|         }
 | |
| 
 | |
|         void applyStateAttribute(osg::StateAttribute* attr)
 | |
|         {
 | |
|             osg::Texture* tex = attr->asTexture();
 | |
|             if (tex)
 | |
|             {
 | |
|                 tex->setFilter(osg::Texture::MIN_FILTER, mMinFilter);
 | |
|                 tex->setFilter(osg::Texture::MAG_FILTER, mMagFilter);
 | |
|                 tex->setMaxAnisotropy(mMaxAnisotropy);
 | |
|             }
 | |
|         }
 | |
|     private:
 | |
|         osg::Texture::FilterMode mMinFilter;
 | |
|         osg::Texture::FilterMode mMagFilter;
 | |
|         int mMaxAnisotropy;
 | |
|     };
 | |
| 
 | |
| 
 | |
| 
 | |
|     SceneManager::SceneManager(const VFS::Manager *vfs, Resource::ImageManager* imageManager, Resource::NifFileManager* nifFileManager)
 | |
|         : ResourceManager(vfs)
 | |
|         , mShaderManager(new Shader::ShaderManager)
 | |
|         , mForceShaders(false)
 | |
|         , mClampLighting(true)
 | |
|         , mForcePerPixelLighting(false)
 | |
|         , mAutoUseNormalMaps(false)
 | |
|         , mAutoUseSpecularMaps(false)
 | |
|         , mInstanceCache(new MultiObjectCache)
 | |
|         , mImageManager(imageManager)
 | |
|         , mNifFileManager(nifFileManager)
 | |
|         , mMinFilter(osg::Texture::LINEAR_MIPMAP_LINEAR)
 | |
|         , mMagFilter(osg::Texture::LINEAR)
 | |
|         , mMaxAnisotropy(1)
 | |
|         , mUnRefImageDataAfterApply(false)
 | |
|         , mParticleSystemMask(~0u)
 | |
|     {
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setForceShaders(bool force)
 | |
|     {
 | |
|         mForceShaders = force;
 | |
|     }
 | |
| 
 | |
|     bool SceneManager::getForceShaders() const
 | |
|     {
 | |
|         return mForceShaders;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::recreateShaders(osg::ref_ptr<osg::Node> node)
 | |
|     {
 | |
|         Shader::ShaderVisitor shaderVisitor(*mShaderManager.get(), *mImageManager, "objects_vertex.glsl", "objects_fragment.glsl");
 | |
|         shaderVisitor.setForceShaders(mForceShaders);
 | |
|         shaderVisitor.setClampLighting(mClampLighting);
 | |
|         shaderVisitor.setForcePerPixelLighting(mForcePerPixelLighting);
 | |
|         shaderVisitor.setAllowedToModifyStateSets(false);
 | |
|         node->accept(shaderVisitor);
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setClampLighting(bool clamp)
 | |
|     {
 | |
|         mClampLighting = clamp;
 | |
|     }
 | |
| 
 | |
|     bool SceneManager::getClampLighting() const
 | |
|     {
 | |
|         return mClampLighting;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setForcePerPixelLighting(bool force)
 | |
|     {
 | |
|         mForcePerPixelLighting = force;
 | |
|     }
 | |
| 
 | |
|     bool SceneManager::getForcePerPixelLighting() const
 | |
|     {
 | |
|         return mForcePerPixelLighting;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setAutoUseNormalMaps(bool use)
 | |
|     {
 | |
|         mAutoUseNormalMaps = use;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setNormalMapPattern(const std::string &pattern)
 | |
|     {
 | |
|         mNormalMapPattern = pattern;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setNormalHeightMapPattern(const std::string &pattern)
 | |
|     {
 | |
|         mNormalHeightMapPattern = pattern;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setAutoUseSpecularMaps(bool use)
 | |
|     {
 | |
|         mAutoUseSpecularMaps = use;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setSpecularMapPattern(const std::string &pattern)
 | |
|     {
 | |
|         mSpecularMapPattern = pattern;
 | |
|     }
 | |
| 
 | |
|     SceneManager::~SceneManager()
 | |
|     {
 | |
|         // this has to be defined in the .cpp file as we can't delete incomplete types
 | |
|     }
 | |
| 
 | |
|     Shader::ShaderManager &SceneManager::getShaderManager()
 | |
|     {
 | |
|         return *mShaderManager.get();
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setShaderPath(const std::string &path)
 | |
|     {
 | |
|         mShaderManager->setShaderPath(path);
 | |
|     }
 | |
| 
 | |
|     /// @brief Callback to read image files from the VFS.
 | |
|     class ImageReadCallback : public osgDB::ReadFileCallback
 | |
|     {
 | |
|     public:
 | |
|         ImageReadCallback(Resource::ImageManager* imageMgr)
 | |
|             : mImageManager(imageMgr)
 | |
|         {
 | |
|         }
 | |
| 
 | |
|         virtual osgDB::ReaderWriter::ReadResult readImage(const std::string& filename, const osgDB::Options* options)
 | |
|         {
 | |
|             try
 | |
|             {
 | |
|                 return osgDB::ReaderWriter::ReadResult(mImageManager->getImage(filename), osgDB::ReaderWriter::ReadResult::FILE_LOADED);
 | |
|             }
 | |
|             catch (std::exception& e)
 | |
|             {
 | |
|                 return osgDB::ReaderWriter::ReadResult(e.what());
 | |
|             }
 | |
|         }
 | |
| 
 | |
|     private:
 | |
|         Resource::ImageManager* mImageManager;
 | |
|     };
 | |
| 
 | |
|     std::string getFileExtension(const std::string& file)
 | |
|     {
 | |
|         size_t extPos = file.find_last_of('.');
 | |
|         if (extPos != std::string::npos && extPos+1 < file.size())
 | |
|             return file.substr(extPos+1);
 | |
|         return std::string();
 | |
|     }
 | |
| 
 | |
|     osg::ref_ptr<osg::Node> load (Files::IStreamPtr file, const std::string& normalizedFilename, Resource::ImageManager* imageManager, Resource::NifFileManager* nifFileManager)
 | |
|     {
 | |
|         std::string ext = getFileExtension(normalizedFilename);
 | |
|         if (ext == "nif")
 | |
|             return NifOsg::Loader::load(nifFileManager->get(normalizedFilename), imageManager);
 | |
|         else
 | |
|         {
 | |
|             osgDB::ReaderWriter* reader = osgDB::Registry::instance()->getReaderWriterForExtension(ext);
 | |
|             if (!reader)
 | |
|             {
 | |
|                 std::stringstream errormsg;
 | |
|                 errormsg << "Error loading " << normalizedFilename << ": no readerwriter for '" << ext << "' found" << std::endl;
 | |
|                 throw std::runtime_error(errormsg.str());
 | |
|             }
 | |
| 
 | |
|             osg::ref_ptr<osgDB::Options> options (new osgDB::Options);
 | |
|             // Set a ReadFileCallback so that image files referenced in the model are read from our virtual file system instead of the osgDB.
 | |
|             // Note, for some formats (.obj/.mtl) that reference other (non-image) files a findFileCallback would be necessary.
 | |
|             // but findFileCallback does not support virtual files, so we can't implement it.
 | |
|             options->setReadFileCallback(new ImageReadCallback(imageManager));
 | |
| 
 | |
|             osgDB::ReaderWriter::ReadResult result = reader->readNode(*file, options);
 | |
|             if (!result.success())
 | |
|             {
 | |
|                 std::stringstream errormsg;
 | |
|                 errormsg << "Error loading " << normalizedFilename << ": " << result.message() << " code " << result.status() << std::endl;
 | |
|                 throw std::runtime_error(errormsg.str());
 | |
|             }
 | |
|             return result.getNode();
 | |
|         }
 | |
|     }
 | |
| 
 | |
|     osg::ref_ptr<const osg::Node> SceneManager::getTemplate(const std::string &name)
 | |
|     {
 | |
|         std::string normalized = name;
 | |
|         mVFS->normalizeFilename(normalized);
 | |
| 
 | |
|         osg::ref_ptr<osg::Object> obj = mCache->getRefFromObjectCache(normalized);
 | |
|         if (obj)
 | |
|             return osg::ref_ptr<const osg::Node>(static_cast<osg::Node*>(obj.get()));
 | |
|         else
 | |
|         {
 | |
|             osg::ref_ptr<osg::Node> loaded;
 | |
|             try
 | |
|             {
 | |
|                 Files::IStreamPtr file = mVFS->get(normalized);
 | |
| 
 | |
|                 loaded = load(file, normalized, mImageManager, mNifFileManager);
 | |
|             }
 | |
|             catch (std::exception& e)
 | |
|             {
 | |
|                 static const char * const sMeshTypes[] = { "nif", "osg", "osgt", "osgb", "osgx", "osg2" };
 | |
| 
 | |
|                 for (unsigned int i=0; i<sizeof(sMeshTypes)/sizeof(sMeshTypes[0]); ++i)
 | |
|                 {
 | |
|                     normalized = "meshes/marker_error." + std::string(sMeshTypes[i]);
 | |
|                     if (mVFS->exists(normalized))
 | |
|                     {
 | |
|                         std::cerr << "Failed to load '" << name << "': " << e.what() << ", using marker_error." << sMeshTypes[i] << " instead" << std::endl;
 | |
|                         Files::IStreamPtr file = mVFS->get(normalized);
 | |
|                         loaded = load(file, normalized, mImageManager, mNifFileManager);
 | |
|                         break;
 | |
|                     }
 | |
|                 }
 | |
| 
 | |
|                 if (!loaded)
 | |
|                     throw;
 | |
|             }
 | |
| 
 | |
|             // set filtering settings
 | |
|             SetFilterSettingsVisitor setFilterSettingsVisitor(mMinFilter, mMagFilter, mMaxAnisotropy);
 | |
|             loaded->accept(setFilterSettingsVisitor);
 | |
|             SetFilterSettingsControllerVisitor setFilterSettingsControllerVisitor(mMinFilter, mMagFilter, mMaxAnisotropy);
 | |
|             loaded->accept(setFilterSettingsControllerVisitor);
 | |
| 
 | |
|             Shader::ShaderVisitor shaderVisitor(*mShaderManager.get(), *mImageManager, "objects_vertex.glsl", "objects_fragment.glsl");
 | |
|             shaderVisitor.setForceShaders(mForceShaders);
 | |
|             shaderVisitor.setClampLighting(mClampLighting);
 | |
|             shaderVisitor.setForcePerPixelLighting(mForcePerPixelLighting);
 | |
|             shaderVisitor.setAutoUseNormalMaps(mAutoUseNormalMaps);
 | |
|             shaderVisitor.setNormalMapPattern(mNormalMapPattern);
 | |
|             shaderVisitor.setNormalHeightMapPattern(mNormalHeightMapPattern);
 | |
|             shaderVisitor.setAutoUseSpecularMaps(mAutoUseSpecularMaps);
 | |
|             shaderVisitor.setSpecularMapPattern(mSpecularMapPattern);
 | |
|             loaded->accept(shaderVisitor);
 | |
| 
 | |
|             // share state
 | |
|             mSharedStateMutex.lock();
 | |
|             osgDB::Registry::instance()->getOrCreateSharedStateManager()->share(loaded.get());
 | |
|             mSharedStateMutex.unlock();
 | |
| 
 | |
|             if (mIncrementalCompileOperation)
 | |
|                 mIncrementalCompileOperation->add(loaded);
 | |
| 
 | |
|             mCache->addEntryToObjectCache(normalized, loaded);
 | |
|             return loaded;
 | |
|         }
 | |
|     }
 | |
| 
 | |
|     osg::ref_ptr<osg::Node> SceneManager::cacheInstance(const std::string &name)
 | |
|     {
 | |
|         std::string normalized = name;
 | |
|         mVFS->normalizeFilename(normalized);
 | |
| 
 | |
|         osg::ref_ptr<osg::Node> node = createInstance(normalized);
 | |
|         mInstanceCache->addEntryToObjectCache(normalized, node.get());
 | |
|         return node;
 | |
|     }
 | |
| 
 | |
|     osg::ref_ptr<osg::Node> SceneManager::createInstance(const std::string& name)
 | |
|     {
 | |
|         osg::ref_ptr<const osg::Node> scene = getTemplate(name);
 | |
|         osg::ref_ptr<osg::Node> cloned = osg::clone(scene.get(), SceneUtil::CopyOp());
 | |
| 
 | |
|         // add a ref to the original template, to hint to the cache that it's still being used and should be kept in cache
 | |
|         cloned->getOrCreateUserDataContainer()->addUserObject(const_cast<osg::Node*>(scene.get()));
 | |
| 
 | |
|         return cloned;
 | |
|     }
 | |
| 
 | |
|     osg::ref_ptr<osg::Node> SceneManager::getInstance(const std::string &name)
 | |
|     {
 | |
|         std::string normalized = name;
 | |
|         mVFS->normalizeFilename(normalized);
 | |
| 
 | |
|         osg::ref_ptr<osg::Object> obj = mInstanceCache->takeFromObjectCache(normalized);
 | |
|         if (obj.get())
 | |
|             return static_cast<osg::Node*>(obj.get());
 | |
| 
 | |
|         return createInstance(normalized);
 | |
| 
 | |
|     }
 | |
| 
 | |
|     osg::ref_ptr<osg::Node> SceneManager::getInstance(const std::string &name, osg::Group* parentNode)
 | |
|     {
 | |
|         osg::ref_ptr<osg::Node> cloned = getInstance(name);
 | |
|         attachTo(cloned, parentNode);
 | |
|         return cloned;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::attachTo(osg::Node *instance, osg::Group *parentNode) const
 | |
|     {
 | |
|         parentNode->addChild(instance);
 | |
|         notifyAttached(instance);
 | |
|     }
 | |
| 
 | |
|     void SceneManager::releaseGLObjects(osg::State *state)
 | |
|     {
 | |
|         mCache->releaseGLObjects(state);
 | |
|         mInstanceCache->releaseGLObjects(state);
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setIncrementalCompileOperation(osgUtil::IncrementalCompileOperation *ico)
 | |
|     {
 | |
|         mIncrementalCompileOperation = ico;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::notifyAttached(osg::Node *node) const
 | |
|     {
 | |
|         InitWorldSpaceParticlesVisitor visitor (mParticleSystemMask);
 | |
|         node->accept(visitor);
 | |
|     }
 | |
| 
 | |
|     Resource::ImageManager* SceneManager::getImageManager()
 | |
|     {
 | |
|         return mImageManager;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setParticleSystemMask(unsigned int mask)
 | |
|     {
 | |
|         mParticleSystemMask = mask;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setFilterSettings(const std::string &magfilter, const std::string &minfilter,
 | |
|                                            const std::string &mipmap, int maxAnisotropy)
 | |
|     {
 | |
|         osg::Texture::FilterMode min = osg::Texture::LINEAR;
 | |
|         osg::Texture::FilterMode mag = osg::Texture::LINEAR;
 | |
| 
 | |
|         if(magfilter == "nearest")
 | |
|             mag = osg::Texture::NEAREST;
 | |
|         else if(magfilter != "linear")
 | |
|             std::cerr<< "Invalid texture mag filter: "<<magfilter <<std::endl;
 | |
| 
 | |
|         if(minfilter == "nearest")
 | |
|             min = osg::Texture::NEAREST;
 | |
|         else if(minfilter != "linear")
 | |
|             std::cerr<< "Invalid texture min filter: "<<minfilter <<std::endl;
 | |
| 
 | |
|         if(mipmap == "nearest")
 | |
|         {
 | |
|             if(min == osg::Texture::NEAREST)
 | |
|                 min = osg::Texture::NEAREST_MIPMAP_NEAREST;
 | |
|             else if(min == osg::Texture::LINEAR)
 | |
|                 min = osg::Texture::LINEAR_MIPMAP_NEAREST;
 | |
|         }
 | |
|         else if(mipmap != "none")
 | |
|         {
 | |
|             if(mipmap != "linear")
 | |
|                 std::cerr<< "Invalid texture mipmap: "<<mipmap <<std::endl;
 | |
|             if(min == osg::Texture::NEAREST)
 | |
|                 min = osg::Texture::NEAREST_MIPMAP_LINEAR;
 | |
|             else if(min == osg::Texture::LINEAR)
 | |
|                 min = osg::Texture::LINEAR_MIPMAP_LINEAR;
 | |
|         }
 | |
| 
 | |
|         mMinFilter = min;
 | |
|         mMagFilter = mag;
 | |
|         mMaxAnisotropy = std::max(1, maxAnisotropy);
 | |
| 
 | |
|         SetFilterSettingsControllerVisitor setFilterSettingsControllerVisitor (mMinFilter, mMagFilter, mMaxAnisotropy);
 | |
|         SetFilterSettingsVisitor setFilterSettingsVisitor (mMinFilter, mMagFilter, mMaxAnisotropy);
 | |
| 
 | |
|         mCache->accept(setFilterSettingsVisitor);
 | |
|         mCache->accept(setFilterSettingsControllerVisitor);
 | |
|     }
 | |
| 
 | |
|     void SceneManager::applyFilterSettings(osg::Texture *tex)
 | |
|     {
 | |
|         tex->setFilter(osg::Texture::MIN_FILTER, mMinFilter);
 | |
|         tex->setFilter(osg::Texture::MAG_FILTER, mMagFilter);
 | |
|         tex->setMaxAnisotropy(mMaxAnisotropy);
 | |
|     }
 | |
| 
 | |
|     void SceneManager::setUnRefImageDataAfterApply(bool unref)
 | |
|     {
 | |
|         mUnRefImageDataAfterApply = unref;
 | |
|     }
 | |
| 
 | |
|     void SceneManager::updateCache(double referenceTime)
 | |
|     {
 | |
|         ResourceManager::updateCache(referenceTime);
 | |
| 
 | |
|         mInstanceCache->removeUnreferencedObjectsInCache();
 | |
|     }
 | |
| 
 | |
| }
 |