osg::TileGeometryLoad Class Reference

TileGeometryLoad holds the load caused by geometry rendering.

#include <OSGTileGeometryLoad.h>

List of all members.

Public Member Functions

Constructors

TileGeometryLoad (UInt32 nodeId, bool useFaceDistribution=false)

TileGeometryLoad (const TileGeometryLoad &source)

Destructor

virtual ~TileGeometryLoad (void)

load calculation

void updateView (Matrix &viewing, Matrix &projection, Real32 near, UInt32 width, UInt32 height)

void updateGeometry ()

bool checkRegion (Int32 min[2], Int32 max[2])

bool isVisible () const

Set

void setValid (bool s)

Get

NodePtr getNode () const

const Int32 * getMin ()

const Int32 * getMax ()

UInt32 getFaces ()

Real32 getVisibleFraction (const Int32 wmin[2], const Int32 wmax[2], Int32 viswmin[2], Int32 viswmax[2])

bool getVisibleArea (const Int32 wmin[2], const Int32 wmax[2], Int32 viswmin[2], Int32 viswmax[2])

bool isInvalid (void)

Assignment

TileGeometryLoad & operator= (const TileGeometryLoad &source)

Comparison

bool operator< (const TileGeometryLoad &other) const

Dump

void dump (void)

Protected Member Functions

utilities

Real32 getFaceDistribution (UInt32 dir, Real32 cut)

Protected Attributes

Members

UInt32 _nodeId

GeometryPtr _geometry

UInt32 _faces

Int32 _min [2]

Int32 _max [2]

std::vector< std::vector
< Real32 > > _faceDistribution

UInt32 _faceDistDirX

UInt32 _faceDistDirY

bool _visible

bool _useFaceDistribution

Real32 _areaSize

bool _valid

Static Protected Attributes

static elements

static std::vector< Plane > _directions

Detailed Description

Definition at line 57 of file OSGTileGeometryLoad.h.

Constructor & Destructor Documentation

TileGeometryLoad::TileGeometryLoad	(	UInt32	nodeId,
		bool	useFaceDistribution = `false`
	)

Constructor

Definition at line 66 of file OSGTileGeometryLoad.cpp.

References _directions, osg::osgsqrt(), and updateGeometry().

00067                                                             :
00068     _nodeId(nodeId),
00069     _faces(0),
00070     _useFaceDistribution(useFaceDistribution),
00071     _valid(false)
00072 {
00073     if(_directions.size()==0)
00074     {
00075         // create directions for face distribution
00076         _directions.push_back(
00077             Plane(Vec3f( 1, 0, 0)              ,Pnt3f(0,0,0)));
00078         _directions.push_back(
00079             Plane(Vec3f( 0, 1, 0)              ,Pnt3f(0,0,0)));
00080         _directions.push_back(
00081             Plane(Vec3f( 0, 0, 1)              ,Pnt3f(0,0,0)));
00082 
00083         _directions.push_back(
00084             Plane(Vec3f( 1, 1, 1)*(1/osgsqrt(3.0f)),Pnt3f(0,0,0)));
00085         _directions.push_back(
00086             Plane(Vec3f(-1, 1, 1)*(1/osgsqrt(3.0f)),Pnt3f(1,0,0)));
00087         _directions.push_back(
00088             Plane(Vec3f( 1,-1, 1)*(1/osgsqrt(3.0f)),Pnt3f(0,1,0)));
00089         _directions.push_back(
00090             Plane(Vec3f( 1, 1,-1)*(1/osgsqrt(3.0f)),Pnt3f(0,0,1)));
00091 
00092         _directions.push_back(
00093             Plane(Vec3f( 1, 1, 0)*(1/osgsqrt(2.0f)),Pnt3f(0,0,0)));
00094         _directions.push_back(
00095             Plane(Vec3f( 1,-1, 0)*(1/osgsqrt(2.0f)),Pnt3f(0,1,0)));
00096         _directions.push_back(
00097             Plane(Vec3f( 0, 1, 1)*(1/osgsqrt(2.0f)),Pnt3f(0,0,0)));
00098         _directions.push_back(
00099             Plane(Vec3f( 0,-1, 1)*(1/osgsqrt(2.0f)),Pnt3f(0,1,0)));
00100         _directions.push_back(
00101             Plane(Vec3f( 1, 0, 1)*(1/osgsqrt(2.0f)),Pnt3f(0,0,0)));
00102         _directions.push_back(
00103             Plane(Vec3f(-1, 0, 1)*(1/osgsqrt(2.0f)),Pnt3f(1,0,0)));
00104 
00105 
00106     }
00107     updateGeometry();
00108 }

