mirror/openmw-tes3mp
1
0
Fork 1
mirror of https://github.com/TES3MP/openmw-tes3mp.git synced 2025-02-28 09:09:39 +00:00
Code Issues Releases Wiki Activity

Merge pull request #2249 from akortunov/cache

Browse source 
Implement generic caching system
This commit is contained in:
Bret Curtis 2019-03-25 13:32:23 +01:00 committed by GitHub
commit 1e9eac568f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 186 additions and 268 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
apps/openmw/mwrender/landmanager.cpp
View file

@ -12,16 +12,15 @@ namespace MWRender
{
LandManager::LandManager(int loadFlags)
: ResourceManager(nullptr)
: GenericResourceManager<std::pair<int, int> >(nullptr)
, mLoadFlags(loadFlags)
{
mCache = new CacheType;
}
osg::ref_ptr<ESMTerrain::LandObject> LandManager::getLand(int x, int y)
{
std::string idstr = std::to_string(x) + " " + std::to_string(y);
osg::ref_ptr<osg::Object> obj = mCache->getRefFromObjectCache(idstr);
osg::ref_ptr<osg::Object> obj = mCache->getRefFromObjectCache(std::make_pair(x,y));
if (obj)
return static_cast<ESMTerrain::LandObject*>(obj.get());
else
@ -30,7 +29,7 @@ osg::ref_ptr<ESMTerrain::LandObject> LandManager::getLand(int x, int y)
if (!land)
return nullptr;
osg::ref_ptr<ESMTerrain::LandObject> landObj (new ESMTerrain::LandObject(land, mLoadFlags));
mCache->addEntryToObjectCache(idstr, landObj.get());
mCache->addEntryToObjectCache(std::make_pair(x,y), landObj.get());
return landObj;
}
}

3
apps/openmw/mwrender/landmanager.hpp
View file

@ -3,6 +3,7 @@
#include <osg/Object>
#include <components/resource/objectcache.hpp>
#include <components/resource/resourcemanager.hpp>
#include <components/esmterrain/storage.hpp>
@ -14,7 +15,7 @@ namespace ESM
namespace MWRender
{
class LandManager : public Resource::ResourceManager
class LandManager : public Resource::GenericResourceManager<std::pair<int, int> >
{
public:
LandManager(int loadFlags);

165
components/resource/objectcache.cpp
View file

@ -1,165 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#include "objectcache.hpp"
#include <osg/Object>
#include <osg/Node>
namespace Resource
{
////////////////////////////////////////////////////////////////////////////////////////////
//
// ObjectCache
//
ObjectCache::ObjectCache():
osg::Referenced(true)
{
}
ObjectCache::~ObjectCache()
{
}
void ObjectCache::addEntryToObjectCache(const std::string& filename, osg::Object* object, double timestamp)
{
if (!object)
{
OSG_ALWAYS << " trying to add NULL object to cache for " << filename << std::endl;
return;
}
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
_objectCache[filename]=ObjectTimeStampPair(object,timestamp);
}
osg::ref_ptr<osg::Object> ObjectCache::getRefFromObjectCache(const std::string& fileName)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
ObjectCacheMap::iterator itr = _objectCache.find(fileName);
if (itr!=_objectCache.end())
{
return itr->second.first;
}
else return 0;
}
bool ObjectCache::checkInObjectCache(const std::string &fileName, double timeStamp)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
ObjectCacheMap::iterator itr = _objectCache.find(fileName);
if (itr!=_objectCache.end())
{
itr->second.second = timeStamp;
return true;
}
else return false;
}
void ObjectCache::updateTimeStampOfObjectsInCacheWithExternalReferences(double referenceTime)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
// look for objects with external references and update their time stamp.
for(ObjectCacheMap::iterator itr=_objectCache.begin();
itr!=_objectCache.end();
++itr)
{
// If ref count is greater than 1, the object has an external reference.
// If the timestamp is yet to be initialized, it needs to be updated too.
if (itr->second.first->referenceCount()>1 || itr->second.second == 0.0)
{
// So update it.
itr->second.second = referenceTime;
}
}
}
void ObjectCache::removeExpiredObjectsInCache(double expiryTime)
{
std::vector<osg::ref_ptr<osg::Object> > objectsToRemove;
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
// Remove expired entries from object cache
ObjectCacheMap::iterator oitr = _objectCache.begin();
while(oitr != _objectCache.end())
{
if (oitr->second.second<=expiryTime)
{
objectsToRemove.push_back(oitr->second.first);
_objectCache.erase(oitr++);
}
else
{
++oitr;
}
}
}
// note, actual unref happens outside of the lock
objectsToRemove.clear();
}
void ObjectCache::removeFromObjectCache(const std::string& fileName)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
ObjectCacheMap::iterator itr = _objectCache.find(fileName);
if (itr!=_objectCache.end()) _objectCache.erase(itr);
}
void ObjectCache::clear()
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
_objectCache.clear();
}
void ObjectCache::releaseGLObjects(osg::State* state)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
for(ObjectCacheMap::iterator itr = _objectCache.begin();
itr != _objectCache.end();
++itr)
{
osg::Object* object = itr->second.first.get();
object->releaseGLObjects(state);
}
}
void ObjectCache::accept(osg::NodeVisitor &nv)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
for(ObjectCacheMap::iterator itr = _objectCache.begin();
itr != _objectCache.end();
++itr)
{
osg::Object* object = itr->second.first.get();
if (object)
{
osg::Node* node = dynamic_cast<osg::Node*>(object);
if (node)
node->accept(nv);
}
}
}
unsigned int ObjectCache::getCacheSize() const
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
return _objectCache.size();
}
}

