NeL: NL3D::CClipTrav class Reference

00533 {
+00534         H_AUTO( NL3D_TravClip_SkeletonShadow );
+00535 
+00536         CScene::ItSkeletonModelList             itSkel;
+00537 
+00538         float   dFade= NL3D_SMM_FADE_SPEED * Scene->getEllapsedTime();
+00539         float   distFadeStart= Scene->getShadowMapDistFadeStart();
+00540         float   distFadeEnd= Scene->getShadowMapDistFadeEnd();
+00541         float   OODeltaDistFade;
+00542         if(distFadeEnd-distFadeStart>0)
+00543                 OODeltaDistFade= 1.0f/(distFadeEnd-distFadeStart);
+00544         else
+00545                 OODeltaDistFade= 1000000;
+00546         uint    maxCastInScreen= Scene->getShadowMapMaxCasterInScreen();
+00547         uint    maxCastAround= Scene->getShadowMapMaxCasterAround();
+00548 
+00549         // **** First select Skeleton ShadowMap to Render
+00550 
+00551         // Lod Skeletons that will cast ShadowMaps.
+00552         static std::vector<CFadeShadowMapSort>          aroundCastSkeletons;
+00553         static std::vector<CFadeShadowMapSort>          screenCastSkeletons;
+00554         aroundCastSkeletons.clear();
+00555         screenCastSkeletons.clear();
+00556 
+00557         // For all skeleton casters
+00558         for(itSkel= Scene->getSkeletonModelListBegin(); itSkel!=Scene->getSkeletonModelListEnd(); itSkel++)
+00559         {
+00560                 CSkeletonModel  *sm= *itSkel;
+00561 
+00562                 // if the sm cast shadow
+00563                 if( sm->canCastShadowMap() )
+00564                 {
+00565                         CShadowMap              *shadowMap= sm->getShadowMap();
+00566                         nlassert( shadowMap );
+00567 
+00568                         // Is a Root Sm ?? Other Skeletons ShadowMaps are not render since the 
+00569                         // Ancestor Skeleton render all of his sons. Additionally, no-op if this skeleton is hidden in HRC!!
+00570                         if( sm->_AncestorSkeletonModel==NULL && sm->isHrcVisible() )
+00571                         {
+00572                                 bool    visible= false;
+00573                                 // if we are already visible, then its ok, we either don't need to test.
+00574                                 if(sm->isClipVisible())
+00575                                         visible= true;
+00576                                 else
+00577                                 {
+00578                                         // TODO_SHADOW: Select a better "Skeleton Sphere". It depends also on Sticked objects/Skeletons.
+00579                                         // Build the sphere around the skeleton that can receive shadow.
+00580                                         CBSphere        sphere;
+00581                                         // Suppose an Object sphere of 3 meter radius, centered on Skeleton Pos.
+00582                                         const   float   objectRadius= 3.f;
+00583                                         sphere.Center= sm->getWorldMatrix().getPos();
+00584                                         // Add to this spehre the max Depth extent. 
+00585                                         // NB: works because suppose that the Shadow BBox include the Skeleton Center.
+00586                                         sphere.Radius= objectRadius + Scene->getShadowMapMaxDepth();
+00587 
+00588                                         // Clip This sphere against the Frustum.
+00589                                         visible= true;
+00590                                         for(uint i=0;i<WorldFrustumPyramid.size();i++)
+00591                                         {
+00592                                                 // if SpherMax OUT return false.
+00593                                                 float   d= WorldFrustumPyramid[i]*sphere.Center;
+00594                                                 if(d>sphere.Radius)
+00595                                                 {
+00596                                                         visible= false;
+00597                                                         break;
+00598                                                 }
+00599                                         }
+00600                                 }
+00601 
+00602                                 // If the ShadowMap is visible, add it to the List Of ShadowMap to Render.
+00603                                 if(visible)
+00604                                         Scene->getRenderTrav().getShadowMapManager().addShadowCaster(sm);
+00605 
+00606                                 // update Fading.
+00607                                 CFadeShadowMapSort      fsms;
+00608                                 fsms.Model= sm;
+00609                                 fsms.Dist= (sm->getWorldMatrix().getPos() - CamPos).norm();
+00610                                 // lod In and Out.
+00611                                 aroundCastSkeletons.push_back(fsms);
+00612                                 if(visible)
+00613                                         screenCastSkeletons.push_back(fsms);
+00614                                 // Compute normal Distance fading.
+00615                                 shadowMap->DistanceFade= (fsms.Dist-distFadeStart)*OODeltaDistFade;
+00616                                 // Increment the TemporalFadeOut by default  (see below)
+00617                                 shadowMap->TemporalOutScreenFade+= dFade;
+00618                                 // if !visible, increment the InScreenFadeAccum
+00619                                 if(!visible)
+00620                                         shadowMap->InScreenFadeAccum+= dFade;
+00621                         }
+00622                         // If the skeleton is not visible, or if temporary bound to a AncestorSkeletonModel
+00623                         else
+00624                         {
+00625                                 // Increment the TemporalFadeOut. Because since will be hidden (or sticked) 
+00626                                 // for a long time, allow the process to free texture.
+00627                                 shadowMap->TemporalOutScreenFade+= dFade;
+00628                                 // Since not visible, increment the InScreenFadeAccum
+00629                                 shadowMap->InScreenFadeAccum+= dFade;
+00630                         }
+00631                 }
+00632         }
+00633 
+00634         // **** Load Balance Skeletons that cast ShadowMaps around, 
+00635 
+00636         sort(aroundCastSkeletons.begin(), aroundCastSkeletons.end());
+00637         sort(screenCastSkeletons.begin(), screenCastSkeletons.end());
+00638 
+00639         // For All Around nearest Casters, decrement their fadeOutScreen
+00640         uint    numNearCast= min((uint)aroundCastSkeletons.size(), maxCastAround);
+00641         uint    i;
+00642         for(i=0;i<numNearCast;i++)
+00643         {
+00644                 CTransform      *model= aroundCastSkeletons[i].Model;
+00645                 CShadowMap      *shadowMap= model->getShadowMap();
+00646                 // Decrement the fade. *2 because default incremented above.
+00647                 shadowMap->TemporalOutScreenFade-= 2*dFade;
+00648         }
+00649 
+00650         // For InScreen Casters, increment or decrement their fadeInScreen. Also resolve InScreenFadeAccum.
+00651         numNearCast= min((uint)screenCastSkeletons.size(), maxCastInScreen);
+00652         // nearest: decrement fadeInScreen, and remove accum
+00653         for(i=0;i<numNearCast;i++)
+00654         {
+00655                 CShadowMap      *shadowMap= screenCastSkeletons[i].Model->getShadowMap();
+00656                 // Decrement the fade.
+00657                 shadowMap->TemporalInScreenFade-= dFade + shadowMap->InScreenFadeAccum;
+00658                 // Since visible and resolved, reset accum
+00659                 shadowMap->InScreenFadeAccum= 0;
+00660         }
+00661         // farthest: increment fadeInScreen, and append accum
+00662         for(i=numNearCast;i<screenCastSkeletons.size();i++)
+00663         {
+00664                 CShadowMap      *shadowMap= screenCastSkeletons[i].Model->getShadowMap();
+00665                 // Increment the fade.
+00666                 shadowMap->TemporalInScreenFade+= dFade + shadowMap->InScreenFadeAccum;
+00667                 // Since visible and resolved, reset accum
+00668                 shadowMap->InScreenFadeAccum= 0;
+00669         }
+00670 
+00671 
+00672         // clamp values, and release texture where appropriated
+00673         for(itSkel= Scene->getSkeletonModelListBegin(); itSkel!=Scene->getSkeletonModelListEnd(); itSkel++)
+00674         {
+00675                 CSkeletonModel  *sm= *itSkel;
+00676                 // if the sm cast shadow (whatever displayed or not)
+00677                 if( sm->canCastShadowMap() )
+00678                 {
+00679                         CShadowMap              *shadowMap= sm->getShadowMap();
+00680                         shadowMap->processFades();
+00681                 }
+00682         }
+00683 
+00684         // **** Use the rendered Skeletons ShadowMap to select the Ones that will be generated this Frame.
+00685         Scene->getRenderTrav().getShadowMapManager().selectShadowMapsToGenerate(Scene);
+00686 
+00687 
+00688         /* **** Then for All Skeleton not visibles but that will generate their shadowMap, 
+00689                 we must compute the LightTraversal(for ShadowLight direction) and AnimDetailTraversal (for bone 
+00690                 animation)
+00691                 We MUST NOT flag the skeleton as Visible, and we MUST NOT insert in LoadBalancing 
+00692                 (since won't be rendered)
+00693                 NB: Do nothing for Sons of the Ancestor Skeleton because:
+00694                         1/ light do nothing with them (see std clip)
+00695                         2/ animDetail will be called recursively (see std clip and CSkeletonModel::traverseAnimDetail())
+00696         */
+00697         for(itSkel= Scene->getSkeletonModelListBegin(); itSkel!=Scene->getSkeletonModelListEnd(); itSkel++)
+00698         {
+00699                 CSkeletonModel  *sm= *itSkel;
+00700                 // compute its shadowMap this frame? and not visible?
+00701                 if(sm->isGeneratingShadowMap() && !sm->isClipVisible() )
+00702                 {
+00703                         nlassert(sm->_AncestorSkeletonModel==NULL);
+00704                         // Add it only to the lightTrav and AnimDetailTrav
+00705                         if( sm->isLightable() )
+00706                                 Scene->getLightTrav().addLightedModel(sm);
+00707                         if( sm->isAnimDetailable() )
+00708                                 Scene->getAnimDetailTrav().addVisibleModel(sm);
+00709                 }
+00710         }
+00711 }
+

