mirror of
				https://github.com/OpenMW/openmw.git
				synced 2025-11-04 07:56:40 +00:00 
			
		
		
		
	
		
			
				
	
	
		
			228 lines
		
	
	
	
		
			7.9 KiB
		
	
	
	
		
			C++
		
	
	
	
	
	
			
		
		
	
	
			228 lines
		
	
	
	
		
			7.9 KiB
		
	
	
	
		
			C++
		
	
	
	
	
	
#include "terraingrid.hpp"
 | 
						|
 | 
						|
#include <memory>
 | 
						|
 | 
						|
#include <components/resource/resourcesystem.hpp>
 | 
						|
#include <components/resource/texturemanager.hpp>
 | 
						|
 | 
						|
#include <components/sceneutil/lightmanager.hpp>
 | 
						|
#include <components/sceneutil/positionattitudetransform.hpp>
 | 
						|
 | 
						|
#include <components/esm/loadland.hpp>
 | 
						|
 | 
						|
#include <osg/Geometry>
 | 
						|
#include <osg/Geode>
 | 
						|
#include <osg/KdTree>
 | 
						|
#include <osg/Version>
 | 
						|
 | 
						|
#include <osgFX/Effect>
 | 
						|
 | 
						|
#include <osgUtil/IncrementalCompileOperation>
 | 
						|
 | 
						|
#include "material.hpp"
 | 
						|
#include "storage.hpp"
 | 
						|
 | 
						|
namespace
 | 
						|
{
 | 
						|
    class StaticBoundingBoxCallback : public osg::Drawable::ComputeBoundingBoxCallback
 | 
						|
    {
 | 
						|
    public:
 | 
						|
        StaticBoundingBoxCallback(const osg::BoundingBox& bounds)
 | 
						|
            : mBoundingBox(bounds)
 | 
						|
        {
 | 
						|
        }
 | 
						|
 | 
						|
        virtual osg::BoundingBox computeBound(const osg::Drawable&) const
 | 
						|
        {
 | 
						|
            return mBoundingBox;
 | 
						|
        }
 | 
						|
 | 
						|
    private:
 | 
						|
        osg::BoundingBox mBoundingBox;
 | 
						|
    };
 | 
						|
}
 | 
						|
 | 
						|
namespace Terrain
 | 
						|
{
 | 
						|
 | 
						|
TerrainGrid::TerrainGrid(osg::Group* parent, Resource::ResourceSystem* resourceSystem, osgUtil::IncrementalCompileOperation* ico,
 | 
						|
                         Storage* storage, int nodeMask)
 | 
						|
    : Terrain::World(parent, resourceSystem, ico, storage, nodeMask)
 | 
						|
    , mNumSplits(4)
 | 
						|
    , mKdTreeBuilder(new osg::KdTreeBuilder)
 | 
						|
{
 | 
						|
    mCache = BufferCache((storage->getCellVertices()-1)/static_cast<float>(mNumSplits) + 1);
 | 
						|
}
 | 
						|
 | 
						|
TerrainGrid::~TerrainGrid()
 | 
						|
{
 | 
						|
    while (!mGrid.empty())
 | 
						|
    {
 | 
						|
        unloadCell(mGrid.begin()->first.first, mGrid.begin()->first.second);
 | 
						|
    }
 | 
						|
}
 | 
						|
 | 
						|
class GridElement
 | 
						|
{
 | 
						|
public:
 | 
						|
    osg::ref_ptr<osg::Node> mNode;
 | 
						|
};
 | 
						|
 | 
						|
osg::ref_ptr<osg::Node> TerrainGrid::buildTerrain (osg::Group* parent, float chunkSize, const osg::Vec2f& chunkCenter)
 | 
						|
{
 | 
						|
    if (chunkSize * mNumSplits > 1.f)
 | 
						|
    {
 | 
						|
        // keep splitting
 | 
						|
        osg::ref_ptr<osg::Group> group (new osg::Group);
 | 
						|
        if (parent)
 | 
						|
            parent->addChild(group);
 | 
						|
 | 
						|
        float newChunkSize = chunkSize/2.f;
 | 
						|
        buildTerrain(group, newChunkSize, chunkCenter + osg::Vec2f(newChunkSize/2.f, newChunkSize/2.f));
 | 
						|
        buildTerrain(group, newChunkSize, chunkCenter + osg::Vec2f(newChunkSize/2.f, -newChunkSize/2.f));
 | 
						|
        buildTerrain(group, newChunkSize, chunkCenter + osg::Vec2f(-newChunkSize/2.f, newChunkSize/2.f));
 | 
						|
        buildTerrain(group, newChunkSize, chunkCenter + osg::Vec2f(-newChunkSize/2.f, -newChunkSize/2.f));
 | 
						|
        return group;
 | 
						|
    }
 | 
						|
    else
 | 
						|
    {
 | 
						|
        float minH, maxH;
 | 
						|
        if (!mStorage->getMinMaxHeights(chunkSize, chunkCenter, minH, maxH))
 | 
						|
            return NULL; // no terrain defined
 | 
						|
 | 
						|
        osg::Vec2f worldCenter = chunkCenter*mStorage->getCellWorldSize();
 | 
						|
        osg::ref_ptr<SceneUtil::PositionAttitudeTransform> transform (new SceneUtil::PositionAttitudeTransform);
 | 
						|
        transform->setPosition(osg::Vec3f(worldCenter.x(), worldCenter.y(), 0.f));
 | 
						|
 | 
						|
        if (parent)
 | 
						|
            parent->addChild(transform);
 | 
						|
 | 
						|
        osg::ref_ptr<osg::Vec3Array> positions (new osg::Vec3Array);
 | 
						|
        osg::ref_ptr<osg::Vec3Array> normals (new osg::Vec3Array);
 | 
						|
        osg::ref_ptr<osg::Vec4Array> colors (new osg::Vec4Array);
 | 
						|
 | 
						|
        osg::ref_ptr<osg::VertexBufferObject> vbo (new osg::VertexBufferObject);
 | 
						|
        positions->setVertexBufferObject(vbo);
 | 
						|
        normals->setVertexBufferObject(vbo);
 | 
						|
        colors->setVertexBufferObject(vbo);
 | 
						|
 | 
						|
        mStorage->fillVertexBuffers(0, chunkSize, chunkCenter, positions, normals, colors);
 | 
						|
 | 
						|
        osg::ref_ptr<osg::Geometry> geometry (new osg::Geometry);
 | 
						|
        geometry->setVertexArray(positions);
 | 
						|
        geometry->setNormalArray(normals, osg::Array::BIND_PER_VERTEX);
 | 
						|
        geometry->setColorArray(colors, osg::Array::BIND_PER_VERTEX);
 | 
						|
        geometry->setUseDisplayList(false);
 | 
						|
        geometry->setUseVertexBufferObjects(true);
 | 
						|
 | 
						|
        geometry->addPrimitiveSet(mCache.getIndexBuffer(0));
 | 
						|
 | 
						|
        // we already know the bounding box, so no need to let OSG compute it.
 | 
						|
        osg::Vec3f min(-0.5f*mStorage->getCellWorldSize()*chunkSize,
 | 
						|
                       -0.5f*mStorage->getCellWorldSize()*chunkSize,
 | 
						|
                       minH);
 | 
						|
        osg::Vec3f max (0.5f*mStorage->getCellWorldSize()*chunkSize,
 | 
						|
                           0.5f*mStorage->getCellWorldSize()*chunkSize,
 | 
						|
                           maxH);
 | 
						|
        osg::BoundingBox bounds(min, max);
 | 
						|
        geometry->setComputeBoundingBoxCallback(new StaticBoundingBoxCallback(bounds));
 | 
						|
 | 
						|
        std::vector<LayerInfo> layerList;
 | 
						|
        std::vector<osg::ref_ptr<osg::Image> > blendmaps;
 | 
						|
        mStorage->getBlendmaps(chunkSize, chunkCenter, false, blendmaps, layerList);
 | 
						|
 | 
						|
        // For compiling textures, I don't think the osgFX::Effect does it correctly
 | 
						|
        osg::ref_ptr<osg::Node> textureCompileDummy (new osg::Node);
 | 
						|
 | 
						|
        std::vector<osg::ref_ptr<osg::Texture2D> > layerTextures;
 | 
						|
        for (std::vector<LayerInfo>::const_iterator it = layerList.begin(); it != layerList.end(); ++it)
 | 
						|
        {
 | 
						|
            layerTextures.push_back(mResourceSystem->getTextureManager()->getTexture2D(it->mDiffuseMap, osg::Texture::REPEAT, osg::Texture::REPEAT));
 | 
						|
            textureCompileDummy->getOrCreateStateSet()->setTextureAttributeAndModes(0, layerTextures.back());
 | 
						|
        }
 | 
						|
 | 
						|
        std::vector<osg::ref_ptr<osg::Texture2D> > blendmapTextures;
 | 
						|
        for (std::vector<osg::ref_ptr<osg::Image> >::const_iterator it = blendmaps.begin(); it != blendmaps.end(); ++it)
 | 
						|
        {
 | 
						|
            osg::ref_ptr<osg::Texture2D> texture (new osg::Texture2D);
 | 
						|
            texture->setImage(*it);
 | 
						|
            texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
 | 
						|
            texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
 | 
						|
            texture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
 | 
						|
            texture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
 | 
						|
            texture->setResizeNonPowerOfTwoHint(false);
 | 
						|
            blendmapTextures.push_back(texture);
 | 
						|
 | 
						|
            textureCompileDummy->getOrCreateStateSet()->setTextureAttributeAndModes(0, layerTextures.back());
 | 
						|
        }
 | 
						|
 | 
						|
        // use texture coordinates for both texture units, the layer texture and blend texture
 | 
						|
        for (unsigned int i=0; i<2; ++i)
 | 
						|
            geometry->setTexCoordArray(i, mCache.getUVBuffer());
 | 
						|
 | 
						|
        float blendmapScale = ESM::Land::LAND_TEXTURE_SIZE*chunkSize;
 | 
						|
        osg::ref_ptr<osgFX::Effect> effect (new Terrain::Effect(layerTextures, blendmapTextures, blendmapScale, blendmapScale));
 | 
						|
 | 
						|
        effect->addCullCallback(new SceneUtil::LightListCallback);
 | 
						|
 | 
						|
        transform->addChild(effect);
 | 
						|
 | 
						|
#if OSG_VERSION_GREATER_OR_EQUAL(3,3,3)
 | 
						|
        osg::Node* toAttach = geometry.get();
 | 
						|
#else
 | 
						|
        osg::ref_ptr<osg::Geode> geode (new osg::Geode);
 | 
						|
        geode->addDrawable(geometry);
 | 
						|
        osg::Node* toAttach = geode.get();
 | 
						|
#endif
 | 
						|
 | 
						|
        effect->addChild(toAttach);
 | 
						|
 | 
						|
        if (mIncrementalCompileOperation)
 | 
						|
        {
 | 
						|
            mIncrementalCompileOperation->add(toAttach);
 | 
						|
            mIncrementalCompileOperation->add(textureCompileDummy);
 | 
						|
        }
 | 
						|
 | 
						|
        return transform;
 | 
						|
    }
 | 
						|
}
 | 
						|
 | 
						|
void TerrainGrid::loadCell(int x, int y)
 | 
						|
{
 | 
						|
    if (mGrid.find(std::make_pair(x, y)) != mGrid.end())
 | 
						|
        return; // already loaded
 | 
						|
 | 
						|
    osg::Vec2f center(x+0.5f, y+0.5f);
 | 
						|
 | 
						|
    osg::ref_ptr<osg::Node> terrainNode = buildTerrain(NULL, 1.f, center);
 | 
						|
    if (!terrainNode)
 | 
						|
        return; // no terrain defined
 | 
						|
 | 
						|
    std::auto_ptr<GridElement> element (new GridElement);
 | 
						|
    element->mNode = terrainNode;
 | 
						|
    mTerrainRoot->addChild(element->mNode);
 | 
						|
 | 
						|
    // kdtree probably not needed with mNumSplits=4
 | 
						|
    /*
 | 
						|
    // build a kdtree to speed up intersection tests with the terrain
 | 
						|
    // Note, the build could be optimized using a custom kdtree builder, since we know that the terrain can be represented by a quadtree
 | 
						|
    geode->accept(*mKdTreeBuilder);
 | 
						|
    */
 | 
						|
 | 
						|
    mGrid[std::make_pair(x,y)] = element.release();
 | 
						|
}
 | 
						|
 | 
						|
void TerrainGrid::unloadCell(int x, int y)
 | 
						|
{
 | 
						|
    Grid::iterator it = mGrid.find(std::make_pair(x,y));
 | 
						|
    if (it == mGrid.end())
 | 
						|
        return;
 | 
						|
 | 
						|
    GridElement* element = it->second;
 | 
						|
    mTerrainRoot->removeChild(element->mNode);
 | 
						|
    delete element;
 | 
						|
 | 
						|
    mGrid.erase(it);
 | 
						|
}
 | 
						|
 | 
						|
}
 |