storage.hpp

Go to the documentation of this file.

#ifndef COMPONENTS_ESM_TERRAIN_STORAGE_H
#define COMPONENTS_ESM_TERRAIN_STORAGE_H

#include <OpenThreads/Mutex>

#include <components/terrain/storage.hpp>

#include <components/esm/loadland.hpp>
#include <components/esm/loadltex.hpp>

namespace VFS
{
    class Manager;
}

namespace ESMTerrain
{

    class LandCache;

    class LandObject : public osg::Object
    {
    public:
        LandObject();
        LandObject(const ESM::Land* land, int loadFlags);
        LandObject(const LandObject& copy, const osg::CopyOp& copyop);
        virtual ~LandObject();

        META_Object(ESMTerrain, LandObject)

        const ESM::Land::LandData* getData(int flags) const;
        int getPlugin() const;

    private:
        const ESM::Land* mLand;
        int mLoadFlags;

        ESM::Land::LandData mData;
    };

    class Storage : public Terrain::Storage
    {
    public:
        Storage(const VFS::Manager* vfs, const std::string& normalMapPattern = "", const std::string& normalHeightMapPattern = "", bool autoUseNormalMaps = false, const std::string& specularMapPattern = "", bool autoUseSpecularMaps = false);

        // Not implemented in this class, because we need different Store implementations for game and editor
        virtual osg::ref_ptr<const LandObject> getLand (int cellX, int cellY)= 0;
        virtual const ESM::LandTexture* getLandTexture(int index, short plugin) = 0;
        virtual void getBounds(float& minX, float& maxX, float& minY, float& maxY) = 0;

        virtual bool getMinMaxHeights (float size, const osg::Vec2f& center, float& min, float& max);

        virtual void fillVertexBuffers (int lodLevel, float size, const osg::Vec2f& center,
                                osg::ref_ptr<osg::Vec3Array> positions,
                                osg::ref_ptr<osg::Vec3Array> normals,
                                osg::ref_ptr<osg::Vec4Array> colours);

        virtual void getBlendmaps (float chunkSize, const osg::Vec2f& chunkCenter, bool pack,
                           ImageVector& blendmaps,
                           std::vector<Terrain::LayerInfo>& layerList);

        virtual float getHeightAt (const osg::Vec3f& worldPos);

        virtual float getCellWorldSize();

        virtual int getCellVertices();

        virtual int getBlendmapScale(float chunkSize);

    private:
        const VFS::Manager* mVFS;

        void fixNormal (osg::Vec3f& normal, int cellX, int cellY, int col, int row, LandCache& cache);
        void fixColour (osg::Vec4f& colour, int cellX, int cellY, int col, int row, LandCache& cache);
        void averageNormal (osg::Vec3f& normal, int cellX, int cellY, int col, int row, LandCache& cache);

        float getVertexHeight (const ESM::Land::LandData* data, int x, int y);

        const LandObject* getLand(int cellX, int cellY, LandCache& cache);

        // Since plugins can define new texture palettes, we need to know the plugin index too
        // in order to retrieve the correct texture name.
        // pair  <texture id, plugin id>
        typedef std::pair<short, short> UniqueTextureId;

        UniqueTextureId getVtexIndexAt(int cellX, int cellY,
                                               int x, int y, LandCache&);
        std::string getTextureName (UniqueTextureId id);

        std::map<std::string, Terrain::LayerInfo> mLayerInfoMap;
        OpenThreads::Mutex mLayerInfoMutex;

        std::string mNormalMapPattern;
        std::string mNormalHeightMapPattern;
        bool mAutoUseNormalMaps;

        std::string mSpecularMapPattern;
        bool mAutoUseSpecularMaps;

        Terrain::LayerInfo getLayerInfo(const std::string& texture);
    };

}

#endif