00121 {
+00122         H_AUTO( NL3D_TravClip );
+00123 
+00124         // The root must exist
+00125         CTransform      *sceneRoot= Scene->getRoot();
+00126 
+00127         // Increment the current date of the traversal
+00128         ++CurrentDate;
+00129         // Update Clip infos.
+00130         CTravCameraScene::update();
+00131 
+00132         // Compute pyramid in view basis.
+00133         CVector         pfoc(0,0,0);
+00134         CVector         lb(Left,  Near, Bottom );
+00135         CVector         lt(Left,  Near, Top    );
+00136         CVector         rb(Right, Near, Bottom );
+00137         CVector         rt(Right, Near, Top    );
+00138 
+00139         CVector         lbFar(Left,  Far, Bottom);
+00140         CVector         ltFar(Left,  Far, Top   );
+00141         CVector         rbFar(Right, Far, Bottom);
+00142         CVector         rtFar(Right, Far, Top   );
+00143 
+00144         uint32 i, j;
+00145 
+00146         ViewPyramid[NL3D_CLIP_PLANE_NEAR].make(lt, lb, rt);
+00147         ViewPyramid[NL3D_CLIP_PLANE_FAR].make(lbFar, ltFar, rtFar);
+00148 
+00149         if(Perspective)
+00150         {
+00151                 ViewPyramid[NL3D_CLIP_PLANE_LEFT].make(pfoc, lt, lb);
+00152                 ViewPyramid[NL3D_CLIP_PLANE_TOP].make(pfoc, rt, lt);
+00153                 ViewPyramid[NL3D_CLIP_PLANE_RIGHT].make(pfoc, rb, rt);
+00154                 ViewPyramid[NL3D_CLIP_PLANE_BOTTOM].make(pfoc, lb, rb);
+00155         }
+00156         else
+00157         {
+00158                 ViewPyramid[NL3D_CLIP_PLANE_LEFT].make(lt, ltFar, lbFar);
+00159                 ViewPyramid[NL3D_CLIP_PLANE_TOP].make(lt, rtFar, ltFar);
+00160                 ViewPyramid[NL3D_CLIP_PLANE_RIGHT].make(rt, rbFar, rtFar);
+00161                 ViewPyramid[NL3D_CLIP_PLANE_BOTTOM].make(lb, lbFar, rbFar);
+00162         }
+00163         
+00164         // Compute pyramid in World basis.
+00165         // The vector transformation M of a plane p is computed as p*M-1.
+00166         // Here, ViewMatrix== CamMatrix-1. Hence the following formula.
+00167         for (i = 0; i < 6; i++)
+00168         {
+00169                 WorldPyramid[i]= ViewPyramid[i]*ViewMatrix;
+00170         }
+00171 
+00172         // bkup this pyramid (because this one may be modified by the cluster system).
+00173         WorldFrustumPyramid= WorldPyramid;
+00174 
+00175 
+00176         // update the QuadGridClipManager.
+00177         if(_QuadGridClipManager)
+00178         {
+00179                 _QuadGridClipManager->updateClustersFromCamera(CamPos);
+00180         }
+00181 
+00182         H_BEFORE( NL3D_TravClip_ClearLists );
+00183 
+00184         // Clear the traversals list.
+00185         Scene->getAnimDetailTrav().clearVisibleList();
+00186         Scene->getLoadBalancingTrav().clearVisibleList();
+00187         Scene->getLightTrav().clearLightedList();
+00188         Scene->getRenderTrav().clearRenderList();
+00189 
+00190         H_AFTER( NL3D_TravClip_ClearLists );
+00191 
+00192 
+00193         H_BEFORE( NL3D_TravClip_ResetVisible );
+00194 
+00195         /* For all objects marked visible in preceding render, reset _Visible state here.
+00196                 NB: must reset _Visible State to false because sometimes traverseClip() are even not executed
+00197                 (Cluster clip, QuadGridClipManager clip...).
+00198                 And somes models read this _Visible state. eg: Skins/StickedObjects test the Visible state of 
+00199                 their _AncestorSkeletonModel.
+00200         */
+00201         for (i=0;i<_CurrentNumVisibleModels;i++)
+00202         {
+00203                 // if the model still exists (see ~CTransform())
+00204                 if( _VisibleList[i] )
+00205                 {
+00206                         // disable his visibility.
+00207                         _VisibleList[i]->_Visible= false;
+00208                         // let him know that it is no more in the list.
+00209                         _VisibleList[i]->_IndexInVisibleList= -1;
+00210                 }
+00211         }
+00212         // Clear The visible List.
+00213         _CurrentNumVisibleModels= 0;
+00214         // Clear the visible cluster list.
+00215         _VisibleClusters.clear();
+00216 
+00217         H_AFTER( NL3D_TravClip_ResetVisible );
+00218 
+00219         // Found where is the camera
+00220         //========================
+00221 
+00222         H_BEFORE( NL3D_TravClip_FindCameraCluster);
+00223 
+00224         // Found the cluster where the camera is
+00225         static vector<CCluster*> vCluster;
+00226 
+00227         vCluster.clear();
+00228         sceneRoot->clipDelChild(RootCluster);
+00229 
+00230         // In which cluster is the camera ?
+00231         CQuadGrid<CCluster*>::CIterator itAcc;
+00232         if (Camera->getClusterSystem() == (CInstanceGroup*)-1)
+00233         {
+00234                 fullSearch(vCluster, RootCluster->Group, CamPos);
+00235                 for (i = 0; i < vCluster.size(); ++i)
+00236                         sceneRoot->clipAddChild(vCluster[i]);
+00237         }
+00238         else
+00239         {
+00240                 bool bInWorld = true;
+00241                 Accel.select (CamPos, CamPos);
+00242                 itAcc = Accel.begin();
+00243                 while (itAcc != Accel.end())
+00244                 {
+00245                         CCluster *pCluster = *itAcc;
+00246                         if (pCluster->Group == Camera->getClusterSystem())
+00247                         if (pCluster->isIn (CamPos))
+00248                         {
+00249                                 sceneRoot->clipAddChild(pCluster);
+00250                                 vCluster.push_back (pCluster);
+00251                                 bInWorld = false;
+00252                         }
+00253                         ++itAcc;
+00254                 }
+00255 
+00256                 if (bInWorld)
+00257                 {
+00258                         sceneRoot->clipAddChild(RootCluster);
+00259                         vCluster.push_back (RootCluster);
+00260                 }
+00261         }
+00262 
+00264         for(i=0;i<vCluster.size();i++)
+00265         {
+00266                 vCluster[i]->setCameraIn(true);
+00267         }
+00268 
+00269 
+00270         H_AFTER( NL3D_TravClip_FindCameraCluster);
+00271 
+00272         // Manage Moving Objects
+00273         //=====================
+00274 
+00275         H_BEFORE( NL3D_TravClip_MovingObjects);
+00276 
+00277         // Unlink the moving objects from their clusters
+00278         CHrcTrav        &hrcTrav= Scene->getHrcTrav();
+00279         for (i = 0; i < hrcTrav._MovingObjects.size(); ++i)
+00280         {
+00281                 CTransformShape *pTfmShp = hrcTrav._MovingObjects[i];
+00282 
+00283                 static vector<CTransform*> vModels;
+00284                 vModels.clear();
+00285                 uint    numClipParents= pTfmShp->clipGetNumParents();
+00286                 for(j=0;j<numClipParents;j++)
+00287                 {
+00288                         CTransform *pFather = pTfmShp->clipGetParent(j);
+00289 
+00290                         // Does the father is a cluster ??
+00291                         if ( pFather->isCluster() )
+00292                         {
+00293                                 vModels.push_back (pFather);
+00294                         }
+00295                 }
+00296                 // Remove me from all clusters
+00297                 for (j = 0; j < vModels.size(); ++j)
+00298                 {
+00299                         vModels[j]->clipDelChild(pTfmShp);
+00300                 }
+00301                 // Remove me from Root Too
+00302                 sceneRoot->clipDelChild(pTfmShp);
+00303 
+00304                 // NB: only the SonsOfAncestorSkeletonModelGroup may still be here.
+00305         }
+00306         
+00307         // Affect the moving objects to their clusters
+00308         for (i = 0; i < hrcTrav._MovingObjects.size(); ++i)
+00309         {
+00310                 CTransformShape *pTfmShp = hrcTrav._MovingObjects[i];
+00311 
+00312                 bool bInWorld = true;
+00313                 CAABBox box;
+00314                 pTfmShp->getAABBox (box);
+00315                 // Transform the box in the world
+00316                 CVector c = box.getCenter();
+00317                 CVector p = box.getCenter()+box.getHalfSize();
+00318                 const CMatrix &wm = pTfmShp->getWorldMatrix();
+00319                 c = wm * c;
+00320                 p = wm * p;
+00321                 float s = (p - c).norm();
+00322 
+00323                 Accel.select (c+CVector(s,s,s), c+CVector(-s,-s,-s));
+00324                 itAcc = Accel.begin();
+00325                 while (itAcc != Accel.end())
+00326                 {
+00327                         CCluster *pCluster = *itAcc;
+00328                         if (pCluster->Group == pTfmShp->getClusterSystem())
+00329                         if (pCluster->isIn (c,s))
+00330                         {
+00331                                 pCluster->clipAddChild(pTfmShp);
+00332                                 bInWorld = false;
+00333                         }
+00334                         ++itAcc;
+00335                 }
+00336 
+00337                 // Moving object in the world -> link to root or to the CQuadGridClipManager.
+00338                 if (bInWorld)
+00339                 {
+00340                         if( _QuadGridClipManager && pTfmShp->isQuadGridClipEnabled() )
+00341                         {
+00342                                 // try to insert in the best cluster of the _QuadGridClipManager.
+00343                                 if(!_QuadGridClipManager->linkModel(pTfmShp))
+00344                                         // if fails, link to "root".
+00345                                         RootCluster->clipAddChild(pTfmShp);
+00346                         }
+00347                         else
+00348                         {
+00349                                 RootCluster->clipAddChild(pTfmShp);
+00350                         }
+00351                 }
+00352         }
+00353 
+00354         H_AFTER( NL3D_TravClip_MovingObjects);
+00355 
+00356         // Clip the graph.
+00357         //=====================
+00358 
+00359         H_BEFORE( NL3D_TravClip_Traverse);
+00360 
+00361 
+00362         // Traverse the graph.
+00363         sceneRoot->traverseClip();
+00364 
+00365 
+00366         // Unlink the cluster where we are
+00367         for (i = 0; i < vCluster.size(); ++i)
+00368         {
+00369                 // reset Camera In Flag.
+00370                 vCluster[i]->setCameraIn(false);
+00371 
+00372                 // remove from Clip Root
+00373                 sceneRoot->clipDelChild(vCluster[i]);
+00374         }
+00375 
+00376         H_AFTER( NL3D_TravClip_Traverse);
+00377 
+00378         // Load Balance the Skeleton CLod state here. 
+00379         // =========================
+00380         /* Can't do it in LoadBalancingTrav because sons with _AncestorSkeletonModel!=NULL may be hiden if a skeleton
+00381                 is displayed in CLod mode.
+00382                 So must do it here, then clip all sons of AncestoreSkeletonModelGroup.
+00383         */
+00384         H_BEFORE( NL3D_TravClip_LoadBalanceCLod);
+00385         loadBalanceSkeletonCLod();
+00386         H_AFTER( NL3D_TravClip_LoadBalanceCLod);
+00387 
+00388         H_BEFORE( NL3D_TravClip_SkeletonClip);
+00389 
+00390         // At the end of the clip traverse, must update clip for Objects which have a skeleton ancestor
+00391         // =========================
+00392         // those are linked to the SonsOfAncestorSkeletonModelGroup, so traverse it now.
+00393         if (Scene->SonsOfAncestorSkeletonModelGroup)
+00394                 Scene->SonsOfAncestorSkeletonModelGroup->traverseClip();
+00395 
+00396         // For All Skeletons, clip their ShadowMap possible projection against the frustum only.
+00397         // =========================
+00398         /*
+00399                 Done here, because can't do in clip() in case of a skeleton in a cluster 
+00400                 (We insert in cluster with the SkeletonModel BBox, not the SkeletonModel + Shadow BBox).
+00401         */
+00402         clipSkeletonShadowMaps();
+00403 
+00404         // Update Here the Skin render Lists of All visible Skeletons
+00405         // =========================
+00406         /*
+00407                 Done here, because AnimDetail and Render need correct lists. NB: important to do it 
+00408                 before Render Traversal, because updateSkinRenderLists() may change the transparency flag!!
+00409                 NB: can't do it in any traverse() because must be sure that it is done 
+00410                 (traverseHRC not called if SonOfAncestorSkeletonModel, and traverseClip not called if in a cluster).
+00411                 NB: must do even if clipped because:
+00412                         1/ maybe used for generateShadow() (through the ancestorSkeletonModel)
+00413                         2/ the cost of method is 0 all the time (but when true changes)
+00414         */
+00415         CScene::ItSkeletonModelList             itSkel;
+00416         for(itSkel= Scene->getSkeletonModelListBegin(); itSkel!=Scene->getSkeletonModelListEnd(); itSkel++)
+00417         {
+00418                 CSkeletonModel  *sm= *itSkel;
+00419                 sm->updateSkinRenderLists();
+00420         }
+00421 
+00422         H_AFTER( NL3D_TravClip_SkeletonClip);
+00423 }
+