130
components/resource/objectcache.hpp
View file

@ -1,5 +1,8 @@
// Resource ObjectCache for OpenMW, forked from osgDB ObjectCache by Robert Osfield, see copyright notice below.
// The main change from the upstream version is that removeExpiredObjectsInCache no longer keeps a lock while the unref happens.
// Changes:
// - removeExpiredObjectsInCache no longer keeps a lock while the unref happens.
// - template allows customized KeyType.
// - objects with uninitialized time stamp are not removed.
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
@ -19,6 +22,7 @@
#include <osg/Referenced>
#include <osg/ref_ptr>
#include <osg/Node>
#include <string>
#include <map>
@ -32,11 +36,13 @@ namespace osg
namespace Resource {
class ObjectCache : public osg::Referenced
template <typename KeyType>
class GenericObjectCache : public osg::Referenced
{
public:
ObjectCache();
GenericObjectCache()
: osg::Referenced(true) {}
/** For each object in the cache which has an reference count greater than 1
* (and therefore referenced by elsewhere in the application) set the time stamp
@ -44,59 +50,149 @@ class ObjectCache : public osg::Referenced
* This would typically be called once per frame by applications which are doing database paging,
* and need to prune objects that are no longer required.
* The time used should be taken from the FrameStamp::getReferenceTime().*/
void updateTimeStampOfObjectsInCacheWithExternalReferences(double referenceTime);
void updateTimeStampOfObjectsInCacheWithExternalReferences(double referenceTime)
{
// look for objects with external references and update their time stamp.
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
for(typename ObjectCacheMap::iterator itr=_objectCache.begin(); itr!=_objectCache.end(); ++itr)
{
// If ref count is greater than 1, the object has an external reference.
// If the timestamp is yet to be initialized, it needs to be updated too.
if (itr->second.first->referenceCount()>1 || itr->second.second == 0.0)
itr->second.second = referenceTime;
}
}
/** Removed object in the cache which have a time stamp at or before the specified expiry time.
* This would typically be called once per frame by applications which are doing database paging,
* and need to prune objects that are no longer required, and called after the a called
* after the call to updateTimeStampOfObjectsInCacheWithExternalReferences(expirtyTime).*/
void removeExpiredObjectsInCache(double expiryTime);
void removeExpiredObjectsInCache(double expiryTime)
{
std::vector<osg::ref_ptr<osg::Object> > objectsToRemove;
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
// Remove expired entries from object cache
typename ObjectCacheMap::iterator oitr = _objectCache.begin();
while(oitr != _objectCache.end())
{
if (oitr->second.second<=expiryTime)
{
objectsToRemove.push_back(oitr->second.first);
_objectCache.erase(oitr++);
}
else
++oitr;
}
}
// note, actual unref happens outside of the lock
objectsToRemove.clear();
}
/** Remove all objects in the cache regardless of having external references or expiry times.*/
void clear();
void clear()
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
_objectCache.clear();
}
/** Add a filename,object,timestamp triple to the Registry::ObjectCache.*/
void addEntryToObjectCache(const std::string& filename, osg::Object* object, double timestamp = 0.0);
/** Add a key,object,timestamp triple to the Registry::ObjectCache.*/
void addEntryToObjectCache(const KeyType& key, osg::Object* object, double timestamp = 0.0)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
_objectCache[key]=ObjectTimeStampPair(object,timestamp);
}
/** Remove Object from cache.*/
void removeFromObjectCache(const std::string& fileName);
void removeFromObjectCache(const KeyType& key)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
typename ObjectCacheMap::iterator itr = _objectCache.find(key);
if (itr!=_objectCache.end()) _objectCache.erase(itr);
}
/** Get an ref_ptr<Object> from the object cache*/
osg::ref_ptr<osg::Object> getRefFromObjectCache(const std::string& fileName);
osg::ref_ptr<osg::Object> getRefFromObjectCache(const KeyType& key)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
typename ObjectCacheMap::iterator itr = _objectCache.find(key);
if (itr!=_objectCache.end())
return itr->second.first;
else return 0;
}
/** Check if an object is in the cache, and if it is, update its usage time stamp. */
bool checkInObjectCache(const std::string& fileName, double timeStamp);
bool checkInObjectCache(const KeyType& key, double timeStamp)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
typename ObjectCacheMap::iterator itr = _objectCache.find(key);
if (itr!=_objectCache.end())
{
itr->second.second = timeStamp;
return true;
}
else return false;
}
/** call releaseGLObjects on all objects attached to the object cache.*/
void releaseGLObjects(osg::State* state);
void releaseGLObjects(osg::State* state)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
for(typename ObjectCacheMap::iterator itr = _objectCache.begin(); itr != _objectCache.end(); ++itr)
{
osg::Object* object = itr->second.first.get();
object->releaseGLObjects(state);
}
}
/** call node->accept(nv); for all nodes in the objectCache. */
void accept(osg::NodeVisitor& nv);
void accept(osg::NodeVisitor& nv)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
for(typename ObjectCacheMap::iterator itr = _objectCache.begin(); itr != _objectCache.end(); ++itr)
{
osg::Object* object = itr->second.first.get();
if (object)
{
osg::Node* node = dynamic_cast<osg::Node*>(object);
if (node)
node->accept(nv);
}
}
}
/** call operator()(osg::Object*) for each object in the cache. */
template <class Functor>
void call(Functor& f)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
for (ObjectCacheMap::iterator it = _objectCache.begin(); it != _objectCache.end(); ++it)
for (typename ObjectCacheMap::iterator it = _objectCache.begin(); it != _objectCache.end(); ++it)
f(it->second.first.get());
}
/** Get the number of objects in the cache. */
unsigned int getCacheSize() const;
unsigned int getCacheSize() const
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_objectCacheMutex);
return _objectCache.size();
}
protected:
virtual ~ObjectCache();
virtual ~GenericObjectCache() {}
typedef std::pair<osg::ref_ptr<osg::Object>, double > ObjectTimeStampPair;
typedef std::map<std::string, ObjectTimeStampPair > ObjectCacheMap;
typedef std::map<KeyType, ObjectTimeStampPair > ObjectCacheMap;
ObjectCacheMap _objectCache;
mutable OpenThreads::Mutex _objectCacheMutex;
};
class ObjectCache : public GenericObjectCache<std::string>
{
};
}
#endif

