NeL: NL3D::CTessBlock class Reference

00043 {
00044         _Patch= NULL;
00045 
00046         // init bounding info.
00047         Empty= true;
00048         // By default, the tessBlock is clipped.
00049         Clipped= true;
00050         FullFar1= false;
00051         EmptyFar1= false;
00052 
00053         // init vert/face list.
00054         for(sint i=0;i<NL3D_TESSBLOCK_TILESIZE;i++)
00055         {
00056                 RdrTileRoot[i]=NULL;
00057         }
00058 
00059         // init LightMap.
00060         LightMapRefCount= 0;
00061 
00062         Far0FaceVector= NULL;
00063         Far1FaceVector= NULL;
00064 
00065         _PrecToModify= NULL;
00066         _NextToModify= NULL;
00067 
00068         FaceTileMaterialRefCount= 0;
00069         TileMaterialRefCount= 0;
00070 
00071         // Micro-vegetation.
00072         VegetableBlock= NULL;
00073 }

00078 {
00079         if(isInModifyList())
00080         {
00081                 removeFromModifyList();
00082         }
00083 
00084         // LightMap should be released
00085         nlassert(LightMapRefCount==0);
00086 }

00355 {
00356         // If already appened, return.
00357         if(isInModifyList())
00358                 return;
00359 
00360         // append to root.
00361         _PrecToModify= &root;
00362         _NextToModify= root._NextToModify;
00363         if(root._NextToModify)
00364                 root._NextToModify->_PrecToModify= this;
00365         root._NextToModify= this;
00366 
00367         // Then delete All faceVector that may exist.
00368         deleteFaceVectorFar0(mgr);
00369         deleteFaceVectorFar1(mgr);
00370         deleteFaceVectorTile(mgr);
00371 }

00147 {
00148         Clipped= false;
00149         for(sint i=0;i<NL3D_TESSBLOCK_NUM_CLIP_PLANE;i++)
00150         {
00151                 // If entirely out.
00152                 if(!BSphere.clipBack( CTessBlock::CurrentPyramid[i] ))
00153                 {
00154                         Clipped= true;
00155                         break;
00156                 }
00157         }
00158 }

00161 {
00162         float   r= (refineCenter-BSphere.Center).norm();
00163         if( (r-BSphere.Radius) > tileDistNear)
00164         {
00165                 FullFar1= true;
00166         }
00167         else
00168         {
00169                 if( (r+BSphere.Radius) < (tileDistNear-farTransition) )
00170                         EmptyFar1= true;
00171         }
00172 }

00199 {
00200         nlassert(Far0FaceVector==NULL);
00201         // If size is not 0.
00202         if(FarFaceList.size()>0)
00203         {
00204                 // Create a faceVector of the wanted triangles size.
00205                 Far0FaceVector= mgr.createFaceVector(FarFaceList.size());
00206 
00207                 // init.
00208                 refillFaceVectorFar0();
00209         }
00210 
00211 }

00243 {
00244         nlassert(Far1FaceVector==NULL);
00245         // If size is not 0.
00246         if(FarFaceList.size()>0)
00247         {
00248                 // Create a faceVector of the wanted triangles size.
00249                 Far1FaceVector= mgr.createFaceVector(FarFaceList.size());
00250 
00251                 // init.
00252                 refillFaceVectorFar1();
00253         }
00254 }

00303 {
00304         // For all tiles existing, and for all facePass existing, create the faceVector.
00305         for(uint tileId=0; tileId<NL3D_TESSBLOCK_TILESIZE; tileId++)
00306         {
00307                 // if tile exist.
00308                 if(RdrTileRoot[tileId])
00309                 {
00310                         // For all Pass faces of the tile.
00311                         for(uint facePass=0; facePass<NL3D_MAX_TILE_FACE; facePass++)
00312                         {
00313                                 CTessList<CTileFace>    &faceList= RdrTileRoot[tileId]->TileFaceList[facePass];
00314                                 uint32          *&faceVector= RdrTileRoot[tileId]->TileFaceVectors[facePass];
00315                                 // If some triangles create them.
00316                                 if(faceList.size()>0)
00317                                 {
00318                                         // Create a faceVector of the wanted triangles size.
00319                                         faceVector= mgr.createFaceVector(faceList.size());
00320                                 }
00321                         }
00322                 }
00323         }
00324 
00325         // init.
00326         refillFaceVectorTile();
00327 }

