FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added support for boundary equalization to GeometryTechnique

Browse Source
This commit is contained in:
Robert Osfield
2010-04-01 21:06:56 +00:00
parent 15afc29018
commit a8bbf0a809
12 changed files with 927 additions and 284 deletions
Download Patch File Download Diff File Expand all files Collapse all files

800
src/osgTerrain/GeometryTechnique.cpp
View File

File diff suppressed because it is too large Load Diff

40
src/osgTerrain/Terrain.cpp
View File

@@ -13,6 +13,7 @@
#include <osgTerrain/Terrain>
#include <osgTerrain/GeometryTechnique>
#include <osgUtil/UpdateVisitor>
#include <OpenThreads/ScopedLock>
@@ -24,6 +25,7 @@ Terrain::Terrain():
_verticalScale(1.0),
_blendingPolicy(TerrainTile::INHERIT)
{
setNumChildrenRequiringUpdateTraversal(1);
_terrainTechnique = new GeometryTechnique;
}
@@ -34,6 +36,7 @@ Terrain::Terrain(const Terrain& ts, const osg::CopyOp& copyop):
_blendingPolicy(ts._blendingPolicy),
_terrainTechnique(ts._terrainTechnique)
{
setNumChildrenRequiringUpdateTraversal(getNumChildrenRequiringUpdateTraversal()+1);
}
@@ -54,13 +57,40 @@ Terrain::~Terrain()
void Terrain::traverse(osg::NodeVisitor& nv)
{
if (nv.getVisitorType()==osg::NodeVisitor::UPDATE_VISITOR)
{
// need to check if any TerrainTechniques need to have their update called on them.
osgUtil::UpdateVisitor* uv = dynamic_cast<osgUtil::UpdateVisitor*>(&nv);
if (uv)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
for(TerrainTileSet::iterator itr = _updateTerrainTileSet.begin();
itr != _updateTerrainTileSet.end();
++itr)
{
TerrainTile* tile = *itr;
if (tile->getTerrainTechnique()) tile->getTerrainTechnique()->update(uv);
}
_updateTerrainTileSet.clear();
}
}
Group::traverse(nv);
}
void Terrain::updateTerrainTileOnNextFrame(TerrainTile* terrainTile)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
_updateTerrainTileSet.insert(terrainTile);
}
TerrainTile* Terrain::getTile(const TileID& tileID)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
// OSG_NOTICE<<"Terrain::getTile("<<tileID.level<<", "<<tileID.x<<", "<<tileID.y<<")"<<std::endl;
TerrainTileMap::iterator itr = _terrainTileMap.find(tileID);
if (itr == _terrainTileMap.end()) return 0;
@@ -95,17 +125,18 @@ void Terrain::registerTerrainTile(TerrainTile* tile)
if (!tile) return;
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
if (tile->getTileID().valid())
{
_terrainTileMap[tile->getTileID()] = tile;
}
_terrainTileSet.insert(tile);
if (_terrainTileSet.size() > s_maxNumTiles) s_maxNumTiles = _terrainTileSet.size();
// osg::notify(osg::NOTICE)<<"Terrain::registerTerrainTile "<<tile<<" total number of tile "<<_terrainTileSet.size()<<" max = "<<s_maxNumTiles<<std::endl;
// OSG_NOTICE<<"Terrain::registerTerrainTile "<<tile<<" total number of tile "<<_terrainTileSet.size()<<" max = "<<s_maxNumTiles<<std::endl;
// OSG_NOTICE<<" tileID("<<tile->getTileID().level<<", "<<tile->getTileID().x<<", "<<tile->getTileID().y<<")"<<std::endl;
}
void Terrain::unregisterTerrainTile(TerrainTile* tile)
@@ -120,6 +151,7 @@ void Terrain::unregisterTerrainTile(TerrainTile* tile)
}
_terrainTileSet.erase(tile);
_updateTerrainTileSet.erase(tile);
// osg::notify(osg::NOTICE)<<"Terrain::unregisterTerrainTile "<<tile<<" total number of tile "<<_terrainTileSet.size()<<" max = "<<s_maxNumTiles<<std::endl;
// OSG_NOTICE<<"Terrain::unregisterTerrainTile "<<tile<<" total number of tile "<<_terrainTileSet.size()<<" max = "<<s_maxNumTiles<<std::endl;
}

51
src/osgTerrain/TerrainTechnique.cpp
View File

@@ -16,6 +16,48 @@
using namespace osgTerrain;
/////////////////////////////////////////////////////////////////////////////////////
//
// TerrainNeighbours
//
TerrainNeighbours::TerrainNeighbours()
{
}
TerrainNeighbours::~TerrainNeighbours()
{
clear();
}
void TerrainNeighbours::addNeighbour(TerrainTile* tile)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_neighboursMutex);
_neighbours.insert(tile);
}
void TerrainNeighbours::removeNeighbour(TerrainTile* tile)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_neighboursMutex);
_neighbours.erase(tile);
}
void TerrainNeighbours::clear()
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_neighboursMutex);
_neighbours.clear();
}
bool TerrainNeighbours::containsNeighbour(TerrainTile* tile) const
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_neighboursMutex);
return _neighbours.count(tile)!=0;
}
/////////////////////////////////////////////////////////////////////////////////////
//
// TerrainTechnique
//
TerrainTechnique::TerrainTechnique():
_terrainTile(0)
{
@@ -32,6 +74,15 @@ TerrainTechnique::~TerrainTechnique()
{
}
void TerrainTechnique::setTerrainTile(TerrainTile* tile)
{
if (_terrainTile==tile) return;
_neighbours.clear();
_terrainTile = tile;
}
void TerrainTechnique::init()
{
OSG_NOTIFY(osg::NOTICE)<<className()<<"::initialize(..) not implementated yet"<<std::endl;

43
src/osgTerrain/TerrainTile.cpp
View File

@@ -58,7 +58,7 @@ osg::ref_ptr<TerrainTile::TileLoadedCallback>& TerrainTile::getTileLoadedCallbac
TerrainTile::TerrainTile():
_terrain(0),
_dirty(false),
_dirtyMask(NOT_DIRTY),
_hasBeenTraversal(false),
_requiresNormals(true),
_treatBoundariesToValidDataAsDefaultValue(false),
@@ -70,7 +70,7 @@ TerrainTile::TerrainTile():
TerrainTile::TerrainTile(const TerrainTile& terrain,const osg::CopyOp& copyop):
Group(terrain,copyop),
_terrain(0),
_dirty(false),
_dirtyMask(NOT_DIRTY),
_hasBeenTraversal(false),
_elevationLayer(terrain._elevationLayer),
_colorLayers(terrain._colorLayers),
@@ -86,6 +86,11 @@ TerrainTile::TerrainTile(const TerrainTile& terrain,const osg::CopyOp& copyop):
TerrainTile::~TerrainTile()
{
if (_terrainTechnique.valid())
{
_terrainTechnique->setTerrainTile(0);
}
if (_terrain) setTerrain(0);
}
@@ -134,9 +139,9 @@ void TerrainTile::traverse(osg::NodeVisitor& nv)
}
}
}
init();
_hasBeenTraversal = true;
}
@@ -162,7 +167,7 @@ void TerrainTile::traverse(osg::NodeVisitor& nv)
void TerrainTile::init()
{
if (!_terrainTechnique)
{
{
if (_terrain && _terrain->getTerrainTechniquePrototype())
{
osg::ref_ptr<osg::Object> object = _terrain->getTerrainTechniquePrototype()->clone(osg::CopyOp::DEEP_COPY_ALL);
@@ -177,45 +182,47 @@ void TerrainTile::init()
if (_terrainTechnique.valid() && getDirty())
{
_terrainTechnique->init();
setDirty(false);
}
}
}
void TerrainTile::setTerrainTechnique(TerrainTechnique* terrainTechnique)
{
if (_terrainTechnique == terrainTechnique) return;
int dirtyDelta = _dirty ? -1 : 0;
int dirtyDelta = (_dirtyMask==NOT_DIRTY) ? 0 : -1;
if (_terrainTechnique.valid())
{
_terrainTechnique->_terrainTile = 0;
_terrainTechnique->setTerrainTile(0);
}
_terrainTechnique = terrainTechnique;
if (_terrainTechnique.valid())
{
_terrainTechnique->_terrainTile = this;
_terrainTechnique->setTerrainTile(this);
++dirtyDelta;
}
if (dirtyDelta>0) setDirty(true);
else if (dirtyDelta<0) setDirty(false);
if (dirtyDelta>0) setDirtyMask(ALL_DIRTY);
else if (dirtyDelta<0) setDirtyMask(NOT_DIRTY);
}
void TerrainTile::setDirty(bool dirty)
void TerrainTile::setDirtyMask(int dirtyMask)
{
if (_dirty==dirty) return;
if (_dirtyMask==dirtyMask) return;
_dirty = dirty;
int dirtyDelta = (_dirtyMask==NOT_DIRTY) ? 0 : -1;
if (_dirty)
_dirtyMask = dirtyMask;
if (_dirtyMask!=NOT_DIRTY) dirtyDelta += 1;
if (dirtyDelta>0)
{
setNumChildrenRequiringUpdateTraversal(getNumChildrenRequiringUpdateTraversal()+1);
}
else if (getNumChildrenRequiringUpdateTraversal()>0)
else if (dirtyDelta<0 && getNumChildrenRequiringUpdateTraversal()>0)
{
setNumChildrenRequiringUpdateTraversal(getNumChildrenRequiringUpdateTraversal()-1);
}

50
src/osgWrappers/introspection/osgTerrain/GeometryTechnique.cpp
View File

@@ -15,7 +15,6 @@
#include <osg/Object>
#include <osg/State>
#include <osg/Uniform>
#include <osg/Vec3d>
#include <osgTerrain/GeometryTechnique>
#include <osgTerrain/Locator>
#include <osgUtil/CullVisitor>
@@ -81,31 +80,6 @@ BEGIN_OBJECT_REFLECTOR(osgTerrain::GeometryTechnique)
__Locator_P1__computeMasterLocator,
"",
"");
I_Method1(osg::Vec3d, computeCenterModel, IN, osgTerrain::Locator *, masterLocator,
Properties::VIRTUAL,
__osg_Vec3d__computeCenterModel__Locator_P1,
"",
"");
I_Method2(void, generateGeometry, IN, osgTerrain::Locator *, masterLocator, IN, const osg::Vec3d &, centerModel,
Properties::VIRTUAL,
__void__generateGeometry__Locator_P1__C5_osg_Vec3d_R1,
"",
"");
I_Method0(void, applyColorLayers,
Properties::VIRTUAL,
__void__applyColorLayers,
"",
"");
I_Method0(void, applyTransparency,
Properties::VIRTUAL,
__void__applyTransparency,
"",
"");
I_Method0(void, smoothGeometry,
Properties::VIRTUAL,
__void__smoothGeometry,
"",
"");
I_Method1(void, update, IN, osgUtil::UpdateVisitor *, nv,
Properties::VIRTUAL,
__void__update__osgUtil_UpdateVisitor_P1,
@@ -171,22 +145,28 @@ BEGIN_OBJECT_REFLECTOR(osgTerrain::GeometryTechnique)
__void__releaseGLObjects__osg_State_P1,
"If State is non-zero, this function releases any associated OpenGL objects for the specified graphics context. ",
"Otherwise, releases OpenGL objects for all graphics contexts. ");
I_ProtectedMethod0(void, swapBuffers,
Properties::NON_VIRTUAL,
I_ProtectedMethod2(osg::Vec3d, computeCenterModel, IN, osg::BufferData &, buffer, IN, osgTerrain::Locator *, masterLocator,
Properties::VIRTUAL,
Properties::NON_CONST,
__void__swapBuffers,
__osg_Vec3d__computeCenterModel__BufferData_R1__Locator_P1,
"",
"");
I_ProtectedMethod0(osg::BufferData &, getReadOnlyBuffer,
Properties::NON_VIRTUAL,
I_ProtectedMethod3(void, generateGeometry, IN, osg::BufferData &, buffer, IN, osgTerrain::Locator *, masterLocator, IN, const osg::Vec3d &, centerModel,
Properties::VIRTUAL,
Properties::NON_CONST,
__BufferData_R1__getReadOnlyBuffer,
__void__generateGeometry__BufferData_R1__Locator_P1__C5_osg_Vec3d_R1,
"",
"");
I_ProtectedMethod0(osg::BufferData &, getWriteBuffer,
Properties::NON_VIRTUAL,
I_ProtectedMethod1(void, applyColorLayers, IN, osg::BufferData &, buffer,
Properties::VIRTUAL,
Properties::NON_CONST,
__BufferData_R1__getWriteBuffer,
__void__applyColorLayers__BufferData_R1,
"",
"");
I_ProtectedMethod1(void, applyTransparency, IN, osg::BufferData &, buffer,
Properties::VIRTUAL,
Properties::NON_CONST,
__void__applyTransparency__BufferData_R1,
"",
"");
I_SimpleProperty(float, FilterBias,

5
src/osgWrappers/introspection/osgTerrain/Terrain.cpp
View File

@@ -125,6 +125,11 @@ BEGIN_OBJECT_REFLECTOR(osgTerrain::Terrain)
__C5_TerrainTechnique_P1__getTerrainTechniquePrototype,
"Get the const TerrainTechnique protype. ",
"");
I_Method1(void, updateTerrainTileOnNextFrame, IN, osgTerrain::TerrainTile *, terrainTile,
Properties::NON_VIRTUAL,
__void__updateTerrainTileOnNextFrame__TerrainTile_P1,
"Tell the Terrain node to call the terrainTile's TerrainTechnique on the next update traversal. ",
"");
I_ProtectedMethod0(void, dirtyRegisteredTiles,
Properties::NON_VIRTUAL,
Properties::NON_CONST,

67
src/osgWrappers/introspection/osgTerrain/TerrainTechnique.cpp
View File

@@ -27,9 +27,42 @@
#undef OUT
#endif
BEGIN_VALUE_REFLECTOR(osgTerrain::TerrainNeighbours)
I_DeclaringFile("osgTerrain/TerrainTechnique");
I_Constructor0(____TerrainNeighbours,
"",
"");
I_Method0(void, clear,
Properties::NON_VIRTUAL,
__void__clear,
"",
"");
I_Method1(void, addNeighbour, IN, osgTerrain::TerrainTile *, tile,
Properties::NON_VIRTUAL,
__void__addNeighbour__TerrainTile_P1,
"",
"");
I_Method1(void, removeNeighbour, IN, osgTerrain::TerrainTile *, tile,
Properties::NON_VIRTUAL,
__void__removeNeighbour__TerrainTile_P1,
"",
"");
I_Method1(bool, containsNeighbour, IN, osgTerrain::TerrainTile *, tile,
Properties::NON_VIRTUAL,
__bool__containsNeighbour__TerrainTile_P1,
"",
"");
I_ProtectedConstructor1(IN, const osgTerrain::TerrainNeighbours &, tn,
Properties::NON_EXPLICIT,
____TerrainNeighbours__C5_TerrainNeighbours_R1,
"",
"");
END_REFLECTOR
BEGIN_OBJECT_REFLECTOR(osgTerrain::TerrainTechnique)
I_DeclaringFile("osgTerrain/TerrainTechnique");
I_BaseType(osg::Object);
I_BaseType(osg::Observer);
I_Constructor0(____TerrainTechnique,
"",
"");
@@ -102,12 +135,46 @@ BEGIN_OBJECT_REFLECTOR(osgTerrain::TerrainTechnique)
__void__releaseGLObjects__osg_State_P1,
"If State is non-zero, this function releases any associated OpenGL objects for the specified graphics context. ",
"Otherwise, releases OpenGL objects for all graphics contexts. ");
I_Method1(void, addNeighbour, IN, osgTerrain::TerrainTile *, tile,
Properties::NON_VIRTUAL,
__void__addNeighbour__TerrainTile_P1,
"",
"");
I_Method1(void, removeNeighbour, IN, osgTerrain::TerrainTile *, tile,
Properties::NON_VIRTUAL,
__void__removeNeighbour__TerrainTile_P1,
"",
"");
I_Method1(bool, containsNeighbour, IN, osgTerrain::TerrainTile *, tile,
Properties::NON_VIRTUAL,
__bool__containsNeighbour__TerrainTile_P1,
"",
"");
I_Method0(osgTerrain::TerrainNeighbours &, getNeighbours,
Properties::NON_VIRTUAL,
__TerrainNeighbours_R1__getNeighbours,
"",
"");
I_Method0(const osgTerrain::TerrainNeighbours &, getNeighbours,
Properties::NON_VIRTUAL,
__C5_TerrainNeighbours_R1__getNeighbours,
"",
"");
I_ProtectedMethod1(void, setTerrainTile, IN, osgTerrain::TerrainTile *, tile,
Properties::NON_VIRTUAL,
Properties::NON_CONST,
__void__setTerrainTile__TerrainTile_P1,
"",
"");
I_ProtectedMethod1(void, setDirty, IN, bool, dirty,
Properties::NON_VIRTUAL,
Properties::NON_CONST,
__void__setDirty__bool,
"",
"");
I_SimpleProperty(osgTerrain::TerrainNeighbours &, Neighbours,
__TerrainNeighbours_R1__getNeighbours,
0);
I_SimpleProperty(osgTerrain::TerrainTile *, TerrainTile,
__TerrainTile_P1__getTerrainTile,
0);

32
src/osgWrappers/introspection/osgTerrain/TerrainTile.cpp
View File

@@ -38,6 +38,19 @@ BEGIN_ENUM_REFLECTOR(osgTerrain::TerrainTile::BlendingPolicy)
I_EnumLabel(osgTerrain::TerrainTile::ENABLE_BLENDING_WHEN_ALPHA_PRESENT);
END_REFLECTOR
BEGIN_ENUM_REFLECTOR(osgTerrain::TerrainTile::DirtyMask)
I_DeclaringFile("osgTerrain/TerrainTile");
I_EnumLabel(osgTerrain::TerrainTile::NOT_DIRTY);
I_EnumLabel(osgTerrain::TerrainTile::IMAGERY_DIRTY);
I_EnumLabel(osgTerrain::TerrainTile::ELEVATION_DIRTY);
I_EnumLabel(osgTerrain::TerrainTile::LEFT_EDGE_DIRTY);
I_EnumLabel(osgTerrain::TerrainTile::RIGHT_EDGE_DIRTY);
I_EnumLabel(osgTerrain::TerrainTile::TOP_EDGE_DIRTY);
I_EnumLabel(osgTerrain::TerrainTile::BOTTOM_EDGE_DIRTY);
I_EnumLabel(osgTerrain::TerrainTile::EDGES_DIRTY);
I_EnumLabel(osgTerrain::TerrainTile::ALL_DIRTY);
END_REFLECTOR
BEGIN_OBJECT_REFLECTOR(osgTerrain::TerrainTile)
I_DeclaringFile("osgTerrain/TerrainTile");
I_BaseType(osg::Group);
@@ -213,9 +226,19 @@ BEGIN_OBJECT_REFLECTOR(osgTerrain::TerrainTile)
__void__setDirty__bool,
"Set the dirty flag on/off. ",
"");
I_Method0(bool, getDirty,
I_Method0(int, getDirty,
Properties::NON_VIRTUAL,
__bool__getDirty,
__int__getDirty,
"return true if the any of the DirtyMask are set. ",
"");
I_Method1(void, setDirtyMask, IN, int, dirtyMask,
Properties::NON_VIRTUAL,
__void__setDirtyMask__int,
"Set the dirty flag on/off. ",
"");
I_Method0(int, getDirtyMask,
Properties::NON_VIRTUAL,
__int__getDirtyMask,
"return true if the tile is dirty and needs to be updated, ",
"");
I_Method0(osg::BoundingSphere, computeBound,
@@ -247,8 +270,11 @@ BEGIN_OBJECT_REFLECTOR(osgTerrain::TerrainTile)
0,
0);
I_SimpleProperty(bool, Dirty,
__bool__getDirty,
0,
__void__setDirty__bool);
I_SimpleProperty(int, DirtyMask,
__int__getDirtyMask,
__void__setDirtyMask__int);
I_SimpleProperty(osgTerrain::Layer *, ElevationLayer,
__Layer_P1__getElevationLayer,
__void__setElevationLayer__Layer_P1);