46
components/resource/resourcemanager.cpp
View file

@ -1,46 +0,0 @@
#include "resourcemanager.hpp"
#include "objectcache.hpp"
namespace Resource
{
ResourceManager::ResourceManager(const VFS::Manager *vfs)
: mVFS(vfs)
, mCache(new Resource::ObjectCache)
, mExpiryDelay(0.0)
{
}
ResourceManager::~ResourceManager()
{
}
void ResourceManager::updateCache(double referenceTime)
{
mCache->updateTimeStampOfObjectsInCacheWithExternalReferences(referenceTime);
mCache->removeExpiredObjectsInCache(referenceTime - mExpiryDelay);
}
void ResourceManager::clearCache()
{
mCache->clear();
}
void ResourceManager::setExpiryDelay(double expiryDelay)
{
mExpiryDelay = expiryDelay;
}
const VFS::Manager* ResourceManager::getVFS() const
{
return mVFS;
}
void ResourceManager::releaseGLObjects(osg::State *state)
{
mCache->releaseGLObjects(state);
}
}

52
components/resource/resourcemanager.hpp
View file

@ -3,6 +3,8 @@
#include <osg/ref_ptr>
#include "objectcache.hpp"
namespace VFS
{
class Manager;
@ -16,37 +18,67 @@ namespace osg
namespace Resource
{
class ObjectCache;
class BaseResourceManager
{
public:
virtual ~BaseResourceManager() {}
virtual void updateCache(double referenceTime) {}
virtual void clearCache() {}
virtual void setExpiryDelay(double expiryDelay) {}
virtual void reportStats(unsigned int frameNumber, osg::Stats* stats) const {}
virtual void releaseGLObjects(osg::State* state) {}
};
/// @brief Base class for managers that require a virtual file system and object cache.
/// @par This base class implements clearing of the cache, but populating it and what it's used for is up to the individual sub classes.
class ResourceManager
template <class KeyType>
class GenericResourceManager : public BaseResourceManager
{
public:
ResourceManager(const VFS::Manager* vfs);
virtual ~ResourceManager();
typedef GenericObjectCache<KeyType> CacheType;
GenericResourceManager(const VFS::Manager* vfs)
: mVFS(vfs)
, mCache(new CacheType)
, mExpiryDelay(0.0)
{
}
virtual ~GenericResourceManager() {}
/// Clear cache entries that have not been referenced for longer than expiryDelay.
virtual void updateCache(double referenceTime);
virtual void updateCache(double referenceTime)
{
mCache->updateTimeStampOfObjectsInCacheWithExternalReferences(referenceTime);
mCache->removeExpiredObjectsInCache(referenceTime - mExpiryDelay);
}
/// Clear all cache entries.
virtual void clearCache();
virtual void clearCache() { mCache->clear(); }
/// How long to keep objects in cache after no longer being referenced.
void setExpiryDelay (double expiryDelay);
void setExpiryDelay (double expiryDelay) { mExpiryDelay = expiryDelay; }
const VFS::Manager* getVFS() const;
const VFS::Manager* getVFS() const { return mVFS; }
virtual void reportStats(unsigned int frameNumber, osg::Stats* stats) const {}
virtual void releaseGLObjects(osg::State* state);
virtual void releaseGLObjects(osg::State* state) { mCache->releaseGLObjects(state); }
protected:
const VFS::Manager* mVFS;
osg::ref_ptr<Resource::ObjectCache> mCache;
osg::ref_ptr<CacheType> mCache;
double mExpiryDelay;
};
class ResourceManager : public GenericResourceManager<std::string>
{
public:
ResourceManager(const VFS::Manager* vfs) : GenericResourceManager<std::string>(vfs) {}
};
}
#endif

16
components/resource/resourcesystem.cpp
View file

@ -54,7 +54,7 @@ namespace Resource
void ResourceSystem::setExpiryDelay(double expiryDelay)
{
for (std::vector<ResourceManager*>::iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
for (std::vector<BaseResourceManager*>::iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
(*it)->setExpiryDelay(expiryDelay);
// NIF files aren't needed any more once the converted objects are cached in SceneManager / BulletShapeManager,
@ -64,24 +64,24 @@ namespace Resource
void ResourceSystem::updateCache(double referenceTime)
{
for (std::vector<ResourceManager*>::iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
for (std::vector<BaseResourceManager*>::iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
(*it)->updateCache(referenceTime);
}
void ResourceSystem::clearCache()
{
for (std::vector<ResourceManager*>::iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
for (std::vector<BaseResourceManager*>::iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
(*it)->clearCache();
}
void ResourceSystem::addResourceManager(ResourceManager *resourceMgr)
void ResourceSystem::addResourceManager(BaseResourceManager *resourceMgr)
{
mResourceManagers.push_back(resourceMgr);
}
void ResourceSystem::removeResourceManager(ResourceManager *resourceMgr)
void ResourceSystem::removeResourceManager(BaseResourceManager *resourceMgr)
{
std::vector<ResourceManager*>::iterator found = std::find(mResourceManagers.begin(), mResourceManagers.end(), resourceMgr);
std::vector<BaseResourceManager*>::iterator found = std::find(mResourceManagers.begin(), mResourceManagers.end(), resourceMgr);
if (found != mResourceManagers.end())
mResourceManagers.erase(found);
}
@ -93,13 +93,13 @@ namespace Resource
void ResourceSystem::reportStats(unsigned int frameNumber, osg::Stats *stats) const
{
for (std::vector<ResourceManager*>::const_iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
for (std::vector<BaseResourceManager*>::const_iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
(*it)->reportStats(frameNumber, stats);
}
void ResourceSystem::releaseGLObjects(osg::State *state)
{
for (std::vector<ResourceManager*>::const_iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
for (std::vector<BaseResourceManager*>::const_iterator it = mResourceManagers.begin(); it != mResourceManagers.end(); ++it)
(*it)->releaseGLObjects(state);
}

8
components/resource/resourcesystem.hpp
View file

@ -22,7 +22,7 @@ namespace Resource
class ImageManager;
class NifFileManager;
class KeyframeManager;
class ResourceManager;
class BaseResourceManager;
/// @brief Wrapper class that constructs and provides access to the most commonly used resource subsystems.
/// @par Resource subsystems can be used with multiple OpenGL contexts, just like the OSG equivalents, but
@ -48,10 +48,10 @@ namespace Resource
/// Add this ResourceManager to be handled by the ResourceSystem.
/// @note Does not transfer ownership.
void addResourceManager(ResourceManager* resourceMgr);
void addResourceManager(BaseResourceManager* resourceMgr);
/// @note Do nothing if resourceMgr does not exist.
/// @note Does not delete resourceMgr.
void removeResourceManager(ResourceManager* resourceMgr);
void removeResourceManager(BaseResourceManager* resourceMgr);
/// How long to keep objects in cache after no longer being referenced.
void setExpiryDelay(double expiryDelay);
@ -72,7 +72,7 @@ namespace Resource
// Store the base classes separately to get convenient access to the common interface
// Here users can register their own resourcemanager as well
std::vector<ResourceManager*> mResourceManagers;
std::vector<BaseResourceManager*> mResourceManagers;
const VFS::Manager* mVFS;

15
components/terrain/chunkmanager.cpp
View file

@ -22,7 +22,7 @@ namespace Terrain
{
ChunkManager::ChunkManager(Storage *storage, Resource::SceneManager *sceneMgr, TextureManager* textureManager, CompositeMapRenderer* renderer)
: ResourceManager(nullptr)
: GenericResourceManager<ChunkId>(nullptr)
, mStorage(storage)
, mSceneManager(sceneMgr)
, mTextureManager(textureManager)
@ -35,12 +35,9 @@ ChunkManager::ChunkManager(Storage *storage, Resource::SceneManager *sceneMgr, T
}
osg::ref_ptr<osg::Node> ChunkManager::getChunk(float size, const osg::Vec2f &center, int lod, unsigned int lodFlags)
osg::ref_ptr<osg::Node> ChunkManager::getChunk(float size, const osg::Vec2f &center, unsigned char lod, unsigned int lodFlags)
{
std::ostringstream stream;
stream << size << " " << center.x() << " " << center.y() << " " << lod << " " << lodFlags;
std::string id = stream.str();
ChunkId id = std::make_tuple(center, lod, lodFlags);
osg::ref_ptr<osg::Object> obj = mCache->getRefFromObjectCache(id);
if (obj)
return obj->asNode();
@ -59,14 +56,14 @@ void ChunkManager::reportStats(unsigned int frameNumber, osg::Stats *stats) cons
void ChunkManager::clearCache()
{
ResourceManager::clearCache();
GenericResourceManager<ChunkId>::clearCache();
mBufferCache.clearCache();
}
void ChunkManager::releaseGLObjects(osg::State *state)
{
ResourceManager::releaseGLObjects(state);
GenericResourceManager<ChunkId>::releaseGLObjects(state);
mBufferCache.releaseGLObjects(state);
}
@ -164,7 +161,7 @@ std::vector<osg::ref_ptr<osg::StateSet> > ChunkManager::createPasses(float chunk
return ::Terrain::createPasses(useShaders, &mSceneManager->getShaderManager(), layers, blendmapTextures, blendmapScale, blendmapScale);
}
osg::ref_ptr<osg::Node> ChunkManager::createChunk(float chunkSize, const osg::Vec2f &chunkCenter, int lod, unsigned int lodFlags)
osg::ref_ptr<osg::Node> ChunkManager::createChunk(float chunkSize, const osg::Vec2f &chunkCenter, unsigned char lod, unsigned int lodFlags)
{
osg::Vec2f worldCenter = chunkCenter*mStorage->getCellWorldSize();
osg::ref_ptr<SceneUtil::PositionAttitudeTransform> transform (new SceneUtil::PositionAttitudeTransform);

10
components/terrain/chunkmanager.hpp
View file

@ -1,6 +1,8 @@
#ifndef OPENMW_COMPONENTS_TERRAIN_CHUNKMANAGER_H
#define OPENMW_COMPONENTS_TERRAIN_CHUNKMANAGER_H
#include <tuple>
#include <components/resource/resourcemanager.hpp>
#include "buffercache.hpp"
@ -24,13 +26,15 @@ namespace Terrain
class Storage;
class CompositeMap;
typedef std::tuple<osg::Vec2f, unsigned char, unsigned int> ChunkId; // Center, Lod, Lod Flags
/// @brief Handles loading and caching of terrain chunks
class ChunkManager : public Resource::ResourceManager
class ChunkManager : public Resource::GenericResourceManager<ChunkId>
{
public:
ChunkManager(Storage* storage, Resource::SceneManager* sceneMgr, TextureManager* textureManager, CompositeMapRenderer* renderer);
osg::ref_ptr<osg::Node> getChunk(float size, const osg::Vec2f& center, int lod, unsigned int lodFlags);
osg::ref_ptr<osg::Node> getChunk(float size, const osg::Vec2f& center, unsigned char lod, unsigned int lodFlags);
void setCullingActive(bool active) { mCullingActive = active; }
void setCompositeMapSize(unsigned int size) { mCompositeMapSize = size; }
@ -44,7 +48,7 @@ namespace Terrain
void releaseGLObjects(osg::State* state) override;
private:
osg::ref_ptr<osg::Node> createChunk(float size, const osg::Vec2f& center, int lod, unsigned int lodFlags);
osg::ref_ptr<osg::Node> createChunk(float size, const osg::Vec2f& center, unsigned char lod, unsigned int lodFlags);
osg::ref_ptr<osg::Texture2D> createCompositeMapRTT();