Cluster system related methods.
void	addVisibleCluster (CCluster *cluster)
	Add a visible cluster to the list.
bool	fullSearch (std::vector< CCluster * > &result, CInstanceGroup *pIG, const CVector &pos)
bool	getClusterVisibilityTracking ()
	Check the activation of cluster visibility tracking.
const std::vector< CCluster * > &	getVisibleClusters ()
void	setClusterVisibilityTracking (bool track)
	Set cluster tracking on/off (ie storage of thje visible cluster during clip traversal).
bool	_TrackClusterVisibility
	Add a visible cluster to the list.
std::vector< CCluster * >	_VisibleClusters
	Add a visible cluster to the list.
Public Member Functions
	CClipTrav ()
	Constructor.
const CQuadGridClipManager *	getQuadGridClipManager () const
void	registerCluster (CCluster *pCluster)
void	setCamMatrix (const NLMISC::CMatrix &camMatrix)
	Setup the camera matrix (a translation/rotation matrix).
void	setFrustum (float width, float height, float znear, float zfar, bool perspective=true)
	Setup the camera mode as a perspective/ortho camera. NB: znear and zfar must be >0 (if perspective).
void	setFrustum (float left, float right, float bottom, float top, float znear, float zfar, bool perspective=true)
	Setup the camera mode as a perspective/ortho camera. NB: znear and zfar must be >0 (if perspective).
