teamnwah/openmw-tes3coop
2
0
Fork 1
forked from mirror/openmw-tes3mp
Code Issues Pull requests 1 Releases Wiki Activity

Move keyframe loading out of SceneManager to new KeyframeManager

Browse source
This commit is contained in:
scrawl 2015-12-12 18:52:06 +01:00
parent 295563ba65
commit 64424e7262
10 changed files with 112 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
apps/openmw/mwrender/animation.cpp
View file

@ -19,6 +19,7 @@
#include <components/resource/resourcesystem.hpp>
#include <components/resource/scenemanager.hpp>
#include <components/resource/keyframemanager.hpp>
#include <components/resource/texturemanager.hpp>
#include <components/nifosg/nifloader.hpp> // KeyframeHolder
@ -402,7 +403,7 @@ namespace MWRender
boost::shared_ptr<AnimSource> animsrc;
animsrc.reset(new AnimSource);
animsrc->mKeyframes = mResourceSystem->getSceneManager()->getKeyframes(kfname);
animsrc->mKeyframes = mResourceSystem->getKeyframeManager()->get(kfname);
if (!animsrc->mKeyframes || animsrc->mKeyframes->mTextKeys.empty() || animsrc->mKeyframes->mKeyframeControllers.empty())
return;

2
components/CMakeLists.txt
View file

@ -41,7 +41,7 @@ add_component_dir (vfs
)
add_component_dir (resource
scenemanager texturemanager resourcesystem bulletshapemanager bulletshape niffilemanager objectcache
scenemanager keyframemanager texturemanager resourcesystem bulletshapemanager bulletshape niffilemanager objectcache
)
add_component_dir (sceneutil

11
components/nifosg/nifloader.hpp
View file

@ -37,11 +37,20 @@ namespace NifOsg
};
class KeyframeHolder : public osg::Referenced
class KeyframeHolder : public osg::Object
{
public:
KeyframeHolder() {}
KeyframeHolder(const KeyframeHolder& copy, const osg::CopyOp& copyop)
: mTextKeys(copy.mTextKeys)
, mKeyframeControllers(copy.mKeyframeControllers)
{
}
TextKeyMap mTextKeys;
META_Object(OpenMW, KeyframeHolder)
typedef std::map<std::string, osg::ref_ptr<const KeyframeController> > KeyframeControllerMap;
KeyframeControllerMap mKeyframeControllers;
};

41
components/resource/keyframemanager.cpp Normal file
View file

@ -0,0 +1,41 @@
#include "keyframemanager.hpp"
#include <components/vfs/manager.hpp>
#include <components/nifosg/nifloader.hpp>
#include "objectcache.hpp"
namespace Resource
{
KeyframeManager::KeyframeManager(const VFS::Manager* vfs)
: mCache(new osgDB::ObjectCache)
, mVFS(vfs)
{
}
KeyframeManager::~KeyframeManager()
{
}
osg::ref_ptr<const NifOsg::KeyframeHolder> KeyframeManager::get(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 NifOsg::KeyframeHolder>(static_cast<NifOsg::KeyframeHolder*>(obj.get()));
else
{
osg::ref_ptr<NifOsg::KeyframeHolder> loaded (new NifOsg::KeyframeHolder);
NifOsg::Loader::loadKf(Nif::NIFFilePtr(new Nif::NIFFile(mVFS->getNormalized(normalized), normalized)), *loaded.get());
mCache->addEntryToObjectCache(name, loaded);
return loaded;
}
}
}

47
components/resource/keyframemanager.hpp Normal file
View file

@ -0,0 +1,47 @@
#ifndef OPENMW_COMPONENTS_KEYFRAMEMANAGER_H
#define OPENMW_COMPONENTS_KEYFRAMEMANAGER_H
#include <osg/ref_ptr>
#include <string>
namespace VFS
{
class Manager;
}
namespace osgDB
{
class ObjectCache;
}
namespace NifOsg
{
class KeyframeHolder;
}
namespace Resource
{
/// @brief Managing of keyframe resources
class KeyframeManager
{
public:
KeyframeManager(const VFS::Manager* vfs);
~KeyframeManager();
void clearCache();
/// Retrieve a read-only keyframe resource by name (case-insensitive).
/// @note This method is safe to call from any thread.
/// @note Throws an exception if the resource is not found.
osg::ref_ptr<const NifOsg::KeyframeHolder> get(const std::string& name);
private:
osg::ref_ptr<osgDB::ObjectCache> mCache;
const VFS::Manager* mVFS;
};
}
#endif