00214 {
00215         if(Far0FaceVector)
00216         {
00217                 mgr.deleteFaceVector(Far0FaceVector);
00218                 Far0FaceVector= NULL;
00219         }
00220 }

00257 {
00258         if(Far1FaceVector)
00259         {
00260                 mgr.deleteFaceVector(Far1FaceVector);
00261                 Far1FaceVector= NULL;
00262         }
00263 }

00330 {
00331         // For all tiles existing, and for all facePass existing, delete the faceVector.
00332         for(uint tileId=0; tileId<NL3D_TESSBLOCK_TILESIZE; tileId++)
00333         {
00334                 // if tile exist.
00335                 if(RdrTileRoot[tileId])
00336                 {
00337                         // For all Pass faces of the tile.
00338                         for(uint facePass=0; facePass<NL3D_MAX_TILE_FACE; facePass++)
00339                         {
00340                                 uint32          *&faceVector= RdrTileRoot[tileId]->TileFaceVectors[facePass];
00341                                 // If the faceVector exist, delete it.
00342                                 if(faceVector)
00343                                 {
00344                                         mgr.deleteFaceVector(faceVector);
00345                                         faceVector= NULL;
00346                                 }
00347                         }
00348                 }
00349         }
00350 }

00116 {
00117         if( !BBox.include(vec) )
00118                 BBox.extend(vec);
00119 }

00123 {
00124         BSphere.Center= BBox.getCenter();
00125         BSphere.Radius= BBox.getRadius();
00126 }

00103 {
00104         if(Empty)
00105         {
00106                 Empty= false;
00107                 BBox.setCenter(vec);
00108                 BBox.setHalfSize(CVector::Null);
00109         }
00110         else
00111                 extendSphereAdd(vec);
00112 }

00140 {
00141         Clipped= true;
00142 }

00132 {return Clipped;}

00160 {return _NextToModify;}

00095 {
00096         return _Patch;
00097 }

00090 {
00091         _Patch= patch;
00092 }

00152 {return _PrecToModify!=NULL;}

00178 {
00179         // If size is not 0.
00180         if(FarFaceList.size()>0)
00181         {
00182                 nlassert(Far0FaceVector!=NULL);
00183 
00184                 // Fill this faceVector, with FarFaceList
00185                 CTessFace       *pFace;
00186                 uint32          *dest= Far0FaceVector+1;
00187                 for(pFace= FarFaceList.begin(); pFace; pFace= (CTessFace*)pFace->Next)
00188                 {
00189                         *(dest++)= pFace->FVBase->Index0;
00190                         *(dest++)= pFace->FVLeft->Index0;
00191                         *(dest++)= pFace->FVRight->Index0;
00192                 }
00193         }
00194 }

00224 {
00225         // If size is not 0.
00226         if(FarFaceList.size()>0)
00227         {
00228                 nlassert(Far1FaceVector!=NULL);
00229                 // Fill this faceVector, with FarFaceList
00230                 CTessFace       *pFace;
00231                 uint32          *dest= Far1FaceVector+1;
00232                 for(pFace= FarFaceList.begin(); pFace; pFace= (CTessFace*)pFace->Next)
00233                 {
00234                         *(dest++)= pFace->FVBase->Index1;
00235                         *(dest++)= pFace->FVLeft->Index1;
00236                         *(dest++)= pFace->FVRight->Index1;
00237                 }
00238         }
00239 }