TileGeometryLoad::TileGeometryLoad ( const TileGeometryLoad & source )

copy Constructor

Definition at line 113 of file OSGTileGeometryLoad.cpp.

References _areaSize, _faceDistribution, _faces, _max, _min, and _visible.

00113                                                                 :
00114     _nodeId(source._nodeId),
00115     _useFaceDistribution(source._useFaceDistribution),
00116     _valid(source._valid)
00117 {
00118     _min[0]           = source._min[0];
00119     _min[1]           = source._min[1];
00120     _max[0]           = source._max[0];
00121     _max[1]           = source._max[1];
00122     _faces            = source._faces;
00123     _visible          = source._visible;
00124     _faceDistribution = source._faceDistribution;
00125     _areaSize         = source._areaSize;
00126 }

TileGeometryLoad::~TileGeometryLoad ( void ) [virtual]

Destructor documentation

Definition at line 133 of file OSGTileGeometryLoad.cpp.

00134 {
00135 }

Member Function Documentation

void TileGeometryLoad::updateView	(	Matrix &	viewing,
		Matrix &	projection,
		Real32	rNear,
		UInt32	width,
		UInt32	height
	)

Update the view dependend load parameters

Definition at line 140 of file OSGTileGeometryLoad.cpp.

References _areaSize, _directions, _faceDistDirX, _faceDistDirY, _max, _min, _nodeId, _useFaceDistribution, _visible, osg::NodePtr::dcast(), osg::DynamicVolume::getBounds(), osg::TransformationMatrix< ValueTypeT >::multFullMatrixPnt(), osg::TransformationMatrix< ValueTypeT >::multLeft(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize(), osg::NullFC, p, osg::FieldContainerFactory::the(), and osg::DynamicVolume::transform().

00145 {
00146     Vec3f                        vol[2];
00147     Pnt3f                        pnt;
00148     Real32                       minx = 0.0,miny = 0.0;
00149     Real32                       maxx = 0.0,maxy = 0.0;
00150     Matrix                      *p;
00151     Real32                       bestScalX;
00152     UInt32                       bestDirX = 0;
00153     Real32                       bestScalY;
00154     UInt32                       bestDirY = 0;
00155 
00156     NodePtr node = NodePtr::dcast(FieldContainerFactory::the()->getContainer(_nodeId));
00157     if(node == NullFC)
00158         return;
00159 
00160     // get whole transformation
00161     Matrix m=node->getToWorld();
00162     m.multLeft(viewing);
00163     // get transformed volume
00164     node->updateVolume();
00165     DynamicVolume volume=node->getVolume();
00166     // bug in osg base
00167     /*
00168     if(volume.isEmpty())
00169     {
00170         _visible=false;
00171         return;
00172     }
00173     */
00174     volume.transform(m);
00175     // get min,max
00176     volume.getBounds(vol[0], vol[1]);
00177     // min < rNear
00178     if(vol[0][2] > -rNear)
00179     {
00180         _visible=false;
00181         return;
00182     }
00183 
00184     // find best directon for face distribution
00185     if(_useFaceDistribution)
00186     {
00187         Real32 scal;
00188         Vec3f xdir(m[0][0],m[1][0],m[2][0]);
00189         Vec3f ydir(m[0][1],m[1][1],m[2][1]);
00190         xdir.normalize();
00191         ydir.normalize();
00192         bestScalX=bestScalY=0;
00193         for(UInt32 dir=0;dir<_directions.size();++dir)
00194         {
00195             scal=_directions[dir].getNormal()*xdir;
00196             if(scal>bestScalX)
00197             {
00198                 bestScalX=scal;
00199                 bestDirX =dir*2;
00200             }
00201             if((-scal)>bestScalX)
00202             {
00203                 bestScalX=-scal;
00204                 bestDirX =dir*2+1;
00205             }
00206             scal=_directions[dir].getNormal()*ydir;
00207             if(scal>bestScalY)
00208             {
00209                 bestScalY=scal;
00210                 bestDirY =dir*2;
00211             }
00212             if((-scal)>bestScalY)
00213             {
00214                 bestScalY=-scal;
00215                 bestDirY =dir*2+1;
00216             }
00217         }
00218         // cout << "x " << xdir << " " << _directions[bestDirX>>1].getNormal() << endl;
00219         // cout << "y " << ydir << " " << _directions[bestDirY>>1].getNormal() << endl;
00220         _faceDistDirX=bestDirX;
00221         _faceDistDirY=bestDirY;
00222         // cout << "best X:" << bestDirX << endl;
00223         // cout << "best Y:" << bestDirY << endl;
00224     }
00225 
00226     if(vol[1][2] > -rNear)
00227     {
00228         // volume lays on the fron clipping plane
00229         vol[1][2] = -rNear;
00230         p=&projection;
00231     }
00232     else
00233     {
00234         // volume lays on the visible side of the clipping plane
00235         node->getVolume().getBounds(vol[0], vol[1]);
00236         m.multLeft(projection);
00237         p=&m;
00238     }
00239     // create corners of a bounding box
00240     for(int i=0;i<8;++i)
00241     {
00242         p->multFullMatrixPnt(Pnt3f( vol[ (i   )&1 ][0] ,
00243                                     vol[ (i>>1)&1 ][1] ,
00244                                     vol[ (i>>2)&1 ][2]) , pnt);
00245         if(i>0)
00246         {
00247             if(minx > pnt[0]) minx = pnt[0];
00248             if(miny > pnt[1]) miny = pnt[1];
00249             if(maxx < pnt[0]) maxx = pnt[0];
00250             if(maxy < pnt[1]) maxy = pnt[1];
00251         }
00252         else
00253         {
00254             maxx = minx = pnt[0];
00255             maxy = miny = pnt[1];
00256         }
00257     }
00258     // visible ?
00259     if(maxx<-1 || maxy<-1 ||
00260        minx> 1 || miny> 1)
00261     {
00262         _visible = false;
00263     }
00264     else
00265     {
00266         minx=width  * ( minx + 1.0f ) / 2.0f - .5f;
00267         maxx=width  * ( maxx + 1.0f ) / 2.0f + .5f;
00268         miny=height * ( miny + 1.0f ) / 2.0f - .5f;
00269         maxy=height * ( maxy + 1.0f ) / 2.0f + .5f;
00270         _min[0]=(Int32)minx;
00271         _max[0]=(Int32)maxx;
00272         _min[1]=(Int32)miny;
00273         _max[1]=(Int32)maxy;
00274 
00275         _areaSize =
00276             (Real32)( _max[0] - _min[0] + 1 ) *
00277             (Real32)( _max[1] - _min[1] + 1 );
00278         /* Don't clip!
00279         if(_min[0]<0) _min[0]=0;
00280         if(_min[1]<0) _min[1]=0;
00281         if(_max[0]>=width ) _max[0]=width-1;
00282         if(_max[1]>=height) _max[1]=height-1;
00283         */
00284         _visible = true;
00285     }
00286 }

void TileGeometryLoad::updateGeometry ( )

Update geometry dependend load parameters

This funciton should only be called when geometies have changed.

todo: Use a simple cost estimation mechanism for rapidly changeing geometries.

Definition at line 296 of file OSGTileGeometryLoad.cpp.

References _directions, _faceDistribution, _faces, _nodeId, _useFaceDistribution, osg::AttachmentContainerPtr::dcast(), osg::NodePtr::dcast(), FACE_DISTRIBUTION_SAMPLING_COUNT, osg::NodePtr::getCore(), osg::TriangleIterator::getPosition(), osg::NullFC, osg::osgMax(), osg::osgMin(), osg::osgsqrt(), p, and osg::FieldContainerFactory::the().

Referenced by TileGeometryLoad().

00297 {
00298     NodePtr node = NodePtr::dcast(FieldContainerFactory::the()->getContainer(_nodeId));
00299     if(node == NullFC)
00300         return;
00301 
00302     const OSG::Volume *volume = &(node->getVolume().getInstance());
00303     TriangleIterator   f;
00304     int                p,s;
00305     Vec3f              vmin,vmax;
00306     Pnt3f              pos;
00307     Real32             min = 0.0,max = 0.0;
00308     PrimitiveIterator  it;
00309     NodeCorePtr        core;
00310     GeometryPtr        geo;
00311     const Real32       sq2=osgsqrt(2.0f);
00312     const Real32       sq3=osgsqrt(3.0f);
00313 
00314     _faces = 0;
00315     core=node->getCore();
00316     if(node->getCore() == NullFC)
00317         return;
00318     geo=GeometryPtr::dcast(core);
00319     if(geo == NullFC)
00320         return;
00321 
00322     // get volume min,max
00323     volume->getBounds(vmin,vmax);
00324 
00325     // count faces
00326     for(f=geo->beginTriangles() ; f!=geo->endTriangles() ; ++f)
00327     {
00328         ++_faces;
00329     }
00330     if(_useFaceDistribution)
00331     {
00332         _faceDistribution.resize(_directions.size()*2);
00333         // loop through all directions
00334         for(UInt32 d=0;d<_directions.size();++d)
00335         {
00336             // init dist
00337             _faceDistribution[d*2  ].resize(FACE_DISTRIBUTION_SAMPLING_COUNT);
00338             _faceDistribution[d*2+1].resize(FACE_DISTRIBUTION_SAMPLING_COUNT);
00339             for(s=0;s<FACE_DISTRIBUTION_SAMPLING_COUNT;++s)
00340             {
00341                 _faceDistribution[d*2  ][s]=0;
00342                 _faceDistribution[d*2+1][s]=0;
00343             }
00344             // loop over all faces
00345             for(f=geo->beginTriangles() ;
00346                 f!=geo->endTriangles() ;
00347                 ++f)
00348             {
00349                 for(p=0;p<3;++p)
00350                 {
00351                     // get point and rescale
00352                     pos=(f.getPosition(p) - vmin);
00353                     pos[0]/=vmax[0]-vmin[0];
00354                     pos[1]/=vmax[1]-vmin[1];
00355                     pos[2]/=vmax[2]-vmin[2];
00356                     if(p==0)
00357                     {
00358                         max=min=_directions[d].distance(pos);
00359                     }
00360                     else
00361                     {
00362                         max=osgMax(max,_directions[d].distance(pos));
00363                         min=osgMin(min,_directions[d].distance(pos));
00364                     }
00365                 }
00366                 if(d>=7)
00367                 {
00368                     min/=sq2;
00369                     max/=sq2;
00370                 }
00371                 else if(d>=3)
00372                 {
00373                     min/=sq3;
00374                     max/=sq3;
00375                 }
00376                 _faceDistribution
00377                     [d*2  ]
00378                     [(int)(ceil(min*
00379                                 (FACE_DISTRIBUTION_SAMPLING_COUNT-1)))]++;
00380                 _faceDistribution
00381                     [d*2+1]
00382                     [(int)(ceil((1-max)*
00383                                 (FACE_DISTRIBUTION_SAMPLING_COUNT-1)))]++;
00384             }
00385         }
00386         for(UInt32 d=0;d<_directions.size();++d)
00387         {
00388             _faceDistribution[d*2  ][0]/=_faces;
00389             _faceDistribution[d*2+1][0]/=_faces;
00390             for(s=1;s<FACE_DISTRIBUTION_SAMPLING_COUNT;++s)
00391             {
00392                 _faceDistribution[d*2  ][s]/=_faces;
00393                 _faceDistribution[d*2+1][s]/=_faces;
00394                 _faceDistribution[d*2  ][s]+=_faceDistribution[d*2  ][s-1];
00395                 _faceDistribution[d*2+1][s]+=_faceDistribution[d*2+1][s-1];
00396             }
00397 #if 0
00398             printf("--> ");
00399             for(s=0;s<FACE_DISTRIBUTION_SAMPLING_COUNT;++s)
00400                 printf("%4.3f ",_faceDistribution[d*2  ][s]);
00401             printf("\n<-- ");
00402             for(s=0;s<FACE_DISTRIBUTION_SAMPLING_COUNT;++s)
00403                 printf("%4.3f ",_faceDistribution[d*2+1][s]);
00404             printf("\n");
00405 #endif
00406         }
00407     }
00408 }

bool TileGeometryLoad::checkRegion	(	Int32	min[2],
		Int32	max[2]
	)

Check if one part of the geometry lays in the given region

Parameters:

	min	[ minx, miny ]
	max	[ maxx, maxy ]

Definition at line 566 of file OSGTileGeometryLoad.cpp.

References _max, and _min.

00568 {
00569     if(min[0] > _max[0] ||
00570        max[0] < _min[0] ||
00571        min[1] > _max[1] ||
00572        max[1] < _min[1])
00573         return false;
00574     else
00575         return true;
00576 }

bool TileGeometryLoad::isVisible ( ) const

Is the geometry visible in the current viewport

Definition at line 472 of file OSGTileGeometryLoad.cpp.

References _visible.

00473 {
00474     return _visible;
00475 }

void TileGeometryLoad::setValid ( bool s )

Definition at line 578 of file OSGTileGeometryLoad.cpp.

References _valid.

00579 {
00580     _valid = s;
00581 }

NodePtr TileGeometryLoad::getNode ( ) const

Get Node ptr

Definition at line 479 of file OSGTileGeometryLoad.cpp.

References _nodeId, osg::NodePtr::dcast(), and osg::FieldContainerFactory::the().

00480 {
00481     return NodePtr::dcast(FieldContainerFactory::the()->getContainer(_nodeId));
00482 }

const Int32 * TileGeometryLoad::getMin ( void )

Return min valuse in window coordinates

Definition at line 458 of file OSGTileGeometryLoad.cpp.

References _min.

00459 {
00460     return _min;
00461 }

const Int32 * TileGeometryLoad::getMax ( void )

Return max valuse in window coordinates

Definition at line 465 of file OSGTileGeometryLoad.cpp.

References _max.

00466 {
00467     return _max;
00468 }

UInt32 TileGeometryLoad::getFaces ( )

Get number of faces in the geometry

Definition at line 486 of file OSGTileGeometryLoad.cpp.

References _faces.

Referenced by osg::TileLoadBalancer::RegionLoad::getCost(), and osg::TileLoadBalancer::RegionLoad::updateCost().

00487 {
00488     return _faces;
00489 }

Real32 TileGeometryLoad::getVisibleFraction	(	const Int32	wmin[2],
		const Int32	wmax[2],
		Int32	viswmin[2],
		Int32	viswmax[2]
	)

Which part of the faces are visible

Definition at line 493 of file OSGTileGeometryLoad.cpp.

References _areaSize, _faceDistDirX, _faceDistDirY, _max, _min, _useFaceDistribution, _visible, getFaceDistribution(), and getVisibleArea().

Referenced by osg::TileLoadBalancer::RegionLoad::getCost(), and osg::TileLoadBalancer::RegionLoad::updateCost().

00497 {
00498     Real32 x,y;
00499 
00500     if(_visible==false)
00501         return 0;
00502 
00503     // get visible area
00504     if(!getVisibleArea(wmin,wmax,viswmin,viswmax))
00505     {
00506         // not in region
00507         return 0;
00508     }
00509     // geometry complete in region?
00510     if(viswmin[0] == _min[0] &&
00511        viswmin[1] == _min[1] &&
00512        viswmax[0] == _max[0] &&
00513        viswmax[1] == _max[1])
00514     {
00515         return 1;
00516     }
00517 
00518     if(_useFaceDistribution)
00519     {
00520         x=1.0f/(_max[0]-_min[0]+1);
00521         y=1.0f/(_max[1]-_min[1]+1);
00522         return
00523             (getFaceDistribution(_faceDistDirX^1,
00524                                  1.0f - (viswmin[0] - _min[0]    ) * x) +
00525              getFaceDistribution(_faceDistDirX,
00526                                        (viswmax[0] - _min[0] + 1) * x) - 1)
00527             *
00528             (getFaceDistribution(_faceDistDirY^1,
00529                                  1.0f - (viswmin[1] - _min[1]    ) * y) +
00530              getFaceDistribution(_faceDistDirY,
00531                                        (viswmax[1] - _min[1] + 1) * y) - 1);
00532     }
00533     else
00534     {
00535         return
00536             ((Real32)(viswmax[0] - viswmin[0] + 1) *
00537              (Real32)(viswmax[1] - viswmin[1] + 1)) / _areaSize;
00538     }
00539 }

bool TileGeometryLoad::getVisibleArea	(	const Int32	wmin[2],
		const Int32	wmax[2],
		Int32	viswmin[2],
		Int32	viswmax[2]
	)

Which area overlaps the given region

Definition at line 543 of file OSGTileGeometryLoad.cpp.

References _max, _min, osg::osgMax(), and osg::osgMin().

Referenced by getVisibleFraction().

00547 {
00548     viswmin[0] = osgMax(wmin[0],_min[0]);
00549     viswmin[1] = osgMax(wmin[1],_min[1]);
00550     viswmax[0] = osgMin(wmax[0],_max[0]);
00551     viswmax[1] = osgMin(wmax[1],_max[1]);
00552     // not in region
00553     if(viswmin[0] > viswmax[0] ||
00554        viswmin[1] > viswmax[1])
00555         return false;
00556     else
00557         return true;
00558 }

bool TileGeometryLoad::isInvalid ( void )

Get Node ptr

Definition at line 583 of file OSGTileGeometryLoad.cpp.

References _valid.

Referenced by osg::TileLoadBalancer::update().

00584 {
00585     return !_valid;
00586 }

TileGeometryLoad & TileGeometryLoad::operator= ( const TileGeometryLoad & source )

assignment

Definition at line 415 of file OSGTileGeometryLoad.cpp.

References _areaSize, _faceDistDirX, _faceDistDirY, _faceDistribution, _faces, _max, _min, _nodeId, _useFaceDistribution, and _visible.

00416 {
00417     if(this == &source)
00418         return *this;
00419     _min[0]              = source._min[0];
00420     _min[1]              = source._min[1];
00421     _max[0]              = source._max[0];
00422     _max[1]              = source._max[1];
00423     _faces               = source._faces;
00424     _visible             = source._visible;
00425     _faceDistribution    = source._faceDistribution;
00426     _faceDistDirX        = source._faceDistDirX;
00427     _faceDistDirY        = source._faceDistDirY;
00428     _nodeId              = source._nodeId;
00429     _useFaceDistribution = source._useFaceDistribution;
00430     _areaSize            = source._areaSize;
00431 
00432     return *this;
00433 }

bool osg::TileGeometryLoad::operator< ( const TileGeometryLoad & other ) const

void TileGeometryLoad::dump ( void )

Definition at line 438 of file OSGTileGeometryLoad.cpp.

References _faces, _max, _min, _visible, and SLOG.

00439 {
00440     if(_visible)
00441     {
00442         SLOG << "Min/Max     :"
00443              << _min[0] << " " << _min[1] << " / "
00444              << _max[0] << " " << _max[1] << std::endl;
00445     }
00446     else
00447     {
00448         SLOG << "invisible " << std::endl;
00449     }
00450     SLOG << "Faces       :" << _faces << std::endl;
00451 }

Real32 osg::TileGeometryLoad::getFaceDistribution	(	UInt32	dir,
		Real32	cut
	)			`[inline, protected]`

Definition at line 41 of file OSGTileGeometryLoad.inl.

References _faceDistribution, and FACE_DISTRIBUTION_SAMPLING_COUNT.

Referenced by getVisibleFraction().

00042 {
00043     if(cut<=0)
00044     {
00045         return 0.0;
00046     }
00047     if(cut >=1.0)
00048     {
00049         return 1.0;
00050     }
00051     cut*=FACE_DISTRIBUTION_SAMPLING_COUNT-1;
00052     
00053     UInt32 a=(UInt32)(floor(cut));
00054     Real32 f=cut-a;
00055 
00056     return _faceDistribution[dir][a] +
00057         (_faceDistribution[dir][a+1] - _faceDistribution[dir][a]) * f;
00058 }

Member Data Documentation

UInt32 osg::TileGeometryLoad::_nodeId [protected]

Definition at line 162 of file OSGTileGeometryLoad.h.

Referenced by getNode(), operator=(), updateGeometry(), and updateView().

GeometryPtr osg::TileGeometryLoad::_geometry [protected]

Definition at line 163 of file OSGTileGeometryLoad.h.

UInt32 osg::TileGeometryLoad::_faces [protected]

Definition at line 164 of file OSGTileGeometryLoad.h.

Referenced by dump(), getFaces(), operator=(), TileGeometryLoad(), and updateGeometry().

Int32 osg::TileGeometryLoad::_min[2] [protected]

Definition at line 165 of file OSGTileGeometryLoad.h.

Referenced by checkRegion(), dump(), getMin(), getVisibleArea(), getVisibleFraction(), operator=(), TileGeometryLoad(), and updateView().

Int32 osg::TileGeometryLoad::_max[2] [protected]

Definition at line 166 of file OSGTileGeometryLoad.h.

Referenced by checkRegion(), dump(), getMax(), getVisibleArea(), getVisibleFraction(), operator=(), TileGeometryLoad(), and updateView().

std::vector<std::vector<Real32> > osg::TileGeometryLoad::_faceDistribution [protected]

Definition at line 167 of file OSGTileGeometryLoad.h.

Referenced by getFaceDistribution(), operator=(), TileGeometryLoad(), and updateGeometry().

UInt32 osg::TileGeometryLoad::_faceDistDirX [protected]

Definition at line 168 of file OSGTileGeometryLoad.h.

Referenced by getVisibleFraction(), operator=(), and updateView().

UInt32 osg::TileGeometryLoad::_faceDistDirY [protected]

Definition at line 169 of file OSGTileGeometryLoad.h.

Referenced by getVisibleFraction(), operator=(), and updateView().

bool osg::TileGeometryLoad::_visible [protected]

Definition at line 170 of file OSGTileGeometryLoad.h.

Referenced by dump(), getVisibleFraction(), isVisible(), operator=(), TileGeometryLoad(), and updateView().

bool osg::TileGeometryLoad::_useFaceDistribution [protected]

Definition at line 171 of file OSGTileGeometryLoad.h.

Referenced by getVisibleFraction(), operator=(), updateGeometry(), and updateView().

Real32 osg::TileGeometryLoad::_areaSize [protected]

Definition at line 172 of file OSGTileGeometryLoad.h.

Referenced by getVisibleFraction(), operator=(), TileGeometryLoad(), and updateView().

bool osg::TileGeometryLoad::_valid [protected]

Definition at line 173 of file OSGTileGeometryLoad.h.

Referenced by isInvalid(), and setValid().

std::vector< Plane > TileGeometryLoad::_directions [static, protected]

Definition at line 181 of file OSGTileGeometryLoad.h.

Referenced by TileGeometryLoad(), updateGeometry(), and updateView().

The documentation for this class was generated from the following files:


Public Member Functions
Constructors

	TileGeometryLoad (UInt32 nodeId, bool useFaceDistribution=false)
	TileGeometryLoad (const TileGeometryLoad &source)
Destructor

virtual	~TileGeometryLoad (void)
load calculation

void	updateView (Matrix &viewing, Matrix &projection, Real32 near, UInt32 width, UInt32 height)
void	updateGeometry ()
bool	checkRegion (Int32 min[2], Int32 max[2])
bool	isVisible () const
Set

void	setValid (bool s)
Get

NodePtr	getNode () const
const Int32 *	getMin ()
const Int32 *	getMax ()
UInt32	getFaces ()
Real32	getVisibleFraction (const Int32 wmin[2], const Int32 wmax[2], Int32 viswmin[2], Int32 viswmax[2])
bool	getVisibleArea (const Int32 wmin[2], const Int32 wmax[2], Int32 viswmin[2], Int32 viswmax[2])
bool	isInvalid (void)
Assignment
TileGeometryLoad &	operator= (const TileGeometryLoad &source)
Comparison

bool	operator< (const TileGeometryLoad &other) const
Dump

void	dump (void)
Protected Member Functions
utilities

Real32	getFaceDistribution (UInt32 dir, Real32 cut)
Protected Attributes
Members

UInt32	_nodeId
GeometryPtr	_geometry
UInt32	_faces
Int32	_min [2]
Int32	_max [2]
std::vector< std::vector < Real32 > >	_faceDistribution
UInt32	_faceDistDirX
UInt32	_faceDistDirY
bool	_visible
bool	_useFaceDistribution
Real32	_areaSize
bool	_valid
Static Protected Attributes
static elements

static std::vector< Plane >	_directions