osg::TileLoadBalancer Class Reference

Manages geometry load.

#include <OSGTileLoadBalancer.h>

List of all members.

Public Types
typedef std::vector< TileGeometryLoad >	TileGeometryLoadLstT
typedef std::map< UInt32, TileGeometryLoadLstT::iterator >	TileGeometryLoadMapT
typedef std::vector< Region >	ResultT
typedef std::vector< RenderNode >	RenderNodeLstT
Public Member Functions
Constructors
*	TileLoadBalancer (bool useFaceDistribution=false, bool cutBestDirection=true)
	TileLoadBalancer (const TileLoadBalancer &source)
Assignment
*TileLoadBalancer &	operator= (const TileLoadBalancer &source)
Destructor
*virtual	~TileLoadBalancer (void)
Load balancing functions
*void	update (NodePtr node)
void	balance (ViewportPtr vp, bool shrink, ResultT &result)
void	addRenderNode (const RenderNode &rn, UInt32 id)
void	drawVolumes (WindowPtr win)
void	setRegionStatistics (ViewportPtr vp, ResultT &result)
Protected Types
Types
typedef std::vector< RegionLoad >	RegionLoadVecT
Protected Member Functions
Member
*double	runFaceBench (GLuint dlist, UInt32 size, Real32 visible)
void	updateSubtree (NodePtr &node, TileGeometryLoadMapT &loadMap)
void	splitRegion (UInt32 rnFrom, UInt32 rnTo, RegionLoadVecT &visible, Int32 amin[2], Int32 amax[2], UInt32 depth, ResultT &result)
Real32	findBestCut (const RenderNode &renderNodeA, const RenderNode &renderNodeB, RegionLoadVecT &visible, Int32 amin[2], Int32 amax[2], Int32 &bestAxis, Int32 &bestCut)
double	calcFaceRenderingCost (TileGeometryLoad *load, Int32 amin[2], Int32 amax[2])
Protected Attributes
Fields
*TileGeometryLoadLstT	_tileGeometryLoad
RenderNodeLstT	_renderNode
bool	_useFaceDistribution
bool	_cutBestDirection
Friends
class	RegionLoad
Classes
struct	Region
class	RegionLoad

---

Detailed Description

Definition at line 56 of file OSGTileLoadBalancer.h.

---

Member Typedef Documentation

typedef std::vector<TileGeometryLoad> osg::TileLoadBalancer::TileGeometryLoadLstT

Definition at line 67 of file OSGTileLoadBalancer.h.

typedef std::map<UInt32,TileGeometryLoadLstT::iterator> osg::TileLoadBalancer::TileGeometryLoadMapT

Definition at line 68 of file OSGTileLoadBalancer.h.

typedef std::vector<Region> osg::TileLoadBalancer::ResultT

Definition at line 69 of file OSGTileLoadBalancer.h.

typedef std::vector<RenderNode> osg::TileLoadBalancer::RenderNodeLstT

Definition at line 70 of file OSGTileLoadBalancer.h.

typedef std::vector<RegionLoad> osg::TileLoadBalancer::RegionLoadVecT [protected]

Definition at line 158 of file OSGTileLoadBalancer.h.

---

Constructor & Destructor Documentation

TileLoadBalancer::TileLoadBalancer (  bool  useFaceDistribution = false, bool  cutBestDirection = true )

Constructor Definition at line 72 of file OSGTileLoadBalancer.cpp. : _useFaceDistribution(useFaceDistribution), _cutBestDirection(cutBestDirection) { }

TileLoadBalancer::TileLoadBalancer (  const TileLoadBalancer &  source  )

Copy Constructor Definition at line 81 of file OSGTileLoadBalancer.cpp. : _tileGeometryLoad(source._tileGeometryLoad), _renderNode(source._renderNode), _useFaceDistribution(source._useFaceDistribution), _cutBestDirection(source._cutBestDirection) { }

TileLoadBalancer::~TileLoadBalancer (  void   )  [virtual]

Destructor documentation Definition at line 94 of file OSGTileLoadBalancer.cpp. { }

---

Member Function Documentation

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

assignment Definition at line 103 of file OSGTileLoadBalancer.cpp. References _cutBestDirection, _renderNode, _tileGeometryLoad, and _useFaceDistribution. { if(this == &source) return *this; _tileGeometryLoad = source._tileGeometryLoad; _renderNode = source._renderNode; _useFaceDistribution = source._useFaceDistribution; _cutBestDirection = source._cutBestDirection; return *this; }

void TileLoadBalancer::update (  NodePtr  node  )