00268 {
00269         // For all tiles existing, and for all facePass existing, fill the faceVector.
00270         for(uint tileId=0; tileId<NL3D_TESSBLOCK_TILESIZE; tileId++)
00271         {
00272                 // if tile exist.
00273                 if(RdrTileRoot[tileId])
00274                 {
00275                         // For all Pass faces of the tile.
00276                         for(uint facePass=0; facePass<NL3D_MAX_TILE_FACE; facePass++)
00277                         {
00278                                 CTessList<CTileFace>    &faceList= RdrTileRoot[tileId]->TileFaceList[facePass];
00279                                 uint32                                  *faceVector= RdrTileRoot[tileId]->TileFaceVectors[facePass];
00280                                 // If some triangles create them.
00281                                 if(faceList.size()>0)
00282                                 {
00283                                         nlassert( faceVector!=NULL );
00284 
00285                                         // Fill this faceVector, with the TileFaceList
00286                                         CTileFace       *pFace;
00287                                         uint32          *dest= faceVector+1;
00288                                         for(pFace= faceList.begin(); pFace; pFace= (CTileFace*)pFace->Next)
00289                                         {
00290                                                 *(dest++)= pFace->V[CTessFace::IdUvBase]->Index;
00291                                                 *(dest++)= pFace->V[CTessFace::IdUvLeft]->Index;
00292                                                 *(dest++)= pFace->V[CTessFace::IdUvRight]->Index;
00293                                         }
00294                                 }
00295                         }
00296                 }
00297         }
00298 }

00374 {
00375         // If already removed, return.
00376         // _PrecToModify must be !NULL
00377         if(!isInModifyList())
00378                 return;
00379 
00380         // unlink.
00381         _PrecToModify->_NextToModify= _NextToModify;
00382         if(_NextToModify)
00383                 _NextToModify->_PrecToModify= _PrecToModify;
00384         _PrecToModify= NULL;
00385         _NextToModify= NULL;
00386 }

00131 {
00132         Clipped= false;
00133         FullFar1= false;
00134         EmptyFar1= false;
00135 }

00133 {return !Clipped && !FullFar1;}

00135 {return !Clipped && !EmptyFar1;}

00134 {return !Clipped && !FullFar1;}


Public Member Functions
void	appendToModifyListAndDeleteFaceVector (CTessBlock &root, CLandscapeFaceVectorManager &mgr)
void	clip ()
void	clipFar (const CVector &refineCenter, float tileDistNear, float farTransition)
void	createFaceVectorFar0 (CLandscapeFaceVectorManager &mgr)
void	createFaceVectorFar1 (CLandscapeFaceVectorManager &mgr)
void	createFaceVectorTile (CLandscapeFaceVectorManager &mgr)
	CTessBlock ()
void	deleteFaceVectorFar0 (CLandscapeFaceVectorManager &mgr)
void	deleteFaceVectorFar1 (CLandscapeFaceVectorManager &mgr)
void	deleteFaceVectorTile (CLandscapeFaceVectorManager &mgr)
void	extendSphereAdd (const CVector &vec)
void	extendSphereCompile ()
void	extendSphereFirst (const CVector &vec)
void	forceClip ()
bool	getClipped () const
CTessBlock *	getNextToModify ()
CPatch *	getPatch ()
void	init (CPatch *patch)
bool	isInModifyList () const
void	refillFaceVectorFar0 ()
void	refillFaceVectorFar1 ()
void	refillFaceVectorTile ()
void	removeFromModifyList ()
void	resetClip ()
bool	visibleFar0 () const
bool	visibleFar1 () const
bool	visibleTile () const
	~CTessBlock ()
Data Fields
uint	FaceTileMaterialRefCount
uint32 *	Far0FaceVector
uint32 *	Far1FaceVector
CTessList< CTessFace >	FarFaceList
CTessList< CTessFarVertex >	FarVertexList
uint	LightMapId
CPatchRdrPass *	LightMapRdrPass
uint	LightMapRefCount
CTessList< CTessNearVertex >	NearVertexList
CTileMaterial *	RdrTileRoot [4]
uint	TileMaterialRefCount
CLandscapeVegetableBlock *	VegetableBlock
Static Public Attributes
CPlane	CurrentPyramid [4]
Private Attributes
CTessBlock *	_NextToModify
CPatch *	_Patch
CTessBlock *	_PrecToModify
NLMISC::CAABBox	BBox
NLMISC::CBSphere	BSphere
bool	Clipped
bool	Empty
bool	EmptyFar1
bool	FullFar1

NL3D::CTessBlock Class Reference

Detailed Description

Public Member Functions

Data Fields

Static Public Attributes

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation