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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
include/osgTerrain/GeometryTechnique
View File

@ -38,16 +38,7 @@ class OSGTERRAIN_EXPORT GeometryTechnique : public TerrainTechnique
virtual Locator* computeMasterLocator();
virtual osg::Vec3d computeCenterModel(Locator* masterLocator);
virtual void generateGeometry(Locator* masterLocator, const osg::Vec3d& centerModel);
virtual void applyColorLayers();
virtual void applyTransparency();
virtual void smoothGeometry();
virtual void update(osgUtil::UpdateVisitor* nv);
virtual void cull(osgUtil::CullVisitor* nv);
@ -86,24 +77,32 @@ class OSGTERRAIN_EXPORT GeometryTechnique : public TerrainTechnique
virtual ~GeometryTechnique();
struct BufferData
class BufferData : public osg::Referenced
{
public:
BufferData() {}
osg::ref_ptr<osg::MatrixTransform> _transform;
osg::ref_ptr<osg::Geode> _geode;
osg::ref_ptr<osg::Geometry> _geometry;
};
unsigned int _currentReadOnlyBuffer;
unsigned int _currentWriteBuffer;
BufferData _bufferData[2];
void swapBuffers();
inline BufferData& getReadOnlyBuffer() { return _bufferData[_currentReadOnlyBuffer]; }
inline BufferData& getWriteBuffer() { return _bufferData[_currentWriteBuffer]; }
protected:
~BufferData() {}
};
virtual osg::Vec3d computeCenterModel(BufferData& buffer, Locator* masterLocator);
virtual void generateGeometry(BufferData& buffer, Locator* masterLocator, const osg::Vec3d& centerModel);
virtual void applyColorLayers(BufferData& buffer);
virtual void applyTransparency(BufferData& buffer);
OpenThreads::Mutex _writeBufferMutex;
osg::ref_ptr<BufferData> _currentBufferData;
osg::ref_ptr<BufferData> _newBufferData;
float _filterBias;
osg::ref_ptr<osg::Uniform> _filterBiasUniform;
float _filterWidth;

4
include/osgTerrain/Terrain
View File

@ -91,6 +91,9 @@ class OSGTERRAIN_EXPORT Terrain : public osg::Group
/** Get the const TerrainTechnique protype*/
const TerrainTechnique* getTerrainTechniquePrototype() const { return _terrainTechnique.get(); }
/** Tell the Terrain node to call the terrainTile's TerrainTechnique on the next update traversal.*/
void updateTerrainTileOnNextFrame(TerrainTile* terrainTile);
protected:
virtual ~Terrain();
@ -112,6 +115,7 @@ class OSGTERRAIN_EXPORT Terrain : public osg::Group
mutable OpenThreads::Mutex _mutex;
TerrainTileSet _terrainTileSet;
TerrainTileMap _terrainTileMap;
TerrainTileSet _updateTerrainTileSet;
osg::ref_ptr<TerrainTechnique> _terrainTechnique;
};

47
include/osgTerrain/TerrainTechnique
View File

@ -25,7 +25,31 @@ namespace osgTerrain {
class TerrainTile;
class OSGTERRAIN_EXPORT TerrainTechnique : public osg::Object
class OSGTERRAIN_EXPORT TerrainNeighbours
{
public:
TerrainNeighbours();
~TerrainNeighbours();
void clear();
void addNeighbour(TerrainTile* tile);
void removeNeighbour(TerrainTile* tile);
bool containsNeighbour(TerrainTile* tile) const;
protected:
TerrainNeighbours(const TerrainNeighbours& tn) {}
TerrainNeighbours& operator = (const TerrainNeighbours& rhs) { return *this; }
typedef std::set<TerrainTile*> Neighbours;
mutable OpenThreads::Mutex _neighboursMutex;
Neighbours _neighbours;
};
class OSGTERRAIN_EXPORT TerrainTechnique : public osg::Object, public osg::Observer
{
public:
@ -33,7 +57,7 @@ class OSGTERRAIN_EXPORT TerrainTechnique : public osg::Object
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
TerrainTechnique(const TerrainTechnique&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Object(osgTerrain, TerrainTechnique);
TerrainTile* getTerrainTile() { return _terrainTile; }
@ -56,15 +80,26 @@ class OSGTERRAIN_EXPORT TerrainTechnique : public osg::Object
* for all graphics contexts. */
virtual void releaseGLObjects(osg::State* = 0) const {}
void addNeighbour(TerrainTile* tile) { _neighbours.addNeighbour(tile); }
void removeNeighbour(TerrainTile* tile) { _neighbours.removeNeighbour(tile); }
bool containsNeighbour(TerrainTile* tile) { return _neighbours.containsNeighbour(tile); }
TerrainNeighbours& getNeighbours() { return _neighbours; }
const TerrainNeighbours& getNeighbours() const { return _neighbours; }
protected:
void setDirty(bool dirty);
virtual ~TerrainTechnique();
void setTerrainTile(TerrainTile* tile);
void setDirty(bool dirty);
friend class osgTerrain::TerrainTile;
TerrainTile* _terrainTile;
TerrainTile* _terrainTile;
TerrainNeighbours _neighbours;
};

29
include/osgTerrain/TerrainTile
View File

@ -69,7 +69,7 @@ class OSGTERRAIN_EXPORT TerrainTile : public osg::Group
public:
TerrainTile();
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/
TerrainTile(const TerrainTile&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
@ -172,11 +172,32 @@ class OSGTERRAIN_EXPORT TerrainTile : public osg::Group
BlendingPolicy getBlendingPolicy() const { return _blendingPolicy; }
enum DirtyMask
{
NOT_DIRTY = 0,
IMAGERY_DIRTY = 1<<0,
ELEVATION_DIRTY = 1<<1,
LEFT_EDGE_DIRTY = 1<<2,
RIGHT_EDGE_DIRTY = 1<<3,
TOP_EDGE_DIRTY = 1<<4,
BOTTOM_EDGE_DIRTY = 1<<5,
EDGES_DIRTY = LEFT_EDGE_DIRTY | RIGHT_EDGE_DIRTY | TOP_EDGE_DIRTY | BOTTOM_EDGE_DIRTY,
ALL_DIRTY = IMAGERY_DIRTY | ELEVATION_DIRTY | EDGES_DIRTY
};
/** Set the dirty flag on/off.*/
void setDirty(bool dirty);
void setDirty(bool dirty) { setDirtyMask(dirty ? ALL_DIRTY : NOT_DIRTY); }
/** return true if the any of the DirtyMask are set.*/
int getDirty() const { return _dirtyMask!=NOT_DIRTY; }
/** Set the dirty flag on/off.*/
void setDirtyMask(int dirtyMask);
/** return true if the tile is dirty and needs to be updated,*/
bool getDirty() const { return _dirty; }
int getDirtyMask() const { return _dirtyMask; }
/** Compute the bounding volume of the terrain by computing the union of the bounding volumes of all layers.*/
virtual osg::BoundingSphere computeBound() const;
@ -207,7 +228,7 @@ class OSGTERRAIN_EXPORT TerrainTile : public osg::Group
Terrain* _terrain;
bool _dirty;
int _dirtyMask;
bool _hasBeenTraversal;
TileID _tileID;

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);