2
components/resource/niffilemanager.cpp
View file

@ -4,8 +4,6 @@
#include "objectcache.hpp"
#include <osg/Timer>
namespace Resource
{

9
components/resource/resourcesystem.cpp
View file

@ -3,6 +3,7 @@
#include "scenemanager.hpp"
#include "texturemanager.hpp"
#include "niffilemanager.hpp"
#include "keyframemanager.hpp"
namespace Resource
{
@ -11,6 +12,7 @@ namespace Resource
: mVFS(vfs)
{
mNifFileManager.reset(new NifFileManager(vfs));
mKeyframeManager.reset(new KeyframeManager(vfs));
mTextureManager.reset(new TextureManager(vfs));
mSceneManager.reset(new SceneManager(vfs, mTextureManager.get(), mNifFileManager.get()));
}
@ -30,11 +32,16 @@ namespace Resource
return mTextureManager.get();
}
NifFileManager *ResourceSystem::getNifFileManager()
NifFileManager* ResourceSystem::getNifFileManager()
{
return mNifFileManager.get();
}
KeyframeManager* ResourceSystem::getKeyframeManager()
{
return mKeyframeManager.get();
}
void ResourceSystem::clearCache()
{
mNifFileManager->clearCache();

3
components/resource/resourcesystem.hpp
View file

@ -14,6 +14,7 @@ namespace Resource
class SceneManager;
class TextureManager;
class NifFileManager;
class KeyframeManager;
/// @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
@ -27,6 +28,7 @@ namespace Resource
SceneManager* getSceneManager();
TextureManager* getTextureManager();
NifFileManager* getNifFileManager();
KeyframeManager* getKeyframeManager();
/// Indicates to each resource manager to clear the cache, i.e. to drop cached objects that are no longer referenced.
void clearCache();
@ -37,6 +39,7 @@ namespace Resource
std::auto_ptr<SceneManager> mSceneManager;
std::auto_ptr<TextureManager> mTextureManager;
std::auto_ptr<NifFileManager> mNifFileManager;
std::auto_ptr<KeyframeManager> mKeyframeManager;
const VFS::Manager* mVFS;

25
components/resource/scenemanager.cpp
View file

@ -233,31 +233,6 @@ namespace Resource
return cloned;
}
osg::ref_ptr<const NifOsg::KeyframeHolder> SceneManager::getKeyframes(const std::string &name)
{
std::string normalized = name;
mVFS->normalizeFilename(normalized);
KeyframeIndex::iterator it = mKeyframeIndex.find(normalized);
if (it == mKeyframeIndex.end())
{
Files::IStreamPtr file = mVFS->get(normalized);
std::string ext = getFileExtension(normalized);
if (ext != "nif" && ext != "kf")
return NULL;
osg::ref_ptr<NifOsg::KeyframeHolder> loaded (new NifOsg::KeyframeHolder);
NifOsg::Loader::loadKf(Nif::NIFFilePtr(new Nif::NIFFile(file, normalized)), *loaded.get());
mKeyframeIndex[normalized] = loaded;
return loaded;
}
else
return it->second;
}
void SceneManager::attachTo(osg::Node *instance, osg::Group *parentNode) const
{
parentNode->addChild(instance);

11
components/resource/scenemanager.hpp
View file

@ -18,11 +18,6 @@ namespace VFS
class Manager;
}
namespace NifOsg
{
class KeyframeHolder;
}
namespace osgUtil
{
class IncrementalCompileOperation;
@ -57,9 +52,6 @@ namespace Resource
/// @note Assumes the given instance was not attached to any parents before.
void attachTo(osg::Node* instance, osg::Group* parentNode) const;
/// Get a read-only copy of the given keyframe file.
osg::ref_ptr<const NifOsg::KeyframeHolder> getKeyframes(const std::string& name);
/// Manually release created OpenGL objects for the given graphics context. This may be required
/// in cases where multiple contexts are used over the lifetime of the application.
void releaseGLObjects(osg::State* state);
@ -90,9 +82,6 @@ namespace Resource
typedef std::map<std::string, osg::ref_ptr<const osg::Node> > Index;
Index mIndex;
typedef std::map<std::string, osg::ref_ptr<const NifOsg::KeyframeHolder> > KeyframeIndex;
KeyframeIndex mKeyframeIndex;
SceneManager(const SceneManager&);
void operator = (const SceneManager&);
};