void	setQuadGridClipManager (CQuadGridClipManager *mgr)
	Setup the render traversal (else traverse() won't work).
void	traverse ()
	traverse
void	unregisterCluster (CCluster *pCluster)
	~CClipTrav ()
Visible List mgt. Those visible modles are updated each traverse().
void	addVisibleModel (CTransform *model)
void	reserveVisibleList (uint numModels)
Data Fields
CQuadGrid< CCluster * >	Accel
CCamera *	Camera
sint64	CurrentDate
bool	ForceNoFrustumClip
CCluster *	RootCluster
CScene *	Scene
FOR MODEL TRAVERSAL ONLY. (Read only)
Those variables are valid only in traverse*().
std::vector< CPlane >	ViewPyramid
	Vision Pyramid (6 normalized planes) in the view basis.
std::vector< CPlane >	WorldFrustumPyramid
	Vision Pyramid (6 normalized planes) in the world basis. NB: NOT modified by the ClusterSystem.
std::vector< CPlane >	WorldPyramid
	Vision Pyramid in the world basis. NB: may be modified by the ClusterSystem.
Protected Member Functions
void	update ()
	update the dependent information.
Private Member Functions
void	clipSkeletonShadowMaps ()
void	loadBalanceSkeletonCLod ()
Private Attributes
uint32	_CurrentNumVisibleModels
CQuadGridClipManager *	_QuadGridClipManager
std::vector< CSkeletonKey >	_TmpSortSkeletons
std::vector< CTransform * >	_VisibleList
Friends
class	CTransform

NL3D::CClipTrav Class Reference

Detailed Description

Cluster system related methods.

Public Member Functions

Data Fields

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation