scenemanager.hpp

Go to the documentation of this file.

#ifndef OPENMW_COMPONENTS_RESOURCE_SCENEMANAGER_H
#define OPENMW_COMPONENTS_RESOURCE_SCENEMANAGER_H

#include <string>
#include <map>
#include <memory>

#include <osg/ref_ptr>
#include <osg/Node>
#include <osg/Texture>

#include "resourcemanager.hpp"

namespace Resource
{
    class ImageManager;
    class NifFileManager;
}

namespace osgUtil
{
    class IncrementalCompileOperation;
}

namespace Shader
{
    class ShaderManager;
}

namespace Resource
{

    class MultiObjectCache;

    class SceneManager : public ResourceManager
    {
    public:
        SceneManager(const VFS::Manager* vfs, Resource::ImageManager* imageManager, Resource::NifFileManager* nifFileManager);
        ~SceneManager();

        Shader::ShaderManager& getShaderManager();

        void recreateShaders(osg::ref_ptr<osg::Node> node);

        void setForceShaders(bool force);
        bool getForceShaders() const;

        void setClampLighting(bool clamp);
        bool getClampLighting() const;

        void setForcePerPixelLighting(bool force);
        bool getForcePerPixelLighting() const;

        void setAutoUseNormalMaps(bool use);

        void setNormalMapPattern(const std::string& pattern);

        void setNormalHeightMapPattern(const std::string& pattern);

        void setAutoUseSpecularMaps(bool use);

        void setSpecularMapPattern(const std::string& pattern);

        void setShaderPath(const std::string& path);

        osg::ref_ptr<const osg::Node> getTemplate(const std::string& name);

        osg::ref_ptr<osg::Node> cacheInstance(const std::string& name);

        osg::ref_ptr<osg::Node> getInstance(const std::string& name);

        osg::ref_ptr<osg::Node> getInstance(const std::string& name, osg::Group* parentNode);

        void attachTo(osg::Node* instance, osg::Group* parentNode) const;

        void releaseGLObjects(osg::State* state);

        void setIncrementalCompileOperation(osgUtil::IncrementalCompileOperation* ico);

        void notifyAttached(osg::Node* node) const;

        Resource::ImageManager* getImageManager();

        void setParticleSystemMask(unsigned int mask);

        void setFilterSettings(const std::string &magfilter, const std::string &minfilter,
                               const std::string &mipmap, int maxAnisotropy);

        void applyFilterSettings (osg::Texture* tex);

        void setUnRefImageDataAfterApply(bool unref);

        virtual void updateCache(double referenceTime);

    private:

        osg::ref_ptr<osg::Node> createInstance(const std::string& name);

        std::auto_ptr<Shader::ShaderManager> mShaderManager;
        bool mForceShaders;
        bool mClampLighting;
        bool mForcePerPixelLighting;
        bool mAutoUseNormalMaps;
        std::string mNormalMapPattern;
        std::string mNormalHeightMapPattern;
        bool mAutoUseSpecularMaps;
        std::string mSpecularMapPattern;

        osg::ref_ptr<MultiObjectCache> mInstanceCache;

        OpenThreads::Mutex mSharedStateMutex;

        Resource::ImageManager* mImageManager;
        Resource::NifFileManager* mNifFileManager;

        osg::Texture::FilterMode mMinFilter;
        osg::Texture::FilterMode mMagFilter;
        int mMaxAnisotropy;
        bool mUnRefImageDataAfterApply;

        osg::ref_ptr<osgUtil::IncrementalCompileOperation> mIncrementalCompileOperation;

        unsigned int mParticleSystemMask;

        SceneManager(const SceneManager&);
        void operator = (const SceneManager&);
    };

}

#endif