Update the load balancing information Definition at line 117 of file OSGTileLoadBalancer.cpp. References _tileGeometryLoad, and updateSubtree(). Referenced by osg::SortFirstWindow::clientPreSync(). { TileGeometryLoadMapT loadMap; // collect old load obects for(TileGeometryLoadLstT::iterator gI=_tileGeometryLoad.begin();gI!=_tileGeometryLoad.end();++gI) { loadMap[gI->getNode().getFieldContainerId()] = gI; } updateSubtree(node,loadMap); // remove unused load objects for(TileGeometryLoadMapT::iterator mI=loadMap.begin();mI!=loadMap.end();++mI) { _tileGeometryLoad.erase(mI->second); } }

void TileLoadBalancer::balance (  ViewportPtr  vp, bool  shrink, ResultT &  result )

load balance Parameters: vp  current viewport shrink  shrink to max area of visible objects result  resulting regions Definition at line 141 of file OSGTileLoadBalancer.cpp. References _renderNode, _tileGeometryLoad, RegionLoad, splitRegion(), osg::TileLoadBalancer::Region::x1, osg::TileLoadBalancer::Region::x2, osg::TileLoadBalancer::Region::y1, and osg::TileLoadBalancer::Region::y2. Referenced by osg::SortFirstWindow::clientPreSync(). { Matrix projection,viewing; RegionLoadVecT visible; RegionLoadVecT::iterator vi; Int32 width =vp->getPixelWidth(); Int32 height=vp->getPixelHeight(); Int32 wmin[2]={width,height}; Int32 wmax[2]={0 ,0 }; Real32 rNear=vp->getCamera()->getNear(); result.clear(); vp->getCamera()->getViewing ( viewing ,width,height ); vp->getCamera()->getProjection( projection,width,height ); visible.reserve(_tileGeometryLoad.size()); for(TileGeometryLoadLstT::iterator l=_tileGeometryLoad.begin() ; l!=_tileGeometryLoad.end() ; ++l) { // update view dependent values l->updateView(viewing, projection, rNear, width, height); // sort by min values if(l->isVisible()) { // collect visible geometries visible.push_back(RegionLoad(&(*l))); if(shrink) { if(l->getMin()[0] < wmin[0]) wmin[0]=l->getMin()[0]; if(l->getMin()[1] < wmin[1]) wmin[1]=l->getMin()[1]; if(l->getMax()[0] > wmax[0]) wmax[0]=l->getMax()[0]; if(l->getMax()[1] > wmax[1]) wmax[1]=l->getMax()[1]; } } } if(shrink) { // handle invisible area if(wmax[0]<wmin[0] || wmax[1]<wmin[1] ) wmin[0]=wmax[0]=wmin[1]=wmax[1]=0; // clamp to viewable area if(wmin[0]<0) wmin[0]=0; if(wmin[1]<0) wmin[1]=0; if(wmax[0]>=width ) wmax[0]=width -1; if(wmax[1]>=height) wmax[1]=height-1; } else { wmin[0]=wmin[1]=0; wmax[0]=width-1; wmax[1]=height-1; } // calculate region cost for(vi=visible.begin();vi!=visible.end();vi++) { vi->updateCost(wmin,wmax); } if(_renderNode.size()>1) { splitRegion(0,_renderNode.size()-1, visible, wmin, wmax, 0, result); } else { Region region; region.x1=wmin[0]; region.y1=wmin[1]; region.x2=wmax[0]; region.y2=wmax[1]; result.push_back(region); } }

void TileLoadBalancer::addRenderNode (  const RenderNode &  rn, UInt32  id )

Add new render node Definition at line 297 of file OSGTileLoadBalancer.cpp. References _renderNode. Referenced by osg::SortFirstWindow::clientInit(). { while(_renderNode.size()<=id) _renderNode.push_back(RenderNode()); _renderNode[id]=rn; }

void TileLoadBalancer::drawVolumes (  WindowPtr  win  )

Draw recangular volume projection Definition at line 307 of file OSGTileLoadBalancer.cpp. References _tileGeometryLoad. { glPushMatrix(); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glViewport(0,0,win->getWidth(),win->getHeight()); gluOrtho2D(0,win->getWidth(), 0,win->getHeight()); glDisable(GL_DEPTH_TEST); glEnable(GL_COLOR_MATERIAL); for(TileGeometryLoadLstT::iterator l=_tileGeometryLoad.begin() ; l!=_tileGeometryLoad.end() ; ++l) { if(l->isVisible()) { glBegin(GL_LINE_LOOP); glColor3f(0, 1, 0); glVertex3i(l->getMin()[0],l->getMin()[1],0); glVertex3i(l->getMax()[0],l->getMin()[1],0); glVertex3i(l->getMax()[0],l->getMax()[1],0); glVertex3i(l->getMin()[0],l->getMax()[1],0); glEnd(); } } glDisable(GL_COLOR_MATERIAL); glEnable(GL_DEPTH_TEST); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); }

void TileLoadBalancer::setRegionStatistics (  ViewportPtr  vp, ResultT &  result )

Update the load balancing information Definition at line 231 of file OSGTileLoadBalancer.cpp. References _tileGeometryLoad. { Matrix projection,viewing; Int32 width =vp->getPixelWidth(); Int32 height=vp->getPixelHeight(); Real32 rNear=vp->getCamera()->getNear(); ResultT::iterator resultI; TileGeometryLoadLstT::iterator l; vp->getCamera()->getViewing ( viewing ,width,height ); vp->getCamera()->getProjection( projection,width,height ); for(resultI=result.begin(); resultI!=result.end(); ++resultI) { resultI->culledNodes=0; resultI->faces=0; resultI->culledFaces=0; resultI->pixel=0; } for(l=_tileGeometryLoad.begin() ; l!=_tileGeometryLoad.end() ; ++l) { l->updateView(viewing, projection, rNear, width, height); for(resultI=result.begin(); resultI!=result.end(); ++resultI) { if(!l->isVisible()) resultI->culledNodes++; else { Int32 wmin[2]; Int32 wmax[2]; Int32 vismin[2]; Int32 vismax[2]; wmin[0]=resultI->x1; wmin[1]=resultI->y1; wmax[0]=resultI->x2; wmax[1]=resultI->y2; Real32 visible=l->getVisibleFraction(wmin,wmax,vismin,vismax)* l->getFaces(); if(visible==0) resultI->culledNodes++; else { resultI->faces+=visible; resultI->culledFaces+= l->getFaces()-visible; resultI->pixel+= (vismax[0] - vismin[0] + 1)* (vismax[1] - vismin[1] + 1); } } } } }

* double osg::TileLoadBalancer::runFaceBench (  GLuint  dlist, UInt32  size, Real32  visible )  [protected]

void TileLoadBalancer::updateSubtree (  NodePtr &  node, TileGeometryLoadMapT &  loadMap )  [protected]

Add all geometry nodes in the given tree Definition at line 341 of file OSGTileLoadBalancer.cpp. References _tileGeometryLoad, _useFaceDistribution, osg::AttachmentContainerPtr::dcast(), osg::NodePtr::getCore(), osg::FieldContainerPtrBase::getFieldContainerId(), and osg::NullFC. Referenced by update(). { // is nodecore a geometry? if(node->getCore() != NullFC && GeometryPtr::dcast(node->getCore()) != NullFC) { // is this a new node TileGeometryLoadMapT::iterator mI=loadMap.find(node.getFieldContainerId()); if(mI==loadMap.end()) { _tileGeometryLoad.push_back(TileGeometryLoad(node,_useFaceDistribution)); } else { loadMap.erase(mI); } } // handle all childs for(MFNodePtr::iterator n=node->getMFChildren()->begin(); n!=node->getMFChildren()->end(); ++n) { updateSubtree(*n,loadMap); } }

void TileLoadBalancer::splitRegion (  UInt32  rnFrom, UInt32  rnTo, RegionLoadVecT &  visible, Int32  wmin[2], Int32  wmax[2], UInt32  depth, ResultT &  result )  [protected]

Splitupt region Definition at line 369 of file OSGTileLoadBalancer.cpp. References _cutBestDirection, _renderNode, findBestCut(), osg::RenderNode::getInvisibleFaceCost(), osg::RenderNode::setGroup(), osg::RenderNode::setInvisibleFaceCost(), osg::TileLoadBalancer::Region::x1, osg::TileLoadBalancer::Region::x2, osg::TileLoadBalancer::Region::y1, and osg::TileLoadBalancer::Region::y2. Referenced by balance(). { Int32 axis,cut; Int32 maxA[2]; Int32 minB[2]; RegionLoadVecT visibleA; RegionLoadVecT visibleB; RegionLoadVecT::iterator vi; UInt32 rnToA,rnFromB; RenderNode groupRegionA,groupRegionB; RenderNode *renderNodeA,*renderNodeB; // create group render node if neccessary rnToA =(rnTo+rnFrom)>>1; rnFromB=rnToA+1; if(rnFrom != rnToA) { groupRegionA.setGroup(&_renderNode[rnFrom],&_renderNode[rnToA+1]); renderNodeA=&groupRegionA; } else { renderNodeA=&_renderNode[rnFrom]; } if(rnFromB != rnTo) { groupRegionB.setGroup(&_renderNode[rnFromB],&_renderNode[rnTo+1]); renderNodeB=&groupRegionB; } else { renderNodeB=&_renderNode[rnFromB]; } #if 0 if((rnToA-rnFrom) != (rnTo-rnFromB)) { renderNodeB->setInvisibleFaceCost(renderNodeA->getInvisibleFaceCost()); } #endif // do we check both axis? if(_cutBestDirection) axis=-1; else axis=depth&1; // search for best cut findBestCut(*renderNodeA,*renderNodeB, visible,wmin,wmax,axis,cut); // create new regions maxA[axis ]=cut; maxA[axis^1]=wmax[axis^1]; minB[axis ]=cut+1; minB[axis^1]=wmin[axis^1]; visibleA.reserve(visible.size()); visibleB.reserve(visible.size()); // split regions if(rnFrom != rnToA || rnFromB != rnTo) { // split visible regions for(vi=visible.begin();vi!=visible.end();vi++) { if(vi->getLoad()->getMax()[axis] <= cut) visibleA.push_back(*vi); else if(vi->getLoad()->getMin()[axis] > cut) visibleB.push_back(*vi); else { visibleA.push_back(*vi); visibleB.push_back(*vi); visibleA.rbegin()->updateCost(wmin,maxA); visibleB.rbegin()->updateCost(minB,wmax); } } } if(rnFrom != rnToA) splitRegion(rnFrom,rnToA,visibleA,wmin,maxA,depth+1,result); else { Region region; region.x1=wmin[0]; region.y1=wmin[1]; region.x2=maxA[0]; region.y2=maxA[1]; result.push_back(region); } if(rnFromB != rnTo) splitRegion(rnFromB,rnTo,visibleB,minB,wmax,depth+1,result); else { Region region; region.x1=minB[0]; region.y1=minB[1]; region.x2=wmax[0]; region.y2=wmax[1]; result.push_back(region); } }

Real32 TileLoadBalancer::findBestCut (  const RenderNode &  renderNodeA, const RenderNode &  renderNodeB, RegionLoadVecT &  visible, Int32  wmin[2], Int32  wmax[2], Int32 &  bestAxis, Int32 &  bestCut )  [protected]

Find best cut through the geometries Definition at line 476 of file OSGTileLoadBalancer.cpp. References osg::osgMax(). Referenced by splitRegion(). { RegionLoadVecT::iterator vi; Int32 a,f,t,newCut; Int32 minB[2]; Int32 maxA[2]; Real32 costA=0,costB=0; Real32 newCost; Real32 bestCost; Int32 checkAxisFrom,checkAxisTo; bestCost=1e22; if(bestAxis>=0) { // only check given axis checkAxisFrom=checkAxisTo=bestAxis; } else { // check x and y cut checkAxisFrom=0; checkAxisTo=1; } for(a=checkAxisFrom;a<=checkAxisTo;++a) { f=wmin[a]; t=wmax[a]; maxA[0]=wmax[0];; maxA[1]=wmax[1];; minB[0]=wmin[0];; minB[1]=wmin[1];; do { newCut=(f+t)/2; maxA[a]=newCut; minB[a]=newCut+1; costA=costB=0; for(vi=visible.begin();vi!=visible.end();vi++) { if(vi->getLoad()->getMax()[a] <= newCut) { costA+=vi->getCost(renderNodeA); } else if(vi->getLoad()->getMin()[a] > newCut) { costB+=vi->getCost(renderNodeB); } else { costA+=vi->getCost(renderNodeA,wmin,maxA); costB+=vi->getCost(renderNodeB,minB,wmax); } } newCost= osgMax( costA, costB ); if(newCost<bestCost) { bestCut=newCut; bestCost=newCost; bestAxis=a; } // walk into direction of inbalance if(costA>costB) t=newCut; else f=newCut; } while(t-f > 2); } return bestCost; }

double osg::TileLoadBalancer::calcFaceRenderingCost (  TileGeometryLoad *  load, Int32  amin[2], Int32  amax[2] )  [protected]

---

Friends And Related Function Documentation

friend class RegionLoad [friend]

Definition at line 198 of file OSGTileLoadBalancer.h. Referenced by balance().

---

Member Data Documentation

* TileGeometryLoadLstT osg::TileLoadBalancer::_tileGeometryLoad [protected]

Definition at line 165 of file OSGTileLoadBalancer.h. Referenced by balance(), drawVolumes(), operator=(), setRegionStatistics(), update(), and updateSubtree().

RenderNodeLstT osg::TileLoadBalancer::_renderNode [protected]

Definition at line 166 of file OSGTileLoadBalancer.h. Referenced by addRenderNode(), balance(), operator=(), and splitRegion().

bool osg::TileLoadBalancer::_useFaceDistribution [protected]

Definition at line 167 of file OSGTileLoadBalancer.h. Referenced by operator=(), and updateSubtree().

bool osg::TileLoadBalancer::_cutBestDirection [protected]

Definition at line 168 of file OSGTileLoadBalancer.h. Referenced by operator=(), and splitRegion().

---

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

• OSGTileLoadBalancer.h
• OSGTileLoadBalancer.cpp

---